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