14 files changed, 127 insertions, 117 deletions

diff --git a/drivers/staging/lustre/lustre/llite/file.c b/drivers/staging/lustre/lustre/llite/file.c
index 11bf2c60c31a..02f27593013e 100644
--- a/drivers/staging/lustre/lustre/llite/file.c
+++ b/drivers/staging/lustre/lustre/llite/file.c
@@ -2750,13 +2750,9 @@ ll_file_flock(struct file *file, int cmd, struct file_lock *file_lock)
         rc = md_enqueue(sbi->ll_md_exp, &einfo, NULL,
                         op_data, &lockh, &flock, 0, NULL /* req */, flags);
 
-        if ((file_lock->fl_flags & FL_FLOCK) &&
-            (rc == 0 || file_lock->fl_type == F_UNLCK))
-                rc2  = flock_lock_file_wait(file, file_lock);
-        if ((file_lock->fl_flags & FL_POSIX) &&
-            (rc == 0 || file_lock->fl_type == F_UNLCK) &&
+        if ((rc == 0 || file_lock->fl_type == F_UNLCK) &&
             !(flags & LDLM_FL_TEST_LOCK))
-                rc2  = posix_lock_file_wait(file, file_lock);
+                rc2  = locks_lock_file_wait(file, file_lock);
 
         if (rc2 && file_lock->fl_type != F_UNLCK) {
                 einfo.ei_mode = LCK_NL;
diff --git a/fs/9p/vfs_file.c b/fs/9p/vfs_file.c
index 3abc447783aa..f23fd86697ea 100644
--- a/fs/9p/vfs_file.c
+++ b/fs/9p/vfs_file.c
@@ -161,7 +161,7 @@ static int v9fs_file_do_lock(struct file *filp, int cmd, struct file_lock *fl)
         if ((fl->fl_flags & FL_POSIX) != FL_POSIX)
                 BUG();
 
-        res = posix_lock_file_wait(filp, fl);
+        res = locks_lock_file_wait(filp, fl);
         if (res < 0)
                 goto out;
 
@@ -231,7 +231,7 @@ out_unlock:
         if (res < 0 && fl->fl_type != F_UNLCK) {
                 fl_type = fl->fl_type;
                 fl->fl_type = F_UNLCK;
-                res = posix_lock_file_wait(filp, fl);
+                res = locks_lock_file_wait(filp, fl);
                 fl->fl_type = fl_type;
         }
 out:
diff --git a/fs/ceph/locks.c b/fs/ceph/locks.c
index 6706bde9ad1b..a2cb0c254060 100644
--- a/fs/ceph/locks.c
+++ b/fs/ceph/locks.c
@@ -228,12 +228,12 @@ int ceph_flock(struct file *file, int cmd, struct file_lock *fl)
         err = ceph_lock_message(CEPH_LOCK_FLOCK, CEPH_MDS_OP_SETFILELOCK,
                                 file, lock_cmd, wait, fl);
         if (!err) {
-                err = flock_lock_file_wait(file, fl);
+                err = locks_lock_file_wait(file, fl);
                 if (err) {
                         ceph_lock_message(CEPH_LOCK_FLOCK,
                                           CEPH_MDS_OP_SETFILELOCK,
                                           file, CEPH_LOCK_UNLOCK, 0, fl);
-                        dout("got %d on flock_lock_file_wait, undid lock", err);
+                        dout("got %d on locks_lock_file_wait, undid lock", err);
                 }
         }
         return err;
diff --git a/fs/cifs/file.c b/fs/cifs/file.c
index 62203c387db4..47c5c97e2dd3 100644
--- a/fs/cifs/file.c
+++ b/fs/cifs/file.c
@@ -1553,7 +1553,7 @@ cifs_setlk(struct file *file, struct file_lock *flock, __u32 type,
 
 out:
         if (flock->fl_flags & FL_POSIX && !rc)
-                rc = posix_lock_file_wait(file, flock);
+                rc = locks_lock_file_wait(file, flock);
         return rc;
 }
 
diff --git a/fs/dlm/plock.c b/fs/dlm/plock.c
index 5532f097f6da..3585cc056fd1 100644
--- a/fs/dlm/plock.c
+++ b/fs/dlm/plock.c
@@ -172,7 +172,7 @@ int dlm_posix_lock(dlm_lockspace_t *lockspace, u64 number, struct file *file,
         rv = op->info.rv;
 
         if (!rv) {
-                if (posix_lock_file_wait(file, fl) < 0)
+                if (locks_lock_file_wait(file, fl) < 0)
                         log_error(ls, "dlm_posix_lock: vfs lock error %llx",
                                   (unsigned long long)number);
         }
@@ -262,7 +262,7 @@ int dlm_posix_unlock(dlm_lockspace_t *lockspace, u64 number, struct file *file,
         /* cause the vfs unlock to return ENOENT if lock is not found */
         fl->fl_flags |= FL_EXISTS;
 
-        rv = posix_lock_file_wait(file, fl);
+        rv = locks_lock_file_wait(file, fl);
         if (rv == -ENOENT) {
                 rv = 0;
                 goto out_free;
diff --git a/fs/fuse/file.c b/fs/fuse/file.c
index f523f2f04c19..e0faf8f2c868 100644
--- a/fs/fuse/file.c
+++ b/fs/fuse/file.c
@@ -2189,7 +2189,7 @@ static int fuse_file_flock(struct file *file, int cmd, struct file_lock *fl)
         int err;
 
         if (fc->no_flock) {
-                err = flock_lock_file_wait(file, fl);
+                err = locks_lock_file_wait(file, fl);
         } else {
                 struct fuse_file *ff = file->private_data;
 
diff --git a/fs/gfs2/file.c b/fs/gfs2/file.c
index cf4ab89159f4..9287a2d17b8c 100644
--- a/fs/gfs2/file.c
+++ b/fs/gfs2/file.c
@@ -1000,7 +1000,7 @@ static int gfs2_lock(struct file *file, int cmd, struct file_lock *fl)
         }
         if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags))) {
                 if (fl->fl_type == F_UNLCK)
-                        posix_lock_file_wait(file, fl);
+                        locks_lock_file_wait(file, fl);
                 return -EIO;
         }
         if (IS_GETLK(cmd))
@@ -1031,7 +1031,7 @@ static int do_flock(struct file *file, int cmd, struct file_lock *fl)
         if (gl) {
                 if (fl_gh->gh_state == state)
                         goto out;
-                flock_lock_file_wait(file,
+                locks_lock_file_wait(file,
                                      &(struct file_lock){.fl_type = F_UNLCK});
                 gfs2_glock_dq(fl_gh);
                 gfs2_holder_reinit(state, flags, fl_gh);
@@ -1056,7 +1056,7 @@ static int do_flock(struct file *file, int cmd, struct file_lock *fl)
                 if (error == GLR_TRYFAILED)
                         error = -EAGAIN;
         } else {
-                error = flock_lock_file_wait(file, fl);
+                error = locks_lock_file_wait(file, fl);
                 gfs2_assert_warn(GFS2_SB(&ip->i_inode), !error);
         }
 
@@ -1071,7 +1071,7 @@ static void do_unflock(struct file *file, struct file_lock *fl)
         struct gfs2_holder *fl_gh = &fp->f_fl_gh;
 
         mutex_lock(&fp->f_fl_mutex);
-        flock_lock_file_wait(file, fl);
+        locks_lock_file_wait(file, fl);
         if (fl_gh->gh_gl) {
                 gfs2_glock_dq(fl_gh);
                 gfs2_holder_uninit(fl_gh);
diff --git a/fs/lockd/clntproc.c b/fs/lockd/clntproc.c
index acd394716349..112952037933 100644
--- a/fs/lockd/clntproc.c
+++ b/fs/lockd/clntproc.c
@@ -474,18 +474,7 @@ static void nlmclnt_locks_init_private(struct file_lock *fl, struct nlm_host *ho
 
 static int do_vfs_lock(struct file_lock *fl)
 {
-        int res = 0;
-        switch (fl->fl_flags & (FL_POSIX|FL_FLOCK)) {
-                case FL_POSIX:
-                        res = posix_lock_file_wait(fl->fl_file, fl);
-                        break;
-                case FL_FLOCK:
-                        res = flock_lock_file_wait(fl->fl_file, fl);
-                        break;
-                default:
-                        BUG();
-        }
-        return res;
+        return locks_lock_file_wait(fl->fl_file, fl);
 }
 
 /*
diff --git a/fs/locks.c b/fs/locks.c
index 2a54c800a223..0d2b3267e2a3 100644
--- a/fs/locks.c
+++ b/fs/locks.c
@@ -205,28 +205,32 @@ static struct kmem_cache *filelock_cache __read_mostly;
 static struct file_lock_context *
 locks_get_lock_context(struct inode *inode, int type)
 {
-        struct file_lock_context *new;
+        struct file_lock_context *ctx;
 
-        if (likely(inode->i_flctx) || type == F_UNLCK)
+        /* paired with cmpxchg() below */
+        ctx = smp_load_acquire(&inode->i_flctx);
+        if (likely(ctx) || type == F_UNLCK)
                 goto out;
 
-        new = kmem_cache_alloc(flctx_cache, GFP_KERNEL);
-        if (!new)
+        ctx = kmem_cache_alloc(flctx_cache, GFP_KERNEL);
+        if (!ctx)
                 goto out;
 
-        spin_lock_init(&new->flc_lock);
-        INIT_LIST_HEAD(&new->flc_flock);
-        INIT_LIST_HEAD(&new->flc_posix);
-        INIT_LIST_HEAD(&new->flc_lease);
+        spin_lock_init(&ctx->flc_lock);
+        INIT_LIST_HEAD(&ctx->flc_flock);
+        INIT_LIST_HEAD(&ctx->flc_posix);
+        INIT_LIST_HEAD(&ctx->flc_lease);
 
         /*
          * Assign the pointer if it's not already assigned. If it is, then
          * free the context we just allocated.
          */
-        if (cmpxchg(&inode->i_flctx, NULL, new))
-                kmem_cache_free(flctx_cache, new);
+        if (cmpxchg(&inode->i_flctx, NULL, ctx)) {
+                kmem_cache_free(flctx_cache, ctx);
+                ctx = smp_load_acquire(&inode->i_flctx);
+        }
 out:
-        return inode->i_flctx;
+        return ctx;
 }
 
 void
@@ -762,7 +766,7 @@ posix_test_lock(struct file *filp, struct file_lock *fl)
         struct file_lock_context *ctx;
         struct inode *inode = file_inode(filp);
 
-        ctx = inode->i_flctx;
+        ctx = smp_load_acquire(&inode->i_flctx);
         if (!ctx || list_empty_careful(&ctx->flc_posix)) {
                 fl->fl_type = F_UNLCK;
                 return;
@@ -1167,10 +1171,9 @@ EXPORT_SYMBOL(posix_lock_file);
  * @inode: inode of file to which lock request should be applied
  * @fl: The lock to be applied
  *
- * Variant of posix_lock_file_wait that does not take a filp, and so can be
- * used after the filp has already been torn down.
+ * Apply a POSIX style lock request to an inode.
  */
-int posix_lock_inode_wait(struct inode *inode, struct file_lock *fl)
+static int posix_lock_inode_wait(struct inode *inode, struct file_lock *fl)
 {
         int error;
         might_sleep ();
@@ -1187,7 +1190,6 @@ int posix_lock_inode_wait(struct inode *inode, struct file_lock *fl)
         }
         return error;
 }
-EXPORT_SYMBOL(posix_lock_inode_wait);
 
 /**
  * locks_mandatory_locked - Check for an active lock
@@ -1203,7 +1205,7 @@ int locks_mandatory_locked(struct file *file)
         struct file_lock_context *ctx;
         struct file_lock *fl;
 
-        ctx = inode->i_flctx;
+        ctx = smp_load_acquire(&inode->i_flctx);
         if (!ctx || list_empty_careful(&ctx->flc_posix))
                 return 0;
 
@@ -1388,7 +1390,7 @@ any_leases_conflict(struct inode *inode, struct file_lock *breaker)
 int __break_lease(struct inode *inode, unsigned int mode, unsigned int type)
 {
         int error = 0;
-        struct file_lock_context *ctx = inode->i_flctx;
+        struct file_lock_context *ctx;
         struct file_lock *new_fl, *fl, *tmp;
         unsigned long break_time;
         int want_write = (mode & O_ACCMODE) != O_RDONLY;
@@ -1400,6 +1402,7 @@ int __break_lease(struct inode *inode, unsigned int mode, unsigned int type)
         new_fl->fl_flags = type;
 
         /* typically we will check that ctx is non-NULL before calling */
+        ctx = smp_load_acquire(&inode->i_flctx);
         if (!ctx) {
                 WARN_ON_ONCE(1);
                 return error;
@@ -1494,9 +1497,10 @@ EXPORT_SYMBOL(__break_lease);
 void lease_get_mtime(struct inode *inode, struct timespec *time)
 {
         bool has_lease = false;
-        struct file_lock_context *ctx = inode->i_flctx;
+        struct file_lock_context *ctx;
         struct file_lock *fl;
 
+        ctx = smp_load_acquire(&inode->i_flctx);
         if (ctx && !list_empty_careful(&ctx->flc_lease)) {
                 spin_lock(&ctx->flc_lock);
                 if (!list_empty(&ctx->flc_lease)) {
@@ -1543,10 +1547,11 @@ int fcntl_getlease(struct file *filp)
 {
         struct file_lock *fl;
         struct inode *inode = file_inode(filp);
-        struct file_lock_context *ctx = inode->i_flctx;
+        struct file_lock_context *ctx;
         int type = F_UNLCK;
         LIST_HEAD(dispose);
 
+        ctx = smp_load_acquire(&inode->i_flctx);
         if (ctx && !list_empty_careful(&ctx->flc_lease)) {
                 spin_lock(&ctx->flc_lock);
                 time_out_leases(file_inode(filp), &dispose);
@@ -1711,11 +1716,11 @@ static int generic_delete_lease(struct file *filp, void *owner)
 {
         int error = -EAGAIN;
         struct file_lock *fl, *victim = NULL;
-        struct dentry *dentry = filp->f_path.dentry;
-        struct inode *inode = dentry->d_inode;
-        struct file_lock_context *ctx = inode->i_flctx;
+        struct inode *inode = file_inode(filp);
+        struct file_lock_context *ctx;
         LIST_HEAD(dispose);
 
+        ctx = smp_load_acquire(&inode->i_flctx);
         if (!ctx) {
                 trace_generic_delete_lease(inode, NULL);
                 return error;
@@ -1751,8 +1756,7 @@ static int generic_delete_lease(struct file *filp, void *owner)
 int generic_setlease(struct file *filp, long arg, struct file_lock **flp,
                         void **priv)
 {
-        struct dentry *dentry = filp->f_path.dentry;
-        struct inode *inode = dentry->d_inode;
+        struct inode *inode = file_inode(filp);
         int error;
 
         if ((!uid_eq(current_fsuid(), inode->i_uid)) && !capable(CAP_LEASE))
@@ -1856,7 +1860,7 @@ int fcntl_setlease(unsigned int fd, struct file *filp, long arg)
  *
  * Apply a FLOCK style lock request to an inode.
  */
-int flock_lock_inode_wait(struct inode *inode, struct file_lock *fl)
+static int flock_lock_inode_wait(struct inode *inode, struct file_lock *fl)
 {
         int error;
         might_sleep();
@@ -1873,7 +1877,30 @@ int flock_lock_inode_wait(struct inode *inode, struct file_lock *fl)
         }
         return error;
 }
-EXPORT_SYMBOL(flock_lock_inode_wait);
+
+/**
+ * locks_lock_inode_wait - Apply a lock to an inode
+ * @inode: inode of the file to apply to
+ * @fl: The lock to be applied
+ *
+ * Apply a POSIX or FLOCK style lock request to an inode.
+ */
+int locks_lock_inode_wait(struct inode *inode, struct file_lock *fl)
+{
+        int res = 0;
+        switch (fl->fl_flags & (FL_POSIX|FL_FLOCK)) {
+                case FL_POSIX:
+                        res = posix_lock_inode_wait(inode, fl);
+                        break;
+                case FL_FLOCK:
+                        res = flock_lock_inode_wait(inode, fl);
+                        break;
+                default:
+                        BUG();
+        }
+        return res;
+}
+EXPORT_SYMBOL(locks_lock_inode_wait);
 
 /**
  *      sys_flock: - flock() system call.
@@ -1931,7 +1958,7 @@ SYSCALL_DEFINE2(flock, unsigned int, fd, unsigned int, cmd)
                                           (can_sleep) ? F_SETLKW : F_SETLK,
                                           lock);
         else
-                error = flock_lock_file_wait(f.file, lock);
+                error = locks_lock_file_wait(f.file, lock);
 
  out_free:
         locks_free_lock(lock);
@@ -2107,7 +2134,7 @@ static int do_lock_file_wait(struct file *filp, unsigned int cmd,
         return error;
 }
 
-/* Ensure that fl->fl_filp has compatible f_mode for F_SETLK calls */
+/* Ensure that fl->fl_file has compatible f_mode for F_SETLK calls */
 static int
 check_fmode_for_setlk(struct file_lock *fl)
 {
@@ -2359,13 +2386,14 @@ out:
 void locks_remove_posix(struct file *filp, fl_owner_t owner)
 {
         struct file_lock lock;
-        struct file_lock_context *ctx = file_inode(filp)->i_flctx;
+        struct file_lock_context *ctx;
 
         /*
          * If there are no locks held on this file, we don't need to call
          * posix_lock_file().  Another process could be setting a lock on this
          * file at the same time, but we wouldn't remove that lock anyway.
          */
+        ctx =  smp_load_acquire(&file_inode(filp)->i_flctx);
         if (!ctx || list_empty(&ctx->flc_posix))
                 return;
 
@@ -2389,7 +2417,7 @@ EXPORT_SYMBOL(locks_remove_posix);
 
 /* The i_flctx must be valid when calling into here */
 static void
-locks_remove_flock(struct file *filp)
+locks_remove_flock(struct file *filp, struct file_lock_context *flctx)
 {
         struct file_lock fl = {
                 .fl_owner = filp,
@@ -2400,7 +2428,6 @@ locks_remove_flock(struct file *filp)
                 .fl_end = OFFSET_MAX,
         };
         struct inode *inode = file_inode(filp);
-        struct file_lock_context *flctx = inode->i_flctx;
 
         if (list_empty(&flctx->flc_flock))
                 return;
@@ -2416,10 +2443,8 @@ locks_remove_flock(struct file *filp)
 
 /* The i_flctx must be valid when calling into here */
 static void
-locks_remove_lease(struct file *filp)
+locks_remove_lease(struct file *filp, struct file_lock_context *ctx)
 {
-        struct inode *inode = file_inode(filp);
-        struct file_lock_context *ctx = inode->i_flctx;
         struct file_lock *fl, *tmp;
         LIST_HEAD(dispose);
 
@@ -2439,17 +2464,20 @@ locks_remove_lease(struct file *filp)
  */
 void locks_remove_file(struct file *filp)
 {
-        if (!file_inode(filp)->i_flctx)
+        struct file_lock_context *ctx;
+
+        ctx = smp_load_acquire(&file_inode(filp)->i_flctx);
+        if (!ctx)
                 return;
 
         /* remove any OFD locks */
         locks_remove_posix(filp, filp);
 
         /* remove flock locks */
-        locks_remove_flock(filp);
+        locks_remove_flock(filp, ctx);
 
         /* remove any leases */
-        locks_remove_lease(filp);
+        locks_remove_lease(filp, ctx);
 }
 
 /**
@@ -2616,7 +2644,7 @@ void show_fd_locks(struct seq_file *f,
         struct file_lock_context *ctx;
         int id = 0;
 
-        ctx = inode->i_flctx;
+        ctx = smp_load_acquire(&inode->i_flctx);
         if (!ctx)
                 return;
 
diff --git a/fs/nfs/file.c b/fs/nfs/file.c
index c0f9b1ed12b9..37f639d50af5 100644
--- a/fs/nfs/file.c
+++ b/fs/nfs/file.c
@@ -738,18 +738,7 @@ out_noconflict:
 
 static int do_vfs_lock(struct file *file, struct file_lock *fl)
 {
-        int res = 0;
-        switch (fl->fl_flags & (FL_POSIX|FL_FLOCK)) {
-                case FL_POSIX:
-                        res = posix_lock_file_wait(file, fl);
-                        break;
-                case FL_FLOCK:
-                        res = flock_lock_file_wait(file, fl);
-                        break;
-                default:
-                        BUG();
-        }
-        return res;
+        return locks_lock_file_wait(file, fl);
 }
 
 static int
diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
index 5133bb18830e..0e5ff69455c7 100644
--- a/fs/nfs/nfs4proc.c
+++ b/fs/nfs/nfs4proc.c
@@ -5513,18 +5513,7 @@ static int nfs4_proc_getlk(struct nfs4_state *state, int cmd, struct file_lock *
 
 static int do_vfs_lock(struct inode *inode, struct file_lock *fl)
 {
-        int res = 0;
-        switch (fl->fl_flags & (FL_POSIX|FL_FLOCK)) {
-                case FL_POSIX:
-                        res = posix_lock_inode_wait(inode, fl);
-                        break;
-                case FL_FLOCK:
-                        res = flock_lock_inode_wait(inode, fl);
-                        break;
-                default:
-                        BUG();
-        }
-        return res;
+        return locks_lock_inode_wait(inode, fl);
 }
 
 struct nfs4_unlockdata {
diff --git a/fs/ocfs2/locks.c b/fs/ocfs2/locks.c
index 6b6d092b0998..652ece4a9d9e 100644
--- a/fs/ocfs2/locks.c
+++ b/fs/ocfs2/locks.c
@@ -66,7 +66,7 @@ static int ocfs2_do_flock(struct file *file, struct inode *inode,
                  * level.
                  */
 
-                flock_lock_file_wait(file,
+                locks_lock_file_wait(file,
                                      &(struct file_lock){.fl_type = F_UNLCK});
 
                 ocfs2_file_unlock(file);
@@ -81,7 +81,7 @@ static int ocfs2_do_flock(struct file *file, struct inode *inode,
                 goto out;
         }
 
-        ret = flock_lock_file_wait(file, fl);
+        ret = locks_lock_file_wait(file, fl);
         if (ret)
                 ocfs2_file_unlock(file);
 
@@ -98,7 +98,7 @@ static int ocfs2_do_funlock(struct file *file, int cmd, struct file_lock *fl)
 
         mutex_lock(&fp->fp_mutex);
         ocfs2_file_unlock(file);
-        ret = flock_lock_file_wait(file, fl);
+        ret = locks_lock_file_wait(file, fl);
         mutex_unlock(&fp->fp_mutex);
 
         return ret;
@@ -119,7 +119,7 @@ int ocfs2_flock(struct file *file, int cmd, struct file_lock *fl)
 
         if ((osb->s_mount_opt & OCFS2_MOUNT_LOCALFLOCKS) ||
             ocfs2_mount_local(osb))
-                return flock_lock_file_wait(file, fl);
+                return locks_lock_file_wait(file, fl);
 
         if (fl->fl_type == F_UNLCK)
                 return ocfs2_do_funlock(file, cmd, fl);
diff --git a/include/linux/fs.h b/include/linux/fs.h
index 72d8a844c692..49749688156d 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -1053,12 +1053,11 @@ extern void locks_remove_file(struct file *);
 extern void locks_release_private(struct file_lock *);
 extern void posix_test_lock(struct file *, struct file_lock *);
 extern int posix_lock_file(struct file *, struct file_lock *, struct file_lock *);
-extern int posix_lock_inode_wait(struct inode *, struct file_lock *);
 extern int posix_unblock_lock(struct file_lock *);
 extern int vfs_test_lock(struct file *, struct file_lock *);
 extern int vfs_lock_file(struct file *, unsigned int, struct file_lock *, struct file_lock *);
 extern int vfs_cancel_lock(struct file *filp, struct file_lock *fl);
-extern int flock_lock_inode_wait(struct inode *inode, struct file_lock *fl);
+extern int locks_lock_inode_wait(struct inode *inode, struct file_lock *fl);
 extern int __break_lease(struct inode *inode, unsigned int flags, unsigned int type);
 extern void lease_get_mtime(struct inode *, struct timespec *time);
 extern int generic_setlease(struct file *, long, struct file_lock **, void **priv);
@@ -1144,12 +1143,6 @@ static inline int posix_lock_file(struct file *filp, struct file_lock *fl,
         return -ENOLCK;
 }
 
-static inline int posix_lock_inode_wait(struct inode *inode,
-                                        struct file_lock *fl)
-{
-        return -ENOLCK;
-}
-
 static inline int posix_unblock_lock(struct file_lock *waiter)
 {
         return -ENOENT;
@@ -1171,8 +1164,7 @@ static inline int vfs_cancel_lock(struct file *filp, struct file_lock *fl)
         return 0;
 }
 
-static inline int flock_lock_inode_wait(struct inode *inode,
-                                        struct file_lock *request)
+static inline int locks_lock_inode_wait(struct inode *inode, struct file_lock *fl)
 {
         return -ENOLCK;
 }
@@ -1215,14 +1207,9 @@ static inline struct inode *file_inode(const struct file *f)
         return f->f_inode;
 }
 
-static inline int posix_lock_file_wait(struct file *filp, struct file_lock *fl)
-{
-        return posix_lock_inode_wait(file_inode(filp), fl);
-}
-
-static inline int flock_lock_file_wait(struct file *filp, struct file_lock *fl)
+static inline int locks_lock_file_wait(struct file *filp, struct file_lock *fl)
 {
-        return flock_lock_inode_wait(file_inode(filp), fl);
+        return locks_lock_inode_wait(file_inode(filp), fl);
 }
 
 struct fasync_struct {
diff --git a/include/trace/events/filelock.h b/include/trace/events/filelock.h
index a0d008070962..c72f2dc01d0b 100644
--- a/include/trace/events/filelock.h
+++ b/include/trace/events/filelock.h
@@ -81,15 +81,47 @@ DEFINE_EVENT(filelock_lease, break_lease_block, TP_PROTO(struct inode *inode, st
 DEFINE_EVENT(filelock_lease, break_lease_unblock, TP_PROTO(struct inode *inode, struct file_lock *fl),
                 TP_ARGS(inode, fl));
 
-DEFINE_EVENT(filelock_lease, generic_add_lease, TP_PROTO(struct inode *inode, struct file_lock *fl),
-                TP_ARGS(inode, fl));
-
 DEFINE_EVENT(filelock_lease, generic_delete_lease, TP_PROTO(struct inode *inode, struct file_lock *fl),
                 TP_ARGS(inode, fl));
 
 DEFINE_EVENT(filelock_lease, time_out_leases, TP_PROTO(struct inode *inode, struct file_lock *fl),
                 TP_ARGS(inode, fl));
 
+TRACE_EVENT(generic_add_lease,
+        TP_PROTO(struct inode *inode, struct file_lock *fl),
+
+        TP_ARGS(inode, fl),
+
+        TP_STRUCT__entry(
+                __field(unsigned long, i_ino)
+                __field(int, wcount)
+                __field(int, dcount)
+                __field(int, icount)
+                __field(dev_t, s_dev)
+                __field(fl_owner_t, fl_owner)
+                __field(unsigned int, fl_flags)
+                __field(unsigned char, fl_type)
+        ),
+
+        TP_fast_assign(
+                __entry->s_dev = inode->i_sb->s_dev;
+                __entry->i_ino = inode->i_ino;
+                __entry->wcount = atomic_read(&inode->i_writecount);
+                __entry->dcount = d_count(fl->fl_file->f_path.dentry);
+                __entry->icount = atomic_read(&inode->i_count);
+                __entry->fl_owner = fl ? fl->fl_owner : NULL;
+                __entry->fl_flags = fl ? fl->fl_flags : 0;
+                __entry->fl_type = fl ? fl->fl_type : 0;
+        ),
+
+        TP_printk("dev=0x%x:0x%x ino=0x%lx wcount=%d dcount=%d icount=%d fl_owner=0x%p fl_flags=%s fl_type=%s",
+                MAJOR(__entry->s_dev), MINOR(__entry->s_dev),
+                __entry->i_ino, __entry->wcount, __entry->dcount,
+                __entry->icount, __entry->fl_owner,
+                show_fl_flags(__entry->fl_flags),
+                show_fl_type(__entry->fl_type))
+);
+
 #endif /* _TRACE_FILELOCK_H */
 
 /* This part must be outside protection */