Merge git://git.kernel.org/pub/scm/linux/kernel/git/steve/gfs2-2.6-nmw

* git://git.kernel.org/pub/scm/linux/kernel/git/steve/gfs2-2.6-nmw: (57 commits)
  [GFS2] Accept old format NFS filehandles
  [GFS2] Small fixes to logging code
  [DLM] dump more lock values
  [GFS2] Remove i_mode passing from NFS File Handle
  [GFS2] Obtaining no_formal_ino from directory entry
  [GFS2] git-gfs2-nmw-build-fix
  [GFS2] System won't suspend with GFS2 file system mounted
  [GFS2] remounting w/o acl option leaves acls enabled
  [GFS2] inode size inconsistency
  [DLM] Telnet to port 21064 can stop all lockspaces
  [GFS2] Fix gfs2_block_truncate_page err return
  [GFS2] Addendum to the journaled file/unmount patch
  [GFS2] Simplify multiple glock aquisition
  [GFS2] assertion failure after writing to journaled file, umount
  [GFS2] Use zero_user_page() in stuffed_readpage()
  [GFS2] Remove bogus '\0' in rgrp.c
  [GFS2] Journaled file write/unstuff bug
  [DLM] don't require FS flag on all nodes
  [GFS2] Fix deallocation issues
  [GFS2] return conflicts for GETLK
  ...

1 files changed, 99 insertions, 30 deletions

diff --git a/fs/dlm/user.c b/fs/dlm/user.c
index b0201ec325a7..6438941ab1f8 100644
--- a/fs/dlm/user.c
+++ b/fs/dlm/user.c
@@ -33,16 +33,17 @@ static const struct file_operations device_fops;
 struct dlm_lock_params32 {
         __u8 mode;
         __u8 namelen;
-        __u16 flags;
+        __u16 unused;
+        __u32 flags;
         __u32 lkid;
         __u32 parent;
-
+        __u64 xid;
+        __u64 timeout;
         __u32 castparam;
         __u32 castaddr;
         __u32 bastparam;
         __u32 bastaddr;
         __u32 lksb;
-
         char lvb[DLM_USER_LVB_LEN];
         char name[0];
 };
