[linux.git] / net / sunrpc / sysfs.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (c) 2020 Anna Schumaker <[email protected]>
 */
#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(const struct kobject *kobj)
{
	return &net_ns_type_operations;
}

static const 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) {
		ret = sprintf(buf, "<closed>\n");
		goto out;
	}
	ret = sprintf(buf, "%s\n", xprt->address_strings[RPC_DISPLAY_ADDR]);
	xprt_put(xprt);
out:
	return ret;
}

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);
	size_t buflen = PAGE_SIZE;
	ssize_t ret;

	if (!xprt || !xprt_connected(xprt)) {
		ret = sprintf(buf, "<closed>\n");
	} else if (xprt->ops->get_srcaddr) {
		ret = xprt->ops->get_srcaddr(xprt, buf, buflen);
		if (ret > 0) {
			if (ret < buflen - 1) {
				buf[ret] = '\n';
				ret++;
				buf[ret] = '\0';
			}
		} else
			ret = sprintf(buf, "<closed>\n");
	} else
		ret = sprintf(buf, "<not a socket>\n");
	xprt_put(xprt);
	return ret;
}

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);
	unsigned short srcport = 0;
	size_t buflen = PAGE_SIZE;
	ssize_t ret;

	if (!xprt || !xprt_connected(xprt)) {
		ret = sprintf(buf, "<closed>\n");
		goto out;
	}

	if (xprt->ops->get_srcport)
		srcport = xprt->ops->get_srcport(xprt);

	ret = snprintf(buf, buflen,
		       "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, srcport,
		       atomic_long_read(&xprt->queuelen),
		       xprt->address_strings[RPC_DISPLAY_PORT]);
out:
	xprt_put(xprt);
	return ret;
}

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 && 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;
}

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;
}

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_TCP_TLS ||
	      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 || !xps) {
		count = 0;
		goto out_put;
	}

	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) {
		xprt_set_offline_locked(xprt, xps);
	} else if (online) {
		xprt_set_online_locked(xprt, xps);
	} else if (remove) {
		if (test_bit(XPRT_OFFLINE, &xprt->state))
			xprt_delete_locked(xprt, xps);
		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(const struct kobject *kobj)
{
	return container_of(kobj, struct rpc_sysfs_client, kobject)->net;
}

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

static const void *rpc_sysfs_xprt_namespace(const 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,
};
ATTRIBUTE_GROUPS(rpc_sysfs_xprt);

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,
};
ATTRIBUTE_GROUPS(rpc_sysfs_xprt_switch);

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

static const struct kobj_type rpc_sysfs_xprt_switch_type = {
	.release = rpc_sysfs_xprt_switch_release,
	.default_groups = rpc_sysfs_xprt_switch_groups,
	.sysfs_ops = &kobj_sysfs_ops,
	.namespace = rpc_sysfs_xprt_switch_namespace,
};

static const struct kobj_type rpc_sysfs_xprt_type = {
	.release = rpc_sysfs_xprt_release,
	.default_groups = rpc_sysfs_xprt_groups,
	.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;
	struct rpc_sysfs_xprt_switch *xswitch =
		(struct rpc_sysfs_xprt_switch *)xprt_switch->xps_sysfs;

	if (!xswitch)
		return;

	rpc_client = rpc_sysfs_client_alloc(rpc_sunrpc_client_kobj,
					    net, clnt->cl_clid);
	if (rpc_client) {
		char name[] = "switch";
		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);
	} else {
		xprt_switch->xps_sysfs = NULL;
	}
}

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;

	if (!switch_obj)
		return;

	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 <[email protected]>
	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 *
02a476d9	34	rpc_sysfs_object_child_ns_type(const struct kobject *kobj)
c441f125 OK	35	{
	36	return &net_ns_type_operations;
	37	}
	38
d67307b4	39	static const struct kobj_type rpc_sysfs_object_type = {
c441f125 OK	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
ebbe7887 TM	96	if (!xprt) {
	97	ret = sprintf(buf, "<closed>\n");
	98	goto out;
	99	}
587bc725 OK	100	ret = sprintf(buf, "%s\n", xprt->address_strings[RPC_DISPLAY_ADDR]);
587bc725 OK	101	xprt_put(xprt);
ebbe7887	102	out:
421ab1be	103	return ret;
587bc725 OK	104	}
587bc725 OK	105
e44773da AS	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);
421ab1be	111	size_t buflen = PAGE_SIZE;
ebbe7887	112	ssize_t ret;
e44773da	113
17f09d3f	114	if (!xprt \|\| !xprt_connected(xprt)) {
ebbe7887	115	ret = sprintf(buf, "<closed>\n");
421ab1be TM	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	}
ebbe7887 TM	124	} else
	125	ret = sprintf(buf, "<closed>\n");
	126	} else
	127	ret = sprintf(buf, "<not a socket>\n");
