Merge nfs containerization work from Trond's tree

The nfs containerization work is a prerequisite for Jeff Layton's reboot
recovery rework.

8 files changed, 194 insertions, 70 deletions

diff --git a/fs/lockd/clnt4xdr.c b/fs/lockd/clnt4xdr.c
index f848b52c67b1..3ddcbb1c0a43 100644
--- a/fs/lockd/clnt4xdr.c
+++ b/fs/lockd/clnt4xdr.c
@@ -598,7 +598,7 @@ static struct rpc_procinfo	nlm4_procedures[] = {
         PROC(GRANTED_RES,       res,            norep),
 };
 
-struct rpc_version      nlm_version4 = {
+const struct rpc_version nlm_version4 = {
         .number         = 4,
         .nrprocs        = ARRAY_SIZE(nlm4_procedures),
         .procs          = nlm4_procedures,
diff --git a/fs/lockd/clntlock.c b/fs/lockd/clntlock.c
index 8d4ea8351e3d..ba1dc2eebd1e 100644
--- a/fs/lockd/clntlock.c
+++ b/fs/lockd/clntlock.c
@@ -62,7 +62,8 @@ struct nlm_host *nlmclnt_init(const struct nlmclnt_initdata *nlm_init)
 
         host = nlmclnt_lookup_host(nlm_init->address, nlm_init->addrlen,
                                    nlm_init->protocol, nlm_version,
-                                   nlm_init->hostname, nlm_init->noresvport);
+                                   nlm_init->hostname, nlm_init->noresvport,
+                                   nlm_init->net);
         if (host == NULL) {
                 lockd_down();
                 return ERR_PTR(-ENOLCK);
diff --git a/fs/lockd/clntxdr.c b/fs/lockd/clntxdr.c
index 180ac34feb9a..3d35e3e80c1c 100644
--- a/fs/lockd/clntxdr.c
+++ b/fs/lockd/clntxdr.c
@@ -596,19 +596,19 @@ static struct rpc_procinfo	nlm_procedures[] = {
         PROC(GRANTED_RES,       res,            norep),
 };
 
-static struct rpc_version       nlm_version1 = {
+static const struct rpc_version nlm_version1 = {
                 .number         = 1,
                 .nrprocs        = ARRAY_SIZE(nlm_procedures),
                 .procs          = nlm_procedures,
 };
 
-static struct rpc_version       nlm_version3 = {
+static const struct rpc_version nlm_version3 = {
                 .number         = 3,
                 .nrprocs        = ARRAY_SIZE(nlm_procedures),
                 .procs          = nlm_procedures,
 };
 
-static struct rpc_version       *nlm_versions[] = {
+static const struct rpc_version *nlm_versions[] = {
         [1] = &nlm_version1,
         [3] = &nlm_version3,
 #ifdef CONFIG_LOCKD_V4
@@ -618,7 +618,7 @@ static struct rpc_version	*nlm_versions[] = {
 
 static struct rpc_stat          nlm_rpc_stats;
 
-struct rpc_program              nlm_program = {
+const struct rpc_program        nlm_program = {
                 .name           = "lockd",
                 .number         = NLM_PROGRAM,
                 .nrvers         = ARRAY_SIZE(nlm_versions),
diff --git a/fs/lockd/host.c b/fs/lockd/host.c
index 6f29836ec0cb..eb75ca7c2d6e 100644
--- a/fs/lockd/host.c
+++ b/fs/lockd/host.c
@@ -17,6 +17,8 @@
 #include <linux/lockd/lockd.h>
 #include <linux/mutex.h>
 
+#include <linux/sunrpc/svc_xprt.h>
+
 #include <net/ipv6.h>
 
 #define NLMDBG_FACILITY         NLMDBG_HOSTCACHE
@@ -54,6 +56,7 @@ struct nlm_lookup_host_info {
         const char              *hostname;      /* remote's hostname */
         const size_t            hostname_len;   /* it's length */
         const int               noresvport;     /* use non-priv port */
+        struct net              *net;           /* network namespace to bind */
 };
 
 /*
@@ -155,6 +158,7 @@ static struct nlm_host *nlm_alloc_host(struct nlm_lookup_host_info *ni,
         INIT_LIST_HEAD(&host->h_reclaim);
         host->h_nsmhandle  = nsm;
         host->h_addrbuf    = nsm->sm_addrbuf;
+        host->net          = ni->net;
 
 out:
         return host;
@@ -206,7 +210,8 @@ struct nlm_host *nlmclnt_lookup_host(const struct sockaddr *sap,
                                      const unsigned short protocol,
                                      const u32 version,
                                      const char *hostname,
-                                     int noresvport)
+                                     int noresvport,
+                                     struct net *net)
 {
         struct nlm_lookup_host_info ni = {
                 .server         = 0,
@@ -217,6 +222,7 @@ struct nlm_host *nlmclnt_lookup_host(const struct sockaddr *sap,
                 .hostname       = hostname,
                 .hostname_len   = strlen(hostname),
                 .noresvport     = noresvport,
+                .net            = net,
         };
         struct hlist_head *chain;
         struct hlist_node *pos;
@@ -231,6 +237,8 @@ struct nlm_host *nlmclnt_lookup_host(const struct sockaddr *sap,
 
         chain = &nlm_client_hosts[nlm_hash_address(sap)];
         hlist_for_each_entry(host, pos, chain, h_hash) {
+                if (host->net != net)
+                        continue;
                 if (!rpc_cmp_addr(nlm_addr(host), sap))
                         continue;
 
@@ -318,6 +326,7 @@ struct nlm_host *nlmsvc_lookup_host(const struct svc_rqst *rqstp,
         struct nsm_handle *nsm = NULL;
         struct sockaddr *src_sap = svc_daddr(rqstp);
         size_t src_len = rqstp->rq_daddrlen;
+        struct net *net = rqstp->rq_xprt->xpt_net;
         struct nlm_lookup_host_info ni = {
                 .server         = 1,
                 .sap            = svc_addr(rqstp),
@@ -326,6 +335,7 @@ struct nlm_host *nlmsvc_lookup_host(const struct svc_rqst *rqstp,
                 .version        = rqstp->rq_vers,
                 .hostname       = hostname,
                 .hostname_len   = hostname_len,
+                .net            = net,
         };
 
         dprintk("lockd: %s(host='%*s', vers=%u, proto=%s)\n", __func__,
@@ -339,6 +349,8 @@ struct nlm_host *nlmsvc_lookup_host(const struct svc_rqst *rqstp,
 
         chain = &nlm_server_hosts[nlm_hash_address(ni.sap)];
         hlist_for_each_entry(host, pos, chain, h_hash) {
+                if (host->net != net)
+                        continue;
                 if (!rpc_cmp_addr(nlm_addr(host), ni.sap))
                         continue;
 
@@ -431,7 +443,7 @@ nlm_bind_host(struct nlm_host *host)
                         .to_retries     = 5U,
                 };
                 struct rpc_create_args args = {
-                        .net            = &init_net,
+                        .net            = host->net,
                         .protocol       = host->h_proto,
                         .address        = nlm_addr(host),
                         .addrsize       = host->h_addrlen,
@@ -553,12 +565,8 @@ void nlm_host_rebooted(const struct nlm_reboot *info)
         nsm_release(nsm);
 }
 
-/*
- * Shut down the hosts module.
- * Note that this routine is called only at server shutdown time.
- */
 void
-nlm_shutdown_hosts(void)
+nlm_shutdown_hosts_net(struct net *net)
 {
         struct hlist_head *chain;
         struct hlist_node *pos;
@@ -570,6 +578,8 @@ nlm_shutdown_hosts(void)
         /* First, make all hosts eligible for gc */
         dprintk("lockd: nuking all hosts...\n");
         for_each_host(host, pos, chain, nlm_server_hosts) {
+                if (net && host->net != net)
+                        continue;
                 host->h_expires = jiffies - 1;
                 if (host->h_rpcclnt) {
                         rpc_shutdown_client(host->h_rpcclnt);
@@ -580,15 +590,29 @@ nlm_shutdown_hosts(void)
         /* Then, perform a garbage collection pass */
         nlm_gc_hosts();
         mutex_unlock(&nlm_host_mutex);
+}
+
+/*
+ * Shut down the hosts module.
+ * Note that this routine is called only at server shutdown time.
+ */
+void
+nlm_shutdown_hosts(void)
+{
+        struct hlist_head *chain;
+        struct hlist_node *pos;
+        struct nlm_host *host;
+
+        nlm_shutdown_hosts_net(NULL);
 
         /* complain if any hosts are left */
         if (nrhosts != 0) {
                 printk(KERN_WARNING "lockd: couldn't shutdown host module!\n");
                 dprintk("lockd: %lu hosts left:\n", nrhosts);
                 for_each_host(host, pos, chain, nlm_server_hosts) {
-                        dprintk("       %s (cnt %d use %d exp %ld)\n",
+                        dprintk("       %s (cnt %d use %d exp %ld net %p)\n",
                                 host->h_name, atomic_read(&host->h_count),
-                                host->h_inuse, host->h_expires);
+                                host->h_inuse, host->h_expires, host->net);
                 }
         }
 }
diff --git a/fs/lockd/mon.c b/fs/lockd/mon.c
index 65ba36b80a9e..7ef14b3c5bee 100644
--- a/fs/lockd/mon.c
+++ b/fs/lockd/mon.c
@@ -47,7 +47,7 @@ struct nsm_res {
         u32                     state;
 };
 
-static struct rpc_program       nsm_program;
+static const struct rpc_program nsm_program;
 static                          LIST_HEAD(nsm_handles);
 static                          DEFINE_SPINLOCK(nsm_lock);
 
@@ -62,14 +62,14 @@ static inline struct sockaddr *nsm_addr(const struct nsm_handle *nsm)
         return (struct sockaddr *)&nsm->sm_addr;
 }
 
-static struct rpc_clnt *nsm_create(void)
+static struct rpc_clnt *nsm_create(struct net *net)
 {
         struct sockaddr_in sin = {
                 .sin_family             = AF_INET,
                 .sin_addr.s_addr        = htonl(INADDR_LOOPBACK),
         };
         struct rpc_create_args args = {
-                .net                    = &init_net,
+                .net                    = net,
                 .protocol               = XPRT_TRANSPORT_UDP,
                 .address                = (struct sockaddr *)&sin,
                 .addrsize               = sizeof(sin),
@@ -83,7 +83,8 @@ static struct rpc_clnt *nsm_create(void)
         return rpc_create(&args);
 }
 
-static int nsm_mon_unmon(struct nsm_handle *nsm, u32 proc, struct nsm_res *res)
+static int nsm_mon_unmon(struct nsm_handle *nsm, u32 proc, struct nsm_res *res,
+                         struct net *net)
 {
         struct rpc_clnt *clnt;
         int             status;
@@ -99,7 +100,7 @@ static int nsm_mon_unmon(struct nsm_handle *nsm, u32 proc, struct nsm_res *res)
                 .rpc_resp       = res,
         };
 
-        clnt = nsm_create();
+        clnt = nsm_create(net);
         if (IS_ERR(clnt)) {
                 status = PTR_ERR(clnt);
                 dprintk("lockd: failed to create NSM upcall transport, "
@@ -149,7 +150,7 @@ int nsm_monitor(const struct nlm_host *host)
          */
         nsm->sm_mon_name = nsm_use_hostnames ? nsm->sm_name : nsm->sm_addrbuf;
 
-        status = nsm_mon_unmon(nsm, NSMPROC_MON, &res);
+        status = nsm_mon_unmon(nsm, NSMPROC_MON, &res, host->net);
         if (unlikely(res.status != 0))
                 status = -EIO;
         if (unlikely(status < 0)) {
@@ -183,7 +184,7 @@ void nsm_unmonitor(const struct nlm_host *host)
          && nsm->sm_monitored && !nsm->sm_sticky) {
                 dprintk("lockd: nsm_unmonitor(%s)\n", nsm->sm_name);
 
-                status = nsm_mon_unmon(nsm, NSMPROC_UNMON, &res);
+                status = nsm_mon_unmon(nsm, NSMPROC_UNMON, &res, host->net);
                 if (res.status != 0)
                         status = -EIO;
                 if (status < 0)
@@ -534,19 +535,19 @@ static struct rpc_procinfo	nsm_procedures[] = {
         },
 };
 
-static struct rpc_version       nsm_version1 = {
+static const struct rpc_version nsm_version1 = {
                 .number         = 1,
                 .nrprocs        = ARRAY_SIZE(nsm_procedures),
                 .procs          = nsm_procedures
 };
 
-static struct rpc_version *     nsm_version[] = {
+static const struct rpc_version *nsm_version[] = {
         [1] = &nsm_version1,
 };
 
 static struct rpc_stat          nsm_stats;
 
-static struct rpc_program       nsm_program = {
+static const struct rpc_program nsm_program = {
                 .name           = "statd",
                 .number         = NSM_PROGRAM,
                 .nrvers         = ARRAY_SIZE(nsm_version),
diff --git a/fs/lockd/netns.h b/fs/lockd/netns.h
new file mode 100644
index 000000000000..ce227e0fbc5c
--- /dev/null
+++ b/fs/lockd/netns.h
@@ -0,0 +1,12 @@
+#ifndef __LOCKD_NETNS_H__
+#define __LOCKD_NETNS_H__
+
+#include <net/netns/generic.h>
+
+struct lockd_net {
+        unsigned int nlmsvc_users;
+};
+
+extern int lockd_net_id;
+
+#endif
diff --git a/fs/lockd/svc.c b/fs/lockd/svc.c
index 2444780f5cfa..f49b9afc4436 100644
--- a/fs/lockd/svc.c
+++ b/fs/lockd/svc.c
@@ -35,6 +35,8 @@
 #include <linux/lockd/lockd.h>
 #include <linux/nfs.h>
 
+#include "netns.h"
+
 #define NLMDBG_FACILITY         NLMDBG_SVC
 #define LOCKD_BUFSIZE           (1024 + NLMSVC_XDRSIZE)
 #define ALLOWED_SIGS            (sigmask(SIGKILL))
@@ -50,6 +52,8 @@ static struct task_struct	*nlmsvc_task;
 static struct svc_rqst          *nlmsvc_rqst;
 unsigned long                   nlmsvc_timeout;
 
+int lockd_net_id;
+
 /*
  * These can be set at insmod time (useful for NFS as root filesystem),
  * and also changed through the sysctl interface.  -- Jamie Lokier, Aug 2003
@@ -189,27 +193,29 @@ lockd(void *vrqstp)
 }
 
 static int create_lockd_listener(struct svc_serv *serv, const char *name,
-                                 const int family, const unsigned short port)
+                                 struct net *net, const int family,
+                                 const unsigned short port)
 {
         struct svc_xprt *xprt;
 
-        xprt = svc_find_xprt(serv, name, family, 0);
+        xprt = svc_find_xprt(serv, name, net, family, 0);
         if (xprt == NULL)
-                return svc_create_xprt(serv, name, &init_net, family, port,
+                return svc_create_xprt(serv, name, net, family, port,
                                                 SVC_SOCK_DEFAULTS);
         svc_xprt_put(xprt);
         return 0;
 }
 
-static int create_lockd_family(struct svc_serv *serv, const int family)
+static int create_lockd_family(struct svc_serv *serv, struct net *net,
+                               const int family)
 {
         int err;
 
-        err = create_lockd_listener(serv, "udp", family, nlm_udpport);
+        err = create_lockd_listener(serv, "udp", net, family, nlm_udpport);
         if (err < 0)
                 return err;
 
-        return create_lockd_listener(serv, "tcp", family, nlm_tcpport);
+        return create_lockd_listener(serv, "tcp", net, family, nlm_tcpport);
 }
 
 /*
@@ -222,16 +228,16 @@ static int create_lockd_family(struct svc_serv *serv, const int family)
  * Returns zero if all listeners are available; otherwise a
  * negative errno value is returned.
  */
-static int make_socks(struct svc_serv *serv)
+static int make_socks(struct svc_serv *serv, struct net *net)
 {
         static int warned;
         int err;
 
-        err = create_lockd_family(serv, PF_INET);
+        err = create_lockd_family(serv, net, PF_INET);
         if (err < 0)
                 goto out_err;
 
-        err = create_lockd_family(serv, PF_INET6);
+        err = create_lockd_family(serv, net, PF_INET6);
         if (err < 0 && err != -EAFNOSUPPORT)
                 goto out_err;
 
@@ -245,6 +251,47 @@ out_err:
         return err;
 }
 
+static int lockd_up_net(struct net *net)
+{
+        struct lockd_net *ln = net_generic(net, lockd_net_id);
+        struct svc_serv *serv = nlmsvc_rqst->rq_server;
+        int error;
+
+        if (ln->nlmsvc_users)
+                return 0;
+
+        error = svc_rpcb_setup(serv, net);
+        if (error)
+                goto err_rpcb;
+
+        error = make_socks(serv, net);
+        if (error < 0)
+                goto err_socks;
+        return 0;
+
+err_socks:
+        svc_rpcb_cleanup(serv, net);
+err_rpcb:
+        return error;
+}
+
+static void lockd_down_net(struct net *net)
+{
+        struct lockd_net *ln = net_generic(net, lockd_net_id);
+        struct svc_serv *serv = nlmsvc_rqst->rq_server;
+
+        if (ln->nlmsvc_users) {
+                if (--ln->nlmsvc_users == 0) {
+                        nlm_shutdown_hosts_net(net);
+                        svc_shutdown_net(serv, net);
+                }
+        } else {
+                printk(KERN_ERR "lockd_down_net: no users! task=%p, net=%p\n",
+                                nlmsvc_task, net);
+                BUG();
+        }
+}
+
 /*
  * Bring up the lockd process if it's not already up.
  */
@@ -252,13 +299,16 @@ int lockd_up(void)
 {
         struct svc_serv *serv;
         int             error = 0;
+        struct net *net = current->nsproxy->net_ns;
 
         mutex_lock(&nlmsvc_mutex);
         /*
          * Check whether we're already up and running.
          */
-        if (nlmsvc_rqst)
+        if (nlmsvc_rqst) {
+                error = lockd_up_net(net);
                 goto out;
+        }
 
         /*
          * Sanity check: if there's no pid,
@@ -275,7 +325,7 @@ int lockd_up(void)
                 goto out;
         }
 
-        error = make_socks(serv);
+        error = make_socks(serv, net);
         if (error < 0)
                 goto destroy_and_out;
 
@@ -313,8 +363,12 @@ int lockd_up(void)
 destroy_and_out:
         svc_destroy(serv);
 out:
-        if (!error)
+        if (!error) {
+                struct lockd_net *ln = net_generic(net, lockd_net_id);
+
+                ln->nlmsvc_users++;
                 nlmsvc_users++;
+        }
         mutex_unlock(&nlmsvc_mutex);
         return error;
 }
@@ -328,8 +382,10 @@ lockd_down(void)
 {
         mutex_lock(&nlmsvc_mutex);
         if (nlmsvc_users) {
-                if (--nlmsvc_users)
+                if (--nlmsvc_users) {
+                        lockd_down_net(current->nsproxy->net_ns);
                         goto out;
+                }
         } else {
                 printk(KERN_ERR "lockd_down: no users! task=%p\n",
                         nlmsvc_task);
@@ -497,24 +553,55 @@ module_param_call(nlm_tcpport, param_set_port, param_get_int,
 module_param(nsm_use_hostnames, bool, 0644);
 module_param(nlm_max_connections, uint, 0644);
 
+static int lockd_init_net(struct net *net)
+{
+        return 0;
+}
+
+static void lockd_exit_net(struct net *net)
+{
+}
+
+static struct pernet_operations lockd_net_ops = {
+        .init = lockd_init_net,
+        .exit = lockd_exit_net,
+        .id = &lockd_net_id,
+        .size = sizeof(struct lockd_net),
+};
+
+
 /*
  * Initialising and terminating the module.
  */
 
 static int __init init_nlm(void)
 {
+        int err;
+
 #ifdef CONFIG_SYSCTL
+        err = -ENOMEM;
         nlm_sysctl_table = register_sysctl_table(nlm_sysctl_root);
-        return nlm_sysctl_table ? 0 : -ENOMEM;
-#else
+        if (nlm_sysctl_table == NULL)
+                goto err_sysctl;
+#endif
+        err = register_pernet_subsys(&lockd_net_ops);
+        if (err)
+                goto err_pernet;
         return 0;
+
+err_pernet:
+#ifdef CONFIG_SYSCTL
+        unregister_sysctl_table(nlm_sysctl_table);
 #endif
+err_sysctl:
+        return err;
 }
 
 static void __exit exit_nlm(void)
 {
         /* FIXME: delete all NLM clients */
         nlm_shutdown_hosts();
+        unregister_pernet_subsys(&lockd_net_ops);
 #ifdef CONFIG_SYSCTL
         unregister_sysctl_table(nlm_sysctl_table);
 #endif
diff --git a/fs/lockd/svclock.c b/fs/lockd/svclock.c
index f0179c3745d2..e46353f41a42 100644
--- a/fs/lockd/svclock.c
+++ b/fs/lockd/svclock.c
@@ -46,7 +46,6 @@ static void	nlmsvc_remove_block(struct nlm_block *block);
 static int nlmsvc_setgrantargs(struct nlm_rqst *call, struct nlm_lock *lock);
 static void nlmsvc_freegrantargs(struct nlm_rqst *call);
 static const struct rpc_call_ops nlmsvc_grant_ops;
-static const char *nlmdbg_cookie2a(const struct nlm_cookie *cookie);
 
 /*
  * The list of blocked locks to retry
@@ -54,6 +53,35 @@ static const char *nlmdbg_cookie2a(const struct nlm_cookie *cookie);
 static LIST_HEAD(nlm_blocked);
 static DEFINE_SPINLOCK(nlm_blocked_lock);
 
+#ifdef LOCKD_DEBUG
+static const char *nlmdbg_cookie2a(const struct nlm_cookie *cookie)
+{
+        /*
+         * We can get away with a static buffer because we're only
+         * called with BKL held.
+         */
+        static char buf[2*NLM_MAXCOOKIELEN+1];
+        unsigned int i, len = sizeof(buf);
+        char *p = buf;
+
+        len--;  /* allow for trailing \0 */
+        if (len < 3)
+                return "???";
+        for (i = 0 ; i < cookie->len ; i++) {
+                if (len < 2) {
+                        strcpy(p-3, "...");
+                        break;
+                }
+                sprintf(p, "%02x", cookie->data[i]);
+                p += 2;
+                len -= 2;
+        }
+        *p = '\0';
+
+        return buf;
+}
+#endif
+
 /*
  * Insert a blocked lock into the global list
  */
@@ -935,32 +963,3 @@ nlmsvc_retry_blocked(void)
 
         return timeout;
 }
-
-#ifdef RPC_DEBUG
-static const char *nlmdbg_cookie2a(const struct nlm_cookie *cookie)
-{
-        /*
-         * We can get away with a static buffer because we're only
-         * called with BKL held.
-         */
-        static char buf[2*NLM_MAXCOOKIELEN+1];
-        unsigned int i, len = sizeof(buf);
-        char *p = buf;
-
-        len--;  /* allow for trailing \0 */
-        if (len < 3)
-                return "???";
-        for (i = 0 ; i < cookie->len ; i++) {
-                if (len < 2) {
-                        strcpy(p-3, "...");
-                        break;
-                }
-                sprintf(p, "%02x", cookie->data[i]);
-                p += 2;
-                len -= 2;
-        }
-        *p = '\0';
-
-        return buf;
-}
-#endif