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
cifs_swn_auth_info_krb(struct cifs_tcon * tcon,struct sk_buff * skb)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
cifs_swn_auth_info_ntlm(struct cifs_tcon * tcon,struct sk_buff * skb)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 */
cifs_swn_send_register_message(struct cifs_swn_reg * swnreg)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 */
cifs_swn_send_unregister_message(struct cifs_swn_reg * swnreg)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 */
cifs_find_swn_reg(struct cifs_tcon * tcon)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->treeName);
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->treeName, ret);
266 return ERR_PTR(-EINVAL);
267 }
268
269 share_name = extract_sharename(tcon->treeName);
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->treeName, 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 */
cifs_get_swn_reg(struct cifs_tcon * tcon)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->treeName);
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->treeName);
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
cifs_swn_reg_release(struct kref * ref)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
cifs_put_swn_reg(struct cifs_swn_reg * swnreg)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
cifs_swn_resource_state_changed(struct cifs_swn_reg * swnreg,const char * name,int state)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_ses_mark_for_reconnect(swnreg->tcon->ses);
400 break;
401 case CIFS_SWN_RESOURCE_STATE_AVAILABLE:
402 cifs_dbg(FYI, "%s: resource name '%s' become available\n", __func__, name);
403 cifs_ses_mark_for_reconnect(swnreg->tcon->ses);
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
cifs_sockaddr_equal(struct sockaddr_storage * addr1,struct sockaddr_storage * addr2)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
cifs_swn_store_swn_addr(const struct sockaddr_storage * new,const struct sockaddr_storage * old,struct sockaddr_storage * dst)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
cifs_swn_reconnect(struct cifs_tcon * tcon,struct sockaddr_storage * addr)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 mutex_lock(&tcon->ses->server->srv_mutex);
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 spin_lock(&GlobalMid_Lock);
502 if (tcon->ses->server->tcpStatus != CifsExiting)
503 tcon->ses->server->tcpStatus = CifsNeedReconnect;
504 spin_unlock(&GlobalMid_Lock);
505
506 unlock:
507 mutex_unlock(&tcon->ses->server->srv_mutex);
508
509 return ret;
510 }
511
cifs_swn_client_move(struct cifs_swn_reg * swnreg,struct sockaddr_storage * addr)512 static int cifs_swn_client_move(struct cifs_swn_reg *swnreg, struct sockaddr_storage *addr)
513 {
514 struct sockaddr_in *ipv4 = (struct sockaddr_in *)addr;
515 struct sockaddr_in6 *ipv6 = (struct sockaddr_in6 *)addr;
516
517 if (addr->ss_family == AF_INET)
518 cifs_dbg(FYI, "%s: move to %pI4\n", __func__, &ipv4->sin_addr);
519 else if (addr->ss_family == AF_INET6)
520 cifs_dbg(FYI, "%s: move to %pI6\n", __func__, &ipv6->sin6_addr);
521
522 return cifs_swn_reconnect(swnreg->tcon, addr);
523 }
524
cifs_swn_notify(struct sk_buff * skb,struct genl_info * info)525 int cifs_swn_notify(struct sk_buff *skb, struct genl_info *info)
526 {
527 struct cifs_swn_reg *swnreg;
528 char name[256];
529 int type;
530
531 if (info->attrs[CIFS_GENL_ATTR_SWN_REGISTRATION_ID]) {
532 int swnreg_id;
533
534 swnreg_id = nla_get_u32(info->attrs[CIFS_GENL_ATTR_SWN_REGISTRATION_ID]);
535 mutex_lock(&cifs_swnreg_idr_mutex);
536 swnreg = idr_find(&cifs_swnreg_idr, swnreg_id);
537 mutex_unlock(&cifs_swnreg_idr_mutex);
538 if (swnreg == NULL) {
539 cifs_dbg(FYI, "%s: registration id %d not found\n", __func__, swnreg_id);
540 return -EINVAL;
541 }
542 } else {
543 cifs_dbg(FYI, "%s: missing registration id attribute\n", __func__);
544 return -EINVAL;
545 }
546
547 if (info->attrs[CIFS_GENL_ATTR_SWN_NOTIFICATION_TYPE]) {
548 type = nla_get_u32(info->attrs[CIFS_GENL_ATTR_SWN_NOTIFICATION_TYPE]);
549 } else {
550 cifs_dbg(FYI, "%s: missing notification type attribute\n", __func__);
551 return -EINVAL;
552 }
553
554 switch (type) {
555 case CIFS_SWN_NOTIFICATION_RESOURCE_CHANGE: {
556 int state;
557
558 if (info->attrs[CIFS_GENL_ATTR_SWN_RESOURCE_NAME]) {
559 nla_strscpy(name, info->attrs[CIFS_GENL_ATTR_SWN_RESOURCE_NAME],
560 sizeof(name));
561 } else {
562 cifs_dbg(FYI, "%s: missing resource name attribute\n", __func__);
563 return -EINVAL;
564 }
565 if (info->attrs[CIFS_GENL_ATTR_SWN_RESOURCE_STATE]) {
566 state = nla_get_u32(info->attrs[CIFS_GENL_ATTR_SWN_RESOURCE_STATE]);
567 } else {
568 cifs_dbg(FYI, "%s: missing resource state attribute\n", __func__);
569 return -EINVAL;
570 }
571 return cifs_swn_resource_state_changed(swnreg, name, state);
572 }
573 case CIFS_SWN_NOTIFICATION_CLIENT_MOVE: {
574 struct sockaddr_storage addr;
575
576 if (info->attrs[CIFS_GENL_ATTR_SWN_IP]) {
577 nla_memcpy(&addr, info->attrs[CIFS_GENL_ATTR_SWN_IP], sizeof(addr));
578 } else {
579 cifs_dbg(FYI, "%s: missing IP address attribute\n", __func__);
580 return -EINVAL;
581 }
582 return cifs_swn_client_move(swnreg, &addr);
583 }
584 default:
585 cifs_dbg(FYI, "%s: unknown notification type %d\n", __func__, type);
586 break;
587 }
588
589 return 0;
590 }
591
cifs_swn_register(struct cifs_tcon * tcon)592 int cifs_swn_register(struct cifs_tcon *tcon)
593 {
594 struct cifs_swn_reg *swnreg;
595 int ret;
596
597 swnreg = cifs_get_swn_reg(tcon);
598 if (IS_ERR(swnreg))
599 return PTR_ERR(swnreg);
600
601 ret = cifs_swn_send_register_message(swnreg);
602 if (ret < 0) {
603 cifs_dbg(VFS, "%s: Failed to send swn register message: %d\n", __func__, ret);
604 /* Do not put the swnreg or return error, the echo task will retry */
605 }
606
607 return 0;
608 }
609
cifs_swn_unregister(struct cifs_tcon * tcon)610 int cifs_swn_unregister(struct cifs_tcon *tcon)
611 {
612 struct cifs_swn_reg *swnreg;
613
614 mutex_lock(&cifs_swnreg_idr_mutex);
615
616 swnreg = cifs_find_swn_reg(tcon);
617 if (IS_ERR(swnreg)) {
618 mutex_unlock(&cifs_swnreg_idr_mutex);
619 return PTR_ERR(swnreg);
620 }
621
622 mutex_unlock(&cifs_swnreg_idr_mutex);
623
624 cifs_put_swn_reg(swnreg);
625
626 return 0;
627 }
628
cifs_swn_dump(struct seq_file * m)629 void cifs_swn_dump(struct seq_file *m)
630 {
631 struct cifs_swn_reg *swnreg;
632 struct sockaddr_in *sa;
633 struct sockaddr_in6 *sa6;
634 int id;
635
636 seq_puts(m, "Witness registrations:");
637
638 mutex_lock(&cifs_swnreg_idr_mutex);
639 idr_for_each_entry(&cifs_swnreg_idr, swnreg, id) {
640 seq_printf(m, "\nId: %u Refs: %u Network name: '%s'%s Share name: '%s'%s Ip address: ",
641 id, kref_read(&swnreg->ref_count),
642 swnreg->net_name, swnreg->net_name_notify ? "(y)" : "(n)",
643 swnreg->share_name, swnreg->share_name_notify ? "(y)" : "(n)");
644 switch (swnreg->tcon->ses->server->dstaddr.ss_family) {
645 case AF_INET:
646 sa = (struct sockaddr_in *) &swnreg->tcon->ses->server->dstaddr;
647 seq_printf(m, "%pI4", &sa->sin_addr.s_addr);
648 break;
649 case AF_INET6:
650 sa6 = (struct sockaddr_in6 *) &swnreg->tcon->ses->server->dstaddr;
651 seq_printf(m, "%pI6", &sa6->sin6_addr.s6_addr);
652 if (sa6->sin6_scope_id)
653 seq_printf(m, "%%%u", sa6->sin6_scope_id);
654 break;
655 default:
656 seq_puts(m, "(unknown)");
657 }
658 seq_printf(m, "%s", swnreg->ip_notify ? "(y)" : "(n)");
659 }
660 mutex_unlock(&cifs_swnreg_idr_mutex);
661 seq_puts(m, "\n");
662 }
663
cifs_swn_check(void)664 void cifs_swn_check(void)
665 {
666 struct cifs_swn_reg *swnreg;
667 int id;
668 int ret;
669
670 mutex_lock(&cifs_swnreg_idr_mutex);
671 idr_for_each_entry(&cifs_swnreg_idr, swnreg, id) {
672 ret = cifs_swn_send_register_message(swnreg);
673 if (ret < 0)
674 cifs_dbg(FYI, "%s: Failed to send register message: %d\n", __func__, ret);
675 }
676 mutex_unlock(&cifs_swnreg_idr_mutex);
677 }
678