Merge branch 'linux-next' of git://git.infradead.org/~dedekind/ubi-2.6

6 files changed, 69 insertions, 62 deletions

diff --git a/fs/lockd/clntproc.c b/fs/lockd/clntproc.c
index 5df517b81f3f..1f6dc518505c 100644
--- a/fs/lockd/clntproc.c
+++ b/fs/lockd/clntproc.c
@@ -224,7 +224,9 @@ void nlm_release_call(struct nlm_rqst *call)
 
 static void nlmclnt_rpc_release(void *data)
 {
+        lock_kernel();
         nlm_release_call(data);
+        unlock_kernel();
 }
 
 static int nlm_wait_on_grace(wait_queue_head_t *queue)
@@ -430,7 +432,7 @@ nlmclnt_test(struct nlm_rqst *req, struct file_lock *fl)
                          * Report the conflicting lock back to the application.
                          */
                         fl->fl_start = req->a_res.lock.fl.fl_start;
-                        fl->fl_end = req->a_res.lock.fl.fl_start;
+                        fl->fl_end = req->a_res.lock.fl.fl_end;
                         fl->fl_type = req->a_res.lock.fl.fl_type;
                         fl->fl_pid = 0;
                         break;
@@ -710,7 +712,9 @@ static void nlmclnt_unlock_callback(struct rpc_task *task, void *data)
 die:
         return;
  retry_rebind:
+        lock_kernel();
         nlm_rebind_host(req->a_host);
+        unlock_kernel();
  retry_unlock:
         rpc_restart_call(task);
 }
@@ -788,7 +792,9 @@ retry_cancel:
         /* Don't ever retry more than 3 times */
         if (req->a_retries++ >= NLMCLNT_MAX_RETRIES)
                 goto die;
+        lock_kernel();
         nlm_rebind_host(req->a_host);
+        unlock_kernel();
         rpc_restart_call(task);
         rpc_delay(task, 30 * HZ);
 }
diff --git a/fs/lockd/svc.c b/fs/lockd/svc.c
index 2169af4d5455..5bd9bf0fa9df 100644
--- 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;
 
@@ -194,20 +194,11 @@ lockd(void *vrqstp)
 
                 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;
 }
 
@@ -254,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;
         }
 
@@ -288,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);
@@ -298,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;
         }
 
@@ -346,6 +336,9 @@ lockd_down(void)
                 BUG();
         }
         kthread_stop(nlmsvc_task);
+        svc_exit_thread(nlmsvc_rqst);
+        nlmsvc_task = NULL;
+        nlmsvc_rqst = NULL;
 out:
         mutex_unlock(&nlmsvc_mutex);
 }
