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 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 */
cifs_swn_send_unregister_message(struct cifs_swn_reg * swnreg)184 static int cifs_swn_send_unregister_message(struct cifs_swn_reg *swnreg)
185 {
186 struct sk_buff *skb;
187 struct genlmsghdr *hdr;
188 int ret;
189
190 skb = genlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
191 if (skb == NULL)
192 return -ENOMEM;
193
194 hdr = genlmsg_put(skb, 0, 0, &cifs_genl_family, 0, CIFS_GENL_CMD_SWN_UNREGISTER);
195 if (hdr == NULL) {
196 ret = -ENOMEM;
197 goto nlmsg_fail;
198 }
199
200 ret = nla_put_u32(skb, CIFS_GENL_ATTR_SWN_REGISTRATION_ID, swnreg->id);
201 if (ret < 0)
202 goto nlmsg_fail;
203
204 ret = nla_put_string(skb, CIFS_GENL_ATTR_SWN_NET_NAME, swnreg->net_name);
205 if (ret < 0)
206 goto nlmsg_fail;
207
208 ret = nla_put_string(skb, CIFS_GENL_ATTR_SWN_SHARE_NAME, swnreg->share_name);
209 if (ret < 0)
210 goto nlmsg_fail;
211
212 ret = nla_put(skb, CIFS_GENL_ATTR_SWN_IP, sizeof(struct sockaddr_storage),
213 &swnreg->tcon->ses->server->dstaddr);
214 if (ret < 0)
215 goto nlmsg_fail;
216
217 if (swnreg->net_name_notify) {
218 ret = nla_put_flag(skb, CIFS_GENL_ATTR_SWN_NET_NAME_NOTIFY);
219 if (ret < 0)
220 goto nlmsg_fail;
221 }
222
223 if (swnreg->share_name_notify) {
224 ret = nla_put_flag(skb, CIFS_GENL_ATTR_SWN_SHARE_NAME_NOTIFY);
225 if (ret < 0)
226 goto nlmsg_fail;
227 }
228
229 if (swnreg->ip_notify) {
230 ret = nla_put_flag(skb, CIFS_GENL_ATTR_SWN_IP_NOTIFY);
231 if (ret < 0)
232 goto nlmsg_fail;
233 }
234
235 genlmsg_end(skb, hdr);
236 genlmsg_multicast(&cifs_genl_family, skb, 0, CIFS_GENL_MCGRP_SWN, GFP_ATOMIC);
237
238 cifs_dbg(FYI, "%s: Message to unregister for network name %s with id %d sent\n", __func__,
239 swnreg->net_name, swnreg->id);
240
241 return 0;
242
243 nlmsg_fail:
244 genlmsg_cancel(skb, hdr);
245 nlmsg_free(skb);
246 return ret;
247 }
248
249 /*
250 * Try to find a matching registration for the tcon's server name and share name.
251 * Calls to this function must be protected by cifs_swnreg_idr_mutex.
252 * TODO Try to avoid memory allocations
253 */
cifs_find_swn_reg(struct cifs_tcon * tcon)254 static struct cifs_swn_reg *cifs_find_swn_reg(struct cifs_tcon *tcon)
255 {
256 struct cifs_swn_reg *swnreg;
257 int id;
258 const char *share_name;
259 const char *net_name;
260
261 net_name = extract_hostname(tcon->treeName);
262 if (IS_ERR(net_name)) {
263 int ret;
264
265 ret = PTR_ERR(net_name);
266 cifs_dbg(VFS, "%s: failed to extract host name from target '%s': %d\n",
267 __func__, tcon->treeName, ret);
268 return ERR_PTR(-EINVAL);
269 }
270
271 share_name = extract_sharename(tcon->treeName);
272 if (IS_ERR(share_name)) {
273 int ret;
274
275 ret = PTR_ERR(share_name);
276 cifs_dbg(VFS, "%s: failed to extract share name from target '%s': %d\n",
277 __func__, tcon->treeName, ret);
278 kfree(net_name);
279 return ERR_PTR(-EINVAL);
280 }
281
282 idr_for_each_entry(&cifs_swnreg_idr, swnreg, id) {
283 if (strcasecmp(swnreg->net_name, net_name) != 0
284 || strcasecmp(swnreg->share_name, share_name) != 0) {
285 continue;
286 }
287
288 cifs_dbg(FYI, "Existing swn registration for %s:%s found\n", swnreg->net_name,
289 swnreg->share_name);
290
291 kfree(net_name);
292 kfree(share_name);
293
294 return swnreg;
295 }
296
297 kfree(net_name);
298 kfree(share_name);
299
300 return ERR_PTR(-EEXIST);
301 }
302
303 /*
304 * Get a registration for the tcon's server and share name, allocating a new one if it does not
305 * exists
306 */
cifs_get_swn_reg(struct cifs_tcon * tcon)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(®->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(®->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
cifs_swn_reg_release(struct kref * ref)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
cifs_put_swn_reg(struct cifs_swn_reg * swnreg)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
cifs_swn_resource_state_changed(struct cifs_swn_reg * swnreg,const char * name,int state)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
cifs_sockaddr_equal(struct sockaddr_storage * addr1,struct sockaddr_storage * addr2)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
cifs_swn_store_swn_addr(const struct sockaddr_storage * new,const struct sockaddr_storage * old,struct sockaddr_storage * dst)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
cifs_swn_reconnect(struct cifs_tcon * tcon,struct sockaddr_storage * addr)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
cifs_swn_client_move(struct cifs_swn_reg * swnreg,struct sockaddr_storage * addr)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
cifs_swn_notify(struct sk_buff * skb,struct genl_info * info)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
cifs_swn_register(struct cifs_tcon * tcon)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
cifs_swn_unregister(struct cifs_tcon * tcon)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
cifs_swn_dump(struct seq_file * m)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
cifs_swn_check(void)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 }
696