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 }