1 // SPDX-License-Identifier: GPL-2.0
3 * Copyright (c) 2020 Anna Schumaker <Anna.Schumaker@Netapp.com>
5 #include <linux/sunrpc/clnt.h>
6 #include <linux/kobject.h>
7 #include <linux/sunrpc/addr.h>
8 #include <linux/sunrpc/xprtsock.h>
17 static void free_xprt_addr(struct rcu_head *head)
19 struct xprt_addr *addr = container_of(head, struct xprt_addr, rcu);
25 static struct kset *rpc_sunrpc_kset;
26 static struct kobject *rpc_sunrpc_client_kobj, *rpc_sunrpc_xprt_switch_kobj;
28 static void rpc_sysfs_object_release(struct kobject *kobj)
33 static const struct kobj_ns_type_operations *
34 rpc_sysfs_object_child_ns_type(struct kobject *kobj)
36 return &net_ns_type_operations;
39 static struct kobj_type rpc_sysfs_object_type = {
40 .release = rpc_sysfs_object_release,
41 .sysfs_ops = &kobj_sysfs_ops,
42 .child_ns_type = rpc_sysfs_object_child_ns_type,
45 static struct kobject *rpc_sysfs_object_alloc(const char *name,
47 struct kobject *parent)
51 kobj = kzalloc(sizeof(*kobj), GFP_KERNEL);
54 if (kobject_init_and_add(kobj, &rpc_sysfs_object_type,
55 parent, "%s", name) == 0)
62 static inline struct rpc_xprt *
63 rpc_sysfs_xprt_kobj_get_xprt(struct kobject *kobj)
65 struct rpc_sysfs_xprt *x = container_of(kobj,
66 struct rpc_sysfs_xprt, kobject);
68 return xprt_get(x->xprt);
71 static inline struct rpc_xprt_switch *
72 rpc_sysfs_xprt_kobj_get_xprt_switch(struct kobject *kobj)
74 struct rpc_sysfs_xprt *x = container_of(kobj,
75 struct rpc_sysfs_xprt, kobject);
77 return xprt_switch_get(x->xprt_switch);
80 static inline struct rpc_xprt_switch *
81 rpc_sysfs_xprt_switch_kobj_get_xprt(struct kobject *kobj)
83 struct rpc_sysfs_xprt_switch *x = container_of(kobj,
84 struct rpc_sysfs_xprt_switch, kobject);
86 return xprt_switch_get(x->xprt_switch);
89 static ssize_t rpc_sysfs_xprt_dstaddr_show(struct kobject *kobj,
90 struct kobj_attribute *attr,
93 struct rpc_xprt *xprt = rpc_sysfs_xprt_kobj_get_xprt(kobj);
98 ret = sprintf(buf, "%s\n", xprt->address_strings[RPC_DISPLAY_ADDR]);
103 static ssize_t rpc_sysfs_xprt_info_show(struct kobject *kobj,
104 struct kobj_attribute *attr,
107 struct rpc_xprt *xprt = rpc_sysfs_xprt_kobj_get_xprt(kobj);
113 ret = sprintf(buf, "last_used=%lu\ncur_cong=%lu\ncong_win=%lu\n"
114 "max_num_slots=%u\nmin_num_slots=%u\nnum_reqs=%u\n"
115 "binding_q_len=%u\nsending_q_len=%u\npending_q_len=%u\n"
116 "backlog_q_len=%u\nmain_xprt=%d\nsrc_port=%u\n"
117 "tasks_queuelen=%ld\n",
118 xprt->last_used, xprt->cong, xprt->cwnd, xprt->max_reqs,
119 xprt->min_reqs, xprt->num_reqs, xprt->binding.qlen,
120 xprt->sending.qlen, xprt->pending.qlen,
121 xprt->backlog.qlen, xprt->main,
122 (xprt->xprt_class->ident == XPRT_TRANSPORT_TCP) ?
123 get_srcport(xprt) : 0,
124 atomic_long_read(&xprt->queuelen));
129 static ssize_t rpc_sysfs_xprt_state_show(struct kobject *kobj,
130 struct kobj_attribute *attr,
133 struct rpc_xprt *xprt = rpc_sysfs_xprt_kobj_get_xprt(kobj);
135 int locked, connected, connecting, close_wait, bound, binding,
136 closing, congested, cwnd_wait, write_space, offline;
142 ret = sprintf(buf, "state=CLOSED\n");
144 locked = test_bit(XPRT_LOCKED, &xprt->state);
145 connected = test_bit(XPRT_CONNECTED, &xprt->state);
146 connecting = test_bit(XPRT_CONNECTING, &xprt->state);
147 close_wait = test_bit(XPRT_CLOSE_WAIT, &xprt->state);
148 bound = test_bit(XPRT_BOUND, &xprt->state);
149 binding = test_bit(XPRT_BINDING, &xprt->state);
150 closing = test_bit(XPRT_CLOSING, &xprt->state);
151 congested = test_bit(XPRT_CONGESTED, &xprt->state);
152 cwnd_wait = test_bit(XPRT_CWND_WAIT, &xprt->state);
153 write_space = test_bit(XPRT_WRITE_SPACE, &xprt->state);
154 offline = test_bit(XPRT_OFFLINE, &xprt->state);
156 ret = sprintf(buf, "state=%s %s %s %s %s %s %s %s %s %s %s\n",
157 locked ? "LOCKED" : "",
158 connected ? "CONNECTED" : "",
159 connecting ? "CONNECTING" : "",
160 close_wait ? "CLOSE_WAIT" : "",
161 bound ? "BOUND" : "",
162 binding ? "BOUNDING" : "",
163 closing ? "CLOSING" : "",
164 congested ? "CONGESTED" : "",
165 cwnd_wait ? "CWND_WAIT" : "",
166 write_space ? "WRITE_SPACE" : "",
167 offline ? "OFFLINE" : "");
174 static ssize_t rpc_sysfs_xprt_switch_info_show(struct kobject *kobj,
175 struct kobj_attribute *attr,
178 struct rpc_xprt_switch *xprt_switch =
179 rpc_sysfs_xprt_switch_kobj_get_xprt(kobj);
184 ret = sprintf(buf, "num_xprts=%u\nnum_active=%u\nqueue_len=%ld\n",
185 xprt_switch->xps_nxprts, xprt_switch->xps_nactive,
186 atomic_long_read(&xprt_switch->xps_queuelen));
187 xprt_switch_put(xprt_switch);
191 static ssize_t rpc_sysfs_xprt_dstaddr_store(struct kobject *kobj,
192 struct kobj_attribute *attr,
193 const char *buf, size_t count)
195 struct rpc_xprt *xprt = rpc_sysfs_xprt_kobj_get_xprt(kobj);
196 struct sockaddr *saddr;
199 struct xprt_addr *saved_addr;
204 if (!(xprt->xprt_class->ident == XPRT_TRANSPORT_TCP ||
205 xprt->xprt_class->ident == XPRT_TRANSPORT_RDMA)) {
210 if (wait_on_bit_lock(&xprt->state, XPRT_LOCKED, TASK_KILLABLE)) {
214 saddr = (struct sockaddr *)&xprt->addr;
215 port = rpc_get_port(saddr);
217 /* buf_len is the len until the first occurence of either
220 buf_len = strcspn(buf, "\n");
222 dst_addr = kstrndup(buf, buf_len, GFP_KERNEL);
225 saved_addr = kzalloc(sizeof(*saved_addr), GFP_KERNEL);
229 rcu_dereference_raw(xprt->address_strings[RPC_DISPLAY_ADDR]);
230 rcu_assign_pointer(xprt->address_strings[RPC_DISPLAY_ADDR], dst_addr);
231 call_rcu(&saved_addr->rcu, free_xprt_addr);
232 xprt->addrlen = rpc_pton(xprt->xprt_net, buf, buf_len, saddr,
234 rpc_set_port(saddr, port);
236 xprt_force_disconnect(xprt);
238 xprt_release_write(xprt, NULL);
249 static ssize_t rpc_sysfs_xprt_state_change(struct kobject *kobj,
250 struct kobj_attribute *attr,
251 const char *buf, size_t count)
253 struct rpc_xprt *xprt = rpc_sysfs_xprt_kobj_get_xprt(kobj);
254 int offline = 0, online = 0;
255 struct rpc_xprt_switch *xps = rpc_sysfs_xprt_kobj_get_xprt_switch(kobj);
260 if (!strncmp(buf, "offline", 7))
262 else if (!strncmp(buf, "online", 6))
267 if (wait_on_bit_lock(&xprt->state, XPRT_LOCKED, TASK_KILLABLE)) {
276 set_bit(XPRT_OFFLINE, &xprt->state);
277 spin_lock(&xps->xps_lock);
279 spin_unlock(&xps->xps_lock);
281 clear_bit(XPRT_OFFLINE, &xprt->state);
282 spin_lock(&xps->xps_lock);
284 spin_unlock(&xps->xps_lock);
288 xprt_release_write(xprt, NULL);
291 xprt_switch_put(xps);
295 int rpc_sysfs_init(void)
297 rpc_sunrpc_kset = kset_create_and_add("sunrpc", NULL, kernel_kobj);
298 if (!rpc_sunrpc_kset)
300 rpc_sunrpc_client_kobj =
301 rpc_sysfs_object_alloc("rpc-clients", rpc_sunrpc_kset, NULL);
302 if (!rpc_sunrpc_client_kobj)
304 rpc_sunrpc_xprt_switch_kobj =
305 rpc_sysfs_object_alloc("xprt-switches", rpc_sunrpc_kset, NULL);
306 if (!rpc_sunrpc_xprt_switch_kobj)
310 kobject_put(rpc_sunrpc_client_kobj);
311 rpc_sunrpc_client_kobj = NULL;
313 kset_unregister(rpc_sunrpc_kset);
314 rpc_sunrpc_kset = NULL;
318 static void rpc_sysfs_client_release(struct kobject *kobj)
320 struct rpc_sysfs_client *c;
322 c = container_of(kobj, struct rpc_sysfs_client, kobject);
326 static void rpc_sysfs_xprt_switch_release(struct kobject *kobj)
328 struct rpc_sysfs_xprt_switch *xprt_switch;
330 xprt_switch = container_of(kobj, struct rpc_sysfs_xprt_switch, kobject);
334 static void rpc_sysfs_xprt_release(struct kobject *kobj)
336 struct rpc_sysfs_xprt *xprt;
338 xprt = container_of(kobj, struct rpc_sysfs_xprt, kobject);
342 static const void *rpc_sysfs_client_namespace(struct kobject *kobj)
344 return container_of(kobj, struct rpc_sysfs_client, kobject)->net;
347 static const void *rpc_sysfs_xprt_switch_namespace(struct kobject *kobj)
349 return container_of(kobj, struct rpc_sysfs_xprt_switch, kobject)->net;
352 static const void *rpc_sysfs_xprt_namespace(struct kobject *kobj)
354 return container_of(kobj, struct rpc_sysfs_xprt,
355 kobject)->xprt->xprt_net;
358 static struct kobj_attribute rpc_sysfs_xprt_dstaddr = __ATTR(dstaddr,
359 0644, rpc_sysfs_xprt_dstaddr_show, rpc_sysfs_xprt_dstaddr_store);
361 static struct kobj_attribute rpc_sysfs_xprt_info = __ATTR(xprt_info,
362 0444, rpc_sysfs_xprt_info_show, NULL);
364 static struct kobj_attribute rpc_sysfs_xprt_change_state = __ATTR(xprt_state,
365 0644, rpc_sysfs_xprt_state_show, rpc_sysfs_xprt_state_change);
367 static struct attribute *rpc_sysfs_xprt_attrs[] = {
368 &rpc_sysfs_xprt_dstaddr.attr,
369 &rpc_sysfs_xprt_info.attr,
370 &rpc_sysfs_xprt_change_state.attr,
374 static struct kobj_attribute rpc_sysfs_xprt_switch_info =
375 __ATTR(xprt_switch_info, 0444, rpc_sysfs_xprt_switch_info_show, NULL);
377 static struct attribute *rpc_sysfs_xprt_switch_attrs[] = {
378 &rpc_sysfs_xprt_switch_info.attr,
382 static struct kobj_type rpc_sysfs_client_type = {
383 .release = rpc_sysfs_client_release,
384 .sysfs_ops = &kobj_sysfs_ops,
385 .namespace = rpc_sysfs_client_namespace,
388 static struct kobj_type rpc_sysfs_xprt_switch_type = {
389 .release = rpc_sysfs_xprt_switch_release,
390 .default_attrs = rpc_sysfs_xprt_switch_attrs,
391 .sysfs_ops = &kobj_sysfs_ops,
392 .namespace = rpc_sysfs_xprt_switch_namespace,
395 static struct kobj_type rpc_sysfs_xprt_type = {
396 .release = rpc_sysfs_xprt_release,
397 .default_attrs = rpc_sysfs_xprt_attrs,
398 .sysfs_ops = &kobj_sysfs_ops,
399 .namespace = rpc_sysfs_xprt_namespace,
402 void rpc_sysfs_exit(void)
404 kobject_put(rpc_sunrpc_client_kobj);
405 kobject_put(rpc_sunrpc_xprt_switch_kobj);
406 kset_unregister(rpc_sunrpc_kset);
409 static struct rpc_sysfs_client *rpc_sysfs_client_alloc(struct kobject *parent,
413 struct rpc_sysfs_client *p;
415 p = kzalloc(sizeof(*p), GFP_KERNEL);
418 p->kobject.kset = rpc_sunrpc_kset;
419 if (kobject_init_and_add(&p->kobject, &rpc_sysfs_client_type,
420 parent, "clnt-%d", clid) == 0)
422 kobject_put(&p->kobject);
427 static struct rpc_sysfs_xprt_switch *
428 rpc_sysfs_xprt_switch_alloc(struct kobject *parent,
429 struct rpc_xprt_switch *xprt_switch,
433 struct rpc_sysfs_xprt_switch *p;
435 p = kzalloc(sizeof(*p), gfp_flags);
438 p->kobject.kset = rpc_sunrpc_kset;
439 if (kobject_init_and_add(&p->kobject,
440 &rpc_sysfs_xprt_switch_type,
442 xprt_switch->xps_id) == 0)
444 kobject_put(&p->kobject);
449 static struct rpc_sysfs_xprt *rpc_sysfs_xprt_alloc(struct kobject *parent,
450 struct rpc_xprt *xprt,
453 struct rpc_sysfs_xprt *p;
455 p = kzalloc(sizeof(*p), gfp_flags);
458 p->kobject.kset = rpc_sunrpc_kset;
459 if (kobject_init_and_add(&p->kobject, &rpc_sysfs_xprt_type,
460 parent, "xprt-%d-%s", xprt->id,
461 xprt->address_strings[RPC_DISPLAY_PROTO]) == 0)
463 kobject_put(&p->kobject);
468 void rpc_sysfs_client_setup(struct rpc_clnt *clnt,
469 struct rpc_xprt_switch *xprt_switch,
472 struct rpc_sysfs_client *rpc_client;
474 rpc_client = rpc_sysfs_client_alloc(rpc_sunrpc_client_kobj,
477 char name[] = "switch";
478 struct rpc_sysfs_xprt_switch *xswitch =
479 (struct rpc_sysfs_xprt_switch *)xprt_switch->xps_sysfs;
482 clnt->cl_sysfs = rpc_client;
483 rpc_client->clnt = clnt;
484 rpc_client->xprt_switch = xprt_switch;
485 kobject_uevent(&rpc_client->kobject, KOBJ_ADD);
486 ret = sysfs_create_link_nowarn(&rpc_client->kobject,
487 &xswitch->kobject, name);
489 pr_warn("can't create link to %s in sysfs (%d)\n",
494 void rpc_sysfs_xprt_switch_setup(struct rpc_xprt_switch *xprt_switch,
495 struct rpc_xprt *xprt,
498 struct rpc_sysfs_xprt_switch *rpc_xprt_switch;
501 if (xprt_switch->xps_net)
502 net = xprt_switch->xps_net;
504 net = xprt->xprt_net;
506 rpc_sysfs_xprt_switch_alloc(rpc_sunrpc_xprt_switch_kobj,
507 xprt_switch, net, gfp_flags);
508 if (rpc_xprt_switch) {
509 xprt_switch->xps_sysfs = rpc_xprt_switch;
510 rpc_xprt_switch->xprt_switch = xprt_switch;
511 rpc_xprt_switch->xprt = xprt;
512 kobject_uevent(&rpc_xprt_switch->kobject, KOBJ_ADD);
516 void rpc_sysfs_xprt_setup(struct rpc_xprt_switch *xprt_switch,
517 struct rpc_xprt *xprt,
520 struct rpc_sysfs_xprt *rpc_xprt;
521 struct rpc_sysfs_xprt_switch *switch_obj =
522 (struct rpc_sysfs_xprt_switch *)xprt_switch->xps_sysfs;
524 rpc_xprt = rpc_sysfs_xprt_alloc(&switch_obj->kobject, xprt, gfp_flags);
526 xprt->xprt_sysfs = rpc_xprt;
527 rpc_xprt->xprt = xprt;
528 rpc_xprt->xprt_switch = xprt_switch;
529 kobject_uevent(&rpc_xprt->kobject, KOBJ_ADD);
533 void rpc_sysfs_client_destroy(struct rpc_clnt *clnt)
535 struct rpc_sysfs_client *rpc_client = clnt->cl_sysfs;
538 char name[] = "switch";
540 sysfs_remove_link(&rpc_client->kobject, name);
541 kobject_uevent(&rpc_client->kobject, KOBJ_REMOVE);
542 kobject_del(&rpc_client->kobject);
543 kobject_put(&rpc_client->kobject);
544 clnt->cl_sysfs = NULL;
548 void rpc_sysfs_xprt_switch_destroy(struct rpc_xprt_switch *xprt_switch)
550 struct rpc_sysfs_xprt_switch *rpc_xprt_switch = xprt_switch->xps_sysfs;
552 if (rpc_xprt_switch) {
553 kobject_uevent(&rpc_xprt_switch->kobject, KOBJ_REMOVE);
554 kobject_del(&rpc_xprt_switch->kobject);
555 kobject_put(&rpc_xprt_switch->kobject);
556 xprt_switch->xps_sysfs = NULL;
560 void rpc_sysfs_xprt_destroy(struct rpc_xprt *xprt)
562 struct rpc_sysfs_xprt *rpc_xprt = xprt->xprt_sysfs;
565 kobject_uevent(&rpc_xprt->kobject, KOBJ_REMOVE);
566 kobject_del(&rpc_xprt->kobject);
567 kobject_put(&rpc_xprt->kobject);
568 xprt->xprt_sysfs = NULL;