[mirror_ubuntu-jammy-kernel.git] / net / sunrpc / sysfs.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (c) 2020 Anna Schumaker <Anna.Schumaker@Netapp.com>
 */
#include <linux/sunrpc/clnt.h>
#include <linux/kobject.h>
#include <linux/sunrpc/addr.h>
#include <linux/sunrpc/xprtsock.h>

#include "sysfs.h"

struct xprt_addr {
	const char *addr;
	struct rcu_head rcu;
};

static void free_xprt_addr(struct rcu_head *head)
{
	struct xprt_addr *addr = container_of(head, struct xprt_addr, rcu);

	kfree(addr->addr);
	kfree(addr);
}

static struct kset *rpc_sunrpc_kset;
static struct kobject *rpc_sunrpc_client_kobj, *rpc_sunrpc_xprt_switch_kobj;

static void rpc_sysfs_object_release(struct kobject *kobj)
{
	kfree(kobj);
}

static const struct kobj_ns_type_operations *
rpc_sysfs_object_child_ns_type(struct kobject *kobj)
{
	return &net_ns_type_operations;
}

static struct kobj_type rpc_sysfs_object_type = {
	.release = rpc_sysfs_object_release,
	.sysfs_ops = &kobj_sysfs_ops,
	.child_ns_type = rpc_sysfs_object_child_ns_type,
};

static struct kobject *rpc_sysfs_object_alloc(const char *name,
					      struct kset *kset,
					      struct kobject *parent)
{
	struct kobject *kobj;

	kobj = kzalloc(sizeof(*kobj), GFP_KERNEL);
	if (kobj) {
		kobj->kset = kset;
		if (kobject_init_and_add(kobj, &rpc_sysfs_object_type,
					 parent, "%s", name) == 0)
			return kobj;
		kobject_put(kobj);
	}
	return NULL;
}

static inline struct rpc_xprt *
rpc_sysfs_xprt_kobj_get_xprt(struct kobject *kobj)
{
	struct rpc_sysfs_xprt *x = container_of(kobj,
		struct rpc_sysfs_xprt, kobject);

	return xprt_get(x->xprt);
}

static inline struct rpc_xprt_switch *
rpc_sysfs_xprt_kobj_get_xprt_switch(struct kobject *kobj)
{
	struct rpc_sysfs_xprt *x = container_of(kobj,
		struct rpc_sysfs_xprt, kobject);

	return xprt_switch_get(x->xprt_switch);
}

static inline struct rpc_xprt_switch *
rpc_sysfs_xprt_switch_kobj_get_xprt(struct kobject *kobj)
{
	struct rpc_sysfs_xprt_switch *x = container_of(kobj,
		struct rpc_sysfs_xprt_switch, kobject);

	return xprt_switch_get(x->xprt_switch);
}

static ssize_t rpc_sysfs_xprt_dstaddr_show(struct kobject *kobj,
					   struct kobj_attribute *attr,
					   char *buf)
{
	struct rpc_xprt *xprt = rpc_sysfs_xprt_kobj_get_xprt(kobj);
	ssize_t ret;

	if (!xprt)
		return 0;
	ret = sprintf(buf, "%s\n", xprt->address_strings[RPC_DISPLAY_ADDR]);
	xprt_put(xprt);
	return ret + 1;
}

static ssize_t rpc_sysfs_xprt_srcaddr_show(struct kobject *kobj,
					   struct kobj_attribute *attr,
					   char *buf)
{
	struct rpc_xprt *xprt = rpc_sysfs_xprt_kobj_get_xprt(kobj);
	struct sockaddr_storage saddr;
	struct sock_xprt *sock;
	ssize_t ret = -1;

	if (!xprt)
		return 0;

	sock = container_of(xprt, struct sock_xprt, xprt);
	if (kernel_getsockname(sock->sock, (struct sockaddr *)&saddr) < 0)
		goto out;

	ret = sprintf(buf, "%pISc\n", &saddr);
out:
	xprt_put(xprt);
	return ret + 1;
}

