net/sunrpc/sysfs.c

   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                 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);
 102 out:
 103         return ret;
 104 }
 105
 106 static 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
 132 static 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]);
 160 out:
 161         xprt_put(xprt);
 162         return ret;
 163 }
 164
 165 static 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
 209 static 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
 228 static 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         /* buf_len is the len until the first occurence of either
 255          * '\n' or '\0'
 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);
 274 out:
 275         xprt_release_write(xprt, NULL);
 276 out_put:
 277         xprt_put(xprt);
 278         return count;
 279 out_err_free:
 280         kfree(dst_addr);
 281 out_err:
 282         count = -ENOMEM;
 283         goto out;
 284 }
 285
 286 static 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
 345 release_tasks:
 346         xprt_release_write(xprt, NULL);
 347 out_put:
 348         xprt_put(xprt);
 349         xprt_switch_put(xps);
 350         return count;
 351 }
 352
 353 int 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;
 367 err_switch:
 368         kobject_put(rpc_sunrpc_client_kobj);
 369         rpc_sunrpc_client_kobj = NULL;
 370 err_client:
 371         kset_unregister(rpc_sunrpc_kset);
 372         rpc_sunrpc_kset = NULL;
 373         return -ENOMEM;
 374 }
 375
 376 static 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
 384 static 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
 392 static 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
 400 static const void *rpc_sysfs_client_namespace(struct kobject *kobj)
 401 {
 402         return container_of(kobj, struct rpc_sysfs_client, kobject)->net;
 403 }
 404
 405 static 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
 410 static 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
 416 static struct kobj_attribute rpc_sysfs_xprt_dstaddr = __ATTR(dstaddr,
 417         0644, rpc_sysfs_xprt_dstaddr_show, rpc_sysfs_xprt_dstaddr_store);
 418
 419 static struct kobj_attribute rpc_sysfs_xprt_srcaddr = __ATTR(srcaddr,
 420         0644, rpc_sysfs_xprt_srcaddr_show, NULL);
 421
 422 static struct kobj_attribute rpc_sysfs_xprt_info = __ATTR(xprt_info,
 423         0444, rpc_sysfs_xprt_info_show, NULL);
 424
 425 static struct kobj_attribute rpc_sysfs_xprt_change_state = __ATTR(xprt_state,
 426         0644, rpc_sysfs_xprt_state_show, rpc_sysfs_xprt_state_change);
 427
 428 static 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 };
 435 ATTRIBUTE_GROUPS(rpc_sysfs_xprt);
 436
 437 static struct kobj_attribute rpc_sysfs_xprt_switch_info =
 438         __ATTR(xprt_switch_info, 0444, rpc_sysfs_xprt_switch_info_show, NULL);
 439
 440 static struct attribute *rpc_sysfs_xprt_switch_attrs[] = {
 441         &rpc_sysfs_xprt_switch_info.attr,
 442         NULL,
 443 };
 444 ATTRIBUTE_GROUPS(rpc_sysfs_xprt_switch);
 445
 446 static 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
 452 static 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
 459 static 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
 466 void 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
 473 static 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
 491 static struct rpc_sysfs_xprt_switch *
 492 rpc_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
 513 static 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);
 528 out:
 529         return NULL;
 530 }
 531
 532 void 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
 558 void 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
 580 void 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
 597 void 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
 612 void 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
 624 void 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 }