11 files changed, 134 insertions, 92 deletions

diff --git a/fs/debugfs/inode.c b/fs/debugfs/inode.c
index 1d533a2ec3a6..11be8a325e26 100644
--- a/fs/debugfs/inode.c
+++ b/fs/debugfs/inode.c
@@ -345,11 +345,6 @@ void debugfs_remove(struct dentry *dentry)
                         switch (dentry->d_inode->i_mode & S_IFMT) {
                         case S_IFDIR:
                                 ret = simple_rmdir(parent->d_inode, dentry);
-                                if (ret)
-                                        printk(KERN_ERR
-                                                "DebugFS rmdir on %s failed : "
-                                                "directory not empty.\n",
-                                                dentry->d_name.name);
                                 break;
                         case S_IFLNK:
                                 kfree(dentry->d_inode->i_private);
diff --git a/fs/gfs2/ops_file.c b/fs/gfs2/ops_file.c
index 196d83266e34..1a5e8e893d75 100644
--- a/fs/gfs2/ops_file.c
+++ b/fs/gfs2/ops_file.c
@@ -489,6 +489,29 @@ static int gfs2_fsync(struct file *file, struct dentry *dentry, int datasync)
 }
 
 /**
+ * gfs2_setlease - acquire/release a file lease
+ * @file: the file pointer
+ * @arg: lease type
+ * @fl: file lock
+ *
+ * Returns: errno
+ */
+
+static int gfs2_setlease(struct file *file, long arg, struct file_lock **fl)
+{
+        struct gfs2_sbd *sdp = GFS2_SB(file->f_mapping->host);
+
+        /*
+         * We don't currently have a way to enforce a lease across the whole
+         * cluster; until we do, disable leases (by just returning -EINVAL),
+         * unless the administrator has requested purely local locking.
+         */
+        if (!sdp->sd_args.ar_localflocks)
+                return -EINVAL;
+        return setlease(file, arg, fl);
+}
+
+/**
  * gfs2_lock - acquire/release a posix lock on a file
  * @file: the file pointer
  * @cmd: either modify or retrieve lock state, possibly wait
@@ -638,6 +661,7 @@ const struct file_operations gfs2_file_fops = {
         .flock          = gfs2_flock,
         .splice_read    = generic_file_splice_read,
         .splice_write   = generic_file_splice_write,
+        .setlease       = gfs2_setlease,
 };
 
 const struct file_operations gfs2_dir_fops = {
diff --git a/fs/locks.c b/fs/locks.c
index 431a8b871fce..4f2d749ac624 100644
--- a/fs/locks.c
+++ b/fs/locks.c
@@ -458,22 +458,20 @@ static int lease_init(struct file *filp, int type, struct file_lock *fl)
 }
 
 /* Allocate a file_lock initialised to this type of lease */
-static int lease_alloc(struct file *filp, int type, struct file_lock **flp)
+static struct file_lock *lease_alloc(struct file *filp, int type)
 {
         struct file_lock *fl = locks_alloc_lock();
         int error = -ENOMEM;
 
         if (fl == NULL)
-                goto out;
+                return ERR_PTR(error);
 
         error = lease_init(filp, type, fl);
         if (error) {
                 locks_free_lock(fl);
-                fl = NULL;
+                return ERR_PTR(error);
         }
-out:
-        *flp = fl;
-        return error;
+        return fl;
 }
 
 /* Check if two locks overlap each other.
@@ -661,7 +659,7 @@ static int locks_block_on_timeout(struct file_lock *blocker, struct file_lock *w
         return result;
 }
 
-int
+void
 posix_test_lock(struct file *filp, struct file_lock *fl)
 {
         struct file_lock *cfl;
@@ -673,14 +671,12 @@ posix_test_lock(struct file *filp, struct file_lock *fl)
                 if (posix_locks_conflict(cfl, fl))
                         break;
         }
-        if (cfl) {
+        if (cfl)
                 __locks_copy_lock(fl, cfl);
-                unlock_kernel();
-                return 1;
-        } else
+        else
                 fl->fl_type = F_UNLCK;
         unlock_kernel();
-        return 0;
+        return;
 }
 
 EXPORT_SYMBOL(posix_test_lock);
@@ -1169,9 +1165,9 @@ static void time_out_leases(struct inode *inode)
  *      @inode: the inode of the file to return
  *      @mode: the open mode (read or write)
  *
- *      break_lease (inlined for speed) has checked there already
- *      is a lease on this file.  Leases are broken on a call to open()
- *      or truncate().  This function can sleep unless you
+ *      break_lease (inlined for speed) has checked there already is at least
+ *      some kind of lock (maybe a lease) on this file.  Leases are broken on
+ *      a call to open() or truncate().  This function can sleep unless you
  *      specified %O_NONBLOCK to your open().
  */
 int __break_lease(struct inode *inode, unsigned int mode)
