Patched in Tegra support.

1 files changed, 101 insertions, 172 deletions

diff --git a/fs/nfsd/nfssvc.c b/fs/nfsd/nfssvc.c
index cee62ab9d4a..dc5a1bf476b 100644
--- a/fs/nfsd/nfssvc.c
+++ b/fs/nfsd/nfssvc.c
@@ -8,7 +8,6 @@
 
 #include <linux/sched.h>
 #include <linux/freezer.h>
-#include <linux/module.h>
 #include <linux/fs_struct.h>
 #include <linux/swap.h>
 
@@ -21,19 +20,19 @@
 #include "nfsd.h"
 #include "cache.h"
 #include "vfs.h"
-#include "netns.h"
 
 #define NFSDDBG_FACILITY        NFSDDBG_SVC
 
 extern struct svc_program       nfsd_program;
 static int                      nfsd(void *vrqstp);
+struct timeval                  nfssvc_boot;
 
 /*
- * nfsd_mutex protects nn->nfsd_serv -- both the pointer itself and the members
+ * nfsd_mutex protects nfsd_serv -- both the pointer itself and the members
  * of the svc_serv struct. In particular, ->sv_nrthreads but also to some
  * extent ->sv_temp_socks and ->sv_permsocks. It also protects nfsdstats.th_cnt
  *
- * If (out side the lock) nn->nfsd_serv is non-NULL, then it must point to a
+ * If (out side the lock) nfsd_serv is non-NULL, then it must point to a
  * properly initialised 'struct svc_serv' with ->sv_nrthreads > 0. That number
  * of nfsd threads must exist and each must listed in ->sp_all_threads in each
  * entry of ->sv_pools[].
@@ -51,6 +50,7 @@ static int			nfsd(void *vrqstp);
  *      nfsd_versions
  */
 DEFINE_MUTEX(nfsd_mutex);
+struct svc_serv                 *nfsd_serv;
 
 /*
  * nfsd_drc_lock protects nfsd_drc_max_pages and nfsd_drc_pages_used.
@@ -171,32 +171,28 @@ int nfsd_minorversion(u32 minorversion, enum vers_op change)
  */
 #define NFSD_MAXSERVS           8192
 
-int nfsd_nrthreads(struct net *net)
+int nfsd_nrthreads(void)
 {
         int rv = 0;
-        struct nfsd_net *nn = net_generic(net, nfsd_net_id);
-
         mutex_lock(&nfsd_mutex);
-        if (nn->nfsd_serv)
-                rv = nn->nfsd_serv->sv_nrthreads;
+        if (nfsd_serv)
+                rv = nfsd_serv->sv_nrthreads;
         mutex_unlock(&nfsd_mutex);
         return rv;
 }
 
