nfsd: make NFSd service structure allocated per net

This patch makes main step in NFSd containerisation.

There could be different approaches to how to make NFSd able to handle
incoming RPC request from different network namespaces.  The two main
options are:

1) Share NFSd kthreads betwween all network namespaces.
2) Create separated pool of threads for each namespace.

While first approach looks more flexible, second one is simpler and
non-racy.  This patch implements the second option.

To make it possible to allocate separate pools of threads, we have to
make it possible to allocate separate NFSd service structures per net.

Signed-off-by: Stanislav Kinsbursky <skinsbursky@parallels.com>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>

1 files changed, 38 insertions, 25 deletions

diff --git a/fs/nfsd/nfsctl.c b/fs/nfsd/nfsctl.c
index 8536100b7fc1..74934284d9a7 100644
--- a/fs/nfsd/nfsctl.c
+++ b/fs/nfsd/nfsctl.c
@@ -409,7 +409,7 @@ static ssize_t write_threads(struct file *file, char *buf, size_t size)
                 if (rv < 0)
                         return rv;
         } else
-                rv = nfsd_nrthreads();
+                rv = nfsd_nrthreads(net);
 
         return scnprintf(buf, SIMPLE_TRANSACTION_LIMIT, "%d\n", rv);
 }
@@ -450,7 +450,7 @@ static ssize_t write_pool_threads(struct file *file, char *buf, size_t size)
         struct net *net = &init_net;
 
         mutex_lock(&nfsd_mutex);
-        npools = nfsd_nrpools();
+        npools = nfsd_nrpools(net);
         if (npools == 0) {
                 /*
                  * NFS is shut down.  The admin can start it by
@@ -483,7 +483,7 @@ static ssize_t write_pool_threads(struct file *file, char *buf, size_t size)
                         goto out_free;
         }
 
-        rv = nfsd_get_nrthreads(npools, nthreads);
+        rv = nfsd_get_nrthreads(npools, nthreads, net);
         if (rv)
                 goto out_free;
 
@@ -510,11 +510,13 @@ static ssize_t __write_versions(struct file *file, char *buf, size_t size)
         unsigned minor;
         ssize_t tlen = 0;
         char *sep;
+        struct net *net = &init_net;
+        struct nfsd_net *nn = net_generic(net, nfsd_net_id);
 
         if (size>0) {
-                if (nfsd_serv)
+                if (nn->nfsd_serv)
                         /* Cannot change versions without updating
-                         * nfsd_serv->sv_xdrsize, and reallocing
+                         * nn->nfsd_serv->sv_xdrsize, and reallocing
                          * rq_argp and rq_resp
                          */
                         return -EBUSY;
@@ -645,11 +647,13 @@ static ssize_t write_versions(struct file *file, char *buf, size_t size)
  * Zero-length write.  Return a list of NFSD's current listener
  * transports.
  */
-static ssize_t __write_ports_names(char *buf)
+static ssize_t __write_ports_names(char *buf, struct net *net)
 {
-        if (nfsd_serv == NULL)
+        struct nfsd_net *nn = net_generic(net, nfsd_net_id);
+
+        if (nn->nfsd_serv == NULL)
                 return 0;
-        return svc_xprt_names(nfsd_serv, buf, SIMPLE_TRANSACTION_LIMIT);
+        return svc_xprt_names(nn->nfsd_serv, buf, SIMPLE_TRANSACTION_LIMIT);
 }
 
 /*
@@ -661,6 +665,7 @@ static ssize_t __write_ports_addfd(char *buf, struct net *net)
 {
         char *mesg = buf;
         int fd, err;
+        struct nfsd_net *nn = net_generic(net, nfsd_net_id);
 
         err = get_int(&mesg, &fd);
         if (err != 0 || fd < 0)
@@ -670,14 +675,14 @@ static ssize_t __write_ports_addfd(char *buf, struct net *net)
         if (err != 0)
                 return err;
 
-        err = svc_addsock(nfsd_serv, fd, buf, SIMPLE_TRANSACTION_LIMIT);
+        err = svc_addsock(nn->nfsd_serv, fd, buf, SIMPLE_TRANSACTION_LIMIT);
         if (err < 0) {
                 nfsd_destroy(net);
                 return err;
         }
 
         /* Decrease the count, but don't shut down the service */
-        nfsd_serv->sv_nrthreads--;
+        nn->nfsd_serv->sv_nrthreads--;
         return err;
 }
 
@@ -690,6 +695,7 @@ static ssize_t __write_ports_addxprt(char *buf, struct net *net)
         char transport[16];
         struct svc_xprt *xprt;
         int port, err;
+        struct nfsd_net *nn = net_generic(net, nfsd_net_id);
 
         if (sscanf(buf, "%15s %5u", transport, &port) != 2)
                 return -EINVAL;
@@ -701,21 +707,21 @@ static ssize_t __write_ports_addxprt(char *buf, struct net *net)
         if (err != 0)
                 return err;
 