@@ -1179,12 +1175,10 @@ int __break_lease(struct inode *inode, unsigned int mode)
         int error = 0, future;
         struct file_lock *new_fl, *flock;
         struct file_lock *fl;
-        int alloc_err;
         unsigned long break_time;
         int i_have_this_lease = 0;
 
-        alloc_err = lease_alloc(NULL, mode & FMODE_WRITE ? F_WRLCK : F_RDLCK,
-                        &new_fl);
+        new_fl = lease_alloc(NULL, mode & FMODE_WRITE ? F_WRLCK : F_RDLCK);
 
         lock_kernel();
 
@@ -1212,8 +1206,9 @@ int __break_lease(struct inode *inode, unsigned int mode)
                 goto out;
         }
 
-        if (alloc_err && !i_have_this_lease && ((mode & O_NONBLOCK) == 0)) {
-                error = alloc_err;
+        if (IS_ERR(new_fl) && !i_have_this_lease
+                        && ((mode & O_NONBLOCK) == 0)) {
+                error = PTR_ERR(new_fl);
                 goto out;
         }
 
@@ -1260,7 +1255,7 @@ restart:
 
 out:
         unlock_kernel();
-        if (!alloc_err)
+        if (!IS_ERR(new_fl))
                 locks_free_lock(new_fl);
         return error;
 }
@@ -1329,7 +1324,7 @@ int fcntl_getlease(struct file *filp)
 }
 
 /**
- *      __setlease      -       sets a lease on an open file
+ *      setlease        -       sets a lease on an open file
  *      @filp: file pointer
  *      @arg: type of lease to obtain
  *      @flp: input - file_lock to use, output - file_lock inserted
@@ -1339,18 +1334,24 @@ int fcntl_getlease(struct file *filp)
  *
  *      Called with kernel lock held.
  */
-static int __setlease(struct file *filp, long arg, struct file_lock **flp)
+int setlease(struct file *filp, long arg, struct file_lock **flp)
 {
         struct file_lock *fl, **before, **my_before = NULL, *lease;
         struct dentry *dentry = filp->f_path.dentry;
         struct inode *inode = dentry->d_inode;
         int error, rdlease_count = 0, wrlease_count = 0;
 
+        if ((current->fsuid != inode->i_uid) && !capable(CAP_LEASE))
+                return -EACCES;
+        if (!S_ISREG(inode->i_mode))
+                return -EINVAL;
+        error = security_file_lock(filp, arg);
+        if (error)
+                return error;
+
         time_out_leases(inode);
 
-        error = -EINVAL;
-        if (!flp || !(*flp) || !(*flp)->fl_lmops || !(*flp)->fl_lmops->fl_break)
-                goto out;
+        BUG_ON(!(*flp)->fl_lmops->fl_break);
 
         lease = *flp;
 
@@ -1418,39 +1419,49 @@ static int __setlease(struct file *filp, long arg, struct file_lock **flp)
 out:
         return error;
 }