static ssize_t rpc_sysfs_xprt_info_show(struct kobject *kobj,
					struct kobj_attribute *attr,
					char *buf)
{
	struct rpc_xprt *xprt = rpc_sysfs_xprt_kobj_get_xprt(kobj);
	ssize_t ret;

	if (!xprt)
		return 0;

	ret = sprintf(buf, "last_used=%lu\ncur_cong=%lu\ncong_win=%lu\n"
		       "max_num_slots=%u\nmin_num_slots=%u\nnum_reqs=%u\n"
		       "binding_q_len=%u\nsending_q_len=%u\npending_q_len=%u\n"
		       "backlog_q_len=%u\nmain_xprt=%d\nsrc_port=%u\n"
		       "tasks_queuelen=%ld\ndst_port=%s\n",
		       xprt->last_used, xprt->cong, xprt->cwnd, xprt->max_reqs,
		       xprt->min_reqs, xprt->num_reqs, xprt->binding.qlen,
		       xprt->sending.qlen, xprt->pending.qlen,
		       xprt->backlog.qlen, xprt->main,
		       (xprt->xprt_class->ident == XPRT_TRANSPORT_TCP) ?
		       get_srcport(xprt) : 0,
		       atomic_long_read(&xprt->queuelen),
		       (xprt->xprt_class->ident == XPRT_TRANSPORT_TCP) ?
				xprt->address_strings[RPC_DISPLAY_PORT] : "0");
	xprt_put(xprt);
	return ret + 1;
}

static ssize_t rpc_sysfs_xprt_state_show(struct kobject *kobj,
					 struct kobj_attribute *attr,
					 char *buf)
{
	struct rpc_xprt *xprt = rpc_sysfs_xprt_kobj_get_xprt(kobj);
	ssize_t ret;
	int locked, connected, connecting, close_wait, bound, binding,
	    closing, congested, cwnd_wait, write_space, offline, remove;

	if (!xprt)
		return 0;

	if (!xprt->state) {
		ret = sprintf(buf, "state=CLOSED\n");
	} else {
		locked = test_bit(XPRT_LOCKED, &xprt->state);
		connected = test_bit(XPRT_CONNECTED, &xprt->state);
		connecting = test_bit(XPRT_CONNECTING, &xprt->state);
		close_wait = test_bit(XPRT_CLOSE_WAIT, &xprt->state);
		bound = test_bit(XPRT_BOUND, &xprt->state);
		binding = test_bit(XPRT_BINDING, &xprt->state);
		closing = test_bit(XPRT_CLOSING, &xprt->state);
		congested = test_bit(XPRT_CONGESTED, &xprt->state);
		cwnd_wait = test_bit(XPRT_CWND_WAIT, &xprt->state);
		write_space = test_bit(XPRT_WRITE_SPACE, &xprt->state);
		offline = test_bit(XPRT_OFFLINE, &xprt->state);
		remove = test_bit(XPRT_REMOVE, &xprt->state);

		ret = sprintf(buf, "state=%s %s %s %s %s %s %s %s %s %s %s %s\n",
			      locked ? "LOCKED" : "",
			      connected ? "CONNECTED" : "",
			      connecting ? "CONNECTING" : "",
			      close_wait ? "CLOSE_WAIT" : "",
			      bound ? "BOUND" : "",
			      binding ? "BOUNDING" : "",
			      closing ? "CLOSING" : "",
			      congested ? "CONGESTED" : "",
			      cwnd_wait ? "CWND_WAIT" : "",
			      write_space ? "WRITE_SPACE" : "",
			      offline ? "OFFLINE" : "",
			      remove ? "REMOVE" : "");
	}

	xprt_put(xprt);
	return ret + 1;
}

