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 NTLMv2: 151 case RawNTLMSSP: 152 ret = cifs_swn_auth_info_ntlm(swnreg->tcon, skb); 153 if (ret < 0) { 154 cifs_dbg(VFS, "%s: Failed to get NTLM auth info: %d\n", __func__, ret); 155 goto nlmsg_fail; 156 } 157 break; 158 default: 159 cifs_dbg(VFS, "%s: secType %d not supported!\n", __func__, authtype); 160 ret = -EINVAL; 161 goto nlmsg_fail; 162 } 163 164 genlmsg_end(skb, hdr); 165 genlmsg_multicast(&cifs_genl_family, skb, 0, CIFS_GENL_MCGRP_SWN, GFP_ATOMIC); 166 167 cifs_dbg(FYI, "%s: Message to register for network name %s with id %d sent\n", __func__, 168 swnreg->net_name, swnreg->id); 169 170 return 0; 171 172 nlmsg_fail: 173 genlmsg_cancel(skb, hdr); 174 nlmsg_free(skb); 175 fail: 176 return ret; 177 } 178 179 /* 180 * Sends an uregister message to the userspace daemon based on the registration 181 */ 182 static int cifs_swn_send_unregister_message(struct cifs_swn_reg *swnreg) 183 { 184 struct sk_buff *skb; 185 struct genlmsghdr *hdr; 186 int ret; 187 188 skb = genlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 189 if (skb == NULL) 190 return -ENOMEM; 191 192 hdr = genlmsg_put(skb, 0, 0, &cifs_genl_family, 0, CIFS_GENL_CMD_SWN_UNREGISTER); 193 if (hdr == NULL) { 194 ret = -ENOMEM; 195 goto nlmsg_fail; 196 } 197 198 ret = nla_put_u32(skb, CIFS_GENL_ATTR_SWN_REGISTRATION_ID, swnreg->id); 199 if (ret < 0) 200 goto nlmsg_fail; 201 202 ret = nla_put_string(skb, CIFS_GENL_ATTR_SWN_NET_NAME, swnreg->net_name); 203 if (ret < 0) 204 goto nlmsg_fail; 205 206 ret = nla_put_string(skb, CIFS_GENL_ATTR_SWN_SHARE_NAME, swnreg->share_name); 207 if (ret < 0) 208 goto nlmsg_fail; 209 210 ret = nla_put(skb, CIFS_GENL_ATTR_SWN_IP, sizeof(struct sockaddr_storage), 211 &swnreg->tcon->ses->server->dstaddr); 212 if (ret < 0) 213 goto nlmsg_fail; 214 215 if (swnreg->net_name_notify) { 216 ret = nla_put_flag(skb, CIFS_GENL_ATTR_SWN_NET_NAME_NOTIFY); 217 if (ret < 0) 218 goto nlmsg_fail; 219 } 220 221 if (swnreg->share_name_notify) { 222 ret = nla_put_flag(skb, CIFS_GENL_ATTR_SWN_SHARE_NAME_NOTIFY); 223 if (ret < 0) 224 goto nlmsg_fail; 225 } 226 227 if (swnreg->ip_notify) { 228 ret = nla_put_flag(skb, CIFS_GENL_ATTR_SWN_IP_NOTIFY); 229 if (ret < 0) 230 goto nlmsg_fail; 231 } 232 233 genlmsg_end(skb, hdr); 234 genlmsg_multicast(&cifs_genl_family, skb, 0, CIFS_GENL_MCGRP_SWN, GFP_ATOMIC); 235 236 cifs_dbg(FYI, "%s: Message to unregister for network name %s with id %d sent\n", __func__, 237 swnreg->net_name, swnreg->id); 238 239 return 0; 240 241 nlmsg_fail: 242 genlmsg_cancel(skb, hdr); 243 nlmsg_free(skb); 244 return ret; 245 } 246 247 /* 248 * Try to find a matching registration for the tcon's server name and share name. 249 * Calls to this function must be protected by cifs_swnreg_idr_mutex. 250 * TODO Try to avoid memory allocations 251 */ 252 static struct cifs_swn_reg *cifs_find_swn_reg(struct cifs_tcon *tcon) 253 { 254 struct cifs_swn_reg *swnreg; 255 int id; 256 const char *share_name; 257 const char *net_name; 258 259 net_name = extract_hostname(tcon->tree_name); 260 if (IS_ERR(net_name)) { 261 int ret; 262 263 ret = PTR_ERR(net_name); 264 cifs_dbg(VFS, "%s: failed to extract host name from target '%s': %d\n", 265 __func__, tcon->tree_name, ret); 266 return ERR_PTR(-EINVAL); 267 } 268 269 share_name = extract_sharename(tcon->tree_name); 270 if (IS_ERR(share_name)) { 271 int ret; 272 273 ret = PTR_ERR(share_name); 274 cifs_dbg(VFS, "%s: failed to extract share name from target '%s': %d\n", 275 __func__, tcon->tree_name, ret); 276 kfree(net_name); 277 return ERR_PTR(-EINVAL); 278 } 279 280 idr_for_each_entry(&cifs_swnreg_idr, swnreg, id) { 281 if (strcasecmp(swnreg->net_name, net_name) != 0 282 || strcasecmp(swnreg->share_name, share_name) != 0) { 283 continue; 284 } 285 286 cifs_dbg(FYI, "Existing swn registration for %s:%s found\n", swnreg->net_name, 287 swnreg->share_name); 288 289 kfree(net_name); 290 kfree(share_name); 291 292 return swnreg; 293 } 294 295 kfree(net_name); 296 kfree(share_name); 297 298 return ERR_PTR(-EEXIST); 299 } 300 301 /* 302 * Get a registration for the tcon's server and share name, allocating a new one if it does not 303 * exists 304 */ 305 static struct cifs_swn_reg *cifs_get_swn_reg(struct cifs_tcon *tcon) 306 { 307 struct cifs_swn_reg *reg = NULL; 308 int ret; 309 310 mutex_lock(&cifs_swnreg_idr_mutex); 311 312 /* Check if we are already registered for this network and share names */ 313 reg = cifs_find_swn_reg(tcon); 314 if (!IS_ERR(reg)) { 315 kref_get(®->ref_count); 316 mutex_unlock(&cifs_swnreg_idr_mutex); 317 return reg; 318 } else if (PTR_ERR(reg) != -EEXIST) { 319 mutex_unlock(&cifs_swnreg_idr_mutex); 320 return reg; 321 } 322 323 reg = kmalloc(sizeof(struct cifs_swn_reg), GFP_ATOMIC); 324 if (reg == NULL) { 325 mutex_unlock(&cifs_swnreg_idr_mutex); 326 return ERR_PTR(-ENOMEM); 327 } 328 329 kref_init(®->ref_count); 330 331 reg->id = idr_alloc(&cifs_swnreg_idr, reg, 1, 0, GFP_ATOMIC); 332 if (reg->id < 0) { 333 cifs_dbg(FYI, "%s: failed to allocate registration id\n", __func__); 334 ret = reg->id; 335 goto fail; 336 } 337 338 reg->net_name = extract_hostname(tcon->tree_name); 339 if (IS_ERR(reg->net_name)) { 340 ret = PTR_ERR(reg->net_name); 341 cifs_dbg(VFS, "%s: failed to extract host name from target: %d\n", __func__, ret); 342 goto fail_idr; 343 } 344 345 reg->share_name = extract_sharename(tcon->tree_name); 346 if (IS_ERR(reg->share_name)) { 347 ret = PTR_ERR(reg->share_name); 348 cifs_dbg(VFS, "%s: failed to extract share name from target: %d\n", __func__, ret); 349 goto fail_net_name; 350 } 351 352 reg->net_name_notify = true; 353 reg->share_name_notify = true; 354 reg->ip_notify = (tcon->capabilities & SMB2_SHARE_CAP_SCALEOUT); 355 356 reg->tcon = tcon; 357 358 mutex_unlock(&cifs_swnreg_idr_mutex); 359 360 return reg; 361 362 fail_net_name: 363 kfree(reg->net_name); 364 fail_idr: 365 idr_remove(&cifs_swnreg_idr, reg->id); 366 fail: 367 kfree(reg); 368 mutex_unlock(&cifs_swnreg_idr_mutex); 369 return ERR_PTR(ret); 370 } 371 372 static void cifs_swn_reg_release(struct kref *ref) 373 { 374 struct cifs_swn_reg *swnreg = container_of(ref, struct cifs_swn_reg, ref_count); 375 int ret; 376 377 ret = cifs_swn_send_unregister_message(swnreg); 378 if (ret < 0) 379 cifs_dbg(VFS, "%s: Failed to send unregister message: %d\n", __func__, ret); 380 381 idr_remove(&cifs_swnreg_idr, swnreg->id); 382 kfree(swnreg->net_name); 383 kfree(swnreg->share_name); 384 kfree(swnreg); 385 } 386 387 static void cifs_put_swn_reg(struct cifs_swn_reg *swnreg) 388 { 389 mutex_lock(&cifs_swnreg_idr_mutex); 390 kref_put(&swnreg->ref_count, cifs_swn_reg_release); 391 mutex_unlock(&cifs_swnreg_idr_mutex); 392 } 393 394 static int cifs_swn_resource_state_changed(struct cifs_swn_reg *swnreg, const char *name, int state) 395 { 396 switch (state) { 397 case CIFS_SWN_RESOURCE_STATE_UNAVAILABLE: 398 cifs_dbg(FYI, "%s: resource name '%s' become unavailable\n", __func__, name); 399 cifs_signal_cifsd_for_reconnect(swnreg->tcon->ses->server, true); 400 break; 401 case CIFS_SWN_RESOURCE_STATE_AVAILABLE: 402 cifs_dbg(FYI, "%s: resource name '%s' become available\n", __func__, name); 403 cifs_signal_cifsd_for_reconnect(swnreg->tcon->ses->server, true); 404 break; 405 case CIFS_SWN_RESOURCE_STATE_UNKNOWN: 406 cifs_dbg(FYI, "%s: resource name '%s' changed to unknown state\n", __func__, name); 407 break; 408 } 409 return 0; 410 } 411 412 static bool cifs_sockaddr_equal(struct sockaddr_storage *addr1, struct sockaddr_storage *addr2) 413 { 414 if (addr1->ss_family != addr2->ss_family) 415 return false; 416 417 if (addr1->ss_family == AF_INET) { 418 return (memcmp(&((const struct sockaddr_in *)addr1)->sin_addr, 419 &((const struct sockaddr_in *)addr2)->sin_addr, 420 sizeof(struct in_addr)) == 0); 421 } 422 423 if (addr1->ss_family == AF_INET6) { 424 return (memcmp(&((const struct sockaddr_in6 *)addr1)->sin6_addr, 425 &((const struct sockaddr_in6 *)addr2)->sin6_addr, 426 sizeof(struct in6_addr)) == 0); 427 } 428 429 return false; 430 } 431 432 static int cifs_swn_store_swn_addr(const struct sockaddr_storage *new, 433 const struct sockaddr_storage *old, 434 struct sockaddr_storage *dst) 435 { 436 __be16 port = cpu_to_be16(CIFS_PORT); 437 438 if (old->ss_family == AF_INET) { 439 struct sockaddr_in *ipv4 = (struct sockaddr_in *)old; 440 441 port = ipv4->sin_port; 442 } else if (old->ss_family == AF_INET6) { 443 struct sockaddr_in6 *ipv6 = (struct sockaddr_in6 *)old; 444 445 port = ipv6->sin6_port; 446 } 447 448 if (new->ss_family == AF_INET) { 449 struct sockaddr_in *ipv4 = (struct sockaddr_in *)new; 450 451 ipv4->sin_port = port; 452 } else if (new->ss_family == AF_INET6) { 453 struct sockaddr_in6 *ipv6 = (struct sockaddr_in6 *)new; 454 455 ipv6->sin6_port = port; 456 } 457 458 *dst = *new; 459 460 return 0; 461 } 462 463 static int cifs_swn_reconnect(struct cifs_tcon *tcon, struct sockaddr_storage *addr) 464 { 465 int ret = 0; 466 467 /* Store the reconnect address */ 468 cifs_server_lock(tcon->ses->server); 469 if (cifs_sockaddr_equal(&tcon->ses->server->dstaddr, addr)) 470 goto unlock; 471 472 ret = cifs_swn_store_swn_addr(addr, &tcon->ses->server->dstaddr, 473 &tcon->ses->server->swn_dstaddr); 474 if (ret < 0) { 475 cifs_dbg(VFS, "%s: failed to store address: %d\n", __func__, ret); 476 goto unlock; 477 } 478 tcon->ses->server->use_swn_dstaddr = true; 479 480 /* 481 * Unregister to stop receiving notifications for the old IP address. 482 */ 483 ret = cifs_swn_unregister(tcon); 484 if (ret < 0) { 485 cifs_dbg(VFS, "%s: Failed to unregister for witness notifications: %d\n", 486 __func__, ret); 487 goto unlock; 488 } 489 490 /* 491 * And register to receive notifications for the new IP address now that we have 492 * stored the new address. 493 */ 494 ret = cifs_swn_register(tcon); 495 if (ret < 0) { 496 cifs_dbg(VFS, "%s: Failed to register for witness notifications: %d\n", 497 __func__, ret); 498 goto unlock; 499 } 500 501 cifs_signal_cifsd_for_reconnect(tcon->ses->server, false); 502 503 unlock: 504 cifs_server_unlock(tcon->ses->server); 505 506 return ret; 507 } 508 509 static int cifs_swn_client_move(struct cifs_swn_reg *swnreg, struct sockaddr_storage *addr) 510 { 511 struct sockaddr_in *ipv4 = (struct sockaddr_in *)addr; 512 struct sockaddr_in6 *ipv6 = (struct sockaddr_in6 *)addr; 513 514 if (addr->ss_family == AF_INET) 515 cifs_dbg(FYI, "%s: move to %pI4\n", __func__, &ipv4->sin_addr); 516 else if (addr->ss_family == AF_INET6) 517 cifs_dbg(FYI, "%s: move to %pI6\n", __func__, &ipv6->sin6_addr); 518 519 return cifs_swn_reconnect(swnreg->tcon, addr); 520 } 521 522 int cifs_swn_notify(struct sk_buff *skb, struct genl_info *info) 523 { 524 struct cifs_swn_reg *swnreg; 525 char name[256]; 526 int type; 527 528 if (info->attrs[CIFS_GENL_ATTR_SWN_REGISTRATION_ID]) { 529 int swnreg_id; 530 531 swnreg_id = nla_get_u32(info->attrs[CIFS_GENL_ATTR_SWN_REGISTRATION_ID]); 532 mutex_lock(&cifs_swnreg_idr_mutex); 533 swnreg = idr_find(&cifs_swnreg_idr, swnreg_id); 534 mutex_unlock(&cifs_swnreg_idr_mutex); 535 if (swnreg == NULL) { 536 cifs_dbg(FYI, "%s: registration id %d not found\n", __func__, swnreg_id); 537 return -EINVAL; 538 } 539 } else { 540 cifs_dbg(FYI, "%s: missing registration id attribute\n", __func__); 541 return -EINVAL; 542 } 543 544 if (info->attrs[CIFS_GENL_ATTR_SWN_NOTIFICATION_TYPE]) { 545 type = nla_get_u32(info->attrs[CIFS_GENL_ATTR_SWN_NOTIFICATION_TYPE]); 546 } else { 547 cifs_dbg(FYI, "%s: missing notification type attribute\n", __func__); 548 return -EINVAL; 549 } 550 551 switch (type) { 552 case CIFS_SWN_NOTIFICATION_RESOURCE_CHANGE: { 553 int state; 554 555 if (info->attrs[CIFS_GENL_ATTR_SWN_RESOURCE_NAME]) { 556 nla_strscpy(name, info->attrs[CIFS_GENL_ATTR_SWN_RESOURCE_NAME], 557 sizeof(name)); 558 } else { 559 cifs_dbg(FYI, "%s: missing resource name attribute\n", __func__); 560 return -EINVAL; 561 } 562 if (info->attrs[CIFS_GENL_ATTR_SWN_RESOURCE_STATE]) { 563 state = nla_get_u32(info->attrs[CIFS_GENL_ATTR_SWN_RESOURCE_STATE]); 564 } else { 565 cifs_dbg(FYI, "%s: missing resource state attribute\n", __func__); 566 return -EINVAL; 567 } 568 return cifs_swn_resource_state_changed(swnreg, name, state); 569 } 570 case CIFS_SWN_NOTIFICATION_CLIENT_MOVE: { 571 struct sockaddr_storage addr; 572 573 if (info->attrs[CIFS_GENL_ATTR_SWN_IP]) { 574 nla_memcpy(&addr, info->attrs[CIFS_GENL_ATTR_SWN_IP], sizeof(addr)); 575 } else { 576 cifs_dbg(FYI, "%s: missing IP address attribute\n", __func__); 577 return -EINVAL; 578 } 579 return cifs_swn_client_move(swnreg, &addr); 580 } 581 default: 582 cifs_dbg(FYI, "%s: unknown notification type %d\n", __func__, type); 583 break; 584 } 585 586 return 0; 587 } 588 589 int cifs_swn_register(struct cifs_tcon *tcon) 590 { 591 struct cifs_swn_reg *swnreg; 592 int ret; 593 594 swnreg = cifs_get_swn_reg(tcon); 595 if (IS_ERR(swnreg)) 596 return PTR_ERR(swnreg); 597 598 ret = cifs_swn_send_register_message(swnreg); 599 if (ret < 0) { 600 cifs_dbg(VFS, "%s: Failed to send swn register message: %d\n", __func__, ret); 601 /* Do not put the swnreg or return error, the echo task will retry */ 602 } 603 604 return 0; 605 } 606 607 int cifs_swn_unregister(struct cifs_tcon *tcon) 608 { 609 struct cifs_swn_reg *swnreg; 610 611 mutex_lock(&cifs_swnreg_idr_mutex); 612 613 swnreg = cifs_find_swn_reg(tcon); 614 if (IS_ERR(swnreg)) { 615 mutex_unlock(&cifs_swnreg_idr_mutex); 616 return PTR_ERR(swnreg); 617 } 618 619 mutex_unlock(&cifs_swnreg_idr_mutex); 620 621 cifs_put_swn_reg(swnreg); 622 623 return 0; 624 } 625 626 void cifs_swn_dump(struct seq_file *m) 627 { 628 struct cifs_swn_reg *swnreg; 629 struct sockaddr_in *sa; 630 struct sockaddr_in6 *sa6; 631 int id; 632 633 seq_puts(m, "Witness registrations:"); 634 635 mutex_lock(&cifs_swnreg_idr_mutex); 636 idr_for_each_entry(&cifs_swnreg_idr, swnreg, id) { 637 seq_printf(m, "\nId: %u Refs: %u Network name: '%s'%s Share name: '%s'%s Ip address: ", 638 id, kref_read(&swnreg->ref_count), 639 swnreg->net_name, swnreg->net_name_notify ? "(y)" : "(n)", 640 swnreg->share_name, swnreg->share_name_notify ? "(y)" : "(n)"); 641 switch (swnreg->tcon->ses->server->dstaddr.ss_family) { 642 case AF_INET: 643 sa = (struct sockaddr_in *) &swnreg->tcon->ses->server->dstaddr; 644 seq_printf(m, "%pI4", &sa->sin_addr.s_addr); 645 break; 646 case AF_INET6: 647 sa6 = (struct sockaddr_in6 *) &swnreg->tcon->ses->server->dstaddr; 648 seq_printf(m, "%pI6", &sa6->sin6_addr.s6_addr); 649 if (sa6->sin6_scope_id) 650 seq_printf(m, "%%%u", sa6->sin6_scope_id); 651 break; 652 default: 653 seq_puts(m, "(unknown)"); 654 } 655 seq_printf(m, "%s", swnreg->ip_notify ? "(y)" : "(n)"); 656 } 657 mutex_unlock(&cifs_swnreg_idr_mutex); 658 seq_puts(m, "\n"); 659 } 660 661 void cifs_swn_check(void) 662 { 663 struct cifs_swn_reg *swnreg; 664 int id; 665 int ret; 666 667 mutex_lock(&cifs_swnreg_idr_mutex); 668 idr_for_each_entry(&cifs_swnreg_idr, swnreg, id) { 669 ret = cifs_swn_send_register_message(swnreg); 670 if (ret < 0) 671 cifs_dbg(FYI, "%s: Failed to send register message: %d\n", __func__, ret); 672 } 673 mutex_unlock(&cifs_swnreg_idr_mutex); 674 } 675