1 files changed, 186 insertions, 162 deletions

diff --git a/fs/namei.c b/fs/namei.c
index 385f7817bfcc..88339f59efb5 100644
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -1109,7 +1109,7 @@ static bool __follow_mount_rcu(struct nameidata *nd, struct path *path,
                         return false;
 
                 if (!d_mountpoint(path->dentry))
-                        break;
+                        return true;
 
                 mounted = __lookup_mnt(path->mnt, path->dentry);
                 if (!mounted)
@@ -1125,20 +1125,7 @@ static bool __follow_mount_rcu(struct nameidata *nd, struct path *path,
                  */
                 *inode = path->dentry->d_inode;
         }
-        return true;
-}
-
-static void follow_mount_rcu(struct nameidata *nd)
-{
-        while (d_mountpoint(nd->path.dentry)) {
-                struct mount *mounted;
-                mounted = __lookup_mnt(nd->path.mnt, nd->path.dentry);
-                if (!mounted)
-                        break;
-                nd->path.mnt = &mounted->mnt;
-                nd->path.dentry = mounted->mnt.mnt_root;
-                nd->seq = read_seqcount_begin(&nd->path.dentry->d_seq);
-        }
+        return read_seqretry(&mount_lock, nd->m_seq);
 }
 
 static int follow_dotdot_rcu(struct nameidata *nd)
@@ -1166,7 +1153,17 @@ static int follow_dotdot_rcu(struct nameidata *nd)
                         break;
                 nd->seq = read_seqcount_begin(&nd->path.dentry->d_seq);
         }
-        follow_mount_rcu(nd);
+        while (d_mountpoint(nd->path.dentry)) {
+                struct mount *mounted;
+                mounted = __lookup_mnt(nd->path.mnt, nd->path.dentry);
+                if (!mounted)
+                        break;
+                nd->path.mnt = &mounted->mnt;
+                nd->path.dentry = mounted->mnt.mnt_root;
+                nd->seq = read_seqcount_begin(&nd->path.dentry->d_seq);
+                if (!read_seqretry(&mount_lock, nd->m_seq))
+                        goto failed;
+        }
         nd->inode = nd->path.dentry->d_inode;
         return 0;
 
@@ -1799,7 +1796,7 @@ static int link_path_walk(const char *name, struct nameidata *nd)
                         if (err)
                                 return err;
                 }
