[XFS] Make xfs_bmap_*_count_leaves void.

[linux-2.6] / fs / lockd / svc.c

diff --git a/fs/lockd/svc.c b/fs/lockd/svc.c
index 66b5c98c7ff5bfbb72e6ee6d183a0e5bf15146be..5bd9bf0fa9df09121f8c190d7e47ec8ef7871ede 100644 (file)
--- a/fs/lockd/svc.c
+++ b/fs/lockd/svc.c
@@ -50,7 +50,7 @@ EXPORT_SYMBOL(nlmsvc_ops);
 static DEFINE_MUTEX(nlmsvc_mutex);
 static unsigned int            nlmsvc_users;
 static struct task_struct      *nlmsvc_task;
-static struct svc_serv         *nlmsvc_serv;
+static struct svc_rqst         *nlmsvc_rqst;
 int                            nlmsvc_grace_period;
 unsigned long                  nlmsvc_timeout;
 
@@ -72,7 +72,9 @@ static const unsigned long    nlm_timeout_min = 3;
 static const unsigned long     nlm_timeout_max = 20;
 static const int               nlm_port_min = 0, nlm_port_max = 65535;
 
+#ifdef CONFIG_SYSCTL
 static struct ctl_table_header * nlm_sysctl_table;
+#endif
 
 static unsigned long get_lockd_grace_period(void)
 {
@@ -112,7 +114,7 @@ static inline void clear_grace_period(void)
 static int
 lockd(void *vrqstp)
 {
-       int             err = 0;
+       int             err = 0, preverr = 0;
        struct svc_rqst *rqstp = vrqstp;
        unsigned long grace_period_expire;
 
@@ -172,34 +174,31 @@ lockd(void *vrqstp)
                 * recvfrom routine.
                 */
                err = svc_recv(rqstp, timeout);
-               if (err == -EAGAIN || err == -EINTR)
+               if (err == -EAGAIN || err == -EINTR) {
+                       preverr = err;
                        continue;
+               }
                if (err < 0) {
-                       printk(KERN_WARNING
-                              "lockd: terminating on error %d\n",
-                              -err);
-                       break;
+                       if (err != preverr) {
+                               printk(KERN_WARNING "%s: unexpected error "
+                                       "from svc_recv (%d)\n", __func__, err);
+                               preverr = err;
+                       }
+                       schedule_timeout_interruptible(HZ);
+                       continue;
                }
+               preverr = err;
 
                dprintk("lockd: request from %s\n",
                                svc_print_addr(rqstp, buf, sizeof(buf)));
 
                svc_process(rqstp);
        }
-
        flush_signals(current);
        if (nlmsvc_ops)
                nlmsvc_invalidate_all();
        nlm_shutdown_hosts();
-
        unlock_kernel();
-
-       nlmsvc_task = NULL;
-       nlmsvc_serv = NULL;
-
-       /* Exit the RPC thread */
-       svc_exit_thread(rqstp);
-
        return 0;
 }
 
@@ -246,16 +245,15 @@ int
 lockd_up(int proto) /* Maybe add a 'family' option when IPv6 is supported ?? */
 {
        struct svc_serv *serv;
-       struct svc_rqst *rqstp;
        int             error = 0;
 
        mutex_lock(&nlmsvc_mutex);
        /*
         * Check whether we're already up and running.
         */
-       if (nlmsvc_serv) {
+       if (nlmsvc_rqst) {
                if (proto)
-                       error = make_socks(nlmsvc_serv, proto);
+                       error = make_socks(nlmsvc_rqst->rq_server, proto);
                goto out;
        }
 
@@ -280,9 +278,10 @@ lockd_up(int proto) /* Maybe add a 'family' option when IPv6 is supported ?? */
        /*
         * Create the kernel thread and wait for it to start.
         */
-       rqstp = svc_prepare_thread(serv, &serv->sv_pools[0]);
-       if (IS_ERR(rqstp)) {
-               error = PTR_ERR(rqstp);
+       nlmsvc_rqst = svc_prepare_thread(serv, &serv->sv_pools[0]);
+       if (IS_ERR(nlmsvc_rqst)) {
+               error = PTR_ERR(nlmsvc_rqst);
+               nlmsvc_rqst = NULL;
                printk(KERN_WARNING
                        "lockd_up: svc_rqst allocation failed, error=%d\n",
                        error);
@@ -290,16 +289,15 @@ lockd_up(int proto) /* Maybe add a 'family' option when IPv6 is supported ?? */
        }
 
        svc_sock_update_bufs(serv);
-       nlmsvc_serv = rqstp->rq_server;
 
-       nlmsvc_task = kthread_run(lockd, rqstp, serv->sv_name);
+       nlmsvc_task = kthread_run(lockd, nlmsvc_rqst, serv->sv_name);
        if (IS_ERR(nlmsvc_task)) {
                error = PTR_ERR(nlmsvc_task);
+               svc_exit_thread(nlmsvc_rqst);
                nlmsvc_task = NULL;
-               nlmsvc_serv = NULL;
+               nlmsvc_rqst = NULL;
                printk(KERN_WARNING
                        "lockd_up: kthread_run failed, error=%d\n", error);
-               svc_exit_thread(rqstp);
                goto destroy_and_out;
        }
 
@@ -338,11 +336,16 @@ lockd_down(void)
                BUG();
        }
        kthread_stop(nlmsvc_task);
+       svc_exit_thread(nlmsvc_rqst);
+       nlmsvc_task = NULL;
+       nlmsvc_rqst = NULL;
 out:
        mutex_unlock(&nlmsvc_mutex);
 }
 EXPORT_SYMBOL(lockd_down);
 
+#ifdef CONFIG_SYSCTL
+
 /*
  * Sysctl parameters (same as module parameters, different interface).
  */
@@ -427,6 +430,8 @@ static ctl_table nlm_sysctl_root[] = {
        { .ctl_name = 0 }
 };
 
+#endif /* CONFIG_SYSCTL */
+
 /*
  * Module (and sysfs) parameters.
  */
@@ -500,15 +505,21 @@ module_param(nsm_use_hostnames, bool, 0644);
 
 static int __init init_nlm(void)
 {
+#ifdef CONFIG_SYSCTL
        nlm_sysctl_table = register_sysctl_table(nlm_sysctl_root);
        return nlm_sysctl_table ? 0 : -ENOMEM;
+#else
+       return 0;
+#endif
 }
 
 static void __exit exit_nlm(void)
 {
        /* FIXME: delete all NLM clients */
        nlm_shutdown_hosts();
+#ifdef CONFIG_SYSCTL
        unregister_sysctl_table(nlm_sysctl_table);
+#endif
 }
 
 module_init(init_nlm);