static ssize_t rpc_sysfs_xprt_switch_info_show(struct kobject *kobj,
					       struct kobj_attribute *attr,
					       char *buf)
{
	struct rpc_xprt_switch *xprt_switch =
		rpc_sysfs_xprt_switch_kobj_get_xprt(kobj);
	ssize_t ret;

	if (!xprt_switch)
		return 0;
	ret = sprintf(buf, "num_xprts=%u\nnum_active=%u\n"
		      "num_unique_destaddr=%u\nqueue_len=%ld\n",
		      xprt_switch->xps_nxprts, xprt_switch->xps_nactive,
		      xprt_switch->xps_nunique_destaddr_xprts,
		      atomic_long_read(&xprt_switch->xps_queuelen));
	xprt_switch_put(xprt_switch);
	return ret + 1;
}

static ssize_t rpc_sysfs_xprt_dstaddr_store(struct kobject *kobj,
					    struct kobj_attribute *attr,
					    const char *buf, size_t count)
{
	struct rpc_xprt *xprt = rpc_sysfs_xprt_kobj_get_xprt(kobj);
	struct sockaddr *saddr;
	char *dst_addr;
	int port;
	struct xprt_addr *saved_addr;
	size_t buf_len;

	if (!xprt)
		return 0;
	if (!(xprt->xprt_class->ident == XPRT_TRANSPORT_TCP ||
	      xprt->xprt_class->ident == XPRT_TRANSPORT_RDMA)) {
		xprt_put(xprt);
		return -EOPNOTSUPP;
	}

	if (wait_on_bit_lock(&xprt->state, XPRT_LOCKED, TASK_KILLABLE)) {
		count = -EINTR;
		goto out_put;
	}
	saddr = (struct sockaddr *)&xprt->addr;
	port = rpc_get_port(saddr);

	/* buf_len is the len until the first occurence of either
	 * '\n' or '\0'
	 */
	buf_len = strcspn(buf, "\n");

	dst_addr = kstrndup(buf, buf_len, GFP_KERNEL);
	if (!dst_addr)
		goto out_err;
	saved_addr = kzalloc(sizeof(*saved_addr), GFP_KERNEL);
	if (!saved_addr)
		goto out_err_free;
	saved_addr->addr =
		rcu_dereference_raw(xprt->address_strings[RPC_DISPLAY_ADDR]);
	rcu_assign_pointer(xprt->address_strings[RPC_DISPLAY_ADDR], dst_addr);
	call_rcu(&saved_addr->rcu, free_xprt_addr);
	xprt->addrlen = rpc_pton(xprt->xprt_net, buf, buf_len, saddr,
				 sizeof(*saddr));
	rpc_set_port(saddr, port);

	xprt_force_disconnect(xprt);
out:
	xprt_release_write(xprt, NULL);
out_put:
	xprt_put(xprt);
	return count;
out_err_free:
	kfree(dst_addr);
out_err:
	count = -ENOMEM;
	goto out;
}

static ssize_t rpc_sysfs_xprt_state_change(struct kobject *kobj,
					   struct kobj_attribute *attr,
					   const char *buf, size_t count)
{
	struct rpc_xprt *xprt = rpc_sysfs_xprt_kobj_get_xprt(kobj);
	int offline = 0, online = 0, remove = 0;
	struct rpc_xprt_switch *xps = rpc_sysfs_xprt_kobj_get_xprt_switch(kobj);

	if (!xprt)
		return 0;

	if (!strncmp(buf, "offline", 7))
		offline = 1;
	else if (!strncmp(buf, "online", 6))
		online = 1;
	else if (!strncmp(buf, "remove", 6))
		remove = 1;
	else {
		count = -EINVAL;
		goto out_put;
	}

	if (wait_on_bit_lock(&xprt->state, XPRT_LOCKED, TASK_KILLABLE)) {
		count = -EINTR;
		goto out_put;
	}
	if (xprt->main) {
		count = -EINVAL;
		goto release_tasks;
	}
	if (offline) {
		if (!test_and_set_bit(XPRT_OFFLINE, &xprt->state)) {
			spin_lock(&xps->xps_lock);
			xps->xps_nactive--;
			spin_unlock(&xps->xps_lock);
		}
	} else if (online) {
		if (test_and_clear_bit(XPRT_OFFLINE, &xprt->state)) {
			spin_lock(&xps->xps_lock);
			xps->xps_nactive++;
			spin_unlock(&xps->xps_lock);
		}
	} else if (remove) {
		if (test_bit(XPRT_OFFLINE, &xprt->state)) {
			if (!test_and_set_bit(XPRT_REMOVE, &xprt->state)) {
				xprt_force_disconnect(xprt);
				if (test_bit(XPRT_CONNECTED, &xprt->state)) {
					if (!xprt->sending.qlen &&
					    !xprt->pending.qlen &&
					    !xprt->backlog.qlen &&
					    !atomic_long_read(&xprt->queuelen))
						rpc_xprt_switch_remove_xprt(xps, xprt);
				}
			}
		} else {
			count = -EINVAL;
		}
	}

release_tasks:
	xprt_release_write(xprt, NULL);
out_put:
	xprt_put(xprt);
	xprt_switch_put(xps);
	return count;
}

