Merge remote-tracking branch 'file-locks/linux-next'
[karo-tx-linux.git] / fs / locks.c
index add3eeb..ba7fcdb 100644 (file)
@@ -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))
@@ -1892,7 +1896,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();
@@ -1909,7 +1913,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.
@@ -1967,7 +1994,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);
@@ -2143,7 +2170,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)
 {
@@ -2395,13 +2422,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;
 
@@ -2425,7 +2453,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,
@@ -2436,7 +2464,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;
@@ -2452,10 +2479,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);
 
@@ -2475,17 +2500,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);
 }
 
 /**
@@ -2652,7 +2680,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;