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