int rpc_sysfs_init(void)
{
	rpc_sunrpc_kset = kset_create_and_add("sunrpc", NULL, kernel_kobj);
	if (!rpc_sunrpc_kset)
		return -ENOMEM;
	rpc_sunrpc_client_kobj =
		rpc_sysfs_object_alloc("rpc-clients", rpc_sunrpc_kset, NULL);
	if (!rpc_sunrpc_client_kobj)
		goto err_client;
	rpc_sunrpc_xprt_switch_kobj =
		rpc_sysfs_object_alloc("xprt-switches", rpc_sunrpc_kset, NULL);
	if (!rpc_sunrpc_xprt_switch_kobj)
		goto err_switch;
	return 0;
err_switch:
	kobject_put(rpc_sunrpc_client_kobj);
	rpc_sunrpc_client_kobj = NULL;
err_client:
	kset_unregister(rpc_sunrpc_kset);
	rpc_sunrpc_kset = NULL;
	return -ENOMEM;
}

static void rpc_sysfs_client_release(struct kobject *kobj)
{
	struct rpc_sysfs_client *c;

	c = container_of(kobj, struct rpc_sysfs_client, kobject);
	kfree(c);
}

static void rpc_sysfs_xprt_switch_release(struct kobject *kobj)
{
	struct rpc_sysfs_xprt_switch *xprt_switch;

	xprt_switch = container_of(kobj, struct rpc_sysfs_xprt_switch, kobject);
	kfree(xprt_switch);
}

static void rpc_sysfs_xprt_release(struct kobject *kobj)
{
	struct rpc_sysfs_xprt *xprt;

	xprt = container_of(kobj, struct rpc_sysfs_xprt, kobject);
	kfree(xprt);
}

static const void *rpc_sysfs_client_namespace(struct kobject *kobj)
{
	return container_of(kobj, struct rpc_sysfs_client, kobject)->net;
}

static const void *rpc_sysfs_xprt_switch_namespace(struct kobject *kobj)
{
	return container_of(kobj, struct rpc_sysfs_xprt_switch, kobject)->net;
}

static const void *rpc_sysfs_xprt_namespace(struct kobject *kobj)
{
	return container_of(kobj, struct rpc_sysfs_xprt,
			    kobject)->xprt->xprt_net;
}

static struct kobj_attribute rpc_sysfs_xprt_dstaddr = __ATTR(dstaddr,
	0644, rpc_sysfs_xprt_dstaddr_show, rpc_sysfs_xprt_dstaddr_store);

static struct kobj_attribute rpc_sysfs_xprt_srcaddr = __ATTR(srcaddr,
	0644, rpc_sysfs_xprt_srcaddr_show, NULL);

static struct kobj_attribute rpc_sysfs_xprt_info = __ATTR(xprt_info,
	0444, rpc_sysfs_xprt_info_show, NULL);