e44773da	128	xprt_put(xprt);
421ab1be	129	return ret;
e44773da AS	130	}
e44773da AS	131
4a09651a	132	static ssize_t rpc_sysfs_xprt_info_show(struct kobject *kobj,
421ab1be	133	struct kobj_attribute attr, char buf)
4a09651a OK	134	{
4a09651a OK	135	struct rpc_xprt *xprt = rpc_sysfs_xprt_kobj_get_xprt(kobj);
421ab1be TM	136	unsigned short srcport = 0;
421ab1be TM	137	size_t buflen = PAGE_SIZE;
4a09651a OK	138	ssize_t ret;
4a09651a OK	139
17f09d3f	140	if (!xprt \|\| !xprt_connected(xprt)) {
ebbe7887 TM	141	ret = sprintf(buf, "<closed>\n");
ebbe7887 TM	142	goto out;
17f09d3f	143	}
4a09651a	144
421ab1be TM	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"
4a09651a OK	150	"max_num_slots=%u\nmin_num_slots=%u\nnum_reqs=%u\n"
4a09651a OK	151	"binding_q_len=%u\nsending_q_len=%u\npending_q_len=%u\n"
6a284059	152	"backlog_q_len=%u\nmain_xprt=%d\nsrc_port=%u\n"
69f2cd6d	153	"tasks_queuelen=%ld\ndst_port=%s\n",
c1830a63 OK	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,
421ab1be	157	xprt->backlog.qlen, xprt->main, srcport,
69f2cd6d	158	atomic_long_read(&xprt->queuelen),
421ab1be	159	xprt->address_strings[RPC_DISPLAY_PORT]);
ebbe7887	160	out:
4a09651a	161	xprt_put(xprt);
421ab1be	162	return ret;
4a09651a OK	163	}
4a09651a OK	164
681d5699 OK	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,
6f081693	172	closing, congested, cwnd_wait, write_space, offline, remove;
681d5699	173
ebbe7887	174	if (!(xprt && xprt->state)) {
681d5699 OK	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);
5b7eb784	187	offline = test_bit(XPRT_OFFLINE, &xprt->state);
6f081693	188	remove = test_bit(XPRT_REMOVE, &xprt->state);
681d5699	189
6f081693	190	ret = sprintf(buf, "state=%s %s %s %s %s %s %s %s %s %s %s %s\n",
681d5699 OK	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" : "",
5b7eb784	200	write_space ? "WRITE_SPACE" : "",
6f081693 OK	201	offline ? "OFFLINE" : "",
6f081693 OK	202	remove ? "REMOVE" : "");
681d5699 OK	203	}
	204
	205	xprt_put(xprt);
421ab1be	206	return ret;
681d5699 OK	207	}
681d5699 OK	208
0e559035 OK	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;
df205d0a OK	219	ret = sprintf(buf, "num_xprts=%u\nnum_active=%u\n"
df205d0a OK	220	"num_unique_destaddr=%u\nqueue_len=%ld\n",
0e559035	221	xprt_switch->xps_nxprts, xprt_switch->xps_nactive,
df205d0a	222	xprt_switch->xps_nunique_destaddr_xprts,
0e559035 OK	223	atomic_long_read(&xprt_switch->xps_queuelen));
0e559035 OK	224	xprt_switch_put(xprt_switch);
421ab1be	225	return ret;
0e559035 OK	226	}
0e559035 OK	227
587bc725 OK	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 \|\|
75eb6af7	242	xprt->xprt_class->ident == XPRT_TRANSPORT_TCP_TLS \|\|
587bc725 OK	243	xprt->xprt_class->ident == XPRT_TRANSPORT_RDMA)) {
	244	xprt_put(xprt);
	245	return -EOPNOTSUPP;
	246	}
	247
	248	if (wait_on_bit_lock(&xprt->state, XPRT_LOCKED, TASK_KILLABLE)) {
	249	count = -EINTR;
	250	goto out_put;
	251	}
	252	saddr = (struct sockaddr *)&xprt->addr;
	253	port = rpc_get_port(saddr);
	254
	255	/* buf_len is the len until the first occurence of either
	256	* '\n' or '\0'
	257	*/
	258	buf_len = strcspn(buf, "\n");
	259
	260	dst_addr = kstrndup(buf, buf_len, GFP_KERNEL);
	261	if (!dst_addr)
	262	goto out_err;
	263	saved_addr = kzalloc(sizeof(*saved_addr), GFP_KERNEL);
	264	if (!saved_addr)
	265	goto out_err_free;
	266	saved_addr->addr =
	267	rcu_dereference_raw(xprt->address_strings[RPC_DISPLAY_ADDR]);
	268	rcu_assign_pointer(xprt->address_strings[RPC_DISPLAY_ADDR], dst_addr);
	269	call_rcu(&saved_addr->rcu, free_xprt_addr);
	270	xprt->addrlen = rpc_pton(xprt->xprt_net, buf, buf_len, saddr,
	271	sizeof(*saddr));
	272	rpc_set_port(saddr, port);
	273
	274	xprt_force_disconnect(xprt);
	275	out:
	276	xprt_release_write(xprt, NULL);
	277	out_put:
	278	xprt_put(xprt);
	279	return count;
	280	out_err_free:
	281	kfree(dst_addr);
	282	out_err:
	283	count = -ENOMEM;
	284	goto out;
	285	}
	286