+EXPORT_SYMBOL(setlease);
 
  /**
- *      setlease        -       sets a lease on an open file
+ *      vfs_setlease        -       sets a lease on an open file
  *      @filp: file pointer
  *      @arg: type of lease to obtain
  *      @lease: file_lock to use
  *
  *      Call this to establish a lease on the file.
- *      The fl_lmops fl_break function is required by break_lease
+ *      The (*lease)->fl_lmops->fl_break operation must be set; if not,
+ *      break_lease will oops!
+ *
+ *      This will call the filesystem's setlease file method, if
+ *      defined.  Note that there is no getlease method; instead, the
+ *      filesystem setlease method should call back to setlease() to
+ *      add a lease to the inode's lease list, where fcntl_getlease() can
+ *      find it.  Since fcntl_getlease() only reports whether the current
+ *      task holds a lease, a cluster filesystem need only do this for
+ *      leases held by processes on this node.
+ *
+ *      There is also no break_lease method; filesystems that
+ *      handle their own leases shoud break leases themselves from the
+ *      filesystem's open, create, and (on truncate) setattr methods.
+ *
+ *      Warning: the only current setlease methods exist only to disable
+ *      leases in certain cases.  More vfs changes may be required to
+ *      allow a full filesystem lease implementation.
  */
 
-int setlease(struct file *filp, long arg, struct file_lock **lease)
+int vfs_setlease(struct file *filp, long arg, struct file_lock **lease)
 {
-        struct dentry *dentry = filp->f_path.dentry;
-        struct inode *inode = dentry->d_inode;
         int error;
 
-        if ((current->fsuid != inode->i_uid) && !capable(CAP_LEASE))
-                return -EACCES;
-        if (!S_ISREG(inode->i_mode))
-                return -EINVAL;
-        error = security_file_lock(filp, arg);
-        if (error)
-                return error;
-
         lock_kernel();
-        error = __setlease(filp, arg, lease);
+        if (filp->f_op && filp->f_op->setlease)
+                error = filp->f_op->setlease(filp, arg, lease);
+        else
+                error = setlease(filp, arg, lease);
         unlock_kernel();
 
         return error;
 }
-
-EXPORT_SYMBOL(setlease);
+EXPORT_SYMBOL_GPL(vfs_setlease);
 
 /**
  *      fcntl_setlease  -       sets a lease on an open file
@@ -1469,14 +1480,6 @@ int fcntl_setlease(unsigned int fd, struct file *filp, long arg)
         struct inode *inode = dentry->d_inode;
         int error;
 
-        if ((current->fsuid != inode->i_uid) && !capable(CAP_LEASE))
-                return -EACCES;
-        if (!S_ISREG(inode->i_mode))
-                return -EINVAL;
-        error = security_file_lock(filp, arg);
-        if (error)
-                return error;
-
         locks_init_lock(&fl);
         error = lease_init(filp, arg, &fl);
         if (error)
@@ -1484,15 +1487,15 @@ int fcntl_setlease(unsigned int fd, struct file *filp, long arg)
 
         lock_kernel();
 
-        error = __setlease(filp, arg, &flp);
+        error = vfs_setlease(filp, arg, &flp);
         if (error || arg == F_UNLCK)
                 goto out_unlock;
 
         error = fasync_helper(fd, filp, 1, &flp->fl_fasync);
         if (error < 0) {
-                /* remove lease just inserted by __setlease */
+                /* remove lease just inserted by setlease */
                 flp->fl_type = F_UNLCK | F_INPROGRESS;
-                flp->fl_break_time = jiffies- 10;
+                flp->fl_break_time = jiffies - 10;
                 time_out_leases(inode);
                 goto out_unlock;
         }