static struct kobj_attribute rpc_sysfs_xprt_change_state = __ATTR(xprt_state,
	0644, rpc_sysfs_xprt_state_show, rpc_sysfs_xprt_state_change);

static struct attribute *rpc_sysfs_xprt_attrs[] = {
	&rpc_sysfs_xprt_dstaddr.attr,
	&rpc_sysfs_xprt_srcaddr.attr,
	&rpc_sysfs_xprt_info.attr,
	&rpc_sysfs_xprt_change_state.attr,
	NULL,
};

static struct kobj_attribute rpc_sysfs_xprt_switch_info =
	__ATTR(xprt_switch_info, 0444, rpc_sysfs_xprt_switch_info_show, NULL);

static struct attribute *rpc_sysfs_xprt_switch_attrs[] = {
	&rpc_sysfs_xprt_switch_info.attr,
	NULL,
};

static struct kobj_type rpc_sysfs_client_type = {
	.release = rpc_sysfs_client_release,
	.sysfs_ops = &kobj_sysfs_ops,
	.namespace = rpc_sysfs_client_namespace,
};

static struct kobj_type rpc_sysfs_xprt_switch_type = {
	.release = rpc_sysfs_xprt_switch_release,
	.default_attrs = rpc_sysfs_xprt_switch_attrs,
	.sysfs_ops = &kobj_sysfs_ops,
	.namespace = rpc_sysfs_xprt_switch_namespace,
};

static struct kobj_type rpc_sysfs_xprt_type = {
	.release = rpc_sysfs_xprt_release,
	.default_attrs = rpc_sysfs_xprt_attrs,
	.sysfs_ops = &kobj_sysfs_ops,
	.namespace = rpc_sysfs_xprt_namespace,
};

void rpc_sysfs_exit(void)
{
	kobject_put(rpc_sunrpc_client_kobj);
	kobject_put(rpc_sunrpc_xprt_switch_kobj);
	kset_unregister(rpc_sunrpc_kset);
}

static struct rpc_sysfs_client *rpc_sysfs_client_alloc(struct kobject *parent,
						       struct net *net,
						       int clid)
{
	struct rpc_sysfs_client *p;

	p = kzalloc(sizeof(*p), GFP_KERNEL);
	if (p) {
		p->net = net;
		p->kobject.kset = rpc_sunrpc_kset;
		if (kobject_init_and_add(&p->kobject, &rpc_sysfs_client_type,
					 parent, "clnt-%d", clid) == 0)
			return p;
		kobject_put(&p->kobject);
	}
	return NULL;
}

static struct rpc_sysfs_xprt_switch *
rpc_sysfs_xprt_switch_alloc(struct kobject *parent,
			    struct rpc_xprt_switch *xprt_switch,
			    struct net *net,
			    gfp_t gfp_flags)
{
	struct rpc_sysfs_xprt_switch *p;

	p = kzalloc(sizeof(*p), gfp_flags);
	if (p) {
		p->net = net;
		p->kobject.kset = rpc_sunrpc_kset;
		if (kobject_init_and_add(&p->kobject,
					 &rpc_sysfs_xprt_switch_type,
					 parent, "switch-%d",
					 xprt_switch->xps_id) == 0)
			return p;
		kobject_put(&p->kobject);
	}
	return NULL;
}

static struct rpc_sysfs_xprt *rpc_sysfs_xprt_alloc(struct kobject *parent,
						   struct rpc_xprt *xprt,
						   gfp_t gfp_flags)
{
	struct rpc_sysfs_xprt *p;

	p = kzalloc(sizeof(*p), gfp_flags);
	if (!p)
		goto out;
	p->kobject.kset = rpc_sunrpc_kset;
	if (kobject_init_and_add(&p->kobject, &rpc_sysfs_xprt_type,
				 parent, "xprt-%d-%s", xprt->id,
				 xprt->address_strings[RPC_DISPLAY_PROTO]) == 0)
		return p;
	kobject_put(&p->kobject);
out:
	return NULL;
}