5b7eb784 OK	287	static ssize_t rpc_sysfs_xprt_state_change(struct kobject *kobj,
	288	struct kobj_attribute *attr,
	289	const char *buf, size_t count)
	290	{
	291	struct rpc_xprt *xprt = rpc_sysfs_xprt_kobj_get_xprt(kobj);
6f081693	292	int offline = 0, online = 0, remove = 0;
5b7eb784 OK	293	struct rpc_xprt_switch *xps = rpc_sysfs_xprt_kobj_get_xprt_switch(kobj);
5b7eb784 OK	294
bfc48f1b XX	295	if (!xprt \|\| !xps) {
	296	count = 0;
	297	goto out_put;
	298	}
5b7eb784 OK	299
	300	if (!strncmp(buf, "offline", 7))
	301	offline = 1;
	302	else if (!strncmp(buf, "online", 6))
	303	online = 1;
6f081693 OK	304	else if (!strncmp(buf, "remove", 6))
6f081693 OK	305	remove = 1;
776d794f XY	306	else {
	307	count = -EINVAL;
	308	goto out_put;
	309	}
5b7eb784 OK	310
	311	if (wait_on_bit_lock(&xprt->state, XPRT_LOCKED, TASK_KILLABLE)) {
	312	count = -EINTR;
	313	goto out_put;
	314	}
	315	if (xprt->main) {
	316	count = -EINVAL;
	317	goto release_tasks;
	318	}
	319	if (offline) {
7ffcdaa6	320	xprt_set_offline_locked(xprt, xps);
5b7eb784	321	} else if (online) {
7ffcdaa6	322	xprt_set_online_locked(xprt, xps);
6f081693	323	} else if (remove) {
7ffcdaa6 OK	324	if (test_bit(XPRT_OFFLINE, &xprt->state))
	325	xprt_delete_locked(xprt, xps);
	326	else
6f081693	327	count = -EINVAL;
5b7eb784 OK	328	}
	329
	330	release_tasks:
	331	xprt_release_write(xprt, NULL);
	332	out_put:
	333	xprt_put(xprt);
	334	xprt_switch_put(xps);
	335	return count;
	336	}
	337
74678748 OK	338	int rpc_sysfs_init(void)
	339	{
	340	rpc_sunrpc_kset = kset_create_and_add("sunrpc", NULL, kernel_kobj);
	341	if (!rpc_sunrpc_kset)
	342	return -ENOMEM;
baea9944 OK	343	rpc_sunrpc_client_kobj =
	344	rpc_sysfs_object_alloc("rpc-clients", rpc_sunrpc_kset, NULL);
	345	if (!rpc_sunrpc_client_kobj)
	346	goto err_client;
	347	rpc_sunrpc_xprt_switch_kobj =
	348	rpc_sysfs_object_alloc("xprt-switches", rpc_sunrpc_kset, NULL);
	349	if (!rpc_sunrpc_xprt_switch_kobj)
	350	goto err_switch;
74678748	351	return 0;
baea9944 OK	352	err_switch:
	353	kobject_put(rpc_sunrpc_client_kobj);
	354	rpc_sunrpc_client_kobj = NULL;
	355	err_client:
	356	kset_unregister(rpc_sunrpc_kset);
	357	rpc_sunrpc_kset = NULL;
	358	return -ENOMEM;
74678748 OK	359	}
74678748 OK	360
c5a382eb OK	361	static void rpc_sysfs_client_release(struct kobject *kobj)
	362	{
	363	struct rpc_sysfs_client *c;
	364
	365	c = container_of(kobj, struct rpc_sysfs_client, kobject);
	366	kfree(c);
	367	}
	368