@@ -1597,8 +1600,7 @@ asmlinkage long sys_flock(unsigned int fd, unsigned int cmd)
 /**
  * vfs_test_lock - test file byte range lock
  * @filp: The file to test lock for
- * @fl: The lock to test
- * @conf: Place to return a copy of the conflicting lock, if found
+ * @fl: The lock to test; also used to hold result
  *
  * Returns -ERRNO on failure.  Indicates presence of conflicting lock by
  * setting conf->fl_type to something other than F_UNLCK.
diff --git a/fs/nfs/file.c b/fs/nfs/file.c
index 8689b736fdd9..c87dc713b5d7 100644
--- a/fs/nfs/file.c
+++ b/fs/nfs/file.c
@@ -53,6 +53,7 @@ static int  nfs_fsync(struct file *, struct dentry *dentry, int datasync);
 static int nfs_check_flags(int flags);
 static int nfs_lock(struct file *filp, int cmd, struct file_lock *fl);
 static int nfs_flock(struct file *filp, int cmd, struct file_lock *fl);
+static int nfs_setlease(struct file *file, long arg, struct file_lock **fl);
 
 const struct file_operations nfs_file_operations = {
         .llseek         = nfs_file_llseek,
@@ -69,6 +70,7 @@ const struct file_operations nfs_file_operations = {
         .flock          = nfs_flock,
         .splice_read    = nfs_file_splice_read,
         .check_flags    = nfs_check_flags,
+        .setlease       = nfs_setlease,
 };
 
 const struct inode_operations nfs_file_inode_operations = {
@@ -400,7 +402,9 @@ static int do_getlk(struct file *filp, int cmd, struct file_lock *fl)
 
         lock_kernel();
         /* Try local locking first */
-        if (posix_test_lock(filp, fl)) {
+        posix_test_lock(filp, fl);
+        if (fl->fl_type != F_UNLCK) {
+                /* found a conflict */
                 goto out;
         }
 
@@ -558,3 +562,13 @@ static int nfs_flock(struct file *filp, int cmd, struct file_lock *fl)
                 return do_unlk(filp, cmd, fl);
         return do_setlk(filp, cmd, fl);
 }
+
+static int nfs_setlease(struct file *file, long arg, struct file_lock **fl)
+{
+        /*
+         * There is no protocol support for leases, so we have no way
+         * to implement them correctly in the face of opens by other
+         * clients.
+         */
+        return -EINVAL;
+}
diff --git a/fs/nfsd/nfs4state.c b/fs/nfsd/nfs4state.c
index e4a4c87ec8c6..6284807bd37e 100644
--- a/fs/nfsd/nfs4state.c
+++ b/fs/nfsd/nfs4state.c
@@ -256,7 +256,7 @@ nfs4_close_delegation(struct nfs4_delegation *dp)
         /* The following nfsd_close may not actually close the file,
          * but we want to remove the lease in any case. */
         if (dp->dl_flock)
-                setlease(filp, F_UNLCK, &dp->dl_flock);
+                vfs_setlease(filp, F_UNLCK, &dp->dl_flock);
         nfsd_close(filp);
 }
 
@@ -1402,7 +1402,7 @@ void nfsd_release_deleg_cb(struct file_lock *fl)
 /*
  * Set the delegation file_lock back pointer.
  *
- * Called from __setlease() with lock_kernel() held.
+ * Called from setlease() with lock_kernel() held.
  */
 static
 void nfsd_copy_lock_deleg_cb(struct file_lock *new, struct file_lock *fl)
@@ -1416,7 +1416,7 @@ void nfsd_copy_lock_deleg_cb(struct file_lock *new, struct file_lock *fl)
 }
 
 /*
- * Called from __setlease() with lock_kernel() held
+ * Called from setlease() with lock_kernel() held
  */
 static
 int nfsd_same_client_deleg_cb(struct file_lock *onlist, struct file_lock *try)