-static int nfsd_init_socks(struct net *net)
+static int nfsd_init_socks(int port)
 {
         int error;
-        struct nfsd_net *nn = net_generic(net, nfsd_net_id);
-
-        if (!list_empty(&nn->nfsd_serv->sv_permsocks))
+        if (!list_empty(&nfsd_serv->sv_permsocks))
                 return 0;
 
-        error = svc_create_xprt(nn->nfsd_serv, "udp", net, PF_INET, NFS_PORT,
+        error = svc_create_xprt(nfsd_serv, "udp", &init_net, PF_INET, port,
                                         SVC_SOCK_DEFAULTS);
         if (error < 0)
                 return error;
 
-        error = svc_create_xprt(nn->nfsd_serv, "tcp", net, PF_INET, NFS_PORT,
+        error = svc_create_xprt(nfsd_serv, "tcp", &init_net, PF_INET, port,
                                         SVC_SOCK_DEFAULTS);
         if (error < 0)
                 return error;
@@ -204,15 +200,14 @@ static int nfsd_init_socks(struct net *net)
         return 0;
 }
 
-static int nfsd_users = 0;
+static bool nfsd_up = false;
 
-static int nfsd_startup_generic(int nrservs)
+static int nfsd_startup(unsigned short port, int nrservs)
 {
         int ret;
 
-        if (nfsd_users++)
+        if (nfsd_up)
                 return 0;
-
         /*
          * Readahead param cache - will no-op if it already exists.
          * (Note therefore results will be suboptimal if number of
@@ -221,85 +216,49 @@ static int nfsd_startup_generic(int nrservs)
         ret = nfsd_racache_init(2*nrservs);
         if (ret)
                 return ret;
-        ret = nfs4_state_start();
+        ret = nfsd_init_socks(port);
         if (ret)
                 goto out_racache;
-        return 0;
-
-out_racache:
-        nfsd_racache_shutdown();
-        return ret;
-}
-
-static void nfsd_shutdown_generic(void)
-{
-        if (--nfsd_users)
-                return;
-
-        nfs4_state_shutdown();
-        nfsd_racache_shutdown();
-}
-
-static int nfsd_startup_net(int nrservs, struct net *net)
-{
-        struct nfsd_net *nn = net_generic(net, nfsd_net_id);
-        int ret;
-
-        if (nn->nfsd_net_up)
-                return 0;
-
-        ret = nfsd_startup_generic(nrservs);
+        ret = lockd_up();
         if (ret)
-                return ret;
-        ret = nfsd_init_socks(net);
-        if (ret)
-                goto out_socks;
-        ret = lockd_up(net);
-        if (ret)
-                goto out_socks;
-        ret = nfs4_state_start_net(net);
+                goto out_racache;
+        ret = nfs4_state_start();
         if (ret)
                 goto out_lockd;
-
-        nn->nfsd_net_up = true;
+        nfsd_up = true;
         return 0;
-
 out_lockd:
-        lockd_down(net);
-out_socks:
-        nfsd_shutdown_generic();
+        lockd_down();
+out_racache:
+        nfsd_racache_shutdown();
         return ret;
 }
 
-static void nfsd_shutdown_net(struct net *net)
-{
-        struct nfsd_net *nn = net_generic(net, nfsd_net_id);
-
-        nfs4_state_shutdown_net(net);
-        lockd_down(net);
-        nn->nfsd_net_up = false;
-        nfsd_shutdown_generic();
-}
-
-static void nfsd_last_thread(struct svc_serv *serv, struct net *net)
+static void nfsd_shutdown(void)
 {
-        struct nfsd_net *nn = net_generic(net, nfsd_net_id);
-
         /*
          * write_ports can create the server without actually starting
          * any threads--if we get shut down before any threads are
          * started, then nfsd_last_thread will be run before any of this
          * other initialization has been done.
          */
-        if (!nn->nfsd_net_up)
+        if (!nfsd_up)
                 return;
-        nfsd_shutdown_net(net);
+        nfs4_state_shutdown();
+        lockd_down();
+        nfsd_racache_shutdown();
+        nfsd_up = false;
+}
 
-        svc_rpcb_cleanup(serv, net);
+static void nfsd_last_thread(struct svc_serv *serv)
+{
+        /* When last nfsd thread exits we need to do some clean-up */
+        nfsd_serv = NULL;
+        nfsd_shutdown();
 
         printk(KERN_WARNING "nfsd: last server has exited, flushing export "
                             "cache\n");
-        nfsd_export_flush(net);
+        nfsd_export_flush();
 }
 
 void nfsd_reset_versions(void)
@@ -345,105 +304,76 @@ static void set_max_drc(void)
         dprintk("%s nfsd_drc_max_mem %u \n", __func__, nfsd_drc_max_mem);
 }
 
-static int nfsd_get_default_max_blksize(void)
-{
-        struct sysinfo i;
-        unsigned long long target;
-        unsigned long ret;
-
-        si_meminfo(&i);
-        target = (i.totalram - i.totalhigh) << PAGE_SHIFT;
-        /*
-         * Aim for 1/4096 of memory per thread This gives 1MB on 4Gig
-         * machines, but only uses 32K on 128M machines.  Bottom out at
-         * 8K on 32M and smaller.  Of course, this is only a default.
-         */
-        target >>= 12;
-
-        ret = NFSSVC_MAXBLKSIZE;
-        while (ret > target && ret >= 8*1024*2)
-                ret /= 2;
-        return ret;
-}
-
-int nfsd_create_serv(struct net *net)
+int nfsd_create_serv(void)
 {
-        int error;
-        struct nfsd_net *nn = net_generic(net, nfsd_net_id);
+        int err = 0;
 
         WARN_ON(!mutex_is_locked(&nfsd_mutex));
-        if (nn->nfsd_serv) {
-                svc_get(nn->nfsd_serv);
+        if (nfsd_serv) {
+                svc_get(nfsd_serv);
                 return 0;
         }
-        if (nfsd_max_blksize == 0)
-                nfsd_max_blksize = nfsd_get_default_max_blksize();
+        if (nfsd_max_blksize == 0) {
+                /* choose a suitable default */
+                struct sysinfo i;
+                si_meminfo(&i);
+                /* Aim for 1/4096 of memory per thread
+                 * This gives 1MB on 4Gig machines
+                 * But only uses 32K on 128M machines.
+                 * Bottom out at 8K on 32M and smaller.
+                 * Of course, this is only a default.
+                 */
+                nfsd_max_blksize = NFSSVC_MAXBLKSIZE;
+                i.totalram <<= PAGE_SHIFT - 12;
+                while (nfsd_max_blksize > i.totalram &&
+                       nfsd_max_blksize >= 8*1024*2)
+                        nfsd_max_blksize /= 2;
+        }
         nfsd_reset_versions();
-        nn->nfsd_serv = svc_create_pooled(&nfsd_program, nfsd_max_blksize,
+
+        nfsd_serv = svc_create_pooled(&nfsd_program, nfsd_max_blksize,
                                       nfsd_last_thread, nfsd, THIS_MODULE);
-        if (nn->nfsd_serv == NULL)
+        if (nfsd_serv == NULL)
                 return -ENOMEM;
 
-        error = svc_bind(nn->nfsd_serv, net);
-        if (error < 0) {
-                svc_destroy(nn->nfsd_serv);
-                return error;
-        }
-
         set_max_drc();
-        do_gettimeofday(&nn->nfssvc_boot);              /* record boot time */
-        return 0;
+        do_gettimeofday(&nfssvc_boot);          /* record boot time */
+        return err;
 }
 
-int nfsd_nrpools(struct net *net)
+int nfsd_nrpools(void)
 {
-        struct nfsd_net *nn = net_generic(net, nfsd_net_id);
-
-        if (nn->nfsd_serv == NULL)
+        if (nfsd_serv == NULL)
                 return 0;
         else
-                return nn->nfsd_serv->sv_nrpools;
+                return nfsd_serv->sv_nrpools;
 }
 
-int nfsd_get_nrthreads(int n, int *nthreads, struct net *net)
+int nfsd_get_nrthreads(int n, int *nthreads)
 {
         int i = 0;
-        struct nfsd_net *nn = net_generic(net, nfsd_net_id);
 
-        if (nn->nfsd_serv != NULL) {
-                for (i = 0; i < nn->nfsd_serv->sv_nrpools && i < n; i++)
-                        nthreads[i] = nn->nfsd_serv->sv_pools[i].sp_nrthreads;
+        if (nfsd_serv != NULL) {
+                for (i = 0; i < nfsd_serv->sv_nrpools && i < n; i++)
+                        nthreads[i] = nfsd_serv->sv_pools[i].sp_nrthreads;
         }
 
         return 0;
 }
 
-void nfsd_destroy(struct net *net)
-{
-        struct nfsd_net *nn = net_generic(net, nfsd_net_id);
-        int destroy = (nn->nfsd_serv->sv_nrthreads == 1);
-
-        if (destroy)
-                svc_shutdown_net(nn->nfsd_serv, net);
-        svc_destroy(nn->nfsd_serv);
-        if (destroy)
-                nn->nfsd_serv = NULL;
-}
-
-int nfsd_set_nrthreads(int n, int *nthreads, struct net *net)
+int nfsd_set_nrthreads(int n, int *nthreads)
 {
         int i = 0;
         int tot = 0;
         int err = 0;
-        struct nfsd_net *nn = net_generic(net, nfsd_net_id);
 
         WARN_ON(!mutex_is_locked(&nfsd_mutex));
 
-        if (nn->nfsd_serv == NULL || n <= 0)
+        if (nfsd_serv == NULL || n <= 0)
                 return 0;
 
-        if (n > nn->nfsd_serv->sv_nrpools)
-                n = nn->nfsd_serv->sv_nrpools;
+        if (n > nfsd_serv->sv_nrpools)
+                n = nfsd_serv->sv_nrpools;
 
         /* enforce a global maximum number of threads */
         tot = 0;
@@ -473,14 +403,15 @@ int nfsd_set_nrthreads(int n, int *nthreads, struct net *net)
                 nthreads[0] = 1;
 
         /* apply the new numbers */
-        svc_get(nn->nfsd_serv);
+        svc_get(nfsd_serv);
         for (i = 0; i < n; i++) {
-                err = svc_set_num_threads(nn->nfsd_serv, &nn->nfsd_serv->sv_pools[i],
+                err = svc_set_num_threads(nfsd_serv, &nfsd_serv->sv_pools[i],
                                           nthreads[i]);
                 if (err)
                         break;
         }
-        nfsd_destroy(net);
+        svc_destroy(nfsd_serv);
+
         return err;
 }
 
@@ -490,11 +421,10 @@ int nfsd_set_nrthreads(int n, int *nthreads, struct net *net)
  * this is the first time nrservs is nonzero.
  */
 int
-nfsd_svc(int nrservs, struct net *net)
+nfsd_svc(unsigned short port, int nrservs)
 {
         int     error;
         bool    nfsd_up_before;
-        struct nfsd_net *nn = net_generic(net, nfsd_net_id);
 
         mutex_lock(&nfsd_mutex);
         dprintk("nfsd: creating service\n");
@@ -503,31 +433,31 @@ nfsd_svc(int nrservs, struct net *net)
         if (nrservs > NFSD_MAXSERVS)
                 nrservs = NFSD_MAXSERVS;
         error = 0;
-        if (nrservs == 0 && nn->nfsd_serv == NULL)
+        if (nrservs == 0 && nfsd_serv == NULL)
                 goto out;
 
-        error = nfsd_create_serv(net);
+        error = nfsd_create_serv();
         if (error)
                 goto out;
 
-        nfsd_up_before = nn->nfsd_net_up;
+        nfsd_up_before = nfsd_up;
 
-        error = nfsd_startup_net(nrservs, net);
+        error = nfsd_startup(port, nrservs);
         if (error)
                 goto out_destroy;
-        error = svc_set_num_threads(nn->nfsd_serv, NULL, nrservs);
+        error = svc_set_num_threads(nfsd_serv, NULL, nrservs);
         if (error)
                 goto out_shutdown;
-        /* We are holding a reference to nn->nfsd_serv which
+        /* We are holding a reference to nfsd_serv which
          * we don't want to count in the return value,
          * so subtract 1
          */
-        error = nn->nfsd_serv->sv_nrthreads - 1;
+        error = nfsd_serv->sv_nrthreads - 1;
 out_shutdown:
         if (error < 0 && !nfsd_up_before)
-                nfsd_shutdown_net(net);
+                nfsd_shutdown();
 out_destroy:
-        nfsd_destroy(net);              /* Release server */
+        svc_destroy(nfsd_serv);         /* Release server */
 out:
         mutex_unlock(&nfsd_mutex);
         return error;
@@ -541,9 +471,7 @@ static int
 nfsd(void *vrqstp)
 {
         struct svc_rqst *rqstp = (struct svc_rqst *) vrqstp;
-        struct svc_xprt *perm_sock = list_entry(rqstp->rq_server->sv_permsocks.next, typeof(struct svc_xprt), xpt_list);
-        struct net *net = perm_sock->xpt_net;
-        int err;
+        int err, preverr = 0;
 
         /* Lock module and set up kernel thread */
         mutex_lock(&nfsd_mutex);
@@ -590,6 +518,16 @@ nfsd(void *vrqstp)
                         ;
                 if (err == -EINTR)
                         break;
+                else if (err < 0) {
+                        if (err != preverr) {
+                                printk(KERN_WARNING "%s: unexpected error "
+                                        "from svc_recv (%d)\n", __func__, -err);
+                                preverr = err;
+                        }
+                        schedule_timeout_uninterruptible(HZ);
+                        continue;
+                }
+
                 validate_process_creds();
                 svc_process(rqstp);
                 validate_process_creds();
@@ -602,13 +540,9 @@ nfsd(void *vrqstp)
         nfsdstats.th_cnt --;
 
 out:
-        rqstp->rq_server = NULL;
-
         /* Release the thread */
         svc_exit_thread(rqstp);
 
-        nfsd_destroy(net);
-
         /* Release module */
         mutex_unlock(&nfsd_mutex);
         module_put_and_exit(0);
@@ -696,24 +630,21 @@ nfsd_dispatch(struct svc_rqst *rqstp, __be32 *statp)
         }
 
         /* Store reply in cache. */
-        nfsd_cache_update(rqstp, rqstp->rq_cachetype, statp + 1);
+        nfsd_cache_update(rqstp, proc->pc_cachetype, statp + 1);
         return 1;
 }
 
 int nfsd_pool_stats_open(struct inode *inode, struct file *file)
 {
         int ret;
-        struct net *net = &init_net;
-        struct nfsd_net *nn = net_generic(net, nfsd_net_id);
-
         mutex_lock(&nfsd_mutex);
-        if (nn->nfsd_serv == NULL) {
+        if (nfsd_serv == NULL) {
                 mutex_unlock(&nfsd_mutex);
                 return -ENODEV;
         }
         /* bump up the psudo refcount while traversing */
-        svc_get(nn->nfsd_serv);
-        ret = svc_pool_stats_open(nn->nfsd_serv, file);
+        svc_get(nfsd_serv);
+        ret = svc_pool_stats_open(nfsd_serv, file);
         mutex_unlock(&nfsd_mutex);
         return ret;
 }
@@ -721,11 +652,9 @@ int nfsd_pool_stats_open(struct inode *inode, struct file *file)
 int nfsd_pool_stats_release(struct inode *inode, struct file *file)
 {
         int ret = seq_release(inode, file);
-        struct net *net = &init_net;
-
         mutex_lock(&nfsd_mutex);
         /* this function really, really should have been called svc_put() */
-        nfsd_destroy(net);
+        svc_destroy(nfsd_serv);
         mutex_unlock(&nfsd_mutex);
         return ret;
 }