nfsd: only set file_lock.fl_lmops in nfsd4_lockt if a stateowner is found

[linux-2.6-omap-h63xx.git] / fs / nfsd / nfs4state.c

diff --git a/fs/nfsd/nfs4state.c b/fs/nfsd/nfs4state.c
index 13e0e074dbb8154aa4cc49a45405478efe929cb7..b6f60f48e94b4038473faf04b766ce706e60a9d4 100644 (file)
--- a/fs/nfsd/nfs4state.c
+++ b/fs/nfsd/nfs4state.c
@@ -2416,6 +2416,26 @@ out:
 #define LOCK_HASH_SIZE             (1 << LOCK_HASH_BITS)
 #define LOCK_HASH_MASK             (LOCK_HASH_SIZE - 1)
 
+static inline u64
+end_offset(u64 start, u64 len)
+{
+       u64 end;
+
+       end = start + len;
+       return end >= start ? end: NFS4_MAX_UINT64;
+}
+
+/* last octet in a range */
+static inline u64
+last_byte_offset(u64 start, u64 len)
+{
+       u64 end;
+
+       BUG_ON(!len);
+       end = start + len;
+       return end > start ? end - 1: NFS4_MAX_UINT64;
+}
+
 #define lockownerid_hashval(id) \
         ((id) & LOCK_HASH_MASK)
 
@@ -2435,13 +2455,13 @@ static struct list_head lockstateid_hashtbl[STATEID_HASH_SIZE];
 static struct nfs4_stateid *
 find_stateid(stateid_t *stid, int flags)
 {
-       struct nfs4_stateid *local = NULL;
+       struct nfs4_stateid *local;
        u32 st_id = stid->si_stateownerid;
        u32 f_id = stid->si_fileid;
        unsigned int hashval;
 
        dprintk("NFSD: find_stateid flags 0x%x\n",flags);
-       if ((flags & LOCK_STATE) || (flags & RD_STATE) || (flags & WR_STATE)) {
+       if (flags & (LOCK_STATE | RD_STATE | WR_STATE)) {
                hashval = stateid_hashval(st_id, f_id);
                list_for_each_entry(local, &lockstateid_hashtbl[hashval], st_hash) {
                        if ((local->st_stateid.si_stateownerid == st_id) &&
@@ -2449,7 +2469,8 @@ find_stateid(stateid_t *stid, int flags)
                                return local;
                }
        } 
-       if ((flags & OPEN_STATE) || (flags & RD_STATE) || (flags & WR_STATE)) {
+
+       if (flags & (OPEN_STATE | RD_STATE | WR_STATE)) {
                hashval = stateid_hashval(st_id, f_id);
                list_for_each_entry(local, &stateid_hashtbl[hashval], st_hash) {
                        if ((local->st_stateid.si_stateownerid == st_id) &&
@@ -2518,8 +2539,8 @@ nfs4_set_lock_denied(struct file_lock *fl, struct nfsd4_lock_denied *deny)
                deny->ld_clientid.cl_id = 0;
        }
        deny->ld_start = fl->fl_start;
-       deny->ld_length = ~(u64)0;
-       if (fl->fl_end != ~(u64)0)
+       deny->ld_length = NFS4_MAX_UINT64;
+       if (fl->fl_end != NFS4_MAX_UINT64)
                deny->ld_length = fl->fl_end - fl->fl_start + 1;        
        deny->ld_type = NFS4_READ_LT;
        if (fl->fl_type != F_RDLCK)
@@ -2616,7 +2637,7 @@ out:
 static int
 check_lock_length(u64 offset, u64 length)
 {
-       return ((length == 0)  || ((length != ~(u64)0) &&
+       return ((length == 0)  || ((length != NFS4_MAX_UINT64) &&
             LOFF_OVERFLOW(offset, length)));
 }
 
@@ -2736,11 +2757,7 @@ nfsd4_lock(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
        file_lock.fl_lmops = &nfsd_posix_mng_ops;
 
        file_lock.fl_start = lock->lk_offset;
-       if ((lock->lk_length == ~(u64)0) || 
-                       LOFF_OVERFLOW(lock->lk_offset, lock->lk_length))
-               file_lock.fl_end = ~(u64)0;
-       else
-               file_lock.fl_end = lock->lk_offset + lock->lk_length - 1;
+       file_lock.fl_end = last_byte_offset(lock->lk_offset, lock->lk_length);
        nfs4_transform_lock_offset(&file_lock);
 
        /*
@@ -2780,6 +2797,25 @@ out:
        return status;
 }
 
+/*
+ * The NFSv4 spec allows a client to do a LOCKT without holding an OPEN,
+ * so we do a temporary open here just to get an open file to pass to
+ * vfs_test_lock.  (Arguably perhaps test_lock should be done with an
+ * inode operation.)
+ */
+static int nfsd_test_lock(struct svc_rqst *rqstp, struct svc_fh *fhp, struct file_lock *lock)
+{
+       struct file *file;
+       int err;
+
+       err = nfsd_open(rqstp, fhp, S_IFREG, NFSD_MAY_READ, &file);
+       if (err)
+               return err;
+       err = vfs_test_lock(file, lock);
+       nfsd_close(file);
+       return err;
+}
+
 /*
  * LOCKT operation
  */
@@ -2788,7 +2824,6 @@ nfsd4_lockt(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
            struct nfsd4_lockt *lockt)
 {
        struct inode *inode;
-       struct file file;
        struct file_lock file_lock;
        int error;
        __be32 status;
@@ -2836,26 +2871,14 @@ nfsd4_lockt(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
                file_lock.fl_owner = (fl_owner_t)lockt->lt_stateowner;
        file_lock.fl_pid = current->tgid;
        file_lock.fl_flags = FL_POSIX;
-       file_lock.fl_lmops = &nfsd_posix_mng_ops;
 
        file_lock.fl_start = lockt->lt_offset;
-       if ((lockt->lt_length == ~(u64)0) || LOFF_OVERFLOW(lockt->lt_offset, lockt->lt_length))
-               file_lock.fl_end = ~(u64)0;
-       else
-               file_lock.fl_end = lockt->lt_offset + lockt->lt_length - 1;
+       file_lock.fl_end = last_byte_offset(lockt->lt_offset, lockt->lt_length);
 
        nfs4_transform_lock_offset(&file_lock);
 
-       /* vfs_test_lock uses the struct file _only_ to resolve the inode.
-        * since LOCKT doesn't require an OPEN, and therefore a struct
-        * file may not exist, pass vfs_test_lock a struct file with
-        * only the dentry:inode set.
-        */
-       memset(&file, 0, sizeof (struct file));
-       file.f_path.dentry = cstate->current_fh.fh_dentry;
-
        status = nfs_ok;
-       error = vfs_test_lock(&file, &file_lock);
+       error = nfsd_test_lock(rqstp, &cstate->current_fh, &file_lock);
        if (error) {
                status = nfserrno(error);
                goto out;
@@ -2906,10 +2929,7 @@ nfsd4_locku(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
        file_lock.fl_lmops = &nfsd_posix_mng_ops;
        file_lock.fl_start = locku->lu_offset;
 
-       if ((locku->lu_length == ~(u64)0) || LOFF_OVERFLOW(locku->lu_offset, locku->lu_length))
-               file_lock.fl_end = ~(u64)0;
-       else
-               file_lock.fl_end = locku->lu_offset + locku->lu_length - 1;
+       file_lock.fl_end = last_byte_offset(locku->lu_offset, locku->lu_length);
        nfs4_transform_lock_offset(&file_lock);
 
        /*