diff --git a/fs/lockd/svc4proc.c b/fs/lockd/svc4proc.c
index 385437e3387d..399444639337 100644
--- a/fs/lockd/svc4proc.c
+++ b/fs/lockd/svc4proc.c
@@ -58,8 +58,7 @@ nlm4svc_retrieve_args(struct svc_rqst *rqstp, struct nlm_args *argp,
         return 0;
 
 no_locks:
-        if (host)
-                nlm_release_host(host);
+        nlm_release_host(host);
         if (error)
                 return error;   
         return nlm_lck_denied_nolocks;
@@ -100,7 +99,7 @@ nlm4svc_proc_test(struct svc_rqst *rqstp, struct nlm_args *argp,
                 return resp->status == nlm_drop_reply ? rpc_drop_reply :rpc_success;
 
         /* Now check for conflicting locks */
-        resp->status = nlmsvc_testlock(rqstp, file, &argp->lock, &resp->lock, &resp->cookie);
+        resp->status = nlmsvc_testlock(rqstp, file, host, &argp->lock, &resp->lock, &resp->cookie);
         if (resp->status == nlm_drop_reply)
                 rc = rpc_drop_reply;
         else
@@ -146,7 +145,7 @@ nlm4svc_proc_lock(struct svc_rqst *rqstp, struct nlm_args *argp,
 #endif
 
         /* Now try to lock the file */
-        resp->status = nlmsvc_lock(rqstp, file, &argp->lock,
+        resp->status = nlmsvc_lock(rqstp, file, host, &argp->lock,
                                         argp->block, &argp->cookie);
         if (resp->status == nlm_drop_reply)
                 rc = rpc_drop_reply;
@@ -248,7 +247,9 @@ static void nlm4svc_callback_exit(struct rpc_task *task, void *data)
 
 static void nlm4svc_callback_release(void *data)
 {
+        lock_kernel();
         nlm_release_call(data);
+        unlock_kernel();
 }
 
 static const struct rpc_call_ops nlm4svc_callback_ops = {
diff --git a/fs/lockd/svclock.c b/fs/lockd/svclock.c
index 81aca859bfde..821b9acdfb66 100644
--- a/fs/lockd/svclock.c
+++ b/fs/lockd/svclock.c
@@ -129,9 +129,9 @@ nlmsvc_lookup_block(struct nlm_file *file, struct nlm_lock *lock)
 
 static inline int nlm_cookie_match(struct nlm_cookie *a, struct nlm_cookie *b)
 {
-        if(a->len != b->len)
+        if (a->len != b->len)
                 return 0;
-        if(memcmp(a->data,b->data,a->len))
+        if (memcmp(a->data, b->data, a->len))
                 return 0;
         return 1;
 }
@@ -180,6 +180,7 @@ nlmsvc_create_block(struct svc_rqst *rqstp, struct nlm_host *host,
         struct nlm_block        *block;
         struct nlm_rqst         *call = NULL;
 
+        nlm_get_host(host);
         call = nlm_alloc_call(host);
         if (call == NULL)
                 return NULL;
@@ -358,10 +359,10 @@ nlmsvc_defer_lock_rqst(struct svc_rqst *rqstp, struct nlm_block *block)
  */
 __be32
 nlmsvc_lock(struct svc_rqst *rqstp, struct nlm_file *file,
-                        struct nlm_lock *lock, int wait, struct nlm_cookie *cookie)
+            struct nlm_host *host, struct nlm_lock *lock, int wait,
+            struct nlm_cookie *cookie)
 {
         struct nlm_block        *block = NULL;
-        struct nlm_host         *host;
         int                     error;
         __be32                  ret;
 
@@ -373,11 +374,6 @@ nlmsvc_lock(struct svc_rqst *rqstp, struct nlm_file *file,
                                 (long long)lock->fl.fl_end,
                                 wait);
 
-        /* Create host handle for callback */
-        host = nlmsvc_lookup_host(rqstp, lock->caller, lock->len);
-        if (host == NULL)
-                return nlm_lck_denied_nolocks;
-
         /* Lock file against concurrent access */
         mutex_lock(&file->f_mutex);
         /* Get existing block (in case client is busy-waiting)
@@ -385,8 +381,7 @@ nlmsvc_lock(struct svc_rqst *rqstp, struct nlm_file *file,
          */
         block = nlmsvc_lookup_block(file, lock);
         if (block == NULL) {
-                block = nlmsvc_create_block(rqstp, nlm_get_host(host), file,
-                                lock, cookie);
+                block = nlmsvc_create_block(rqstp, host, file, lock, cookie);
                 ret = nlm_lck_denied_nolocks;
                 if (block == NULL)
                         goto out;
@@ -417,7 +412,7 @@ nlmsvc_lock(struct svc_rqst *rqstp, struct nlm_file *file,
         lock->fl.fl_flags &= ~FL_SLEEP;
 
         dprintk("lockd: vfs_lock_file returned %d\n", error);
-        switch(error) {
+        switch (error) {
                 case 0:
                         ret = nlm_granted;
                         goto out;
@@ -450,7 +445,6 @@ nlmsvc_lock(struct svc_rqst *rqstp, struct nlm_file *file,
 out:
         mutex_unlock(&file->f_mutex);
         nlmsvc_release_block(block);
-        nlm_release_host(host);
         dprintk("lockd: nlmsvc_lock returned %u\n", ret);
         return ret;
 }
@@ -460,8 +454,8 @@ out:
  */
 __be32
 nlmsvc_testlock(struct svc_rqst *rqstp, struct nlm_file *file,
-                struct nlm_lock *lock, struct nlm_lock *conflock,
-                struct nlm_cookie *cookie)
+                struct nlm_host *host, struct nlm_lock *lock,
+                struct nlm_lock *conflock, struct nlm_cookie *cookie)
 {
         struct nlm_block        *block = NULL;
         int                     error;
@@ -479,16 +473,9 @@ nlmsvc_testlock(struct svc_rqst *rqstp, struct nlm_file *file,
 
         if (block == NULL) {
                 struct file_lock *conf = kzalloc(sizeof(*conf), GFP_KERNEL);
-                struct nlm_host *host;
 
                 if (conf == NULL)
                         return nlm_granted;
-                /* Create host handle for callback */
-                host = nlmsvc_lookup_host(rqstp, lock->caller, lock->len);
-                if (host == NULL) {
-                        kfree(conf);
-                        return nlm_lck_denied_nolocks;
-                }
                 block = nlmsvc_create_block(rqstp, host, file, lock, cookie);
                 if (block == NULL) {
                         kfree(conf);
@@ -795,6 +782,7 @@ static void nlmsvc_grant_callback(struct rpc_task *task, void *data)
 
         dprintk("lockd: GRANT_MSG RPC callback\n");
 
+        lock_kernel();
         /* if the block is not on a list at this point then it has
          * been invalidated. Don't try to requeue it.
          *
@@ -804,7 +792,7 @@ static void nlmsvc_grant_callback(struct rpc_task *task, void *data)
          * for nlm_blocked?
          */
         if (list_empty(&block->b_list))
-                return;
+                goto out;
 
         /* Technically, we should down the file semaphore here. Since we
          * move the block towards the head of the queue only, no harm
@@ -818,13 +806,17 @@ static void nlmsvc_grant_callback(struct rpc_task *task, void *data)
         }
         nlmsvc_insert_block(block, timeout);
         svc_wake_up(block->b_daemon);
+out:
+        unlock_kernel();
 }
 
 static void nlmsvc_grant_release(void *data)
 {
         struct nlm_rqst         *call = data;
 
+        lock_kernel();
         nlmsvc_release_block(call->a_block);
+        unlock_kernel();
 }
 
 static const struct rpc_call_ops nlmsvc_grant_ops = {
@@ -892,7 +884,7 @@ nlmsvc_retry_blocked(void)
 
                 if (block->b_when == NLM_NEVER)
                         break;
-                if (time_after(block->b_when,jiffies)) {
+                if (time_after(block->b_when, jiffies)) {
                         timeout = block->b_when - jiffies;
                         break;
                 }
diff --git a/fs/lockd/svcproc.c b/fs/lockd/svcproc.c
index 88379cc6e0b1..76019d2ff72d 100644
--- a/fs/lockd/svcproc.c
+++ b/fs/lockd/svcproc.c
@@ -87,8 +87,7 @@ nlmsvc_retrieve_args(struct svc_rqst *rqstp, struct nlm_args *argp,
         return 0;
 
 no_locks:
-        if (host)
-                nlm_release_host(host);
+        nlm_release_host(host);
         if (error)
                 return error;
         return nlm_lck_denied_nolocks;
@@ -129,7 +128,7 @@ nlmsvc_proc_test(struct svc_rqst *rqstp, struct nlm_args *argp,
                 return resp->status == nlm_drop_reply ? rpc_drop_reply :rpc_success;
 
         /* Now check for conflicting locks */
-        resp->status = cast_status(nlmsvc_testlock(rqstp, file, &argp->lock, &resp->lock, &resp->cookie));
+        resp->status = cast_status(nlmsvc_testlock(rqstp, file, host, &argp->lock, &resp->lock, &resp->cookie));
         if (resp->status == nlm_drop_reply)
                 rc = rpc_drop_reply;
         else
@@ -176,7 +175,7 @@ nlmsvc_proc_lock(struct svc_rqst *rqstp, struct nlm_args *argp,
 #endif
 
         /* Now try to lock the file */
-        resp->status = cast_status(nlmsvc_lock(rqstp, file, &argp->lock,
+        resp->status = cast_status(nlmsvc_lock(rqstp, file, host, &argp->lock,
                                                argp->block, &argp->cookie));
         if (resp->status == nlm_drop_reply)
                 rc = rpc_drop_reply;
@@ -278,7 +277,9 @@ static void nlmsvc_callback_exit(struct rpc_task *task, void *data)
 
 static void nlmsvc_callback_release(void *data)
 {
+        lock_kernel();
         nlm_release_call(data);
+        unlock_kernel();
 }
 
 static const struct rpc_call_ops nlmsvc_callback_ops = {
diff --git a/fs/lockd/svcsubs.c b/fs/lockd/svcsubs.c
index d1c48b539df8..198b4e55b373 100644
--- a/fs/lockd/svcsubs.c
+++ b/fs/lockd/svcsubs.c
@@ -373,13 +373,16 @@ nlmsvc_free_host_resources(struct nlm_host *host)
         }
 }
 
-/*
- * Remove all locks held for clients
+/**
+ * nlmsvc_invalidate_all - remove all locks held for clients
+ *
+ * Release all locks held by NFS clients.
+ *
  */
 void
 nlmsvc_invalidate_all(void)
 {
-        /* Release all locks held by NFS clients.
+        /*
          * Previously, the code would call
          * nlmsvc_free_host_resources for each client in
          * turn, which is about as inefficient as it gets.
@@ -396,6 +399,12 @@ nlmsvc_match_sb(void *datap, struct nlm_file *file)
         return sb == file->f_file->f_path.mnt->mnt_sb;
 }
 
+/**
+ * nlmsvc_unlock_all_by_sb - release locks held on this file system
+ * @sb: super block
+ *
+ * Release all locks held by clients accessing this file system.
+ */
 int
 nlmsvc_unlock_all_by_sb(struct super_block *sb)
 {
@@ -409,17 +418,22 @@ EXPORT_SYMBOL_GPL(nlmsvc_unlock_all_by_sb);
 static int
 nlmsvc_match_ip(void *datap, struct nlm_host *host)
 {
-        __be32 *server_addr = datap;
-
-        return host->h_saddr.sin_addr.s_addr == *server_addr;
+        return nlm_cmp_addr(&host->h_saddr, datap);
 }
 
+/**
+ * nlmsvc_unlock_all_by_ip - release local locks by IP address
+ * @server_addr: server's IP address as seen by clients
+ *
+ * Release all locks held by clients accessing this host
+ * via the passed in IP address.
+ */
 int
-nlmsvc_unlock_all_by_ip(__be32 server_addr)
+nlmsvc_unlock_all_by_ip(struct sockaddr *server_addr)
 {
         int ret;
-        ret = nlm_traverse_files(&server_addr, nlmsvc_match_ip, NULL);
-        return ret ? -EIO : 0;
 
+        ret = nlm_traverse_files(server_addr, nlmsvc_match_ip, NULL);
+        return ret ? -EIO : 0;
 }
 EXPORT_SYMBOL_GPL(nlmsvc_unlock_all_by_ip);