fs/cifs/cifs_swn.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Witness Service client for CIFS
   4  *
   5  * Copyright (c) 2020 Samuel Cabrero <scabrero@suse.de>
   6  */
   7
   8 #include <linux/kref.h>
   9 #include <net/genetlink.h>
  10 #include <uapi/linux/cifs/cifs_netlink.h>
  11
  12 #include "cifs_swn.h"
  13 #include "cifsglob.h"
  14 #include "cifsproto.h"
  15 #include "fscache.h"
  16 #include "cifs_debug.h"
  17 #include "netlink.h"
  18
  19 static DEFINE_IDR(cifs_swnreg_idr);
  20 static DEFINE_MUTEX(cifs_swnreg_idr_mutex);
  21
  22 struct cifs_swn_reg {
  23         int id;
  24         struct kref ref_count;
  25
  26         const char *net_name;
  27         const char *share_name;
  28         bool net_name_notify;
  29         bool share_name_notify;
  30         bool ip_notify;
  31
  32         struct cifs_tcon *tcon;
  33 };
  34
  35 static int cifs_swn_auth_info_krb(struct cifs_tcon *tcon, struct sk_buff *skb)
  36 {
  37         int ret;
  38
  39         ret = nla_put_flag(skb, CIFS_GENL_ATTR_SWN_KRB_AUTH);
  40         if (ret < 0)
  41                 return ret;
  42
  43         return 0;
  44 }
  45
  46 static int cifs_swn_auth_info_ntlm(struct cifs_tcon *tcon, struct sk_buff *skb)
  47 {
  48         int ret;
  49
  50         if (tcon->ses->user_name != NULL) {
  51                 ret = nla_put_string(skb, CIFS_GENL_ATTR_SWN_USER_NAME, tcon->ses->user_name);
  52                 if (ret < 0)
  53                         return ret;
  54         }
  55
  56         if (tcon->ses->password != NULL) {
  57                 ret = nla_put_string(skb, CIFS_GENL_ATTR_SWN_PASSWORD, tcon->ses->password);
  58                 if (ret < 0)
  59                         return ret;
  60         }
  61
  62         if (tcon->ses->domainName != NULL) {
  63                 ret = nla_put_string(skb, CIFS_GENL_ATTR_SWN_DOMAIN_NAME, tcon->ses->domainName);
  64                 if (ret < 0)
  65                         return ret;
  66         }
  67
  68         return 0;
  69 }
  70
  71 /*
  72  * Sends a register message to the userspace daemon based on the registration.
  73  * The authentication information to connect to the witness service is bundled
  74  * into the message.
  75  */
  76 static int cifs_swn_send_register_message(struct cifs_swn_reg *swnreg)
  77 {
  78         struct sk_buff *skb;
  79         struct genlmsghdr *hdr;
  80         enum securityEnum authtype;
  81         struct sockaddr_storage *addr;
  82         int ret;
  83
  84         skb = genlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
  85         if (skb == NULL) {
  86                 ret = -ENOMEM;
  87                 goto fail;
  88         }
  89
  90         hdr = genlmsg_put(skb, 0, 0, &cifs_genl_family, 0, CIFS_GENL_CMD_SWN_REGISTER);
  91         if (hdr == NULL) {
  92                 ret = -ENOMEM;
  93                 goto nlmsg_fail;
  94         }
  95
  96         ret = nla_put_u32(skb, CIFS_GENL_ATTR_SWN_REGISTRATION_ID, swnreg->id);
  97         if (ret < 0)
  98                 goto nlmsg_fail;
  99
 100         ret = nla_put_string(skb, CIFS_GENL_ATTR_SWN_NET_NAME, swnreg->net_name);
 101         if (ret < 0)
 102                 goto nlmsg_fail;
 103
 104         ret = nla_put_string(skb, CIFS_GENL_ATTR_SWN_SHARE_NAME, swnreg->share_name);
 105         if (ret < 0)
 106                 goto nlmsg_fail;
 107
 108         /*
 109          * If there is an address stored use it instead of the server address, because we are
 110          * in the process of reconnecting to it after a share has been moved or we have been
 111          * told to switch to it (client move message). In these cases we unregister from the
 112          * server address and register to the new address when we receive the notification.
 113          */
 114         if (swnreg->tcon->ses->server->use_swn_dstaddr)
 115                 addr = &swnreg->tcon->ses->server->swn_dstaddr;
 116         else
 117                 addr = &swnreg->tcon->ses->server->dstaddr;
 118
 119         ret = nla_put(skb, CIFS_GENL_ATTR_SWN_IP, sizeof(struct sockaddr_storage), addr);
 120         if (ret < 0)
 121                 goto nlmsg_fail;
 122
 123         if (swnreg->net_name_notify) {
 124                 ret = nla_put_flag(skb, CIFS_GENL_ATTR_SWN_NET_NAME_NOTIFY);
 125                 if (ret < 0)
 126                         goto nlmsg_fail;
 127         }
 128
 129         if (swnreg->share_name_notify) {
 130                 ret = nla_put_flag(skb, CIFS_GENL_ATTR_SWN_SHARE_NAME_NOTIFY);
 131                 if (ret < 0)
 132                         goto nlmsg_fail;
 133         }
 134
 135         if (swnreg->ip_notify) {
 136                 ret = nla_put_flag(skb, CIFS_GENL_ATTR_SWN_IP_NOTIFY);
 137                 if (ret < 0)
 138                         goto nlmsg_fail;
 139         }
 140
 141         authtype = cifs_select_sectype(swnreg->tcon->ses->server, swnreg->tcon->ses->sectype);
 142         switch (authtype) {
 143         case Kerberos:
 144                 ret = cifs_swn_auth_info_krb(swnreg->tcon, skb);
 145                 if (ret < 0) {
 146                         cifs_dbg(VFS, "%s: Failed to get kerberos auth info: %d\n", __func__, ret);
 147                         goto nlmsg_fail;
 148                 }
 149                 break;
 150         case LANMAN:
 151         case NTLM:
 152         case NTLMv2:
 153         case RawNTLMSSP:
 154                 ret = cifs_swn_auth_info_ntlm(swnreg->tcon, skb);
 155                 if (ret < 0) {
 156                         cifs_dbg(VFS, "%s: Failed to get NTLM auth info: %d\n", __func__, ret);
 157                         goto nlmsg_fail;
 158                 }
 159                 break;
 160         default:
 161                 cifs_dbg(VFS, "%s: secType %d not supported!\n", __func__, authtype);
 162                 ret = -EINVAL;
 163                 goto nlmsg_fail;
 164         }
 165
 166         genlmsg_end(skb, hdr);
 167         genlmsg_multicast(&cifs_genl_family, skb, 0, CIFS_GENL_MCGRP_SWN, GFP_ATOMIC);
 168
 169         cifs_dbg(FYI, "%s: Message to register for network name %s with id %d sent\n", __func__,
 170                         swnreg->net_name, swnreg->id);
 171
 172         return 0;
 173
 174 nlmsg_fail:
 175         genlmsg_cancel(skb, hdr);
 176         nlmsg_free(skb);
 177 fail:
 178         return ret;
 179 }
 180
 181 /*
 182  * Sends an uregister message to the userspace daemon based on the registration
 183  */
 184 static int cifs_swn_send_unregister_message(struct cifs_swn_reg *swnreg)
 185 {
 186         struct sk_buff *skb;
 187         struct genlmsghdr *hdr;
 188         int ret;
 189
 190         skb = genlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
 191         if (skb == NULL)
 192                 return -ENOMEM;
 193
 194         hdr = genlmsg_put(skb, 0, 0, &cifs_genl_family, 0, CIFS_GENL_CMD_SWN_UNREGISTER);
 195         if (hdr == NULL) {
 196                 ret = -ENOMEM;
 197                 goto nlmsg_fail;
 198         }
 199
 200         ret = nla_put_u32(skb, CIFS_GENL_ATTR_SWN_REGISTRATION_ID, swnreg->id);
 201         if (ret < 0)
 202                 goto nlmsg_fail;
 203
 204         ret = nla_put_string(skb, CIFS_GENL_ATTR_SWN_NET_NAME, swnreg->net_name);
 205         if (ret < 0)
 206                 goto nlmsg_fail;
 207
 208         ret = nla_put_string(skb, CIFS_GENL_ATTR_SWN_SHARE_NAME, swnreg->share_name);
 209         if (ret < 0)
 210                 goto nlmsg_fail;
 211
 212         ret = nla_put(skb, CIFS_GENL_ATTR_SWN_IP, sizeof(struct sockaddr_storage),
 213                         &swnreg->tcon->ses->server->dstaddr);
 214         if (ret < 0)
 215                 goto nlmsg_fail;
 216
 217         if (swnreg->net_name_notify) {
 218                 ret = nla_put_flag(skb, CIFS_GENL_ATTR_SWN_NET_NAME_NOTIFY);
 219                 if (ret < 0)
 220                         goto nlmsg_fail;
 221         }
 222
 223         if (swnreg->share_name_notify) {
 224                 ret = nla_put_flag(skb, CIFS_GENL_ATTR_SWN_SHARE_NAME_NOTIFY);
 225                 if (ret < 0)
 226                         goto nlmsg_fail;
 227         }
 228
 229         if (swnreg->ip_notify) {
 230                 ret = nla_put_flag(skb, CIFS_GENL_ATTR_SWN_IP_NOTIFY);
 231                 if (ret < 0)
 232                         goto nlmsg_fail;
 233         }
 234
 235         genlmsg_end(skb, hdr);
 236         genlmsg_multicast(&cifs_genl_family, skb, 0, CIFS_GENL_MCGRP_SWN, GFP_ATOMIC);
 237
 238         cifs_dbg(FYI, "%s: Message to unregister for network name %s with id %d sent\n", __func__,
 239                         swnreg->net_name, swnreg->id);
 240
 241         return 0;
 242
 243 nlmsg_fail:
 244         genlmsg_cancel(skb, hdr);
 245         nlmsg_free(skb);
 246         return ret;
 247 }
 248
 249 /*
 250  * Try to find a matching registration for the tcon's server name and share name.
 251  * Calls to this function must be protected by cifs_swnreg_idr_mutex.
 252  * TODO Try to avoid memory allocations
 253  */
 254 static struct cifs_swn_reg *cifs_find_swn_reg(struct cifs_tcon *tcon)
 255 {
 256         struct cifs_swn_reg *swnreg;
 257         int id;
 258         const char *share_name;
 259         const char *net_name;
 260
 261         net_name = extract_hostname(tcon->treeName);
 262         if (IS_ERR(net_name)) {
 263                 int ret;
 264
 265                 ret = PTR_ERR(net_name);
 266                 cifs_dbg(VFS, "%s: failed to extract host name from target '%s': %d\n",
 267                                 __func__, tcon->treeName, ret);
 268                 return ERR_PTR(-EINVAL);
 269         }
 270
 271         share_name = extract_sharename(tcon->treeName);
 272         if (IS_ERR(share_name)) {
 273                 int ret;
 274
 275                 ret = PTR_ERR(share_name);
 276                 cifs_dbg(VFS, "%s: failed to extract share name from target '%s': %d\n",
 277                                 __func__, tcon->treeName, ret);
 278                 kfree(net_name);
 279                 return ERR_PTR(-EINVAL);
 280         }
 281
 282         idr_for_each_entry(&cifs_swnreg_idr, swnreg, id) {
 283                 if (strcasecmp(swnreg->net_name, net_name) != 0
 284                     || strcasecmp(swnreg->share_name, share_name) != 0) {
 285                         continue;
 286                 }
 287
 288                 cifs_dbg(FYI, "Existing swn registration for %s:%s found\n", swnreg->net_name,
 289                                 swnreg->share_name);
 290
 291                 kfree(net_name);
 292                 kfree(share_name);
 293
 294                 return swnreg;
 295         }
 296
 297         kfree(net_name);
 298         kfree(share_name);
 299
 300         return ERR_PTR(-EEXIST);
 301 }
 302
 303 /*
 304  * Get a registration for the tcon's server and share name, allocating a new one if it does not
 305  * exists
 306  */
 307 static struct cifs_swn_reg *cifs_get_swn_reg(struct cifs_tcon *tcon)
 308 {
 309         struct cifs_swn_reg *reg = NULL;
 310         int ret;
 311
 312         mutex_lock(&cifs_swnreg_idr_mutex);
 313
 314         /* Check if we are already registered for this network and share names */
 315         reg = cifs_find_swn_reg(tcon);
 316         if (!IS_ERR(reg)) {
 317                 kref_get(&reg->ref_count);
 318                 mutex_unlock(&cifs_swnreg_idr_mutex);
 319                 return reg;
 320         } else if (PTR_ERR(reg) != -EEXIST) {
 321                 mutex_unlock(&cifs_swnreg_idr_mutex);
 322                 return reg;
 323         }
 324
 325         reg = kmalloc(sizeof(struct cifs_swn_reg), GFP_ATOMIC);
 326         if (reg == NULL) {
 327                 mutex_unlock(&cifs_swnreg_idr_mutex);
 328                 return ERR_PTR(-ENOMEM);
 329         }
 330
 331         kref_init(&reg->ref_count);
 332
 333         reg->id = idr_alloc(&cifs_swnreg_idr, reg, 1, 0, GFP_ATOMIC);
 334         if (reg->id < 0) {
 335                 cifs_dbg(FYI, "%s: failed to allocate registration id\n", __func__);
 336                 ret = reg->id;
 337                 goto fail;
 338         }
 339
 340         reg->net_name = extract_hostname(tcon->treeName);
 341         if (IS_ERR(reg->net_name)) {
 342                 ret = PTR_ERR(reg->net_name);
 343                 cifs_dbg(VFS, "%s: failed to extract host name from target: %d\n", __func__, ret);
 344                 goto fail_idr;
 345         }
 346
 347         reg->share_name = extract_sharename(tcon->treeName);
 348         if (IS_ERR(reg->share_name)) {
 349                 ret = PTR_ERR(reg->share_name);
 350                 cifs_dbg(VFS, "%s: failed to extract share name from target: %d\n", __func__, ret);
 351                 goto fail_net_name;
 352         }
 353
 354         reg->net_name_notify = true;
 355         reg->share_name_notify = true;
 356         reg->ip_notify = (tcon->capabilities & SMB2_SHARE_CAP_SCALEOUT);
 357
 358         reg->tcon = tcon;
 359
 360         mutex_unlock(&cifs_swnreg_idr_mutex);
 361
 362         return reg;
 363
 364 fail_net_name:
 365         kfree(reg->net_name);
 366 fail_idr:
 367         idr_remove(&cifs_swnreg_idr, reg->id);
 368 fail:
 369         kfree(reg);
 370         mutex_unlock(&cifs_swnreg_idr_mutex);
 371         return ERR_PTR(ret);
 372 }
 373
 374 static void cifs_swn_reg_release(struct kref *ref)
 375 {
 376         struct cifs_swn_reg *swnreg = container_of(ref, struct cifs_swn_reg, ref_count);
 377         int ret;
 378
 379         ret = cifs_swn_send_unregister_message(swnreg);
 380         if (ret < 0)
 381                 cifs_dbg(VFS, "%s: Failed to send unregister message: %d\n", __func__, ret);
 382
 383         idr_remove(&cifs_swnreg_idr, swnreg->id);
 384         kfree(swnreg->net_name);
 385         kfree(swnreg->share_name);
 386         kfree(swnreg);
 387 }
 388
 389 static void cifs_put_swn_reg(struct cifs_swn_reg *swnreg)
 390 {
 391         mutex_lock(&cifs_swnreg_idr_mutex);
 392         kref_put(&swnreg->ref_count, cifs_swn_reg_release);
 393         mutex_unlock(&cifs_swnreg_idr_mutex);
 394 }
 395
 396 static int cifs_swn_resource_state_changed(struct cifs_swn_reg *swnreg, const char *name, int state)
 397 {
 398         int i;
 399
 400         switch (state) {
 401         case CIFS_SWN_RESOURCE_STATE_UNAVAILABLE:
 402                 cifs_dbg(FYI, "%s: resource name '%s' become unavailable\n", __func__, name);
 403                 for (i = 0; i < swnreg->tcon->ses->chan_count; i++) {
 404                         spin_lock(&GlobalMid_Lock);
 405                         if (swnreg->tcon->ses->chans[i].server->tcpStatus != CifsExiting)
 406                                 swnreg->tcon->ses->chans[i].server->tcpStatus = CifsNeedReconnect;
 407                         spin_unlock(&GlobalMid_Lock);
 408                 }
 409                 break;
 410         case CIFS_SWN_RESOURCE_STATE_AVAILABLE:
 411                 cifs_dbg(FYI, "%s: resource name '%s' become available\n", __func__, name);
 412                 for (i = 0; i < swnreg->tcon->ses->chan_count; i++) {
 413                         spin_lock(&GlobalMid_Lock);
 414                         if (swnreg->tcon->ses->chans[i].server->tcpStatus != CifsExiting)
 415                                 swnreg->tcon->ses->chans[i].server->tcpStatus = CifsNeedReconnect;
 416                         spin_unlock(&GlobalMid_Lock);
 417                 }
 418                 break;
 419         case CIFS_SWN_RESOURCE_STATE_UNKNOWN:
 420                 cifs_dbg(FYI, "%s: resource name '%s' changed to unknown state\n", __func__, name);
 421                 break;
 422         }
 423         return 0;
 424 }
 425
 426 static bool cifs_sockaddr_equal(struct sockaddr_storage *addr1, struct sockaddr_storage *addr2)
 427 {
 428         if (addr1->ss_family != addr2->ss_family)
 429                 return false;
 430
 431         if (addr1->ss_family == AF_INET) {
 432                 return (memcmp(&((const struct sockaddr_in *)addr1)->sin_addr,
 433                                 &((const struct sockaddr_in *)addr2)->sin_addr,
 434                                 sizeof(struct in_addr)) == 0);
 435         }
 436
 437         if (addr1->ss_family == AF_INET6) {
 438                 return (memcmp(&((const struct sockaddr_in6 *)addr1)->sin6_addr,
 439                                 &((const struct sockaddr_in6 *)addr2)->sin6_addr,
 440                                 sizeof(struct in6_addr)) == 0);
 441         }
 442
 443         return false;
 444 }
 445
 446 static int cifs_swn_store_swn_addr(const struct sockaddr_storage *new,
 447                                    const struct sockaddr_storage *old,
 448                                    struct sockaddr_storage *dst)
 449 {
 450         __be16 port = cpu_to_be16(CIFS_PORT);
 451
 452         if (old->ss_family == AF_INET) {
 453                 struct sockaddr_in *ipv4 = (struct sockaddr_in *)old;
 454
 455                 port = ipv4->sin_port;
 456         } else if (old->ss_family == AF_INET6) {
 457                 struct sockaddr_in6 *ipv6 = (struct sockaddr_in6 *)old;
 458
 459                 port = ipv6->sin6_port;
 460         }
 461
 462         if (new->ss_family == AF_INET) {
 463                 struct sockaddr_in *ipv4 = (struct sockaddr_in *)new;
 464
 465                 ipv4->sin_port = port;
 466         } else if (new->ss_family == AF_INET6) {
 467                 struct sockaddr_in6 *ipv6 = (struct sockaddr_in6 *)new;
 468
 469                 ipv6->sin6_port = port;
 470         }
 471
 472         *dst = *new;
 473
 474         return 0;
 475 }
 476
 477 static int cifs_swn_reconnect(struct cifs_tcon *tcon, struct sockaddr_storage *addr)
 478 {
 479         int ret = 0;
 480
 481         /* Store the reconnect address */
 482         mutex_lock(&tcon->ses->server->srv_mutex);
 483         if (cifs_sockaddr_equal(&tcon->ses->server->dstaddr, addr))
 484                 goto unlock;
 485
 486         ret = cifs_swn_store_swn_addr(addr, &tcon->ses->server->dstaddr,
 487                                       &tcon->ses->server->swn_dstaddr);
 488         if (ret < 0) {
 489                 cifs_dbg(VFS, "%s: failed to store address: %d\n", __func__, ret);
 490                 goto unlock;
 491         }
 492         tcon->ses->server->use_swn_dstaddr = true;
 493
 494         /*
 495          * Unregister to stop receiving notifications for the old IP address.
 496          */
 497         ret = cifs_swn_unregister(tcon);
 498         if (ret < 0) {
 499                 cifs_dbg(VFS, "%s: Failed to unregister for witness notifications: %d\n",
 500                          __func__, ret);
 501                 goto unlock;
 502         }
 503
 504         /*
 505          * And register to receive notifications for the new IP address now that we have
 506          * stored the new address.
 507          */
 508         ret = cifs_swn_register(tcon);
 509         if (ret < 0) {
 510                 cifs_dbg(VFS, "%s: Failed to register for witness notifications: %d\n",
 511                          __func__, ret);
 512                 goto unlock;
 513         }
 514
 515         spin_lock(&GlobalMid_Lock);
 516         if (tcon->ses->server->tcpStatus != CifsExiting)
 517                 tcon->ses->server->tcpStatus = CifsNeedReconnect;
 518         spin_unlock(&GlobalMid_Lock);
 519
 520 unlock:
 521         mutex_unlock(&tcon->ses->server->srv_mutex);
 522
 523         return ret;
 524 }
 525
 526 static int cifs_swn_client_move(struct cifs_swn_reg *swnreg, struct sockaddr_storage *addr)
 527 {
 528         struct sockaddr_in *ipv4 = (struct sockaddr_in *)addr;
 529         struct sockaddr_in6 *ipv6 = (struct sockaddr_in6 *)addr;
 530
 531         if (addr->ss_family == AF_INET)
 532                 cifs_dbg(FYI, "%s: move to %pI4\n", __func__, &ipv4->sin_addr);
 533         else if (addr->ss_family == AF_INET6)
 534                 cifs_dbg(FYI, "%s: move to %pI6\n", __func__, &ipv6->sin6_addr);
 535
 536         return cifs_swn_reconnect(swnreg->tcon, addr);
 537 }
 538
 539 int cifs_swn_notify(struct sk_buff *skb, struct genl_info *info)
 540 {
 541         struct cifs_swn_reg *swnreg;
 542         char name[256];
 543         int type;
 544
 545         if (info->attrs[CIFS_GENL_ATTR_SWN_REGISTRATION_ID]) {
 546                 int swnreg_id;
 547
 548                 swnreg_id = nla_get_u32(info->attrs[CIFS_GENL_ATTR_SWN_REGISTRATION_ID]);
 549                 mutex_lock(&cifs_swnreg_idr_mutex);
 550                 swnreg = idr_find(&cifs_swnreg_idr, swnreg_id);
 551                 mutex_unlock(&cifs_swnreg_idr_mutex);
 552                 if (swnreg == NULL) {
 553                         cifs_dbg(FYI, "%s: registration id %d not found\n", __func__, swnreg_id);
 554                         return -EINVAL;
 555                 }
 556         } else {
 557                 cifs_dbg(FYI, "%s: missing registration id attribute\n", __func__);
 558                 return -EINVAL;
 559         }
 560
 561         if (info->attrs[CIFS_GENL_ATTR_SWN_NOTIFICATION_TYPE]) {
 562                 type = nla_get_u32(info->attrs[CIFS_GENL_ATTR_SWN_NOTIFICATION_TYPE]);
 563         } else {
 564                 cifs_dbg(FYI, "%s: missing notification type attribute\n", __func__);
 565                 return -EINVAL;
 566         }
 567
 568         switch (type) {
 569         case CIFS_SWN_NOTIFICATION_RESOURCE_CHANGE: {
 570                 int state;
 571
 572                 if (info->attrs[CIFS_GENL_ATTR_SWN_RESOURCE_NAME]) {
 573                         nla_strscpy(name, info->attrs[CIFS_GENL_ATTR_SWN_RESOURCE_NAME],
 574                                         sizeof(name));
 575                 } else {
 576                         cifs_dbg(FYI, "%s: missing resource name attribute\n", __func__);
 577                         return -EINVAL;
 578                 }
 579                 if (info->attrs[CIFS_GENL_ATTR_SWN_RESOURCE_STATE]) {
 580                         state = nla_get_u32(info->attrs[CIFS_GENL_ATTR_SWN_RESOURCE_STATE]);
 581                 } else {
 582                         cifs_dbg(FYI, "%s: missing resource state attribute\n", __func__);
 583                         return -EINVAL;
 584                 }
 585                 return cifs_swn_resource_state_changed(swnreg, name, state);
 586         }
 587         case CIFS_SWN_NOTIFICATION_CLIENT_MOVE: {
 588                 struct sockaddr_storage addr;
 589
 590                 if (info->attrs[CIFS_GENL_ATTR_SWN_IP]) {
 591                         nla_memcpy(&addr, info->attrs[CIFS_GENL_ATTR_SWN_IP], sizeof(addr));
 592                 } else {
 593                         cifs_dbg(FYI, "%s: missing IP address attribute\n", __func__);
 594                         return -EINVAL;
 595                 }
 596                 return cifs_swn_client_move(swnreg, &addr);
 597         }
 598         default:
 599                 cifs_dbg(FYI, "%s: unknown notification type %d\n", __func__, type);
 600                 break;
 601         }
 602
 603         return 0;
 604 }
 605
 606 int cifs_swn_register(struct cifs_tcon *tcon)
 607 {
 608         struct cifs_swn_reg *swnreg;
 609         int ret;
 610
 611         swnreg = cifs_get_swn_reg(tcon);
 612         if (IS_ERR(swnreg))
 613                 return PTR_ERR(swnreg);
 614
 615         ret = cifs_swn_send_register_message(swnreg);
 616         if (ret < 0) {
 617                 cifs_dbg(VFS, "%s: Failed to send swn register message: %d\n", __func__, ret);
 618                 /* Do not put the swnreg or return error, the echo task will retry */
 619         }
 620
 621         return 0;
 622 }
 623
 624 int cifs_swn_unregister(struct cifs_tcon *tcon)
 625 {
 626         struct cifs_swn_reg *swnreg;
 627
 628         mutex_lock(&cifs_swnreg_idr_mutex);
 629
 630         swnreg = cifs_find_swn_reg(tcon);
 631         if (IS_ERR(swnreg)) {
 632                 mutex_unlock(&cifs_swnreg_idr_mutex);
 633                 return PTR_ERR(swnreg);
 634         }
 635
 636         mutex_unlock(&cifs_swnreg_idr_mutex);
 637
 638         cifs_put_swn_reg(swnreg);
 639
 640         return 0;
 641 }
 642
 643 void cifs_swn_dump(struct seq_file *m)
 644 {
 645         struct cifs_swn_reg *swnreg;
 646         struct sockaddr_in *sa;
 647         struct sockaddr_in6 *sa6;
 648         int id;
 649
 650         seq_puts(m, "Witness registrations:");
 651
 652         mutex_lock(&cifs_swnreg_idr_mutex);
 653         idr_for_each_entry(&cifs_swnreg_idr, swnreg, id) {
 654                 seq_printf(m, "\nId: %u Refs: %u Network name: '%s'%s Share name: '%s'%s Ip address: ",
 655                                 id, kref_read(&swnreg->ref_count),
 656                                 swnreg->net_name, swnreg->net_name_notify ? "(y)" : "(n)",
 657                                 swnreg->share_name, swnreg->share_name_notify ? "(y)" : "(n)");
 658                 switch (swnreg->tcon->ses->server->dstaddr.ss_family) {
 659                 case AF_INET:
 660                         sa = (struct sockaddr_in *) &swnreg->tcon->ses->server->dstaddr;
 661                         seq_printf(m, "%pI4", &sa->sin_addr.s_addr);
 662                         break;
 663                 case AF_INET6:
 664                         sa6 = (struct sockaddr_in6 *) &swnreg->tcon->ses->server->dstaddr;
 665                         seq_printf(m, "%pI6", &sa6->sin6_addr.s6_addr);
 666                         if (sa6->sin6_scope_id)
 667                                 seq_printf(m, "%%%u", sa6->sin6_scope_id);
 668                         break;
 669                 default:
 670                         seq_puts(m, "(unknown)");
 671                 }
 672                 seq_printf(m, "%s", swnreg->ip_notify ? "(y)" : "(n)");
 673         }
 674         mutex_unlock(&cifs_swnreg_idr_mutex);
 675         seq_puts(m, "\n");
 676 }
 677
 678 void cifs_swn_check(void)
 679 {
 680         struct cifs_swn_reg *swnreg;
 681         int id;
 682         int ret;
 683
 684         mutex_lock(&cifs_swnreg_idr_mutex);
 685         idr_for_each_entry(&cifs_swnreg_idr, swnreg, id) {
 686                 ret = cifs_swn_send_register_message(swnreg);
 687                 if (ret < 0)
 688                         cifs_dbg(FYI, "%s: Failed to send register message: %d\n", __func__, ret);
 689         }
 690         mutex_unlock(&cifs_swnreg_idr_mutex);
 691 }