linux/net/sunrpc/sysfs.c
<<
>>
Prefs
   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
  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        /* 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);
 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