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                 mutex_unlock(&cifs_swnreg_idr_mutex);
 289
 290                 cifs_dbg(FYI, "Existing swn registration for %s:%s found\n", swnreg->net_name,
 291                                 swnreg->share_name);
 292
 293                 kfree(net_name);
 294                 kfree(share_name);
 295
 296                 return swnreg;
 297         }
 298
 299         kfree(net_name);
 300         kfree(share_name);
 301
 302         return ERR_PTR(-EEXIST);
 303 }
 304
 305 /*
 306  * Get a registration for the tcon's server and share name, allocating a new one if it does not
 307  * exists
 308  */
 309 static struct cifs_swn_reg *cifs_get_swn_reg(struct cifs_tcon *tcon)
 310 {
 311         struct cifs_swn_reg *reg = NULL;
 312         int ret;
 313
 314         mutex_lock(&cifs_swnreg_idr_mutex);
 315
 316         /* Check if we are already registered for this network and share names */
 317         reg = cifs_find_swn_reg(tcon);
 318         if (!IS_ERR(reg)) {
 319                 kref_get(&reg->ref_count);
 320                 mutex_unlock(&cifs_swnreg_idr_mutex);
 321                 return reg;
 322         } else if (PTR_ERR(reg) != -EEXIST) {
 323                 mutex_unlock(&cifs_swnreg_idr_mutex);
 324                 return reg;
 325         }
 326
 327         reg = kmalloc(sizeof(struct cifs_swn_reg), GFP_ATOMIC);
 328         if (reg == NULL) {
 329                 mutex_unlock(&cifs_swnreg_idr_mutex);
 330                 return ERR_PTR(-ENOMEM);
 331         }
 332
 333         kref_init(&reg->ref_count);
 334
 335         reg->id = idr_alloc(&cifs_swnreg_idr, reg, 1, 0, GFP_ATOMIC);
 336         if (reg->id < 0) {
 337                 cifs_dbg(FYI, "%s: failed to allocate registration id\n", __func__);
 338                 ret = reg->id;
 339                 goto fail;
 340         }
 341
 342         reg->net_name = extract_hostname(tcon->treeName);
 343         if (IS_ERR(reg->net_name)) {
 344                 ret = PTR_ERR(reg->net_name);
 345                 cifs_dbg(VFS, "%s: failed to extract host name from target: %d\n", __func__, ret);
 346                 goto fail_idr;
 347         }
 348
 349         reg->share_name = extract_sharename(tcon->treeName);
 350         if (IS_ERR(reg->share_name)) {
 351                 ret = PTR_ERR(reg->share_name);
 352                 cifs_dbg(VFS, "%s: failed to extract share name from target: %d\n", __func__, ret);
 353                 goto fail_net_name;
 354         }
 355
 356         reg->net_name_notify = true;
 357         reg->share_name_notify = true;
 358         reg->ip_notify = (tcon->capabilities & SMB2_SHARE_CAP_SCALEOUT);
 359
 360         reg->tcon = tcon;
 361
 362         mutex_unlock(&cifs_swnreg_idr_mutex);
 363
 364         return reg;
 365
 366 fail_net_name:
 367         kfree(reg->net_name);
 368 fail_idr:
 369         idr_remove(&cifs_swnreg_idr, reg->id);
 370 fail:
 371         kfree(reg);
 372         mutex_unlock(&cifs_swnreg_idr_mutex);
 373         return ERR_PTR(ret);
 374 }
 375
 376 static void cifs_swn_reg_release(struct kref *ref)
 377 {
 378         struct cifs_swn_reg *swnreg = container_of(ref, struct cifs_swn_reg, ref_count);
 379         int ret;
 380
 381         ret = cifs_swn_send_unregister_message(swnreg);
 382         if (ret < 0)
 383                 cifs_dbg(VFS, "%s: Failed to send unregister message: %d\n", __func__, ret);
 384
 385         idr_remove(&cifs_swnreg_idr, swnreg->id);
 386         kfree(swnreg->net_name);
 387         kfree(swnreg->share_name);
 388         kfree(swnreg);
 389 }
 390
 391 static void cifs_put_swn_reg(struct cifs_swn_reg *swnreg)
 392 {
 393         mutex_lock(&cifs_swnreg_idr_mutex);
 394         kref_put(&swnreg->ref_count, cifs_swn_reg_release);
 395         mutex_unlock(&cifs_swnreg_idr_mutex);
 396 }
 397
 398 static int cifs_swn_resource_state_changed(struct cifs_swn_reg *swnreg, const char *name, int state)
 399 {
 400         int i;
 401
 402         switch (state) {
 403         case CIFS_SWN_RESOURCE_STATE_UNAVAILABLE:
 404                 cifs_dbg(FYI, "%s: resource name '%s' become unavailable\n", __func__, name);
 405                 for (i = 0; i < swnreg->tcon->ses->chan_count; i++) {
 406                         spin_lock(&GlobalMid_Lock);
 407                         if (swnreg->tcon->ses->chans[i].server->tcpStatus != CifsExiting)
 408                                 swnreg->tcon->ses->chans[i].server->tcpStatus = CifsNeedReconnect;
 409                         spin_unlock(&GlobalMid_Lock);
 410                 }
 411                 break;
 412         case CIFS_SWN_RESOURCE_STATE_AVAILABLE:
 413                 cifs_dbg(FYI, "%s: resource name '%s' become available\n", __func__, name);
 414                 for (i = 0; i < swnreg->tcon->ses->chan_count; i++) {
 415                         spin_lock(&GlobalMid_Lock);
 416                         if (swnreg->tcon->ses->chans[i].server->tcpStatus != CifsExiting)
 417                                 swnreg->tcon->ses->chans[i].server->tcpStatus = CifsNeedReconnect;
 418                         spin_unlock(&GlobalMid_Lock);
 419                 }
 420                 break;
 421         case CIFS_SWN_RESOURCE_STATE_UNKNOWN:
 422                 cifs_dbg(FYI, "%s: resource name '%s' changed to unknown state\n", __func__, name);
 423                 break;
 424         }
 425         return 0;
 426 }
 427
 428 static bool cifs_sockaddr_equal(struct sockaddr_storage *addr1, struct sockaddr_storage *addr2)
 429 {
 430         if (addr1->ss_family != addr2->ss_family)
 431                 return false;
 432
 433         if (addr1->ss_family == AF_INET) {
 434                 return (memcmp(&((const struct sockaddr_in *)addr1)->sin_addr,
 435                                 &((const struct sockaddr_in *)addr2)->sin_addr,
 436                                 sizeof(struct in_addr)) == 0);
 437         }
 438
 439         if (addr1->ss_family == AF_INET6) {
 440                 return (memcmp(&((const struct sockaddr_in6 *)addr1)->sin6_addr,
 441                                 &((const struct sockaddr_in6 *)addr2)->sin6_addr,
 442                                 sizeof(struct in6_addr)) == 0);
 443         }
 444
 445         return false;
 446 }
 447
 448 static int cifs_swn_store_swn_addr(const struct sockaddr_storage *new,
 449                                    const struct sockaddr_storage *old,
 450                                    struct sockaddr_storage *dst)
 451 {
 452         __be16 port;
 453
 454         if (old->ss_family == AF_INET) {
 455                 struct sockaddr_in *ipv4 = (struct sockaddr_in *)old;
 456
 457                 port = ipv4->sin_port;
 458         }
 459
 460         if (old->ss_family == AF_INET6) {
 461                 struct sockaddr_in6 *ipv6 = (struct sockaddr_in6 *)old;
 462
 463                 port = ipv6->sin6_port;
 464         }
 465
 466         if (new->ss_family == AF_INET) {
 467                 struct sockaddr_in *ipv4 = (struct sockaddr_in *)new;
 468
 469                 ipv4->sin_port = port;
 470         }
 471
 472         if (new->ss_family == AF_INET6) {
 473                 struct sockaddr_in6 *ipv6 = (struct sockaddr_in6 *)new;
 474
 475                 ipv6->sin6_port = port;
 476         }
 477
 478         *dst = *new;
 479
 480         return 0;
 481 }
 482
 483 static int cifs_swn_reconnect(struct cifs_tcon *tcon, struct sockaddr_storage *addr)
 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                 int ret;
 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                         return ret;
 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                         return ret;
 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                         return ret;
 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         mutex_unlock(&tcon->ses->server->srv_mutex);
 525
 526         return 0;
 527 }
 528
 529 static int cifs_swn_client_move(struct cifs_swn_reg *swnreg, struct sockaddr_storage *addr)
 530 {
 531         struct sockaddr_in *ipv4 = (struct sockaddr_in *)addr;
 532         struct sockaddr_in6 *ipv6 = (struct sockaddr_in6 *)addr;
 533
 534         if (addr->ss_family == AF_INET)
 535                 cifs_dbg(FYI, "%s: move to %pI4\n", __func__, &ipv4->sin_addr);
 536         else if (addr->ss_family == AF_INET6)
 537                 cifs_dbg(FYI, "%s: move to %pI6\n", __func__, &ipv6->sin6_addr);
 538
 539         return cifs_swn_reconnect(swnreg->tcon, addr);
 540 }
 541
 542 int cifs_swn_notify(struct sk_buff *skb, struct genl_info *info)
 543 {
 544         struct cifs_swn_reg *swnreg;
 545         char name[256];
 546         int type;
 547
 548         if (info->attrs[CIFS_GENL_ATTR_SWN_REGISTRATION_ID]) {
 549                 int swnreg_id;
 550
 551                 swnreg_id = nla_get_u32(info->attrs[CIFS_GENL_ATTR_SWN_REGISTRATION_ID]);
 552                 mutex_lock(&cifs_swnreg_idr_mutex);
 553                 swnreg = idr_find(&cifs_swnreg_idr, swnreg_id);
 554                 mutex_unlock(&cifs_swnreg_idr_mutex);
 555                 if (swnreg == NULL) {
 556                         cifs_dbg(FYI, "%s: registration id %d not found\n", __func__, swnreg_id);
 557                         return -EINVAL;
 558                 }
 559         } else {
 560                 cifs_dbg(FYI, "%s: missing registration id attribute\n", __func__);
 561                 return -EINVAL;
 562         }
 563
 564         if (info->attrs[CIFS_GENL_ATTR_SWN_NOTIFICATION_TYPE]) {
 565                 type = nla_get_u32(info->attrs[CIFS_GENL_ATTR_SWN_NOTIFICATION_TYPE]);
 566         } else {
 567                 cifs_dbg(FYI, "%s: missing notification type attribute\n", __func__);
 568                 return -EINVAL;
 569         }
 570
 571         switch (type) {
 572         case CIFS_SWN_NOTIFICATION_RESOURCE_CHANGE: {
 573                 int state;
 574
 575                 if (info->attrs[CIFS_GENL_ATTR_SWN_RESOURCE_NAME]) {
 576                         nla_strscpy(name, info->attrs[CIFS_GENL_ATTR_SWN_RESOURCE_NAME],
 577                                         sizeof(name));
 578                 } else {
 579                         cifs_dbg(FYI, "%s: missing resource name attribute\n", __func__);
 580                         return -EINVAL;
 581                 }
 582                 if (info->attrs[CIFS_GENL_ATTR_SWN_RESOURCE_STATE]) {
 583                         state = nla_get_u32(info->attrs[CIFS_GENL_ATTR_SWN_RESOURCE_STATE]);
 584                 } else {
 585                         cifs_dbg(FYI, "%s: missing resource state attribute\n", __func__);
 586                         return -EINVAL;
 587                 }
 588                 return cifs_swn_resource_state_changed(swnreg, name, state);
 589         }
 590         case CIFS_SWN_NOTIFICATION_CLIENT_MOVE: {
 591                 struct sockaddr_storage addr;
 592
 593                 if (info->attrs[CIFS_GENL_ATTR_SWN_IP]) {
 594                         nla_memcpy(&addr, info->attrs[CIFS_GENL_ATTR_SWN_IP], sizeof(addr));
 595                 } else {
 596                         cifs_dbg(FYI, "%s: missing IP address attribute\n", __func__);
 597                         return -EINVAL;
 598                 }
 599                 return cifs_swn_client_move(swnreg, &addr);
 600         }
 601         default:
 602                 cifs_dbg(FYI, "%s: unknown notification type %d\n", __func__, type);
 603                 break;
 604         }
 605
 606         return 0;
 607 }
 608
 609 int cifs_swn_register(struct cifs_tcon *tcon)
 610 {
 611         struct cifs_swn_reg *swnreg;
 612         int ret;
 613
 614         swnreg = cifs_get_swn_reg(tcon);
 615         if (IS_ERR(swnreg))
 616                 return PTR_ERR(swnreg);
 617
 618         ret = cifs_swn_send_register_message(swnreg);
 619         if (ret < 0) {
 620                 cifs_dbg(VFS, "%s: Failed to send swn register message: %d\n", __func__, ret);
 621                 /* Do not put the swnreg or return error, the echo task will retry */
 622         }
 623
 624         return 0;
 625 }
 626
 627 int cifs_swn_unregister(struct cifs_tcon *tcon)
 628 {
 629         struct cifs_swn_reg *swnreg;
 630
 631         mutex_lock(&cifs_swnreg_idr_mutex);
 632
 633         swnreg = cifs_find_swn_reg(tcon);
 634         if (IS_ERR(swnreg)) {
 635                 mutex_unlock(&cifs_swnreg_idr_mutex);
 636                 return PTR_ERR(swnreg);
 637         }
 638
 639         mutex_unlock(&cifs_swnreg_idr_mutex);
 640
 641         cifs_put_swn_reg(swnreg);
 642
 643         return 0;
 644 }
 645
 646 void cifs_swn_dump(struct seq_file *m)
 647 {
 648         struct cifs_swn_reg *swnreg;
 649         struct sockaddr_in *sa;
 650         struct sockaddr_in6 *sa6;
 651         int id;
 652
 653         seq_puts(m, "Witness registrations:");
 654
 655         mutex_lock(&cifs_swnreg_idr_mutex);
 656         idr_for_each_entry(&cifs_swnreg_idr, swnreg, id) {
 657                 seq_printf(m, "\nId: %u Refs: %u Network name: '%s'%s Share name: '%s'%s Ip address: ",
 658                                 id, kref_read(&swnreg->ref_count),
 659                                 swnreg->net_name, swnreg->net_name_notify ? "(y)" : "(n)",
 660                                 swnreg->share_name, swnreg->share_name_notify ? "(y)" : "(n)");
 661                 switch (swnreg->tcon->ses->server->dstaddr.ss_family) {
 662                 case AF_INET:
 663                         sa = (struct sockaddr_in *) &swnreg->tcon->ses->server->dstaddr;
 664                         seq_printf(m, "%pI4", &sa->sin_addr.s_addr);
 665                         break;
 666                 case AF_INET6:
 667                         sa6 = (struct sockaddr_in6 *) &swnreg->tcon->ses->server->dstaddr;
 668                         seq_printf(m, "%pI6", &sa6->sin6_addr.s6_addr);
 669                         if (sa6->sin6_scope_id)
 670                                 seq_printf(m, "%%%u", sa6->sin6_scope_id);
 671                         break;
 672                 default:
 673                         seq_puts(m, "(unknown)");
 674                 }
 675                 seq_printf(m, "%s", swnreg->ip_notify ? "(y)" : "(n)");
 676         }
 677         mutex_unlock(&cifs_swnreg_idr_mutex);
 678         seq_puts(m, "\n");
 679 }
 680
 681 void cifs_swn_check(void)
 682 {
 683         struct cifs_swn_reg *swnreg;
 684         int id;
 685         int ret;
 686
 687         mutex_lock(&cifs_swnreg_idr_mutex);
 688         idr_for_each_entry(&cifs_swnreg_idr, swnreg, id) {
 689                 ret = cifs_swn_send_register_message(swnreg);
 690                 if (ret < 0)
 691                         cifs_dbg(FYI, "%s: Failed to send register message: %d\n", __func__, ret);
 692         }
 693         mutex_unlock(&cifs_swnreg_idr_mutex);
 694 }