sunrpc: remove sv_kill_signal field from svc_serv struct

[safe/jmp/linux-2.6] / fs / nfsd / nfssvc.c

diff --git a/fs/nfsd/nfssvc.c b/fs/nfsd/nfssvc.c
index 512bd04..26c8114 100644 (file)
--- a/fs/nfsd/nfssvc.c
+++ b/fs/nfsd/nfssvc.c
@@ -21,6 +21,7 @@
 #include <linux/smp_lock.h>
 #include <linux/freezer.h>
 #include <linux/fs_struct.h>
+#include <linux/kthread.h>
 
 #include <linux/sunrpc/types.h>
 #include <linux/sunrpc/stats.h>
@@ -44,14 +45,9 @@
  * when not handling a request. i.e. when waiting
  */
 #define SHUTDOWN_SIGS  (sigmask(SIGKILL) | sigmask(SIGHUP) | sigmask(SIGINT) | sigmask(SIGQUIT))
-/* if the last thread dies with SIGHUP, then the exports table is
- * left unchanged ( like 2.4-{0-9} ).  Any other signal will clear
- * the exports table (like 2.2).
- */
-#define        SIG_NOCLEAN     SIGHUP
 
 extern struct svc_program      nfsd_program;
-static void                    nfsd(struct svc_rqst *rqstp);
+static int                     nfsd(void *vrqstp);
 struct timeval                 nfssvc_boot;
 static atomic_t                        nfsd_busy;
 static unsigned long           nfsd_last_call;
@@ -70,6 +66,14 @@ static DEFINE_SPINLOCK(nfsd_call_lock);
  * Transitions of the thread count between zero and non-zero are of particular
  * interest since the svc_serv needs to be created and initialized at that
  * point, or freed.
+ *
+ * Finally, the nfsd_mutex also protects some of the global variables that are
+ * accessed when nfsd starts and that are settable via the write_* routines in
+ * nfsctl.c. In particular:
+ *
+ *     user_recovery_dirname
+ *     user_lease_time
+ *     nfsd_versions
  */
 DEFINE_MUTEX(nfsd_mutex);
 struct svc_serv                *nfsd_serv;
@@ -167,7 +171,6 @@ int nfsd_nrthreads(void)
                return nfsd_serv->sv_nrthreads;
 }
 
-static int killsig;    /* signal that was used to kill last nfsd */
 static void nfsd_last_thread(struct svc_serv *serv)
 {
        /* When last nfsd thread exits we need to do some clean-up */
@@ -178,11 +181,9 @@ static void nfsd_last_thread(struct svc_serv *serv)
        nfsd_racache_shutdown();
        nfs4_state_shutdown();
 
-       printk(KERN_WARNING "nfsd: last server has exited\n");
-       if (killsig != SIG_NOCLEAN) {
-               printk(KERN_WARNING "nfsd: unexporting all filesystems\n");
-               nfsd_export_flush();
-       }
+       printk(KERN_WARNING "nfsd: last server has exited, flushing export "
+                           "cache\n");
+       nfsd_export_flush();
 }
 
 void nfsd_reset_versions(void)
@@ -234,10 +235,8 @@ int nfsd_create_serv(void)
        }
 
        atomic_set(&nfsd_busy, 0);
-       nfsd_serv = svc_create_pooled(&nfsd_program,
-                                     nfsd_max_blksize,
-                                     nfsd_last_thread,
-                                     nfsd, SIG_NOCLEAN, THIS_MODULE);
+       nfsd_serv = svc_create_pooled(&nfsd_program, nfsd_max_blksize,
+                                     nfsd_last_thread, nfsd, THIS_MODULE);
        if (nfsd_serv == NULL)
                err = -ENOMEM;
 
@@ -408,18 +407,19 @@ update_thread_usage(int busy_threads)
 /*
  * This is the NFS server kernel thread
  */
-static void
-nfsd(struct svc_rqst *rqstp)
+static int
+nfsd(void *vrqstp)
 {
+       struct svc_rqst *rqstp = (struct svc_rqst *) vrqstp;
        struct fs_struct *fsp;
-       int             err;
        sigset_t shutdown_mask, allowed_mask;
+       int err, preverr = 0;
+       unsigned int signo;
 
        /* Lock module and set up kernel thread */
        mutex_lock(&nfsd_mutex);
-       daemonize("nfsd");
 
-       /* After daemonize() this kernel thread shares current->fs
+       /* At this point, the thread shares current->fs
         * with the init process. We need to create files with a
         * umask of 0 instead of init's umask. */
        fsp = copy_fs_struct(current->fs);
@@ -434,14 +434,18 @@ nfsd(struct svc_rqst *rqstp)
        siginitsetinv(&shutdown_mask, SHUTDOWN_SIGS);
        siginitsetinv(&allowed_mask, ALLOWED_SIGS);
 
+       /*
+        * thread is spawned with all signals set to SIG_IGN, re-enable
+        * the ones that matter
+        */
+       for (signo = 1; signo <= _NSIG; signo++) {
+               if (!sigismember(&shutdown_mask, signo))
+                       allow_signal(signo);
+       }
 
        nfsdstats.th_cnt++;
-
-       rqstp->rq_task = current;
-
        mutex_unlock(&nfsd_mutex);
 
-
        /*
         * We want less throttling in balance_dirty_pages() so that nfs to
         * localhost doesn't cause nfsd to lock up due to all the client's
@@ -463,15 +467,25 @@ nfsd(struct svc_rqst *rqstp)
                 */
                while ((err = svc_recv(rqstp, 60*60*HZ)) == -EAGAIN)
                        ;
-               if (err < 0)
+               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;
+               }
+
                update_thread_usage(atomic_read(&nfsd_busy));
                atomic_inc(&nfsd_busy);
 
                /* Lock the export hash tables for reading. */
                exp_readlock();
 
-               /* Process request with signals blocked.  */
+               /* Process request with signals blocked. */
                sigprocmask(SIG_SETMASK, &allowed_mask, NULL);
 
                svc_process(rqstp);
@@ -482,22 +496,10 @@ nfsd(struct svc_rqst *rqstp)
                atomic_dec(&nfsd_busy);
        }
 
-       if (err != -EINTR) {
-               printk(KERN_WARNING "nfsd: terminating on error %d\n", -err);
-       } else {
-               unsigned int    signo;
-
-               for (signo = 1; signo <= _NSIG; signo++)
-                       if (sigismember(&current->pending.signal, signo) &&
-                           !sigismember(&current->blocked, signo))
-                               break;
-               killsig = signo;
-       }
        /* Clear signals before calling svc_exit_thread() */
        flush_signals(current);
 
        mutex_lock(&nfsd_mutex);
-
        nfsdstats.th_cnt --;
 
 out:
@@ -507,6 +509,7 @@ out:
        /* Release module */
        mutex_unlock(&nfsd_mutex);
        module_put_and_exit(0);
+       return 0;
 }
 
 static __be32 map_new_errors(u32 vers, __be32 nfserr)