-                if (!d_is_directory(nd->path.dentry)) {
+                if (!d_can_lookup(nd->path.dentry)) {
                         err = -ENOTDIR; 
                         break;
                 }
@@ -1820,7 +1817,7 @@ static int path_init(int dfd, const char *name, unsigned int flags,
                 struct dentry *root = nd->root.dentry;
                 struct inode *inode = root->d_inode;
                 if (*name) {
-                        if (!d_is_directory(root))
+                        if (!d_can_lookup(root))
                                 return -ENOTDIR;
                         retval = inode_permission(inode, MAY_EXEC);
                         if (retval)
@@ -1876,7 +1873,7 @@ static int path_init(int dfd, const char *name, unsigned int flags,
                 dentry = f.file->f_path.dentry;
 
                 if (*name) {
-                        if (!d_is_directory(dentry)) {
+                        if (!d_can_lookup(dentry)) {
                                 fdput(f);
                                 return -ENOTDIR;
                         }
@@ -1884,7 +1881,7 @@ static int path_init(int dfd, const char *name, unsigned int flags,
 
                 nd->path = f.file->f_path;
                 if (flags & LOOKUP_RCU) {
-                        if (f.need_put)
+                        if (f.flags & FDPUT_FPUT)
                                 *fp = f.file;
                         nd->seq = __read_seqcount_begin(&nd->path.dentry->d_seq);
                         rcu_read_lock();
@@ -1958,7 +1955,7 @@ static int path_lookupat(int dfd, const char *name,
                 err = complete_walk(nd);
 
         if (!err && nd->flags & LOOKUP_DIRECTORY) {
-                if (!d_is_directory(nd->path.dentry)) {
+                if (!d_can_lookup(nd->path.dentry)) {
                         path_put(&nd->path);
                         err = -ENOTDIR;
                 }
@@ -2417,11 +2414,11 @@ static int may_delete(struct inode *dir, struct dentry *victim, bool isdir)
             IS_IMMUTABLE(inode) || IS_SWAPFILE(inode))
                 return -EPERM;
         if (isdir) {
-                if (!d_is_directory(victim) && !d_is_autodir(victim))
+                if (!d_is_dir(victim))
                         return -ENOTDIR;
                 if (IS_ROOT(victim))
                         return -EBUSY;
-        } else if (d_is_directory(victim) || d_is_autodir(victim))
+        } else if (d_is_dir(victim))
                 return -EISDIR;
         if (IS_DEADDIR(dir))
                 return -ENOENT;
@@ -2572,7 +2569,7 @@ static int handle_truncate(struct file *filp)
         /*
          * Refuse to truncate files with mandatory locks held on them.
          */
-        error = locks_verify_locked(inode);
+        error = locks_verify_locked(filp);
         if (!error)
                 error = security_path_truncate(path);
         if (!error) {
@@ -3019,11 +3016,10 @@ finish_open:
         }
         audit_inode(name, nd->path.dentry, 0);
         error = -EISDIR;
-        if ((open_flag & O_CREAT) &&
-            (d_is_directory(nd->path.dentry) || d_is_autodir(nd->path.dentry)))
+        if ((open_flag & O_CREAT) && d_is_dir(nd->path.dentry))
                 goto out;
         error = -ENOTDIR;
-        if ((nd->flags & LOOKUP_DIRECTORY) && !d_is_directory(nd->path.dentry))
+        if ((nd->flags & LOOKUP_DIRECTORY) && !d_can_lookup(nd->path.dentry))
                 goto out;
         if (!S_ISREG(nd->inode->i_mode))
                 will_truncate = false;
@@ -3747,7 +3743,7 @@ exit1:
 slashes:
         if (d_is_negative(dentry))
                 error = -ENOENT;
-        else if (d_is_directory(dentry) || d_is_autodir(dentry))
+        else if (d_is_dir(dentry))
                 error = -EISDIR;
         else
                 error = -ENOTDIR;
@@ -3977,7 +3973,28 @@ SYSCALL_DEFINE2(link, const char __user *, oldname, const char __user *, newname
         return sys_linkat(AT_FDCWD, oldname, AT_FDCWD, newname, 0);
 }
 
-/*
+/**
+ * vfs_rename - rename a filesystem object
+ * @old_dir:    parent of source
+ * @old_dentry: source
+ * @new_dir:    parent of destination
+ * @new_dentry: destination
+ * @delegated_inode: returns an inode needing a delegation break
+ * @flags:      rename flags
+ *
+ * The caller must hold multiple mutexes--see lock_rename()).
+ *
+ * If vfs_rename discovers a delegation in need of breaking at either
+ * the source or destination, it will return -EWOULDBLOCK and return a
+ * reference to the inode in delegated_inode.  The caller should then
+ * break the delegation and retry.  Because breaking a delegation may
+ * take a long time, the caller should drop all locks before doing
+ * so.
+ *
+ * Alternatively, a caller may pass NULL for delegated_inode.  This may
+ * be appropriate for callers that expect the underlying filesystem not
+ * to be NFS exported.
+ *
  * The worst of all namespace operations - renaming directory. "Perverted"
  * doesn't even start to describe it. Somebody in UCB had a heck of a trip...
  * Problems:
@@ -4005,163 +4022,139 @@ SYSCALL_DEFINE2(link, const char __user *, oldname, const char __user *, newname
  *         ->i_mutex on parents, which works but leads to some truly excessive
  *         locking].
  */
-static int vfs_rename_dir(struct inode *old_dir, struct dentry *old_dentry,
-                          struct inode *new_dir, struct dentry *new_dentry)
+int vfs_rename(struct inode *old_dir, struct dentry *old_dentry,
+               struct inode *new_dir, struct dentry *new_dentry,
+               struct inode **delegated_inode, unsigned int flags)
 {
-        int error = 0;
+        int error;
+        bool is_dir = d_is_dir(old_dentry);
+        const unsigned char *old_name;
+        struct inode *source = old_dentry->d_inode;
         struct inode *target = new_dentry->d_inode;
+        bool new_is_dir = false;
         unsigned max_links = new_dir->i_sb->s_max_links;
 
+        if (source == target)
+                return 0;
+
+        error = may_delete(old_dir, old_dentry, is_dir);
+        if (error)
+                return error;
+
+        if (!target) {
+                error = may_create(new_dir, new_dentry);
+        } else {
+                new_is_dir = d_is_dir(new_dentry);
+
+                if (!(flags & RENAME_EXCHANGE))
+                        error = may_delete(new_dir, new_dentry, is_dir);
+                else
+                        error = may_delete(new_dir, new_dentry, new_is_dir);
+        }
+        if (error)
+                return error;
+
+        if (!old_dir->i_op->rename)
+                return -EPERM;
+
+        if (flags && !old_dir->i_op->rename2)
+                return -EINVAL;
+
         /*
          * If we are going to change the parent - check write permissions,
          * we'll need to flip '..'.
          */
         if (new_dir != old_dir) {
-                error = inode_permission(old_dentry->d_inode, MAY_WRITE);
-                if (error)
-                        return error;
+                if (is_dir) {
+                        error = inode_permission(source, MAY_WRITE);
+                        if (error)
+                                return error;
+                }
+                if ((flags & RENAME_EXCHANGE) && new_is_dir) {
+                        error = inode_permission(target, MAY_WRITE);
+                        if (error)
+                                return error;
+                }
         }
 
-        error = security_inode_rename(old_dir, old_dentry, new_dir, new_dentry);
+        error = security_inode_rename(old_dir, old_dentry, new_dir, new_dentry,
+                                      flags);
         if (error)
                 return error;
 
+        old_name = fsnotify_oldname_init(old_dentry->d_name.name);
         dget(new_dentry);
-        if (target)
+        if (!is_dir || (flags & RENAME_EXCHANGE))
+                lock_two_nondirectories(source, target);
+        else if (target)
                 mutex_lock(&target->i_mutex);
 
         error = -EBUSY;
         if (d_mountpoint(old_dentry) || d_mountpoint(new_dentry))
                 goto out;
 
-        error = -EMLINK;
-        if (max_links && !target && new_dir != old_dir &&
-            new_dir->i_nlink >= max_links)
-                goto out;
-
-        if (target)
+        if (max_links && new_dir != old_dir) {
+                error = -EMLINK;
+                if (is_dir && !new_is_dir && new_dir->i_nlink >= max_links)
+                        goto out;
+                if ((flags & RENAME_EXCHANGE) && !is_dir && new_is_dir &&
+                    old_dir->i_nlink >= max_links)
+                        goto out;
+        }
+        if (is_dir && !(flags & RENAME_EXCHANGE) && target)
                 shrink_dcache_parent(new_dentry);
-        error = old_dir->i_op->rename(old_dir, old_dentry, new_dir, new_dentry);
-        if (error)
-                goto out;
-
-        if (target) {
-                target->i_flags |= S_DEAD;
-                dont_mount(new_dentry);
+        if (!is_dir) {
+                error = try_break_deleg(source, delegated_inode);
+                if (error)
+                        goto out;
         }
-out:
-        if (target)
-                mutex_unlock(&target->i_mutex);
-        dput(new_dentry);
-        if (!error)
-                if (!(old_dir->i_sb->s_type->fs_flags & FS_RENAME_DOES_D_MOVE))
-                        d_move(old_dentry,new_dentry);
-        return error;
-}
-
-static int vfs_rename_other(struct inode *old_dir, struct dentry *old_dentry,
-                            struct inode *new_dir, struct dentry *new_dentry,
-                            struct inode **delegated_inode)
-{
-        struct inode *target = new_dentry->d_inode;
-        struct inode *source = old_dentry->d_inode;
-        int error;
-
-        error = security_inode_rename(old_dir, old_dentry, new_dir, new_dentry);
-        if (error)
-                return error;
-
-        dget(new_dentry);
-        lock_two_nondirectories(source, target);
-
-        error = -EBUSY;
-        if (d_mountpoint(old_dentry)||d_mountpoint(new_dentry))
-                goto out;
-
-        error = try_break_deleg(source, delegated_inode);
-        if (error)
-                goto out;
-        if (target) {
+        if (target && !new_is_dir) {
                 error = try_break_deleg(target, delegated_inode);
                 if (error)
                         goto out;
         }
-        error = old_dir->i_op->rename(old_dir, old_dentry, new_dir, new_dentry);
+        if (!flags) {
+                error = old_dir->i_op->rename(old_dir, old_dentry,
+                                              new_dir, new_dentry);
+        } else {
+                error = old_dir->i_op->rename2(old_dir, old_dentry,
+                                               new_dir, new_dentry, flags);
+        }
         if (error)
                 goto out;
 
-        if (target)
+        if (!(flags & RENAME_EXCHANGE) && target) {
+                if (is_dir)
+                        target->i_flags |= S_DEAD;
                 dont_mount(new_dentry);
-        if (!(old_dir->i_sb->s_type->fs_flags & FS_RENAME_DOES_D_MOVE))
-                d_move(old_dentry, new_dentry);
+        }
+        if (!(old_dir->i_sb->s_type->fs_flags & FS_RENAME_DOES_D_MOVE)) {
+                if (!(flags & RENAME_EXCHANGE))
+                        d_move(old_dentry, new_dentry);
+                else
+                        d_exchange(old_dentry, new_dentry);
+        }
 out:
-        unlock_two_nondirectories(source, target);
+        if (!is_dir || (flags & RENAME_EXCHANGE))
+                unlock_two_nondirectories(source, target);
+        else if (target)
+                mutex_unlock(&target->i_mutex);
         dput(new_dentry);
-        return error;
-}
-
-/**
- * vfs_rename - rename a filesystem object
- * @old_dir:    parent of source
- * @old_dentry: source
- * @new_dir:    parent of destination
- * @new_dentry: destination
- * @delegated_inode: returns an inode needing a delegation break
- *
- * The caller must hold multiple mutexes--see lock_rename()).
- *
- * If vfs_rename discovers a delegation in need of breaking at either
- * the source or destination, it will return -EWOULDBLOCK and return a
- * reference to the inode in delegated_inode.  The caller should then
- * break the delegation and retry.  Because breaking a delegation may
- * take a long time, the caller should drop all locks before doing
- * so.
- *
- * Alternatively, a caller may pass NULL for delegated_inode.  This may
- * be appropriate for callers that expect the underlying filesystem not
- * to be NFS exported.
- */
-int vfs_rename(struct inode *old_dir, struct dentry *old_dentry,
-               struct inode *new_dir, struct dentry *new_dentry,
-               struct inode **delegated_inode)
-{
-        int error;
-        int is_dir = d_is_directory(old_dentry) || d_is_autodir(old_dentry);
-        const unsigned char *old_name;
-
-        if (old_dentry->d_inode == new_dentry->d_inode)
-                return 0;
- 
-        error = may_delete(old_dir, old_dentry, is_dir);
-        if (error)
-                return error;
-
-        if (!new_dentry->d_inode)
-                error = may_create(new_dir, new_dentry);
-        else
-                error = may_delete(new_dir, new_dentry, is_dir);
-        if (error)
-                return error;
-
-        if (!old_dir->i_op->rename)
-                return -EPERM;
-
-        old_name = fsnotify_oldname_init(old_dentry->d_name.name);
-
-        if (is_dir)
-                error = vfs_rename_dir(old_dir,old_dentry,new_dir,new_dentry);
-        else
-                error = vfs_rename_other(old_dir,old_dentry,new_dir,new_dentry,delegated_inode);
-        if (!error)
+        if (!error) {
                 fsnotify_move(old_dir, new_dir, old_name, is_dir,
-                              new_dentry->d_inode, old_dentry);
+                              !(flags & RENAME_EXCHANGE) ? target : NULL, old_dentry);
+                if (flags & RENAME_EXCHANGE) {
+                        fsnotify_move(new_dir, old_dir, old_dentry->d_name.name,
+                                      new_is_dir, NULL, new_dentry);
+                }
+        }
         fsnotify_oldname_free(old_name);
 
         return error;
 }
 
-SYSCALL_DEFINE4(renameat, int, olddfd, const char __user *, oldname,
-                int, newdfd, const char __user *, newname)
+SYSCALL_DEFINE5(renameat2, int, olddfd, const char __user *, oldname,
+                int, newdfd, const char __user *, newname, unsigned int, flags)
 {
         struct dentry *old_dir, *new_dir;
         struct dentry *old_dentry, *new_dentry;
@@ -4173,6 +4166,13 @@ SYSCALL_DEFINE4(renameat, int, olddfd, const char __user *, oldname,
         unsigned int lookup_flags = 0;
         bool should_retry = false;
         int error;
+
+        if (flags & ~(RENAME_NOREPLACE | RENAME_EXCHANGE))
+                return -EINVAL;
+
+        if ((flags & RENAME_NOREPLACE) && (flags & RENAME_EXCHANGE))
+                return -EINVAL;
+
 retry:
         from = user_path_parent(olddfd, oldname, &oldnd, lookup_flags);
         if (IS_ERR(from)) {
@@ -4196,6 +4196,8 @@ retry:
                 goto exit2;
 
         new_dir = newnd.path.dentry;
+        if (flags & RENAME_NOREPLACE)
+                error = -EEXIST;
         if (newnd.last_type != LAST_NORM)
                 goto exit2;
 
@@ -4205,7 +4207,8 @@ retry:
 
         oldnd.flags &= ~LOOKUP_PARENT;
         newnd.flags &= ~LOOKUP_PARENT;
-        newnd.flags |= LOOKUP_RENAME_TARGET;
+        if (!(flags & RENAME_EXCHANGE))
+                newnd.flags |= LOOKUP_RENAME_TARGET;
 
 retry_deleg:
         trap = lock_rename(new_dir, old_dir);
@@ -4218,34 +4221,49 @@ retry_deleg:
         error = -ENOENT;
         if (d_is_negative(old_dentry))
                 goto exit4;
+        new_dentry = lookup_hash(&newnd);
+        error = PTR_ERR(new_dentry);
+        if (IS_ERR(new_dentry))
+                goto exit4;
+        error = -EEXIST;
+        if ((flags & RENAME_NOREPLACE) && d_is_positive(new_dentry))
+                goto exit5;
+        if (flags & RENAME_EXCHANGE) {
+                error = -ENOENT;
+                if (d_is_negative(new_dentry))
+                        goto exit5;
+
+                if (!d_is_dir(new_dentry)) {
+                        error = -ENOTDIR;
+                        if (newnd.last.name[newnd.last.len])
+                                goto exit5;
+                }
+        }
         /* unless the source is a directory trailing slashes give -ENOTDIR */
-        if (!d_is_directory(old_dentry) && !d_is_autodir(old_dentry)) {
+        if (!d_is_dir(old_dentry)) {
                 error = -ENOTDIR;
                 if (oldnd.last.name[oldnd.last.len])
-                        goto exit4;
-                if (newnd.last.name[newnd.last.len])
-                        goto exit4;
+                        goto exit5;
+                if (!(flags & RENAME_EXCHANGE) && newnd.last.name[newnd.last.len])
+                        goto exit5;
         }
         /* source should not be ancestor of target */
         error = -EINVAL;
         if (old_dentry == trap)
-                goto exit4;
-        new_dentry = lookup_hash(&newnd);
-        error = PTR_ERR(new_dentry);
-        if (IS_ERR(new_dentry))
-                goto exit4;
+                goto exit5;
         /* target should not be an ancestor of source */
-        error = -ENOTEMPTY;
+        if (!(flags & RENAME_EXCHANGE))
+                error = -ENOTEMPTY;
         if (new_dentry == trap)
                 goto exit5;
 
         error = security_path_rename(&oldnd.path, old_dentry,
-                                     &newnd.path, new_dentry);
+                                     &newnd.path, new_dentry, flags);
         if (error)
                 goto exit5;
         error = vfs_rename(old_dir->d_inode, old_dentry,
-                                   new_dir->d_inode, new_dentry,
-                                   &delegated_inode);
+                           new_dir->d_inode, new_dentry,
+                           &delegated_inode, flags);
 exit5:
         dput(new_dentry);
 exit4:
@@ -4275,9 +4293,15 @@ exit:
         return error;
 }
 
+SYSCALL_DEFINE4(renameat, int, olddfd, const char __user *, oldname,
+                int, newdfd, const char __user *, newname)
+{
+        return sys_renameat2(olddfd, oldname, newdfd, newname, 0);
+}
+
 SYSCALL_DEFINE2(rename, const char __user *, oldname, const char __user *, newname)
 {
-        return sys_renameat(AT_FDCWD, oldname, AT_FDCWD, newname);
+        return sys_renameat2(AT_FDCWD, oldname, AT_FDCWD, newname, 0);
 }
 
 int vfs_readlink(struct dentry *dentry, char __user *buffer, int buflen, const char *link)