1 // SPDX-License-Identifier: GPL-2.0
3 * Witness Service client for CIFS
5 * Copyright (c) 2020 Samuel Cabrero <scabrero@suse.de>
8 #include <linux/kref.h>
9 #include <net/genetlink.h>
10 #include <uapi/linux/cifs/cifs_netlink.h>
14 #include "cifsproto.h"
16 #include "cifs_debug.h"
19 static DEFINE_IDR(cifs_swnreg_idr);
20 static DEFINE_MUTEX(cifs_swnreg_idr_mutex);
24 struct kref ref_count;
27 const char *share_name;
29 bool share_name_notify;
32 struct cifs_tcon *tcon;
35 static int cifs_swn_auth_info_krb(struct cifs_tcon *tcon, struct sk_buff *skb)
39 ret = nla_put_flag(skb, CIFS_GENL_ATTR_SWN_KRB_AUTH);
46 static int cifs_swn_auth_info_ntlm(struct cifs_tcon *tcon, struct sk_buff *skb)
50 if (tcon->ses->user_name != NULL) {
51 ret = nla_put_string(skb, CIFS_GENL_ATTR_SWN_USER_NAME, tcon->ses->user_name);
56 if (tcon->ses->password != NULL) {
57 ret = nla_put_string(skb, CIFS_GENL_ATTR_SWN_PASSWORD, tcon->ses->password);
62 if (tcon->ses->domainName != NULL) {
63 ret = nla_put_string(skb, CIFS_GENL_ATTR_SWN_DOMAIN_NAME, tcon->ses->domainName);
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
76 static int cifs_swn_send_register_message(struct cifs_swn_reg *swnreg)
79 struct genlmsghdr *hdr;
80 enum securityEnum authtype;
83 skb = genlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
89 hdr = genlmsg_put(skb, 0, 0, &cifs_genl_family, 0, CIFS_GENL_CMD_SWN_REGISTER);
95 ret = nla_put_u32(skb, CIFS_GENL_ATTR_SWN_REGISTRATION_ID, swnreg->id);
99 ret = nla_put_string(skb, CIFS_GENL_ATTR_SWN_NET_NAME, swnreg->net_name);
103 ret = nla_put_string(skb, CIFS_GENL_ATTR_SWN_SHARE_NAME, swnreg->share_name);
107 ret = nla_put(skb, CIFS_GENL_ATTR_SWN_IP, sizeof(struct sockaddr_storage),
108 &swnreg->tcon->ses->server->dstaddr);
112 if (swnreg->net_name_notify) {
113 ret = nla_put_flag(skb, CIFS_GENL_ATTR_SWN_NET_NAME_NOTIFY);
118 if (swnreg->share_name_notify) {
119 ret = nla_put_flag(skb, CIFS_GENL_ATTR_SWN_SHARE_NAME_NOTIFY);
124 if (swnreg->ip_notify) {
125 ret = nla_put_flag(skb, CIFS_GENL_ATTR_SWN_IP_NOTIFY);
130 authtype = cifs_select_sectype(swnreg->tcon->ses->server, swnreg->tcon->ses->sectype);
133 ret = cifs_swn_auth_info_krb(swnreg->tcon, skb);
135 cifs_dbg(VFS, "%s: Failed to get kerberos auth info: %d\n", __func__, ret);
143 ret = cifs_swn_auth_info_ntlm(swnreg->tcon, skb);
145 cifs_dbg(VFS, "%s: Failed to get NTLM auth info: %d\n", __func__, ret);
150 cifs_dbg(VFS, "%s: secType %d not supported!\n", __func__, authtype);
155 genlmsg_end(skb, hdr);
156 genlmsg_multicast(&cifs_genl_family, skb, 0, CIFS_GENL_MCGRP_SWN, GFP_ATOMIC);
158 cifs_dbg(FYI, "%s: Message to register for network name %s with id %d sent\n", __func__,
159 swnreg->net_name, swnreg->id);
164 genlmsg_cancel(skb, hdr);
171 * Sends an uregister message to the userspace daemon based on the registration
173 static int cifs_swn_send_unregister_message(struct cifs_swn_reg *swnreg)
176 struct genlmsghdr *hdr;
179 skb = genlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
183 hdr = genlmsg_put(skb, 0, 0, &cifs_genl_family, 0, CIFS_GENL_CMD_SWN_UNREGISTER);
189 ret = nla_put_u32(skb, CIFS_GENL_ATTR_SWN_REGISTRATION_ID, swnreg->id);
193 ret = nla_put_string(skb, CIFS_GENL_ATTR_SWN_NET_NAME, swnreg->net_name);
197 ret = nla_put_string(skb, CIFS_GENL_ATTR_SWN_SHARE_NAME, swnreg->share_name);
201 ret = nla_put(skb, CIFS_GENL_ATTR_SWN_IP, sizeof(struct sockaddr_storage),
202 &swnreg->tcon->ses->server->dstaddr);
206 if (swnreg->net_name_notify) {
207 ret = nla_put_flag(skb, CIFS_GENL_ATTR_SWN_NET_NAME_NOTIFY);
212 if (swnreg->share_name_notify) {
213 ret = nla_put_flag(skb, CIFS_GENL_ATTR_SWN_SHARE_NAME_NOTIFY);
218 if (swnreg->ip_notify) {
219 ret = nla_put_flag(skb, CIFS_GENL_ATTR_SWN_IP_NOTIFY);
224 genlmsg_end(skb, hdr);
225 genlmsg_multicast(&cifs_genl_family, skb, 0, CIFS_GENL_MCGRP_SWN, GFP_ATOMIC);
227 cifs_dbg(FYI, "%s: Message to unregister for network name %s with id %d sent\n", __func__,
228 swnreg->net_name, swnreg->id);
233 genlmsg_cancel(skb, hdr);
239 * Try to find a matching registration for the tcon's server name and share name.
240 * Calls to this funciton must be protected by cifs_swnreg_idr_mutex.
241 * TODO Try to avoid memory allocations
243 static struct cifs_swn_reg *cifs_find_swn_reg(struct cifs_tcon *tcon)
245 struct cifs_swn_reg *swnreg;
247 const char *share_name;
248 const char *net_name;
250 net_name = extract_hostname(tcon->treeName);
251 if (IS_ERR_OR_NULL(net_name)) {
254 ret = PTR_ERR(net_name);
255 cifs_dbg(VFS, "%s: failed to extract host name from target '%s': %d\n",
256 __func__, tcon->treeName, ret);
260 share_name = extract_sharename(tcon->treeName);
261 if (IS_ERR_OR_NULL(share_name)) {
264 ret = PTR_ERR(net_name);
265 cifs_dbg(VFS, "%s: failed to extract share name from target '%s': %d\n",
266 __func__, tcon->treeName, ret);
271 idr_for_each_entry(&cifs_swnreg_idr, swnreg, id) {
272 if (strcasecmp(swnreg->net_name, net_name) != 0
273 || strcasecmp(swnreg->share_name, share_name) != 0) {
277 mutex_unlock(&cifs_swnreg_idr_mutex);
279 cifs_dbg(FYI, "Existing swn registration for %s:%s found\n", swnreg->net_name,
295 * Get a registration for the tcon's server and share name, allocating a new one if it does not
298 static struct cifs_swn_reg *cifs_get_swn_reg(struct cifs_tcon *tcon)
300 struct cifs_swn_reg *reg = NULL;
303 mutex_lock(&cifs_swnreg_idr_mutex);
305 /* Check if we are already registered for this network and share names */
306 reg = cifs_find_swn_reg(tcon);
309 } else if (reg != NULL) {
310 kref_get(®->ref_count);
311 mutex_unlock(&cifs_swnreg_idr_mutex);
315 reg = kmalloc(sizeof(struct cifs_swn_reg), GFP_ATOMIC);
317 mutex_unlock(&cifs_swnreg_idr_mutex);
318 return ERR_PTR(-ENOMEM);
321 kref_init(®->ref_count);
323 reg->id = idr_alloc(&cifs_swnreg_idr, reg, 1, 0, GFP_ATOMIC);
325 cifs_dbg(FYI, "%s: failed to allocate registration id\n", __func__);
330 reg->net_name = extract_hostname(tcon->treeName);
331 if (IS_ERR(reg->net_name)) {
332 ret = PTR_ERR(reg->net_name);
333 cifs_dbg(VFS, "%s: failed to extract host name from target: %d\n", __func__, ret);
337 reg->share_name = extract_sharename(tcon->treeName);
338 if (IS_ERR(reg->share_name)) {
339 ret = PTR_ERR(reg->share_name);
340 cifs_dbg(VFS, "%s: failed to extract share name from target: %d\n", __func__, ret);
344 reg->net_name_notify = true;
345 reg->share_name_notify = true;
346 reg->ip_notify = (tcon->capabilities & SMB2_SHARE_CAP_SCALEOUT);
350 mutex_unlock(&cifs_swnreg_idr_mutex);
355 kfree(reg->net_name);
357 idr_remove(&cifs_swnreg_idr, reg->id);
360 mutex_unlock(&cifs_swnreg_idr_mutex);
364 static void cifs_swn_reg_release(struct kref *ref)
366 struct cifs_swn_reg *swnreg = container_of(ref, struct cifs_swn_reg, ref_count);
369 ret = cifs_swn_send_unregister_message(swnreg);
371 cifs_dbg(VFS, "%s: Failed to send unregister message: %d\n", __func__, ret);
373 idr_remove(&cifs_swnreg_idr, swnreg->id);
374 kfree(swnreg->net_name);
375 kfree(swnreg->share_name);
379 static void cifs_put_swn_reg(struct cifs_swn_reg *swnreg)
381 mutex_lock(&cifs_swnreg_idr_mutex);
382 kref_put(&swnreg->ref_count, cifs_swn_reg_release);
383 mutex_unlock(&cifs_swnreg_idr_mutex);
386 static int cifs_swn_resource_state_changed(struct cifs_swn_reg *swnreg, const char *name, int state)
391 case CIFS_SWN_RESOURCE_STATE_UNAVAILABLE:
392 cifs_dbg(FYI, "%s: resource name '%s' become unavailable\n", __func__, name);
393 for (i = 0; i < swnreg->tcon->ses->chan_count; i++) {
394 spin_lock(&GlobalMid_Lock);
395 if (swnreg->tcon->ses->chans[i].server->tcpStatus != CifsExiting)
396 swnreg->tcon->ses->chans[i].server->tcpStatus = CifsNeedReconnect;
397 spin_unlock(&GlobalMid_Lock);
400 case CIFS_SWN_RESOURCE_STATE_AVAILABLE:
401 cifs_dbg(FYI, "%s: resource name '%s' become available\n", __func__, name);
402 for (i = 0; i < swnreg->tcon->ses->chan_count; i++) {
403 spin_lock(&GlobalMid_Lock);
404 if (swnreg->tcon->ses->chans[i].server->tcpStatus != CifsExiting)
405 swnreg->tcon->ses->chans[i].server->tcpStatus = CifsNeedReconnect;
406 spin_unlock(&GlobalMid_Lock);
409 case CIFS_SWN_RESOURCE_STATE_UNKNOWN:
410 cifs_dbg(FYI, "%s: resource name '%s' changed to unknown state\n", __func__, name);
416 int cifs_swn_notify(struct sk_buff *skb, struct genl_info *info)
418 struct cifs_swn_reg *swnreg;
422 if (info->attrs[CIFS_GENL_ATTR_SWN_REGISTRATION_ID]) {
425 swnreg_id = nla_get_u32(info->attrs[CIFS_GENL_ATTR_SWN_REGISTRATION_ID]);
426 mutex_lock(&cifs_swnreg_idr_mutex);
427 swnreg = idr_find(&cifs_swnreg_idr, swnreg_id);
428 mutex_unlock(&cifs_swnreg_idr_mutex);
429 if (swnreg == NULL) {
430 cifs_dbg(FYI, "%s: registration id %d not found\n", __func__, swnreg_id);
434 cifs_dbg(FYI, "%s: missing registration id attribute\n", __func__);
438 if (info->attrs[CIFS_GENL_ATTR_SWN_NOTIFICATION_TYPE]) {
439 type = nla_get_u32(info->attrs[CIFS_GENL_ATTR_SWN_NOTIFICATION_TYPE]);
441 cifs_dbg(FYI, "%s: missing notification type attribute\n", __func__);
446 case CIFS_SWN_NOTIFICATION_RESOURCE_CHANGE: {
449 if (info->attrs[CIFS_GENL_ATTR_SWN_RESOURCE_NAME]) {
450 nla_strlcpy(name, info->attrs[CIFS_GENL_ATTR_SWN_RESOURCE_NAME],
453 cifs_dbg(FYI, "%s: missing resource name attribute\n", __func__);
456 if (info->attrs[CIFS_GENL_ATTR_SWN_RESOURCE_STATE]) {
457 state = nla_get_u32(info->attrs[CIFS_GENL_ATTR_SWN_RESOURCE_STATE]);
459 cifs_dbg(FYI, "%s: missing resource state attribute\n", __func__);
462 return cifs_swn_resource_state_changed(swnreg, name, state);
465 cifs_dbg(FYI, "%s: unknown notification type %d\n", __func__, type);
472 int cifs_swn_register(struct cifs_tcon *tcon)
474 struct cifs_swn_reg *swnreg;
477 swnreg = cifs_get_swn_reg(tcon);
479 return PTR_ERR(swnreg);
481 ret = cifs_swn_send_register_message(swnreg);
483 cifs_dbg(VFS, "%s: Failed to send swn register message: %d\n", __func__, ret);
484 /* Do not put the swnreg or return error, the echo task will retry */
490 int cifs_swn_unregister(struct cifs_tcon *tcon)
492 struct cifs_swn_reg *swnreg;
494 mutex_lock(&cifs_swnreg_idr_mutex);
496 swnreg = cifs_find_swn_reg(tcon);
497 if (swnreg == NULL) {
498 mutex_unlock(&cifs_swnreg_idr_mutex);
502 mutex_unlock(&cifs_swnreg_idr_mutex);
504 cifs_put_swn_reg(swnreg);
509 void cifs_swn_dump(struct seq_file *m)
511 struct cifs_swn_reg *swnreg;
512 struct sockaddr_in *sa;
513 struct sockaddr_in6 *sa6;
516 seq_puts(m, "Witness registrations:");
518 mutex_lock(&cifs_swnreg_idr_mutex);
519 idr_for_each_entry(&cifs_swnreg_idr, swnreg, id) {
520 seq_printf(m, "\nId: %u Refs: %u Network name: '%s'%s Share name: '%s'%s Ip address: ",
521 id, kref_read(&swnreg->ref_count),
522 swnreg->net_name, swnreg->net_name_notify ? "(y)" : "(n)",
523 swnreg->share_name, swnreg->share_name_notify ? "(y)" : "(n)");
524 switch (swnreg->tcon->ses->server->dstaddr.ss_family) {
526 sa = (struct sockaddr_in *) &swnreg->tcon->ses->server->dstaddr;
527 seq_printf(m, "%pI4", &sa->sin_addr.s_addr);
530 sa6 = (struct sockaddr_in6 *) &swnreg->tcon->ses->server->dstaddr;
531 seq_printf(m, "%pI6", &sa6->sin6_addr.s6_addr);
532 if (sa6->sin6_scope_id)
533 seq_printf(m, "%%%u", sa6->sin6_scope_id);
536 seq_puts(m, "(unknown)");
538 seq_printf(m, "%s", swnreg->ip_notify ? "(y)" : "(n)");
540 mutex_unlock(&cifs_swnreg_idr_mutex);
544 void cifs_swn_check(void)
546 struct cifs_swn_reg *swnreg;
550 mutex_lock(&cifs_swnreg_idr_mutex);
551 idr_for_each_entry(&cifs_swnreg_idr, swnreg, id) {
552 ret = cifs_swn_send_register_message(swnreg);
554 cifs_dbg(FYI, "%s: Failed to send register message: %d\n", __func__, ret);
556 mutex_unlock(&cifs_swnreg_idr_mutex);