1
2
3
4
5#include <linux/sunrpc/clnt.h>
6#include <linux/kobject.h>
7#include <linux/sunrpc/addr.h>
8#include <linux/sunrpc/xprtsock.h>
9
10#include "sysfs.h"
11
12struct xprt_addr {
13 const char *addr;
14 struct rcu_head rcu;
15};
16
17static void free_xprt_addr(struct rcu_head *head)
18{
19 struct xprt_addr *addr = container_of(head, struct xprt_addr, rcu);
20
21 kfree(addr->addr);
22 kfree(addr);
23}
24
25static struct kset *rpc_sunrpc_kset;
26static struct kobject *rpc_sunrpc_client_kobj, *rpc_sunrpc_xprt_switch_kobj;
27
28static void rpc_sysfs_object_release(struct kobject *kobj)
29{
30 kfree(kobj);
31}
32
33static const struct kobj_ns_type_operations *
34rpc_sysfs_object_child_ns_type(struct kobject *kobj)
35{
36 return &net_ns_type_operations;
37}
38
39static 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,
43};
44
45static struct kobject *rpc_sysfs_object_alloc(const char *name,
46 struct kset *kset,
47 struct kobject *parent)
48{
49 struct kobject *kobj;
50
51 kobj = kzalloc(sizeof(*kobj), GFP_KERNEL);
52 if (kobj) {
53 kobj->kset = kset;
54 if (kobject_init_and_add(kobj, &rpc_sysfs_object_type,
55 parent, "%s", name) == 0)
56 return kobj;
57 kobject_put(kobj);
58 }
59 return NULL;
60}
61
62static inline struct rpc_xprt *
63rpc_sysfs_xprt_kobj_get_xprt(struct kobject *kobj)
64{
65 struct rpc_sysfs_xprt *x = container_of(kobj,
66 struct rpc_sysfs_xprt, kobject);
67
68 return xprt_get(x->xprt);
69}
70
71static inline struct rpc_xprt_switch *
72rpc_sysfs_xprt_kobj_get_xprt_switch(struct kobject *kobj)
73{
74 struct rpc_sysfs_xprt *x = container_of(kobj,
75 struct rpc_sysfs_xprt, kobject);
76
77 return xprt_switch_get(x->xprt_switch);
78}
79
80static inline struct rpc_xprt_switch *
81rpc_sysfs_xprt_switch_kobj_get_xprt(struct kobject *kobj)
82{
83 struct rpc_sysfs_xprt_switch *x = container_of(kobj,
84 struct rpc_sysfs_xprt_switch, kobject);
85
86 return xprt_switch_get(x->xprt_switch);
87}
88
89static ssize_t rpc_sysfs_xprt_dstaddr_show(struct kobject *kobj,
90 struct kobj_attribute *attr,
91 char *buf)
92{
93 struct rpc_xprt *xprt = rpc_sysfs_xprt_kobj_get_xprt(kobj);
94 ssize_t ret;
95
96 if (!xprt) {
97 ret = sprintf(buf, "<closed>\n");
98 goto out;
99 }
100 ret = sprintf(buf, "%s\n", xprt->address_strings[RPC_DISPLAY_ADDR]);
101 xprt_put(xprt);
102out:
103 return ret;
104}
105
106static ssize_t rpc_sysfs_xprt_srcaddr_show(struct kobject *kobj,
107 struct kobj_attribute *attr,
108 char *buf)
109{
110 struct rpc_xprt *xprt = rpc_sysfs_xprt_kobj_get_xprt(kobj);
111 size_t buflen = PAGE_SIZE;
112 ssize_t ret;
113
114 if (!xprt || !xprt_connected(xprt)) {
115 ret = sprintf(buf, "<closed>\n");
116 } else if (xprt->ops->get_srcaddr) {
117 ret = xprt->ops->get_srcaddr(xprt, buf, buflen);
118 if (ret > 0) {
119 if (ret < buflen - 1) {
120 buf[ret] = '\n';
121 ret++;
122 buf[ret] = '\0';
123 }
124 } else
125 ret = sprintf(buf, "<closed>\n");
126 } else
127 ret = sprintf(buf, "<not a socket>\n");
128 xprt_put(xprt);
129 return ret;
130}
131
132static ssize_t rpc_sysfs_xprt_info_show(struct kobject *kobj,
133 struct kobj_attribute *attr, char *buf)
134{
135 struct rpc_xprt *xprt = rpc_sysfs_xprt_kobj_get_xprt(kobj);
136 unsigned short srcport = 0;
137 size_t buflen = PAGE_SIZE;
138 ssize_t ret;
139
140 if (!xprt || !xprt_connected(xprt)) {
141 ret = sprintf(buf, "<closed>\n");
142 goto out;
143 }
144
145 if (xprt->ops->get_srcport)
146 srcport = xprt->ops->get_srcport(xprt);
147
148 ret = snprintf(buf, buflen,
149 "last_used=%lu\ncur_cong=%lu\ncong_win=%lu\n"
150 "max_num_slots=%u\nmin_num_slots=%u\nnum_reqs=%u\n"
151 "binding_q_len=%u\nsending_q_len=%u\npending_q_len=%u\n"
152 "backlog_q_len=%u\nmain_xprt=%d\nsrc_port=%u\n"
153 "tasks_queuelen=%ld\ndst_port=%s\n",
154 xprt->last_used, xprt->cong, xprt->cwnd, xprt->max_reqs,
155 xprt->min_reqs, xprt->num_reqs, xprt->binding.qlen,
156 xprt->sending.qlen, xprt->pending.qlen,
157 xprt->backlog.qlen, xprt->main, srcport,
158 atomic_long_read(&xprt->queuelen),
159 xprt->address_strings[RPC_DISPLAY_PORT]);
160out:
161 xprt_put(xprt);
162 return ret;
163}
164
165static ssize_t rpc_sysfs_xprt_state_show(struct kobject *kobj,
166 struct kobj_attribute *attr,
167 char *buf)
168{
169 struct rpc_xprt *xprt = rpc_sysfs_xprt_kobj_get_xprt(kobj);
170 ssize_t ret;
171 int locked, connected, connecting, close_wait, bound, binding,
172 closing, congested, cwnd_wait, write_space, offline, remove;
173
174 if (!(xprt && xprt->state)) {
175 ret = sprintf(buf, "state=CLOSED\n");
176 } else {
177 locked = test_bit(XPRT_LOCKED, &xprt->state);
178 connected = test_bit(XPRT_CONNECTED, &xprt->state);
179 connecting = test_bit(XPRT_CONNECTING, &xprt->state);
180 close_wait = test_bit(XPRT_CLOSE_WAIT, &xprt->state);
181 bound = test_bit(XPRT_BOUND, &xprt->state);
182 binding = test_bit(XPRT_BINDING, &xprt->state);
183 closing = test_bit(XPRT_CLOSING, &xprt->state);
184 congested = test_bit(XPRT_CONGESTED, &xprt->state);
185 cwnd_wait = test_bit(XPRT_CWND_WAIT, &xprt->state);
186 write_space = test_bit(XPRT_WRITE_SPACE, &xprt->state);
187 offline = test_bit(XPRT_OFFLINE, &xprt->state);
188 remove = test_bit(XPRT_REMOVE, &xprt->state);
189
190 ret = sprintf(buf, "state=%s %s %s %s %s %s %s %s %s %s %s %s\n",
191 locked ? "LOCKED" : "",
192 connected ? "CONNECTED" : "",
193 connecting ? "CONNECTING" : "",
194 close_wait ? "CLOSE_WAIT" : "",
195 bound ? "BOUND" : "",
196 binding ? "BOUNDING" : "",
197 closing ? "CLOSING" : "",
198 congested ? "CONGESTED" : "",
199 cwnd_wait ? "CWND_WAIT" : "",
200 write_space ? "WRITE_SPACE" : "",
201 offline ? "OFFLINE" : "",
202 remove ? "REMOVE" : "");
203 }
204
205 xprt_put(xprt);
206 return ret;
207}
208
209static ssize_t rpc_sysfs_xprt_switch_info_show(struct kobject *kobj,
210 struct kobj_attribute *attr,
211 char *buf)
212{
213 struct rpc_xprt_switch *xprt_switch =
214 rpc_sysfs_xprt_switch_kobj_get_xprt(kobj);
215 ssize_t ret;
216
217 if (!xprt_switch)
218 return 0;
219 ret = sprintf(buf, "num_xprts=%u\nnum_active=%u\n"
220 "num_unique_destaddr=%u\nqueue_len=%ld\n",
221 xprt_switch->xps_nxprts, xprt_switch->xps_nactive,
222 xprt_switch->xps_nunique_destaddr_xprts,
223 atomic_long_read(&xprt_switch->xps_queuelen));
224 xprt_switch_put(xprt_switch);
225 return ret;
226}
227
228static ssize_t rpc_sysfs_xprt_dstaddr_store(struct kobject *kobj,
229 struct kobj_attribute *attr,
230 const char *buf, size_t count)
231{
232 struct rpc_xprt *xprt = rpc_sysfs_xprt_kobj_get_xprt(kobj);
233 struct sockaddr *saddr;
234 char *dst_addr;
235 int port;
236 struct xprt_addr *saved_addr;
237 size_t buf_len;
238
239 if (!xprt)
240 return 0;
241 if (!(xprt->xprt_class->ident == XPRT_TRANSPORT_TCP ||
242 xprt->xprt_class->ident == XPRT_TRANSPORT_RDMA)) {
243 xprt_put(xprt);
244 return -EOPNOTSUPP;
245 }
246
247 if (wait_on_bit_lock(&xprt->state, XPRT_LOCKED, TASK_KILLABLE)) {
248 count = -EINTR;
249 goto out_put;
250 }
251 saddr = (struct sockaddr *)&xprt->addr;
252 port = rpc_get_port(saddr);
253
254
255
256
257 buf_len = strcspn(buf, "\n");
258
259 dst_addr = kstrndup(buf, buf_len, GFP_KERNEL);
260 if (!dst_addr)
261 goto out_err;
262 saved_addr = kzalloc(sizeof(*saved_addr), GFP_KERNEL);
263 if (!saved_addr)
264 goto out_err_free;
265 saved_addr->addr =
266 rcu_dereference_raw(xprt->address_strings[RPC_DISPLAY_ADDR]);
267 rcu_assign_pointer(xprt->address_strings[RPC_DISPLAY_ADDR], dst_addr);
268 call_rcu(&saved_addr->rcu, free_xprt_addr);
269 xprt->addrlen = rpc_pton(xprt->xprt_net, buf, buf_len, saddr,
270 sizeof(*saddr));
271 rpc_set_port(saddr, port);
272
273 xprt_force_disconnect(xprt);
274out:
275 xprt_release_write(xprt, NULL);
276out_put:
277 xprt_put(xprt);
278 return count;
279out_err_free:
280 kfree(dst_addr);
281out_err:
282 count = -ENOMEM;
283 goto out;
284}
285
286static ssize_t rpc_sysfs_xprt_state_change(struct kobject *kobj,
287 struct kobj_attribute *attr,
288 const char *buf, size_t count)
289{
290 struct rpc_xprt *xprt = rpc_sysfs_xprt_kobj_get_xprt(kobj);
291 int offline = 0, online = 0, remove = 0;
292 struct rpc_xprt_switch *xps = rpc_sysfs_xprt_kobj_get_xprt_switch(kobj);
293
294 if (!xprt)
295 return 0;
296
297 if (!strncmp(buf, "offline", 7))
298 offline = 1;
299 else if (!strncmp(buf, "online", 6))
300 online = 1;
301 else if (!strncmp(buf, "remove", 6))
302 remove = 1;
303 else {
304 count = -EINVAL;
305 goto out_put;
306 }
307
308 if (wait_on_bit_lock(&xprt->state, XPRT_LOCKED, TASK_KILLABLE)) {
309 count = -EINTR;
310 goto out_put;
311 }
312 if (xprt->main) {
313 count = -EINVAL;
314 goto release_tasks;
315 }
316 if (offline) {
317 if (!test_and_set_bit(XPRT_OFFLINE, &xprt->state)) {
318 spin_lock(&xps->xps_lock);
319 xps->xps_nactive--;
320 spin_unlock(&xps->xps_lock);
321 }
322 } else if (online) {
323 if (test_and_clear_bit(XPRT_OFFLINE, &xprt->state)) {
324 spin_lock(&xps->xps_lock);
325 xps->xps_nactive++;
326 spin_unlock(&xps->xps_lock);
327 }
328 } else if (remove) {
329 if (test_bit(XPRT_OFFLINE, &xprt->state)) {
330 if (!test_and_set_bit(XPRT_REMOVE, &xprt->state)) {
331 xprt_force_disconnect(xprt);
332 if (test_bit(XPRT_CONNECTED, &xprt->state)) {
333 if (!xprt->sending.qlen &&
334 !xprt->pending.qlen &&
335 !xprt->backlog.qlen &&
336 !atomic_long_read(&xprt->queuelen))
337 rpc_xprt_switch_remove_xprt(xps, xprt);
338 }
339 }
340 } else {
341 count = -EINVAL;
342 }
343 }
344
345release_tasks:
346 xprt_release_write(xprt, NULL);
347out_put:
348 xprt_put(xprt);
349 xprt_switch_put(xps);
350 return count;
351}
352
353int rpc_sysfs_init(void)
354{
355 rpc_sunrpc_kset = kset_create_and_add("sunrpc", NULL, kernel_kobj);
356 if (!rpc_sunrpc_kset)
357 return -ENOMEM;
358 rpc_sunrpc_client_kobj =
359 rpc_sysfs_object_alloc("rpc-clients", rpc_sunrpc_kset, NULL);
360 if (!rpc_sunrpc_client_kobj)
361 goto err_client;
362 rpc_sunrpc_xprt_switch_kobj =
363 rpc_sysfs_object_alloc("xprt-switches", rpc_sunrpc_kset, NULL);
364 if (!rpc_sunrpc_xprt_switch_kobj)
365 goto err_switch;
366 return 0;
367err_switch:
368 kobject_put(rpc_sunrpc_client_kobj);
369 rpc_sunrpc_client_kobj = NULL;
370err_client:
371 kset_unregister(rpc_sunrpc_kset);
372 rpc_sunrpc_kset = NULL;
373 return -ENOMEM;
374}
375
376static void rpc_sysfs_client_release(struct kobject *kobj)
377{
378 struct rpc_sysfs_client *c;
379
380 c = container_of(kobj, struct rpc_sysfs_client, kobject);
381 kfree(c);
382}
383
384static void rpc_sysfs_xprt_switch_release(struct kobject *kobj)
385{
386 struct rpc_sysfs_xprt_switch *xprt_switch;
387
388 xprt_switch = container_of(kobj, struct rpc_sysfs_xprt_switch, kobject);
389 kfree(xprt_switch);
390}
391
392static void rpc_sysfs_xprt_release(struct kobject *kobj)
393{
394 struct rpc_sysfs_xprt *xprt;
395
396 xprt = container_of(kobj, struct rpc_sysfs_xprt, kobject);
397 kfree(xprt);
398}
399
400static const void *rpc_sysfs_client_namespace(struct kobject *kobj)
401{
402 return container_of(kobj, struct rpc_sysfs_client, kobject)->net;
403}
404
405static const void *rpc_sysfs_xprt_switch_namespace(struct kobject *kobj)
406{
407 return container_of(kobj, struct rpc_sysfs_xprt_switch, kobject)->net;
408}
409
410static const void *rpc_sysfs_xprt_namespace(struct kobject *kobj)
411{
412 return container_of(kobj, struct rpc_sysfs_xprt,
413 kobject)->xprt->xprt_net;
414}
415
416static struct kobj_attribute rpc_sysfs_xprt_dstaddr = __ATTR(dstaddr,
417 0644, rpc_sysfs_xprt_dstaddr_show, rpc_sysfs_xprt_dstaddr_store);
418
419static struct kobj_attribute rpc_sysfs_xprt_srcaddr = __ATTR(srcaddr,
420 0644, rpc_sysfs_xprt_srcaddr_show, NULL);
421
422static struct kobj_attribute rpc_sysfs_xprt_info = __ATTR(xprt_info,
423 0444, rpc_sysfs_xprt_info_show, NULL);
424
425static struct kobj_attribute rpc_sysfs_xprt_change_state = __ATTR(xprt_state,
426 0644, rpc_sysfs_xprt_state_show, rpc_sysfs_xprt_state_change);
427
428static struct attribute *rpc_sysfs_xprt_attrs[] = {
429 &rpc_sysfs_xprt_dstaddr.attr,
430 &rpc_sysfs_xprt_srcaddr.attr,
431 &rpc_sysfs_xprt_info.attr,
432 &rpc_sysfs_xprt_change_state.attr,
433 NULL,
434};
435ATTRIBUTE_GROUPS(rpc_sysfs_xprt);
436
437static struct kobj_attribute rpc_sysfs_xprt_switch_info =
438 __ATTR(xprt_switch_info, 0444, rpc_sysfs_xprt_switch_info_show, NULL);
439
440static struct attribute *rpc_sysfs_xprt_switch_attrs[] = {
441 &rpc_sysfs_xprt_switch_info.attr,
442 NULL,
443};
444ATTRIBUTE_GROUPS(rpc_sysfs_xprt_switch);
445
446static struct kobj_type rpc_sysfs_client_type = {
447 .release = rpc_sysfs_client_release,
448 .sysfs_ops = &kobj_sysfs_ops,
449 .namespace = rpc_sysfs_client_namespace,
450};
451
452static struct kobj_type rpc_sysfs_xprt_switch_type = {
453 .release = rpc_sysfs_xprt_switch_release,
454 .default_groups = rpc_sysfs_xprt_switch_groups,
455 .sysfs_ops = &kobj_sysfs_ops,
456 .namespace = rpc_sysfs_xprt_switch_namespace,
457};
458
459static struct kobj_type rpc_sysfs_xprt_type = {
460 .release = rpc_sysfs_xprt_release,
461 .default_groups = rpc_sysfs_xprt_groups,
462 .sysfs_ops = &kobj_sysfs_ops,
463 .namespace = rpc_sysfs_xprt_namespace,
464};
465
466void rpc_sysfs_exit(void)
467{
468 kobject_put(rpc_sunrpc_client_kobj);
469 kobject_put(rpc_sunrpc_xprt_switch_kobj);
470 kset_unregister(rpc_sunrpc_kset);
471}
472
473static struct rpc_sysfs_client *rpc_sysfs_client_alloc(struct kobject *parent,
474 struct net *net,
475 int clid)
476{
477 struct rpc_sysfs_client *p;
478
479 p = kzalloc(sizeof(*p), GFP_KERNEL);
480 if (p) {
481 p->net = net;
482 p->kobject.kset = rpc_sunrpc_kset;
483 if (kobject_init_and_add(&p->kobject, &rpc_sysfs_client_type,
484 parent, "clnt-%d", clid) == 0)
485 return p;
486 kobject_put(&p->kobject);
487 }
488 return NULL;
489}
490
491static struct rpc_sysfs_xprt_switch *
492rpc_sysfs_xprt_switch_alloc(struct kobject *parent,
493 struct rpc_xprt_switch *xprt_switch,
494 struct net *net,
495 gfp_t gfp_flags)
496{
497 struct rpc_sysfs_xprt_switch *p;
498
499 p = kzalloc(sizeof(*p), gfp_flags);
500 if (p) {
501 p->net = net;
502 p->kobject.kset = rpc_sunrpc_kset;
503 if (kobject_init_and_add(&p->kobject,
504 &rpc_sysfs_xprt_switch_type,
505 parent, "switch-%d",
506 xprt_switch->xps_id) == 0)
507 return p;
508 kobject_put(&p->kobject);
509 }
510 return NULL;
511}
512
513static struct rpc_sysfs_xprt *rpc_sysfs_xprt_alloc(struct kobject *parent,
514 struct rpc_xprt *xprt,
515 gfp_t gfp_flags)
516{
517 struct rpc_sysfs_xprt *p;
518
519 p = kzalloc(sizeof(*p), gfp_flags);
520 if (!p)
521 goto out;
522 p->kobject.kset = rpc_sunrpc_kset;
523 if (kobject_init_and_add(&p->kobject, &rpc_sysfs_xprt_type,
524 parent, "xprt-%d-%s", xprt->id,
525 xprt->address_strings[RPC_DISPLAY_PROTO]) == 0)
526 return p;
527 kobject_put(&p->kobject);
528out:
529 return NULL;
530}
531
532void rpc_sysfs_client_setup(struct rpc_clnt *clnt,
533 struct rpc_xprt_switch *xprt_switch,
534 struct net *net)
535{
536 struct rpc_sysfs_client *rpc_client;
537
538 rpc_client = rpc_sysfs_client_alloc(rpc_sunrpc_client_kobj,
539 net, clnt->cl_clid);
540 if (rpc_client) {
541 char name[] = "switch";
542 struct rpc_sysfs_xprt_switch *xswitch =
543 (struct rpc_sysfs_xprt_switch *)xprt_switch->xps_sysfs;
544 int ret;
545
546 clnt->cl_sysfs = rpc_client;
547 rpc_client->clnt = clnt;
548 rpc_client->xprt_switch = xprt_switch;
549 kobject_uevent(&rpc_client->kobject, KOBJ_ADD);
550 ret = sysfs_create_link_nowarn(&rpc_client->kobject,
551 &xswitch->kobject, name);
552 if (ret)
553 pr_warn("can't create link to %s in sysfs (%d)\n",
554 name, ret);
555 }
556}
557
558void rpc_sysfs_xprt_switch_setup(struct rpc_xprt_switch *xprt_switch,
559 struct rpc_xprt *xprt,
560 gfp_t gfp_flags)
561{
562 struct rpc_sysfs_xprt_switch *rpc_xprt_switch;
563 struct net *net;
564
565 if (xprt_switch->xps_net)
566 net = xprt_switch->xps_net;
567 else
568 net = xprt->xprt_net;
569 rpc_xprt_switch =
570 rpc_sysfs_xprt_switch_alloc(rpc_sunrpc_xprt_switch_kobj,
571 xprt_switch, net, gfp_flags);
572 if (rpc_xprt_switch) {
573 xprt_switch->xps_sysfs = rpc_xprt_switch;
574 rpc_xprt_switch->xprt_switch = xprt_switch;
575 rpc_xprt_switch->xprt = xprt;
576 kobject_uevent(&rpc_xprt_switch->kobject, KOBJ_ADD);
577 }
578}
579
580void rpc_sysfs_xprt_setup(struct rpc_xprt_switch *xprt_switch,
581 struct rpc_xprt *xprt,
582 gfp_t gfp_flags)
583{
584 struct rpc_sysfs_xprt *rpc_xprt;
585 struct rpc_sysfs_xprt_switch *switch_obj =
586 (struct rpc_sysfs_xprt_switch *)xprt_switch->xps_sysfs;
587
588 rpc_xprt = rpc_sysfs_xprt_alloc(&switch_obj->kobject, xprt, gfp_flags);
589 if (rpc_xprt) {
590 xprt->xprt_sysfs = rpc_xprt;
591 rpc_xprt->xprt = xprt;
592 rpc_xprt->xprt_switch = xprt_switch;
593 kobject_uevent(&rpc_xprt->kobject, KOBJ_ADD);
594 }
595}
596
597void rpc_sysfs_client_destroy(struct rpc_clnt *clnt)
598{
599 struct rpc_sysfs_client *rpc_client = clnt->cl_sysfs;
600
601 if (rpc_client) {
602 char name[] = "switch";
603
604 sysfs_remove_link(&rpc_client->kobject, name);
605 kobject_uevent(&rpc_client->kobject, KOBJ_REMOVE);
606 kobject_del(&rpc_client->kobject);
607 kobject_put(&rpc_client->kobject);
608 clnt->cl_sysfs = NULL;
609 }
610}
611
612void rpc_sysfs_xprt_switch_destroy(struct rpc_xprt_switch *xprt_switch)
613{
614 struct rpc_sysfs_xprt_switch *rpc_xprt_switch = xprt_switch->xps_sysfs;
615
616 if (rpc_xprt_switch) {
617 kobject_uevent(&rpc_xprt_switch->kobject, KOBJ_REMOVE);
618 kobject_del(&rpc_xprt_switch->kobject);
619 kobject_put(&rpc_xprt_switch->kobject);
620 xprt_switch->xps_sysfs = NULL;
621 }
622}
623
624void rpc_sysfs_xprt_destroy(struct rpc_xprt *xprt)
625{
626 struct rpc_sysfs_xprt *rpc_xprt = xprt->xprt_sysfs;
627
628 if (rpc_xprt) {
629 kobject_uevent(&rpc_xprt->kobject, KOBJ_REMOVE);
630 kobject_del(&rpc_xprt->kobject);
631 kobject_put(&rpc_xprt->kobject);
632 xprt->xprt_sysfs = NULL;
633 }
634}
635