@@ -1716,10 +1716,10 @@ nfs4_open_delegation(struct svc_fh *fh, struct nfsd4_open *open, struct nfs4_sta
         fl.fl_file = stp->st_vfs_file;
         fl.fl_pid = current->tgid;
 
-        /* setlease checks to see if delegation should be handed out.
+        /* vfs_setlease checks to see if delegation should be handed out.
          * the lock_manager callbacks fl_mylease and fl_change are used
          */
-        if ((status = setlease(stp->st_vfs_file,
+        if ((status = vfs_setlease(stp->st_vfs_file,
                 flag == NFS4_OPEN_DELEGATE_READ? F_RDLCK: F_WRLCK, &flp))) {
                 dprintk("NFSD: setlease failed [%d], no delegation\n", status);
                 unhash_delegation(dp);
diff --git a/fs/sysfs/dir.c b/fs/sysfs/dir.c
index aee966c44aac..048e6054c2fd 100644
--- a/fs/sysfs/dir.c
+++ b/fs/sysfs/dir.c
@@ -361,20 +361,20 @@ static struct dentry_operations sysfs_dentry_ops = {
 struct sysfs_dirent *sysfs_new_dirent(const char *name, umode_t mode, int type)
 {
         char *dup_name = NULL;
-        struct sysfs_dirent *sd = NULL;
+        struct sysfs_dirent *sd;
 
         if (type & SYSFS_COPY_NAME) {
                 name = dup_name = kstrdup(name, GFP_KERNEL);
                 if (!name)
-                        goto err_out;
+                        return NULL;
         }
 
         sd = kmem_cache_zalloc(sysfs_dir_cachep, GFP_KERNEL);
         if (!sd)
-                goto err_out;
+                goto err_out1;
 
         if (sysfs_alloc_ino(&sd->s_ino))
-                goto err_out;
+                goto err_out2;
 
         atomic_set(&sd->s_count, 1);
         atomic_set(&sd->s_active, 0);
@@ -386,9 +386,10 @@ struct sysfs_dirent *sysfs_new_dirent(const char *name, umode_t mode, int type)
 
         return sd;
 
- err_out:
-        kfree(dup_name);
+ err_out2:
         kmem_cache_free(sysfs_dir_cachep, sd);
+ err_out1:
+        kfree(dup_name);
         return NULL;
 }
 
@@ -698,17 +699,19 @@ static int create_dir(struct kobject *kobj, struct sysfs_dirent *parent_sd,
 
         /* link in */
         sysfs_addrm_start(&acxt, parent_sd);
+
         if (!sysfs_find_dirent(parent_sd, name)) {
                 sysfs_add_one(&acxt, sd);
                 sysfs_link_sibling(sd);
         }
-        if (sysfs_addrm_finish(&acxt)) {
-                *p_sd = sd;
-                return 0;
+
+        if (!sysfs_addrm_finish(&acxt)) {
+                sysfs_put(sd);
+                return -EEXIST;
         }
 
-        sysfs_put(sd);
-        return -EEXIST;
+        *p_sd = sd;
+        return 0;
 }
 
 int sysfs_create_subdir(struct kobject *kobj, const char *name,
diff --git a/fs/sysfs/file.c b/fs/sysfs/file.c
index cc497994b2a8..3e1cc062a740 100644
--- a/fs/sysfs/file.c
+++ b/fs/sysfs/file.c
@@ -410,11 +410,12 @@ int sysfs_add_file(struct sysfs_dirent *dir_sd, const struct attribute *attr,
                 sysfs_link_sibling(sd);
         }
 
-        if (sysfs_addrm_finish(&acxt))
-                return 0;
+        if (!sysfs_addrm_finish(&acxt)) {
+                sysfs_put(sd);
+                return -EEXIST;
+        }
 
-        sysfs_put(sd);
-        return -EEXIST;
+        return 0;
 }
 
 
diff --git a/fs/sysfs/inode.c b/fs/sysfs/inode.c
index 3756e152285a..10d1b52899f1 100644
--- a/fs/sysfs/inode.c
+++ b/fs/sysfs/inode.c
@@ -133,7 +133,7 @@ static inline void set_inode_attr(struct inode * inode, struct iattr * iattr)
  */
 static struct lock_class_key sysfs_inode_imutex_key;
 
-void sysfs_init_inode(struct sysfs_dirent *sd, struct inode *inode)
+static void sysfs_init_inode(struct sysfs_dirent *sd, struct inode *inode)
 {
         inode->i_blocks = 0;
         inode->i_mapping->a_ops = &sysfs_aops;
diff --git a/fs/sysfs/mount.c b/fs/sysfs/mount.c
index 402cc356203c..60714d075c2f 100644
--- a/fs/sysfs/mount.c
+++ b/fs/sysfs/mount.c
@@ -43,19 +43,19 @@ static int sysfs_fill_super(struct super_block *sb, void *data, int silent)
         sb->s_time_gran = 1;
         sysfs_sb = sb;
 
-        inode = new_inode(sysfs_sb);
+        /* get root inode, initialize and unlock it */
+        inode = sysfs_get_inode(&sysfs_root);
         if (!inode) {
                 pr_debug("sysfs: could not get root inode\n");
                 return -ENOMEM;
         }
 
-        sysfs_init_inode(&sysfs_root, inode);
-
         inode->i_op = &sysfs_dir_inode_operations;
         inode->i_fop = &sysfs_dir_operations;
-        /* directory inodes start off with i_nlink == 2 (for "." entry) */
-        inc_nlink(inode);
+        inc_nlink(inode); /* directory, account for "." */
+        unlock_new_inode(inode);
 
+        /* instantiate and link root dentry */
         root = d_alloc_root(inode);
         if (!root) {
                 pr_debug("%s: could not get root dentry!\n",__FUNCTION__);
diff --git a/fs/sysfs/symlink.c b/fs/sysfs/symlink.c
index 2f86e0422290..4ce687f0b5d0 100644
--- a/fs/sysfs/symlink.c
+++ b/fs/sysfs/symlink.c
@@ -86,7 +86,9 @@ int sysfs_create_link(struct kobject * kobj, struct kobject * target, const char
         sd = sysfs_new_dirent(name, S_IFLNK|S_IRWXUGO, SYSFS_KOBJ_LINK);
         if (!sd)
                 goto out_put;
+
         sd->s_elem.symlink.target_sd = target_sd;
+        target_sd = NULL;       /* reference is now owned by the symlink */
 
         sysfs_addrm_start(&acxt, parent_sd);
 
@@ -95,11 +97,13 @@ int sysfs_create_link(struct kobject * kobj, struct kobject * target, const char
                 sysfs_link_sibling(sd);
         }
 
-        if (sysfs_addrm_finish(&acxt))
-                return 0;
+        if (!sysfs_addrm_finish(&acxt)) {
+                error = -EEXIST;
+                goto out_put;
+        }
+
+        return 0;
 
-        error = -EEXIST;
-        /* fall through */
  out_put:
         sysfs_put(target_sd);
         sysfs_put(sd);
diff --git a/fs/sysfs/sysfs.h b/fs/sysfs/sysfs.h
index 6a37f2386a8d..6b8c8d76d308 100644
--- a/fs/sysfs/sysfs.h
+++ b/fs/sysfs/sysfs.h
@@ -71,7 +71,6 @@ extern void sysfs_remove_one(struct sysfs_addrm_cxt *acxt,
 extern int sysfs_addrm_finish(struct sysfs_addrm_cxt *acxt);
 
 extern void sysfs_delete_inode(struct inode *inode);
-extern void sysfs_init_inode(struct sysfs_dirent *sd, struct inode *inode);
 extern struct inode * sysfs_get_inode(struct sysfs_dirent *sd);
 extern void sysfs_instantiate(struct dentry *dentry, struct inode *inode);