-        err = svc_create_xprt(nfsd_serv, transport, net,
+        err = svc_create_xprt(nn->nfsd_serv, transport, net,
                                 PF_INET, port, SVC_SOCK_ANONYMOUS);
         if (err < 0)
                 goto out_err;
 
-        err = svc_create_xprt(nfsd_serv, transport, net,
+        err = svc_create_xprt(nn->nfsd_serv, transport, net,
                                 PF_INET6, port, SVC_SOCK_ANONYMOUS);
         if (err < 0 && err != -EAFNOSUPPORT)
                 goto out_close;
 
         /* Decrease the count, but don't shut down the service */
-        nfsd_serv->sv_nrthreads--;
+        nn->nfsd_serv->sv_nrthreads--;
         return 0;
 out_close:
-        xprt = svc_find_xprt(nfsd_serv, transport, net, PF_INET, port);
+        xprt = svc_find_xprt(nn->nfsd_serv, transport, net, PF_INET, port);
         if (xprt != NULL) {
                 svc_close_xprt(xprt);
                 svc_xprt_put(xprt);
@@ -729,7 +735,7 @@ static ssize_t __write_ports(struct file *file, char *buf, size_t size,
                              struct net *net)
 {
         if (size == 0)
-                return __write_ports_names(buf);
+                return __write_ports_names(buf, net);
 
         if (isdigit(buf[0]))
                 return __write_ports_addfd(buf, net);
@@ -821,6 +827,9 @@ int nfsd_max_blksize;
 static ssize_t write_maxblksize(struct file *file, char *buf, size_t size)
 {
         char *mesg = buf;
+        struct net *net = &init_net;
+        struct nfsd_net *nn = net_generic(net, nfsd_net_id);
+
         if (size > 0) {
                 int bsize;
                 int rv = get_int(&mesg, &bsize);
@@ -835,7 +844,7 @@ static ssize_t write_maxblksize(struct file *file, char *buf, size_t size)
                         bsize = NFSSVC_MAXBLKSIZE;
                 bsize &= ~(1024-1);
                 mutex_lock(&nfsd_mutex);
-                if (nfsd_serv) {
+                if (nn->nfsd_serv) {
                         mutex_unlock(&nfsd_mutex);
                         return -EBUSY;
                 }
@@ -848,13 +857,14 @@ static ssize_t write_maxblksize(struct file *file, char *buf, size_t size)
 }
 
 #ifdef CONFIG_NFSD_V4
-static ssize_t __nfsd4_write_time(struct file *file, char *buf, size_t size, time_t *time)
+static ssize_t __nfsd4_write_time(struct file *file, char *buf, size_t size,
+                                  time_t *time, struct nfsd_net *nn)
 {
         char *mesg = buf;
         int rv, i;
 
         if (size > 0) {
-                if (nfsd_serv)
+                if (nn->nfsd_serv)
                         return -EBUSY;
                 rv = get_int(&mesg, &i);
                 if (rv)
@@ -879,12 +889,13 @@ static ssize_t __nfsd4_write_time(struct file *file, char *buf, size_t size, tim
         return scnprintf(buf, SIMPLE_TRANSACTION_LIMIT, "%ld\n", *time);
 }
 
-static ssize_t nfsd4_write_time(struct file *file, char *buf, size_t size, time_t *time)
+static ssize_t nfsd4_write_time(struct file *file, char *buf, size_t size,
+                                time_t *time, struct nfsd_net *nn)
 {
         ssize_t rv;
 
         mutex_lock(&nfsd_mutex);
-        rv = __nfsd4_write_time(file, buf, size, time);
+        rv = __nfsd4_write_time(file, buf, size, time, nn);
         mutex_unlock(&nfsd_mutex);
         return rv;
 }
@@ -913,7 +924,7 @@ static ssize_t nfsd4_write_time(struct file *file, char *buf, size_t size, time_
 static ssize_t write_leasetime(struct file *file, char *buf, size_t size)
 {
         struct nfsd_net *nn = net_generic(&init_net, nfsd_net_id);
-        return nfsd4_write_time(file, buf, size, &nn->nfsd4_lease);
+        return nfsd4_write_time(file, buf, size, &nn->nfsd4_lease, nn);
 }
 
 /**
@@ -929,17 +940,18 @@ static ssize_t write_leasetime(struct file *file, char *buf, size_t size)
 static ssize_t write_gracetime(struct file *file, char *buf, size_t size)
 {
         struct nfsd_net *nn = net_generic(&init_net, nfsd_net_id);
-        return nfsd4_write_time(file, buf, size, &nn->nfsd4_grace);
+        return nfsd4_write_time(file, buf, size, &nn->nfsd4_grace, nn);
 }
 
-static ssize_t __write_recoverydir(struct file *file, char *buf, size_t size)
+static ssize_t __write_recoverydir(struct file *file, char *buf, size_t size,
+                                   struct nfsd_net *nn)
 {
         char *mesg = buf;
         char *recdir;
         int len, status;
 
         if (size > 0) {
-                if (nfsd_serv)
+                if (nn->nfsd_serv)
                         return -EBUSY;
                 if (size > PATH_MAX || buf[size-1] != '\n')
                         return -EINVAL;
@@ -983,9 +995,10 @@ static ssize_t __write_recoverydir(struct file *file, char *buf, size_t size)
 static ssize_t write_recoverydir(struct file *file, char *buf, size_t size)
 {
         ssize_t rv;
+        struct nfsd_net *nn = net_generic(&init_net, nfsd_net_id);
 
         mutex_lock(&nfsd_mutex);
-        rv = __write_recoverydir(file, buf, size);
+        rv = __write_recoverydir(file, buf, size, nn);
         mutex_unlock(&nfsd_mutex);
         return rv;
 }