Merge tag 'wq-for-6.6' of git://git.kernel.org/pub/scm/linux/kernel/git/tj/wq
[platform/kernel/linux-rpi.git] / fs / nfs / sysfs.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Copyright (c) 2019 Hammerspace Inc
4  */
5
6 #include <linux/module.h>
7 #include <linux/kobject.h>
8 #include <linux/sysfs.h>
9 #include <linux/fs.h>
10 #include <linux/slab.h>
11 #include <linux/netdevice.h>
12 #include <linux/string.h>
13 #include <linux/nfs_fs.h>
14 #include <linux/rcupdate.h>
15 #include <linux/lockd/lockd.h>
16
17 #include "nfs4_fs.h"
18 #include "netns.h"
19 #include "sysfs.h"
20
21 static struct kset *nfs_kset;
22
23 static void nfs_kset_release(struct kobject *kobj)
24 {
25         struct kset *kset = container_of(kobj, struct kset, kobj);
26         kfree(kset);
27 }
28
29 static const struct kobj_ns_type_operations *nfs_netns_object_child_ns_type(
30                 const struct kobject *kobj)
31 {
32         return &net_ns_type_operations;
33 }
34
35 static struct kobj_type nfs_kset_type = {
36         .release = nfs_kset_release,
37         .sysfs_ops = &kobj_sysfs_ops,
38         .child_ns_type = nfs_netns_object_child_ns_type,
39 };
40
41 int nfs_sysfs_init(void)
42 {
43         int ret;
44
45         nfs_kset = kzalloc(sizeof(*nfs_kset), GFP_KERNEL);
46         if (!nfs_kset)
47                 return -ENOMEM;
48
49         ret = kobject_set_name(&nfs_kset->kobj, "nfs");
50         if (ret) {
51                 kfree(nfs_kset);
52                 return ret;
53         }
54
55         nfs_kset->kobj.parent = fs_kobj;
56         nfs_kset->kobj.ktype = &nfs_kset_type;
57         nfs_kset->kobj.kset = NULL;
58
59         ret = kset_register(nfs_kset);
60         if (ret) {
61                 kfree(nfs_kset);
62                 return ret;
63         }
64
65         return 0;
66 }
67
68 void nfs_sysfs_exit(void)
69 {
70         kset_unregister(nfs_kset);
71 }
72
73 static ssize_t nfs_netns_identifier_show(struct kobject *kobj,
74                 struct kobj_attribute *attr, char *buf)
75 {
76         struct nfs_netns_client *c = container_of(kobj,
77                         struct nfs_netns_client,
78                         kobject);
79         ssize_t ret;
80
81         rcu_read_lock();
82         ret = sysfs_emit(buf, "%s\n", rcu_dereference(c->identifier));
83         rcu_read_unlock();
84         return ret;
85 }
86
87 /* Strip trailing '\n' */
88 static size_t nfs_string_strip(const char *c, size_t len)
89 {
90         while (len > 0 && c[len-1] == '\n')
91                 --len;
92         return len;
93 }
94
95 static ssize_t nfs_netns_identifier_store(struct kobject *kobj,
96                 struct kobj_attribute *attr,
97                 const char *buf, size_t count)
98 {
99         struct nfs_netns_client *c = container_of(kobj,
100                         struct nfs_netns_client,
101                         kobject);
102         const char *old;
103         char *p;
104         size_t len;
105
106         len = nfs_string_strip(buf, min_t(size_t, count, CONTAINER_ID_MAXLEN));
107         if (!len)
108                 return 0;
109         p = kmemdup_nul(buf, len, GFP_KERNEL);
110         if (!p)
111                 return -ENOMEM;
112         old = rcu_dereference_protected(xchg(&c->identifier, (char __rcu *)p), 1);
113         if (old) {
114                 synchronize_rcu();
115                 kfree(old);
116         }
117         return count;
118 }
119
120 static void nfs_netns_client_release(struct kobject *kobj)
121 {
122         struct nfs_netns_client *c = container_of(kobj,
123                         struct nfs_netns_client,
124                         kobject);
125
126         kfree(rcu_dereference_raw(c->identifier));
127 }
128
129 static const void *nfs_netns_client_namespace(const struct kobject *kobj)
130 {
131         return container_of(kobj, struct nfs_netns_client, kobject)->net;
132 }
133
134 static struct kobj_attribute nfs_netns_client_id = __ATTR(identifier,
135                 0644, nfs_netns_identifier_show, nfs_netns_identifier_store);
136
137 static struct attribute *nfs_netns_client_attrs[] = {
138         &nfs_netns_client_id.attr,
139         NULL,
140 };
141 ATTRIBUTE_GROUPS(nfs_netns_client);
142
143 static struct kobj_type nfs_netns_client_type = {
144         .release = nfs_netns_client_release,
145         .default_groups = nfs_netns_client_groups,
146         .sysfs_ops = &kobj_sysfs_ops,
147         .namespace = nfs_netns_client_namespace,
148 };
149
150 static void nfs_netns_object_release(struct kobject *kobj)
151 {
152         struct nfs_netns_client *c = container_of(kobj,
153                         struct nfs_netns_client,
154                         nfs_net_kobj);
155         kfree(c);
156 }
157
158 static const void *nfs_netns_namespace(const struct kobject *kobj)
159 {
160         return container_of(kobj, struct nfs_netns_client, nfs_net_kobj)->net;
161 }
162
163 static struct kobj_type nfs_netns_object_type = {
164         .release = nfs_netns_object_release,
165         .sysfs_ops = &kobj_sysfs_ops,
166         .namespace =  nfs_netns_namespace,
167 };
168
169 static struct nfs_netns_client *nfs_netns_client_alloc(struct kobject *parent,
170                 struct net *net)
171 {
172         struct nfs_netns_client *p;
173
174         p = kzalloc(sizeof(*p), GFP_KERNEL);
175         if (p) {
176                 p->net = net;
177                 p->kobject.kset = nfs_kset;
178                 p->nfs_net_kobj.kset = nfs_kset;
179
180                 if (kobject_init_and_add(&p->nfs_net_kobj, &nfs_netns_object_type,
181                                         parent, "net") != 0) {
182                         kobject_put(&p->nfs_net_kobj);
183                         return NULL;
184                 }
185
186                 if (kobject_init_and_add(&p->kobject, &nfs_netns_client_type,
187                                         &p->nfs_net_kobj, "nfs_client") == 0)
188                         return p;
189
190                 kobject_put(&p->kobject);
191         }
192         return NULL;
193 }
194
195 void nfs_netns_sysfs_setup(struct nfs_net *netns, struct net *net)
196 {
197         struct nfs_netns_client *clp;
198
199         clp = nfs_netns_client_alloc(&nfs_kset->kobj, net);
200         if (clp) {
201                 netns->nfs_client = clp;
202                 kobject_uevent(&clp->kobject, KOBJ_ADD);
203         }
204 }
205
206 void nfs_netns_sysfs_destroy(struct nfs_net *netns)
207 {
208         struct nfs_netns_client *clp = netns->nfs_client;
209
210         if (clp) {
211                 kobject_uevent(&clp->kobject, KOBJ_REMOVE);
212                 kobject_del(&clp->kobject);
213                 kobject_put(&clp->kobject);
214                 kobject_del(&clp->nfs_net_kobj);
215                 kobject_put(&clp->nfs_net_kobj);
216                 netns->nfs_client = NULL;
217         }
218 }
219
220 static bool shutdown_match_client(const struct rpc_task *task, const void *data)
221 {
222         return true;
223 }
224
225 static void shutdown_client(struct rpc_clnt *clnt)
226 {
227         clnt->cl_shutdown = 1;
228         rpc_cancel_tasks(clnt, -EIO, shutdown_match_client, NULL);
229 }
230
231 static ssize_t
232 shutdown_show(struct kobject *kobj, struct kobj_attribute *attr,
233                                 char *buf)
234 {
235         struct nfs_server *server = container_of(kobj, struct nfs_server, kobj);
236         bool shutdown = server->flags & NFS_MOUNT_SHUTDOWN;
237         return sysfs_emit(buf, "%d\n", shutdown);
238 }
239
240 static ssize_t
241 shutdown_store(struct kobject *kobj, struct kobj_attribute *attr,
242                                 const char *buf, size_t count)
243 {
244         struct nfs_server *server;
245         int ret, val;
246
247         server = container_of(kobj, struct nfs_server, kobj);
248
249         ret = kstrtoint(buf, 0, &val);
250         if (ret)
251                 return ret;
252
253         if (val != 1)
254                 return -EINVAL;
255
256         /* already shut down? */
257         if (server->flags & NFS_MOUNT_SHUTDOWN)
258                 goto out;
259
260         server->flags |= NFS_MOUNT_SHUTDOWN;
261         shutdown_client(server->client);
262         shutdown_client(server->nfs_client->cl_rpcclient);
263
264         if (!IS_ERR(server->client_acl))
265                 shutdown_client(server->client_acl);
266
267         if (server->nlm_host)
268                 shutdown_client(server->nlm_host->h_rpcclnt);
269 out:
270         return count;
271 }
272
273 static struct kobj_attribute nfs_sysfs_attr_shutdown = __ATTR_RW(shutdown);
274
275 #define RPC_CLIENT_NAME_SIZE 64
276
277 void nfs_sysfs_link_rpc_client(struct nfs_server *server,
278                         struct rpc_clnt *clnt, const char *uniq)
279 {
280         char name[RPC_CLIENT_NAME_SIZE];
281         int ret;
282
283         strcpy(name, clnt->cl_program->name);
284         strcat(name, uniq ? uniq : "");
285         strcat(name, "_client");
286
287         ret = sysfs_create_link_nowarn(&server->kobj,
288                                                 &clnt->cl_sysfs->kobject, name);
289         if (ret < 0)
290                 pr_warn("NFS: can't create link to %s in sysfs (%d)\n",
291                         name, ret);
292 }
293 EXPORT_SYMBOL_GPL(nfs_sysfs_link_rpc_client);
294
295 static void nfs_sysfs_sb_release(struct kobject *kobj)
296 {
297         /* no-op: why? see lib/kobject.c kobject_cleanup() */
298 }
299
300 static const void *nfs_netns_server_namespace(const struct kobject *kobj)
301 {
302         return container_of(kobj, struct nfs_server, kobj)->nfs_client->cl_net;
303 }
304
305 static struct kobj_type nfs_sb_ktype = {
306         .release = nfs_sysfs_sb_release,
307         .sysfs_ops = &kobj_sysfs_ops,
308         .namespace = nfs_netns_server_namespace,
309         .child_ns_type = nfs_netns_object_child_ns_type,
310 };
311
312 void nfs_sysfs_add_server(struct nfs_server *server)
313 {
314         int ret;
315
316         ret = kobject_init_and_add(&server->kobj, &nfs_sb_ktype,
317                                 &nfs_kset->kobj, "server-%d", server->s_sysfs_id);
318         if (ret < 0) {
319                 pr_warn("NFS: nfs sysfs add server-%d failed (%d)\n",
320                                         server->s_sysfs_id, ret);
321                 return;
322         }
323         ret = sysfs_create_file_ns(&server->kobj, &nfs_sysfs_attr_shutdown.attr,
324                                 nfs_netns_server_namespace(&server->kobj));
325         if (ret < 0)
326                 pr_warn("NFS: sysfs_create_file_ns for server-%d failed (%d)\n",
327                         server->s_sysfs_id, ret);
328 }
329 EXPORT_SYMBOL_GPL(nfs_sysfs_add_server);
330
331 void nfs_sysfs_move_server_to_sb(struct super_block *s)
332 {
333         struct nfs_server *server = s->s_fs_info;
334         int ret;
335
336         ret = kobject_rename(&server->kobj, s->s_id);
337         if (ret < 0)
338                 pr_warn("NFS: rename sysfs %s failed (%d)\n",
339                                         server->kobj.name, ret);
340 }
341
342 void nfs_sysfs_move_sb_to_server(struct nfs_server *server)
343 {
344         const char *s;
345         int ret = -ENOMEM;
346
347         s = kasprintf(GFP_KERNEL, "server-%d", server->s_sysfs_id);
348         if (s) {
349                 ret = kobject_rename(&server->kobj, s);
350                 kfree(s);
351         }
352         if (ret < 0)
353                 pr_warn("NFS: rename sysfs %s failed (%d)\n",
354                                         server->kobj.name, ret);
355 }
356
357 /* unlink, not dec-ref */
358 void nfs_sysfs_remove_server(struct nfs_server *server)
359 {
360         kobject_del(&server->kobj);
361 }