baea9944 OK	369	static void rpc_sysfs_xprt_switch_release(struct kobject *kobj)
	370	{
	371	struct rpc_sysfs_xprt_switch *xprt_switch;
	372
	373	xprt_switch = container_of(kobj, struct rpc_sysfs_xprt_switch, kobject);
	374	kfree(xprt_switch);
	375	}
	376
d408ebe0 OK	377	static void rpc_sysfs_xprt_release(struct kobject *kobj)
	378	{
	379	struct rpc_sysfs_xprt *xprt;
	380
	381	xprt = container_of(kobj, struct rpc_sysfs_xprt, kobject);
	382	kfree(xprt);
	383	}
	384
02a476d9	385	static const void rpc_sysfs_client_namespace(const struct kobject kobj)
c5a382eb OK	386	{
	387	return container_of(kobj, struct rpc_sysfs_client, kobject)->net;
	388	}
	389
02a476d9	390	static const void rpc_sysfs_xprt_switch_namespace(const struct kobject kobj)
baea9944 OK	391	{
	392	return container_of(kobj, struct rpc_sysfs_xprt_switch, kobject)->net;
	393	}
	394
02a476d9	395	static const void rpc_sysfs_xprt_namespace(const struct kobject kobj)
d408ebe0 OK	396	{
	397	return container_of(kobj, struct rpc_sysfs_xprt,
	398	kobject)->xprt->xprt_net;
	399	}
	400
587bc725 OK	401	static struct kobj_attribute rpc_sysfs_xprt_dstaddr = __ATTR(dstaddr,
	402	0644, rpc_sysfs_xprt_dstaddr_show, rpc_sysfs_xprt_dstaddr_store);
	403
e44773da AS	404	static struct kobj_attribute rpc_sysfs_xprt_srcaddr = __ATTR(srcaddr,
	405	0644, rpc_sysfs_xprt_srcaddr_show, NULL);
	406
4a09651a OK	407	static struct kobj_attribute rpc_sysfs_xprt_info = __ATTR(xprt_info,
	408	0444, rpc_sysfs_xprt_info_show, NULL);
	409
681d5699	410	static struct kobj_attribute rpc_sysfs_xprt_change_state = __ATTR(xprt_state,
5b7eb784	411	0644, rpc_sysfs_xprt_state_show, rpc_sysfs_xprt_state_change);
681d5699	412
587bc725 OK	413	static struct attribute *rpc_sysfs_xprt_attrs[] = {
587bc725 OK	414	&rpc_sysfs_xprt_dstaddr.attr,
e44773da	415	&rpc_sysfs_xprt_srcaddr.attr,
4a09651a	416	&rpc_sysfs_xprt_info.attr,
681d5699	417	&rpc_sysfs_xprt_change_state.attr,
587bc725 OK	418	NULL,
587bc725 OK	419	};
86439fa2	420	ATTRIBUTE_GROUPS(rpc_sysfs_xprt);
587bc725	421
0e559035 OK	422	static struct kobj_attribute rpc_sysfs_xprt_switch_info =
	423	__ATTR(xprt_switch_info, 0444, rpc_sysfs_xprt_switch_info_show, NULL);
	424
	425	static struct attribute *rpc_sysfs_xprt_switch_attrs[] = {
	426	&rpc_sysfs_xprt_switch_info.attr,
	427	NULL,
	428	};
86439fa2	429	ATTRIBUTE_GROUPS(rpc_sysfs_xprt_switch);
0e559035	430
d67307b4	431	static const struct kobj_type rpc_sysfs_client_type = {
c5a382eb OK	432	.release = rpc_sysfs_client_release,
	433	.sysfs_ops = &kobj_sysfs_ops,
	434	.namespace = rpc_sysfs_client_namespace,
	435	};
	436
d67307b4	437	static const struct kobj_type rpc_sysfs_xprt_switch_type = {
baea9944	438	.release = rpc_sysfs_xprt_switch_release,
86439fa2	439	.default_groups = rpc_sysfs_xprt_switch_groups,
baea9944 OK	440	.sysfs_ops = &kobj_sysfs_ops,
	441	.namespace = rpc_sysfs_xprt_switch_namespace,
	442	};
	443
