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 funciton 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(net_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;
 451
 452         if (old->ss_family == AF_INET) {
 453                 struct sockaddr_in *ipv4 = (struct sockaddr_in *)old;
 454
 455                 port = ipv4->sin_port;
 456         }
 457
 458         if (old->ss_family == AF_INET6) {
 459                 struct sockaddr_in6 *ipv6 = (struct sockaddr_in6 *)old;
 460
 461                 port = ipv6->sin6_port;
 462         }
 463
 464         if (new->ss_family == AF_INET) {
 465                 struct sockaddr_in *ipv4 = (struct sockaddr_in *)new;
 466
 467                 ipv4->sin_port = port;
 468         }
 469
 470         if (new->ss_family == AF_INET6) {
 471                 struct sockaddr_in6 *ipv6 = (struct sockaddr_in6 *)new;
 472
 473                 ipv6->sin6_port = port;
 474         }
 475
 476         *dst = *new;
 477
 478         return 0;
 479 }
 480
 481 static int cifs_swn_reconnect(struct cifs_tcon *tcon, struct sockaddr_storage *addr)
 482 {
 483         int ret = 0;
 484
 485         /* Store the reconnect address */
 486         mutex_lock(&tcon->ses->server->srv_mutex);
 487         if (cifs_sockaddr_equal(&tcon->ses->server->dstaddr, addr))
 488                 goto unlock;
 489
 490         ret = cifs_swn_store_swn_addr(addr, &tcon->ses->server->dstaddr,
 491                                       &tcon->ses->server->swn_dstaddr);
 492         if (ret < 0) {
 493                 cifs_dbg(VFS, "%s: failed to store address: %d\n", __func__, ret);
 494                 goto unlock;
 495         }
 496         tcon->ses->server->use_swn_dstaddr = true;
 497
 498         /*
 499          * Unregister to stop receiving notifications for the old IP address.
 500          */
 501         ret = cifs_swn_unregister(tcon);
 502         if (ret < 0) {
 503                 cifs_dbg(VFS, "%s: Failed to unregister for witness notifications: %d\n",
 504                          __func__, ret);
 505                 goto unlock;
 506         }
 507
 508         /*
 509          * And register to receive notifications for the new IP address now that we have
 510          * stored the new address.
 511          */
 512         ret = cifs_swn_register(tcon);
 513         if (ret < 0) {
 514                 cifs_dbg(VFS, "%s: Failed to register for witness notifications: %d\n",
 515                          __func__, ret);
 516                 goto unlock;
 517         }
 518
 519         spin_lock(&GlobalMid_Lock);
 520         if (tcon->ses->server->tcpStatus != CifsExiting)
 521                 tcon->ses->server->tcpStatus = CifsNeedReconnect;
 522         spin_unlock(&GlobalMid_Lock);
 523
 524 unlock:
 525         mutex_unlock(&tcon->ses->server->srv_mutex);
 526
 527         return ret;
 528 }
 529
 530 static int cifs_swn_client_move(struct cifs_swn_reg *swnreg, struct sockaddr_storage *addr)
 531 {
 532         struct sockaddr_in *ipv4 = (struct sockaddr_in *)addr;
 533         struct sockaddr_in6 *ipv6 = (struct sockaddr_in6 *)addr;
 534
 535         if (addr->ss_family == AF_INET)
 536                 cifs_dbg(FYI, "%s: move to %pI4\n", __func__, &ipv4->sin_addr);
 537         else if (addr->ss_family == AF_INET6)
 538                 cifs_dbg(FYI, "%s: move to %pI6\n", __func__, &ipv6->sin6_addr);
 539
 540         return cifs_swn_reconnect(swnreg->tcon, addr);
 541 }
 542
 543 int cifs_swn_notify(struct sk_buff *skb, struct genl_info *info)
 544 {
 545         struct cifs_swn_reg *swnreg;
 546         char name[256];
 547         int type;
 548
 549         if (info->attrs[CIFS_GENL_ATTR_SWN_REGISTRATION_ID]) {
 550                 int swnreg_id;
 551
 552                 swnreg_id = nla_get_u32(info->attrs[CIFS_GENL_ATTR_SWN_REGISTRATION_ID]);
 553                 mutex_lock(&cifs_swnreg_idr_mutex);
 554                 swnreg = idr_find(&cifs_swnreg_idr, swnreg_id);
 555                 mutex_unlock(&cifs_swnreg_idr_mutex);
 556                 if (swnreg == NULL) {
 557                         cifs_dbg(FYI, "%s: registration id %d not found\n", __func__, swnreg_id);
 558                         return -EINVAL;
 559                 }
 560         } else {
 561                 cifs_dbg(FYI, "%s: missing registration id attribute\n", __func__);
 562                 return -EINVAL;
 563         }
 564
 565         if (info->attrs[CIFS_GENL_ATTR_SWN_NOTIFICATION_TYPE]) {
 566                 type = nla_get_u32(info->attrs[CIFS_GENL_ATTR_SWN_NOTIFICATION_TYPE]);
 567         } else {
 568                 cifs_dbg(FYI, "%s: missing notification type attribute\n", __func__);
 569                 return -EINVAL;
 570         }
 571
 572         switch (type) {
 573         case CIFS_SWN_NOTIFICATION_RESOURCE_CHANGE: {
 574                 int state;
 575
 576                 if (info->attrs[CIFS_GENL_ATTR_SWN_RESOURCE_NAME]) {
 577                         nla_strscpy(name, info->attrs[CIFS_GENL_ATTR_SWN_RESOURCE_NAME],
 578                                         sizeof(name));
 579                 } else {
 580                         cifs_dbg(FYI, "%s: missing resource name attribute\n", __func__);
 581                         return -EINVAL;
 582                 }
 583                 if (info->attrs[CIFS_GENL_ATTR_SWN_RESOURCE_STATE]) {
 584                         state = nla_get_u32(info->attrs[CIFS_GENL_ATTR_SWN_RESOURCE_STATE]);
 585                 } else {
 586                         cifs_dbg(FYI, "%s: missing resource state attribute\n", __func__);
 587                         return -EINVAL;
 588                 }
 589                 return cifs_swn_resource_state_changed(swnreg, name, state);
 590         }
 591         case CIFS_SWN_NOTIFICATION_CLIENT_MOVE: {
 592                 struct sockaddr_storage addr;
 593
 594                 if (info->attrs[CIFS_GENL_ATTR_SWN_IP]) {
 595                         nla_memcpy(&addr, info->attrs[CIFS_GENL_ATTR_SWN_IP], sizeof(addr));
 596                 } else {
 597                         cifs_dbg(FYI, "%s: missing IP address attribute\n", __func__);
 598                         return -EINVAL;
 599                 }
 600                 return cifs_swn_client_move(swnreg, &addr);
 601         }
 602         default:
 603                 cifs_dbg(FYI, "%s: unknown notification type %d\n", __func__, type);
 604                 break;
 605         }
 606
 607         return 0;
 608 }
 609
 610 int cifs_swn_register(struct cifs_tcon *tcon)
 611 {
 612         struct cifs_swn_reg *swnreg;
 613         int ret;
 614
 615         swnreg = cifs_get_swn_reg(tcon);
 616         if (IS_ERR(swnreg))
 617                 return PTR_ERR(swnreg);
 618
 619         ret = cifs_swn_send_register_message(swnreg);
 620         if (ret < 0) {
 621                 cifs_dbg(VFS, "%s: Failed to send swn register message: %d\n", __func__, ret);
 622                 /* Do not put the swnreg or return error, the echo task will retry */
 623         }
 624
 625         return 0;
 626 }
 627
 628 int cifs_swn_unregister(struct cifs_tcon *tcon)
 629 {
 630         struct cifs_swn_reg *swnreg;
 631
 632         mutex_lock(&cifs_swnreg_idr_mutex);
 633
 634         swnreg = cifs_find_swn_reg(tcon);
 635         if (IS_ERR(swnreg)) {
 636                 mutex_unlock(&cifs_swnreg_idr_mutex);
 637                 return PTR_ERR(swnreg);
 638         }
 639
 640         mutex_unlock(&cifs_swnreg_idr_mutex);
 641
 642         cifs_put_swn_reg(swnreg);
 643
 644         return 0;
 645 }
 646
 647 void cifs_swn_dump(struct seq_file *m)
 648 {
 649         struct cifs_swn_reg *swnreg;
 650         struct sockaddr_in *sa;
 651         struct sockaddr_in6 *sa6;
 652         int id;
 653
 654         seq_puts(m, "Witness registrations:");
 655
 656         mutex_lock(&cifs_swnreg_idr_mutex);
 657         idr_for_each_entry(&cifs_swnreg_idr, swnreg, id) {
 658                 seq_printf(m, "\nId: %u Refs: %u Network name: '%s'%s Share name: '%s'%s Ip address: ",
 659                                 id, kref_read(&swnreg->ref_count),
 660                                 swnreg->net_name, swnreg->net_name_notify ? "(y)" : "(n)",
 661                                 swnreg->share_name, swnreg->share_name_notify ? "(y)" : "(n)");
 662                 switch (swnreg->tcon->ses->server->dstaddr.ss_family) {
 663                 case AF_INET:
 664                         sa = (struct sockaddr_in *) &swnreg->tcon->ses->server->dstaddr;
 665                         seq_printf(m, "%pI4", &sa->sin_addr.s_addr);
 666                         break;
 667                 case AF_INET6:
 668                         sa6 = (struct sockaddr_in6 *) &swnreg->tcon->ses->server->dstaddr;
 669                         seq_printf(m, "%pI6", &sa6->sin6_addr.s6_addr);
 670                         if (sa6->sin6_scope_id)
 671                                 seq_printf(m, "%%%u", sa6->sin6_scope_id);
 672                         break;
 673                 default:
 674                         seq_puts(m, "(unknown)");
 675                 }
 676                 seq_printf(m, "%s", swnreg->ip_notify ? "(y)" : "(n)");
 677         }
 678         mutex_unlock(&cifs_swnreg_idr_mutex);
 679         seq_puts(m, "\n");
 680 }
 681
 682 void cifs_swn_check(void)
 683 {
 684         struct cifs_swn_reg *swnreg;
 685         int id;
 686         int ret;
 687
 688         mutex_lock(&cifs_swnreg_idr_mutex);
 689         idr_for_each_entry(&cifs_swnreg_idr, swnreg, id) {
 690                 ret = cifs_swn_send_register_message(swnreg);
 691                 if (ret < 0)
 692                         cifs_dbg(FYI, "%s: Failed to send register message: %d\n", __func__, ret);
 693         }
 694         mutex_unlock(&cifs_swnreg_idr_mutex);
 695 }