void rpc_sysfs_client_setup(struct rpc_clnt *clnt,
			    struct rpc_xprt_switch *xprt_switch,
			    struct net *net)
{
	struct rpc_sysfs_client *rpc_client;

	rpc_client = rpc_sysfs_client_alloc(rpc_sunrpc_client_kobj,
					    net, clnt->cl_clid);
	if (rpc_client) {
		char name[] = "switch";
		struct rpc_sysfs_xprt_switch *xswitch =
			(struct rpc_sysfs_xprt_switch *)xprt_switch->xps_sysfs;
		int ret;

		clnt->cl_sysfs = rpc_client;
		rpc_client->clnt = clnt;
		rpc_client->xprt_switch = xprt_switch;
		kobject_uevent(&rpc_client->kobject, KOBJ_ADD);
		ret = sysfs_create_link_nowarn(&rpc_client->kobject,
					       &xswitch->kobject, name);
		if (ret)
			pr_warn("can't create link to %s in sysfs (%d)\n",
				name, ret);
	}
}

void rpc_sysfs_xprt_switch_setup(struct rpc_xprt_switch *xprt_switch,
				 struct rpc_xprt *xprt,
				 gfp_t gfp_flags)
{
	struct rpc_sysfs_xprt_switch *rpc_xprt_switch;
	struct net *net;

	if (xprt_switch->xps_net)
		net = xprt_switch->xps_net;
	else
		net = xprt->xprt_net;
	rpc_xprt_switch =
		rpc_sysfs_xprt_switch_alloc(rpc_sunrpc_xprt_switch_kobj,
					    xprt_switch, net, gfp_flags);
	if (rpc_xprt_switch) {
		xprt_switch->xps_sysfs = rpc_xprt_switch;
		rpc_xprt_switch->xprt_switch = xprt_switch;
		rpc_xprt_switch->xprt = xprt;
		kobject_uevent(&rpc_xprt_switch->kobject, KOBJ_ADD);
	}
}

void rpc_sysfs_xprt_setup(struct rpc_xprt_switch *xprt_switch,
			  struct rpc_xprt *xprt,
			  gfp_t gfp_flags)
{
	struct rpc_sysfs_xprt *rpc_xprt;
	struct rpc_sysfs_xprt_switch *switch_obj =
		(struct rpc_sysfs_xprt_switch *)xprt_switch->xps_sysfs;

	rpc_xprt = rpc_sysfs_xprt_alloc(&switch_obj->kobject, xprt, gfp_flags);
	if (rpc_xprt) {
		xprt->xprt_sysfs = rpc_xprt;
		rpc_xprt->xprt = xprt;
		rpc_xprt->xprt_switch = xprt_switch;
		kobject_uevent(&rpc_xprt->kobject, KOBJ_ADD);
	}
}

void rpc_sysfs_client_destroy(struct rpc_clnt *clnt)
{
	struct rpc_sysfs_client *rpc_client = clnt->cl_sysfs;

	if (rpc_client) {
		char name[] = "switch";

		sysfs_remove_link(&rpc_client->kobject, name);
		kobject_uevent(&rpc_client->kobject, KOBJ_REMOVE);
		kobject_del(&rpc_client->kobject);
		kobject_put(&rpc_client->kobject);
		clnt->cl_sysfs = NULL;
	}
}

void rpc_sysfs_xprt_switch_destroy(struct rpc_xprt_switch *xprt_switch)
{
	struct rpc_sysfs_xprt_switch *rpc_xprt_switch = xprt_switch->xps_sysfs;

	if (rpc_xprt_switch) {
		kobject_uevent(&rpc_xprt_switch->kobject, KOBJ_REMOVE);
		kobject_del(&rpc_xprt_switch->kobject);
		kobject_put(&rpc_xprt_switch->kobject);
		xprt_switch->xps_sysfs = NULL;
	}
}

void rpc_sysfs_xprt_destroy(struct rpc_xprt *xprt)
{
	struct rpc_sysfs_xprt *rpc_xprt = xprt->xprt_sysfs;

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