d67307b4	444	static const struct kobj_type rpc_sysfs_xprt_type = {
d408ebe0	445	.release = rpc_sysfs_xprt_release,
86439fa2	446	.default_groups = rpc_sysfs_xprt_groups,
d408ebe0 OK	447	.sysfs_ops = &kobj_sysfs_ops,
	448	.namespace = rpc_sysfs_xprt_namespace,
	449	};
	450
74678748 OK	451	void rpc_sysfs_exit(void)
74678748 OK	452	{
c441f125	453	kobject_put(rpc_sunrpc_client_kobj);
baea9944	454	kobject_put(rpc_sunrpc_xprt_switch_kobj);
74678748 OK	455	kset_unregister(rpc_sunrpc_kset);
74678748 OK	456	}
c5a382eb OK	457
	458	static struct rpc_sysfs_client rpc_sysfs_client_alloc(struct kobject parent,
	459	struct net *net,
	460	int clid)
	461	{
	462	struct rpc_sysfs_client *p;
	463
	464	p = kzalloc(sizeof(*p), GFP_KERNEL);
	465	if (p) {
	466	p->net = net;
	467	p->kobject.kset = rpc_sunrpc_kset;
	468	if (kobject_init_and_add(&p->kobject, &rpc_sysfs_client_type,
	469	parent, "clnt-%d", clid) == 0)
	470	return p;
	471	kobject_put(&p->kobject);
	472	}
	473	return NULL;
	474	}
	475
baea9944 OK	476	static struct rpc_sysfs_xprt_switch *
	477	rpc_sysfs_xprt_switch_alloc(struct kobject *parent,
	478	struct rpc_xprt_switch *xprt_switch,
	479	struct net *net,
	480	gfp_t gfp_flags)
	481	{
	482	struct rpc_sysfs_xprt_switch *p;
	483
	484	p = kzalloc(sizeof(*p), gfp_flags);
	485	if (p) {
	486	p->net = net;
	487	p->kobject.kset = rpc_sunrpc_kset;
	488	if (kobject_init_and_add(&p->kobject,
	489	&rpc_sysfs_xprt_switch_type,
	490	parent, "switch-%d",
	491	xprt_switch->xps_id) == 0)
	492	return p;
	493	kobject_put(&p->kobject);
	494	}
	495	return NULL;
	496	}
	497
d408ebe0 OK	498	static struct rpc_sysfs_xprt rpc_sysfs_xprt_alloc(struct kobject parent,
	499	struct rpc_xprt *xprt,
	500	gfp_t gfp_flags)
	501	{
	502	struct rpc_sysfs_xprt *p;
	503
	504	p = kzalloc(sizeof(*p), gfp_flags);
	505	if (!p)
	506	goto out;
	507	p->kobject.kset = rpc_sunrpc_kset;
	508	if (kobject_init_and_add(&p->kobject, &rpc_sysfs_xprt_type,
	509	parent, "xprt-%d-%s", xprt->id,
	510	xprt->address_strings[RPC_DISPLAY_PROTO]) == 0)
	511	return p;
	512	kobject_put(&p->kobject);
	513	out:
	514	return NULL;
	515	}
	516
2a338a54 OK	517	void rpc_sysfs_client_setup(struct rpc_clnt *clnt,
	518	struct rpc_xprt_switch *xprt_switch,
	519	struct net *net)
c5a382eb OK	520	{
c5a382eb OK	521	struct rpc_sysfs_client *rpc_client;
cbdeaee9 ZX	522	struct rpc_sysfs_xprt_switch *xswitch =
	523	(struct rpc_sysfs_xprt_switch *)xprt_switch->xps_sysfs;
	524
	525	if (!xswitch)
	526	return;
c5a382eb	527
2a338a54 OK	528	rpc_client = rpc_sysfs_client_alloc(rpc_sunrpc_client_kobj,
2a338a54 OK	529	net, clnt->cl_clid);
c5a382eb	530	if (rpc_client) {
2a338a54	531	char name[] = "switch";
2a338a54 OK	532	int ret;
2a338a54 OK	533
c5a382eb	534	clnt->cl_sysfs = rpc_client;
2a338a54 OK	535	rpc_client->clnt = clnt;
2a338a54 OK	536	rpc_client->xprt_switch = xprt_switch;
c5a382eb	537	kobject_uevent(&rpc_client->kobject, KOBJ_ADD);
2a338a54 OK	538	ret = sysfs_create_link_nowarn(&rpc_client->kobject,
	539	&xswitch->kobject, name);
	540	if (ret)
	541	pr_warn("can't create link to %s in sysfs (%d)\n",
	542	name, ret);
c5a382eb OK	543	}
	544	}
	545