@@ -68,6 +69,7 @@ struct dlm_lksb32 {
 };
 
 struct dlm_lock_result32 {
+        __u32 version[3];
         __u32 length;
         __u32 user_astaddr;
         __u32 user_astparam;
@@ -102,6 +104,8 @@ static void compat_input(struct dlm_write_request *kb,
                 kb->i.lock.flags = kb32->i.lock.flags;
                 kb->i.lock.lkid = kb32->i.lock.lkid;
                 kb->i.lock.parent = kb32->i.lock.parent;
+                kb->i.lock.xid = kb32->i.lock.xid;
+                kb->i.lock.timeout = kb32->i.lock.timeout;
                 kb->i.lock.castparam = (void *)(long)kb32->i.lock.castparam;
                 kb->i.lock.castaddr = (void *)(long)kb32->i.lock.castaddr;
                 kb->i.lock.bastparam = (void *)(long)kb32->i.lock.bastparam;
@@ -115,6 +119,10 @@ static void compat_input(struct dlm_write_request *kb,
 static void compat_output(struct dlm_lock_result *res,
                           struct dlm_lock_result32 *res32)
 {
+        res32->version[0] = res->version[0];
+        res32->version[1] = res->version[1];
+        res32->version[2] = res->version[2];
+
         res32->user_astaddr = (__u32)(long)res->user_astaddr;
         res32->user_astparam = (__u32)(long)res->user_astparam;
         res32->user_lksb = (__u32)(long)res->user_lksb;
@@ -130,6 +138,36 @@ static void compat_output(struct dlm_lock_result *res,
 }
 #endif
 
+/* Figure out if this lock is at the end of its life and no longer
+   available for the application to use.  The lkb still exists until
+   the final ast is read.  A lock becomes EOL in three situations:
+     1. a noqueue request fails with EAGAIN
+     2. an unlock completes with EUNLOCK
+     3. a cancel of a waiting request completes with ECANCEL/EDEADLK
+   An EOL lock needs to be removed from the process's list of locks.
+   And we can't allow any new operation on an EOL lock.  This is
+   not related to the lifetime of the lkb struct which is managed
+   entirely by refcount. */
+
+static int lkb_is_endoflife(struct dlm_lkb *lkb, int sb_status, int type)
+{
+        switch (sb_status) {
+        case -DLM_EUNLOCK:
+                return 1;
+        case -DLM_ECANCEL:
+        case -ETIMEDOUT:
+        case -EDEADLK:
+                if (lkb->lkb_grmode == DLM_LOCK_IV)
+                        return 1;
+                break;
+        case -EAGAIN:
+                if (type == AST_COMP && lkb->lkb_grmode == DLM_LOCK_IV)
+                        return 1;
+                break;
+        }
+        return 0;
+}
+
 /* we could possibly check if the cancel of an orphan has resulted in the lkb
    being removed and then remove that lkb from the orphans list and free it */
 
@@ -176,25 +214,7 @@ void dlm_user_add_ast(struct dlm_lkb *lkb, int type)
                 log_debug(ls, "ast overlap %x status %x %x",
                           lkb->lkb_id, ua->lksb.sb_status, lkb->lkb_flags);
 
-        /* Figure out if this lock is at the end of its life and no longer
-           available for the application to use.  The lkb still exists until
-           the final ast is read.  A lock becomes EOL in three situations:
-             1. a noqueue request fails with EAGAIN
-             2. an unlock completes with EUNLOCK
-             3. a cancel of a waiting request completes with ECANCEL
-           An EOL lock needs to be removed from the process's list of locks.
-           And we can't allow any new operation on an EOL lock.  This is
-           not related to the lifetime of the lkb struct which is managed
-           entirely by refcount. */
-
-        if (type == AST_COMP &&
-            lkb->lkb_grmode == DLM_LOCK_IV &&
-            ua->lksb.sb_status == -EAGAIN)
-                eol = 1;
-        else if (ua->lksb.sb_status == -DLM_EUNLOCK ||
-            (ua->lksb.sb_status == -DLM_ECANCEL &&
-             lkb->lkb_grmode == DLM_LOCK_IV))
-                eol = 1;
+        eol = lkb_is_endoflife(lkb, ua->lksb.sb_status, type);
         if (eol) {
                 lkb->lkb_ast_type &= ~AST_BAST;
                 lkb->lkb_flags |= DLM_IFL_ENDOFLIFE;
@@ -252,16 +272,18 @@ static int device_user_lock(struct dlm_user_proc *proc,
         ua->castaddr = params->castaddr;
         ua->bastparam = params->bastparam;
         ua->bastaddr = params->bastaddr;
+        ua->xid = params->xid;
 
         if (params->flags & DLM_LKF_CONVERT)
                 error = dlm_user_convert(ls, ua,
                                          params->mode, params->flags,
-                                         params->lkid, params->lvb);
+                                         params->lkid, params->lvb,
+                                         (unsigned long) params->timeout);
         else {
                 error = dlm_user_request(ls, ua,
                                          params->mode, params->flags,
                                          params->name, params->namelen,
-                                         params->parent);
+                                         (unsigned long) params->timeout);
                 if (!error)
                         error = ua->lksb.sb_lkid;
         }
@@ -299,6 +321,22 @@ static int device_user_unlock(struct dlm_user_proc *proc,
         return error;
 }
 
+static int device_user_deadlock(struct dlm_user_proc *proc,
+                                struct dlm_lock_params *params)
+{
+        struct dlm_ls *ls;
+        int error;
+
+        ls = dlm_find_lockspace_local(proc->lockspace);
+        if (!ls)
+                return -ENOENT;
+
+        error = dlm_user_deadlock(ls, params->flags, params->lkid);
+
+        dlm_put_lockspace(ls);
+        return error;
+}
+
 static int create_misc_device(struct dlm_ls *ls, char *name)
 {
         int error, len;
@@ -348,7 +386,7 @@ static int device_create_lockspace(struct dlm_lspace_params *params)
                 return -EPERM;
 
         error = dlm_new_lockspace(params->name, strlen(params->name),
-                                  &lockspace, 0, DLM_USER_LVB_LEN);
+                                  &lockspace, params->flags, DLM_USER_LVB_LEN);
         if (error)
                 return error;
 
@@ -524,6 +562,14 @@ static ssize_t device_write(struct file *file, const char __user *buf,
                 error = device_user_unlock(proc, &kbuf->i.lock);
                 break;
 
+        case DLM_USER_DEADLOCK:
+                if (!proc) {
+                        log_print("no locking on control device");
+                        goto out_sig;
+                }
+                error = device_user_deadlock(proc, &kbuf->i.lock);
+                break;
+
         case DLM_USER_CREATE_LOCKSPACE:
                 if (proc) {
                         log_print("create/remove only on control device");
@@ -641,6 +687,9 @@ static int copy_result_to_user(struct dlm_user_args *ua, int compat, int type,
         int struct_len;
 
         memset(&result, 0, sizeof(struct dlm_lock_result));
+        result.version[0] = DLM_DEVICE_VERSION_MAJOR;
+        result.version[1] = DLM_DEVICE_VERSION_MINOR;
+        result.version[2] = DLM_DEVICE_VERSION_PATCH;
         memcpy(&result.lksb, &ua->lksb, sizeof(struct dlm_lksb));
         result.user_lksb = ua->user_lksb;
 
@@ -699,6 +748,20 @@ static int copy_result_to_user(struct dlm_user_args *ua, int compat, int type,
         return error;
 }
 
+static int copy_version_to_user(char __user *buf, size_t count)
+{
+        struct dlm_device_version ver;
+
+        memset(&ver, 0, sizeof(struct dlm_device_version));
+        ver.version[0] = DLM_DEVICE_VERSION_MAJOR;
+        ver.version[1] = DLM_DEVICE_VERSION_MINOR;
+        ver.version[2] = DLM_DEVICE_VERSION_PATCH;
+
+        if (copy_to_user(buf, &ver, sizeof(struct dlm_device_version)))
+                return -EFAULT;
+        return sizeof(struct dlm_device_version);
+}
+
 /* a read returns a single ast described in a struct dlm_lock_result */
 
 static ssize_t device_read(struct file *file, char __user *buf, size_t count,
@@ -710,6 +773,16 @@ static ssize_t device_read(struct file *file, char __user *buf, size_t count,
         DECLARE_WAITQUEUE(wait, current);
         int error, type=0, bmode=0, removed = 0;
 
+        if (count == sizeof(struct dlm_device_version)) {
+                error = copy_version_to_user(buf, count);
+                return error;
+        }
+
+        if (!proc) {
+                log_print("non-version read from control device %zu", count);
+                return -EINVAL;
+        }
+
 #ifdef CONFIG_COMPAT
         if (count < sizeof(struct dlm_lock_result32))
 #else
@@ -747,11 +820,6 @@ static ssize_t device_read(struct file *file, char __user *buf, size_t count,
                 }
         }
 
-        if (list_empty(&proc->asts)) {
-                spin_unlock(&proc->asts_spin);
-                return -EAGAIN;
-        }
-
         /* there may be both completion and blocking asts to return for
            the lkb, don't remove lkb from asts list unless no asts remain */
 
@@ -823,6 +891,7 @@ static const struct file_operations device_fops = {
 static const struct file_operations ctl_device_fops = {
         .open    = ctl_device_open,
         .release = ctl_device_close,
+        .read    = device_read,
         .write   = device_write,
         .owner   = THIS_MODULE,
 };