baea9944 OK	546	void rpc_sysfs_xprt_switch_setup(struct rpc_xprt_switch *xprt_switch,
	547	struct rpc_xprt *xprt,
	548	gfp_t gfp_flags)
	549	{
	550	struct rpc_sysfs_xprt_switch *rpc_xprt_switch;
	551	struct net *net;
	552
	553	if (xprt_switch->xps_net)
	554	net = xprt_switch->xps_net;
	555	else
	556	net = xprt->xprt_net;
	557	rpc_xprt_switch =
	558	rpc_sysfs_xprt_switch_alloc(rpc_sunrpc_xprt_switch_kobj,
	559	xprt_switch, net, gfp_flags);
	560	if (rpc_xprt_switch) {
	561	xprt_switch->xps_sysfs = rpc_xprt_switch;
	562	rpc_xprt_switch->xprt_switch = xprt_switch;
	563	rpc_xprt_switch->xprt = xprt;
	564	kobject_uevent(&rpc_xprt_switch->kobject, KOBJ_ADD);
cbdeaee9 ZX	565	} else {
cbdeaee9 ZX	566	xprt_switch->xps_sysfs = NULL;
baea9944 OK	567	}
	568	}
	569
d408ebe0 OK	570	void rpc_sysfs_xprt_setup(struct rpc_xprt_switch *xprt_switch,
	571	struct rpc_xprt *xprt,
	572	gfp_t gfp_flags)
	573	{
	574	struct rpc_sysfs_xprt *rpc_xprt;
	575	struct rpc_sysfs_xprt_switch *switch_obj =
	576	(struct rpc_sysfs_xprt_switch *)xprt_switch->xps_sysfs;
	577
cbdeaee9 ZX	578	if (!switch_obj)
	579	return;
	580
d408ebe0 OK	581	rpc_xprt = rpc_sysfs_xprt_alloc(&switch_obj->kobject, xprt, gfp_flags);
	582	if (rpc_xprt) {
	583	xprt->xprt_sysfs = rpc_xprt;
	584	rpc_xprt->xprt = xprt;
5b7eb784	585	rpc_xprt->xprt_switch = xprt_switch;
d408ebe0 OK	586	kobject_uevent(&rpc_xprt->kobject, KOBJ_ADD);
	587	}
	588	}
	589
c5a382eb OK	590	void rpc_sysfs_client_destroy(struct rpc_clnt *clnt)
	591	{
	592	struct rpc_sysfs_client *rpc_client = clnt->cl_sysfs;
	593
	594	if (rpc_client) {
2a338a54 OK	595	char name[] = "switch";
	596
	597	sysfs_remove_link(&rpc_client->kobject, name);
c5a382eb OK	598	kobject_uevent(&rpc_client->kobject, KOBJ_REMOVE);
	599	kobject_del(&rpc_client->kobject);
	600	kobject_put(&rpc_client->kobject);
	601	clnt->cl_sysfs = NULL;
	602	}
	603	}
baea9944 OK	604
	605	void rpc_sysfs_xprt_switch_destroy(struct rpc_xprt_switch *xprt_switch)
	606	{
	607	struct rpc_sysfs_xprt_switch *rpc_xprt_switch = xprt_switch->xps_sysfs;
	608
	609	if (rpc_xprt_switch) {
	610	kobject_uevent(&rpc_xprt_switch->kobject, KOBJ_REMOVE);
	611	kobject_del(&rpc_xprt_switch->kobject);
	612	kobject_put(&rpc_xprt_switch->kobject);
	613	xprt_switch->xps_sysfs = NULL;
	614	}
	615	}
d408ebe0 OK	616
	617	void rpc_sysfs_xprt_destroy(struct rpc_xprt *xprt)
	618	{
	619	struct rpc_sysfs_xprt *rpc_xprt = xprt->xprt_sysfs;
	620
	621	if (rpc_xprt) {
	622	kobject_uevent(&rpc_xprt->kobject, KOBJ_REMOVE);
	623	kobject_del(&rpc_xprt->kobject);
	624	kobject_put(&rpc_xprt->kobject);
	625	xprt->xprt_sysfs = NULL;
	626	}
	627	}