int (*mkdir) (struct inode *,struct dentry *,umode_t);
        int (*rmdir) (struct inode *,struct dentry *);
        int (*mknod) (struct inode *,struct dentry *,umode_t,dev_t);
-       int (*rename2) (struct inode *, struct dentry *,
+       int (*rename) (struct inode *, struct dentry *,
                        struct inode *, struct dentry *, unsigned int);
        int (*readlink) (struct dentry *, char __user *,int);
        const char *(*get_link) (struct dentry *, struct inode *, void **);
 mkdir:         yes
 unlink:                yes (both)
 rmdir:         yes (both)      (see below)
-rename2:       yes (all)       (see below)
+rename:        yes (all)       (see below)
 readlink:      no
 get_link:      no
 setattr:       yes
 
        Additionally, ->rmdir(), ->unlink() and ->rename() have ->i_mutex on
 victim.
-       cross-directory ->rename2() has (per-superblock) ->s_vfs_rename_sem.
+       cross-directory ->rename() has (per-superblock) ->s_vfs_rename_sem.
 
 See Documentation/filesystems/directory-locking for more detailed discussion
 of the locking scheme for directory operations.
 
        int (*mkdir) (struct inode *,struct dentry *,umode_t);
        int (*rmdir) (struct inode *,struct dentry *);
        int (*mknod) (struct inode *,struct dentry *,umode_t,dev_t);
-       int (*rename2) (struct inode *, struct dentry *,
+       int (*rename) (struct inode *, struct dentry *,
                        struct inode *, struct dentry *, unsigned int);
        int (*readlink) (struct dentry *, char __user *,int);
        const char *(*get_link) (struct dentry *, struct inode *,
 
        .rmdir        = ll_rmdir,
        .symlink            = ll_symlink,
        .link          = ll_link,
-       .rename2        = ll_rename,
+       .rename         = ll_rename,
        .setattr            = ll_setattr,
        .getattr            = ll_getattr,
        .permission      = ll_inode_permission,
 
        .mkdir = v9fs_vfs_mkdir,
        .rmdir = v9fs_vfs_rmdir,
        .mknod = v9fs_vfs_mknod,
-       .rename2 = v9fs_vfs_rename,
+       .rename = v9fs_vfs_rename,
        .getattr = v9fs_vfs_getattr,
        .setattr = v9fs_vfs_setattr,
 };
        .mkdir = v9fs_vfs_mkdir,
        .rmdir = v9fs_vfs_rmdir,
        .mknod = v9fs_vfs_mknod,
-       .rename2 = v9fs_vfs_rename,
+       .rename = v9fs_vfs_rename,
        .getattr = v9fs_vfs_getattr,
        .setattr = v9fs_vfs_setattr,
 };
 
        .mkdir = v9fs_vfs_mkdir_dotl,
        .rmdir = v9fs_vfs_rmdir,
        .mknod = v9fs_vfs_mknod_dotl,
-       .rename2 = v9fs_vfs_rename,
+       .rename = v9fs_vfs_rename,
        .getattr = v9fs_vfs_getattr_dotl,
        .setattr = v9fs_vfs_setattr_dotl,
        .setxattr = generic_setxattr,
 
        .symlink        = affs_symlink,
        .mkdir          = affs_mkdir,
        .rmdir          = affs_rmdir,
-       .rename2        = affs_rename,
+       .rename         = affs_rename,
        .setattr        = affs_notify_change,
 };
 
 
        .symlink        = afs_symlink,
        .mkdir          = afs_mkdir,
        .rmdir          = afs_rmdir,
-       .rename2        = afs_rename,
+       .rename         = afs_rename,
        .permission     = afs_permission,
        .getattr        = afs_getattr,
        .setattr        = afs_setattr,
 
        .mkdir          = bad_inode_mkdir,
        .rmdir          = bad_inode_rmdir,
        .mknod          = bad_inode_mknod,
-       .rename2        = bad_inode_rename2,
+       .rename         = bad_inode_rename2,
        .readlink       = bad_inode_readlink,
        /* follow_link must be no-op, otherwise unmounting this inode
           won't work */
 
        .lookup                 = bfs_lookup,
        .link                   = bfs_link,
        .unlink                 = bfs_unlink,
-       .rename2                = bfs_rename,
+       .rename                 = bfs_rename,
 };
 
 static int bfs_add_entry(struct inode *dir, const unsigned char *name,
 
        .link           = btrfs_link,
        .mkdir          = btrfs_mkdir,
        .rmdir          = btrfs_rmdir,
-       .rename2        = btrfs_rename2,
+       .rename         = btrfs_rename2,
        .symlink        = btrfs_symlink,
        .setattr        = btrfs_setattr,
        .mknod          = btrfs_mknod,
 
            !d_backing_inode(subdir)->i_op->lookup ||
            !d_backing_inode(subdir)->i_op->mkdir ||
            !d_backing_inode(subdir)->i_op->create ||
-           !d_backing_inode(subdir)->i_op->rename2 ||
+           !d_backing_inode(subdir)->i_op->rename ||
            !d_backing_inode(subdir)->i_op->rmdir ||
            !d_backing_inode(subdir)->i_op->unlink)
                goto check_error;
 
        .link = ceph_link,
        .unlink = ceph_unlink,
        .rmdir = ceph_unlink,
-       .rename2 = ceph_rename,
+       .rename = ceph_rename,
        .create = ceph_create,
        .atomic_open = ceph_atomic_open,
 };
        .getattr = ceph_getattr,
        .mkdir = ceph_mkdir,
        .rmdir = ceph_unlink,
-       .rename2 = ceph_rename,
+       .rename = ceph_rename,
 };
 
 const struct dentry_operations ceph_dentry_ops = {
 
        .link = cifs_hardlink,
        .mkdir = cifs_mkdir,
        .rmdir = cifs_rmdir,
-       .rename2 = cifs_rename2,
+       .rename = cifs_rename2,
        .permission = cifs_permission,
        .setattr = cifs_setattr,
        .symlink = cifs_symlink,
 
        .mkdir          = coda_mkdir,
        .rmdir          = coda_rmdir,
        .mknod          = CODA_EIO_ERROR,
-       .rename2        = coda_rename,
+       .rename         = coda_rename,
        .permission     = coda_permission,
        .getattr        = coda_getattr,
        .setattr        = coda_setattr,
 
        .mkdir = ecryptfs_mkdir,
        .rmdir = ecryptfs_rmdir,
        .mknod = ecryptfs_mknod,
-       .rename2 = ecryptfs_rename,
+       .rename = ecryptfs_rename,
        .permission = ecryptfs_permission,
        .setattr = ecryptfs_setattr,
        .setxattr = ecryptfs_setxattr,
 
        .mkdir          = exofs_mkdir,
        .rmdir          = exofs_rmdir,
        .mknod          = exofs_mknod,
-       .rename2        = exofs_rename,
+       .rename         = exofs_rename,
        .setattr        = exofs_setattr,
 };
 
 
        .mkdir          = ext2_mkdir,
        .rmdir          = ext2_rmdir,
        .mknod          = ext2_mknod,
-       .rename2        = ext2_rename,
+       .rename         = ext2_rename,
 #ifdef CONFIG_EXT2_FS_XATTR
        .setxattr       = generic_setxattr,
        .getxattr       = generic_getxattr,
 
        .rmdir          = ext4_rmdir,
        .mknod          = ext4_mknod,
        .tmpfile        = ext4_tmpfile,
-       .rename2        = ext4_rename2,
+       .rename         = ext4_rename2,
        .setattr        = ext4_setattr,
        .setxattr       = generic_setxattr,
        .getxattr       = generic_getxattr,
 
        .mkdir          = f2fs_mkdir,
        .rmdir          = f2fs_rmdir,
        .mknod          = f2fs_mknod,
-       .rename2        = f2fs_rename2,
+       .rename         = f2fs_rename2,
        .tmpfile        = f2fs_tmpfile,
        .getattr        = f2fs_getattr,
        .setattr        = f2fs_setattr,
 
        .unlink         = msdos_unlink,
        .mkdir          = msdos_mkdir,
        .rmdir          = msdos_rmdir,
-       .rename2        = msdos_rename,
+       .rename         = msdos_rename,
        .setattr        = fat_setattr,
        .getattr        = fat_getattr,
 };
 
        .unlink         = vfat_unlink,
        .mkdir          = vfat_mkdir,
        .rmdir          = vfat_rmdir,
-       .rename2        = vfat_rename,
+       .rename         = vfat_rename,
        .setattr        = fat_setattr,
        .getattr        = fat_getattr,
 };
 
        .symlink        = fuse_symlink,
        .unlink         = fuse_unlink,
        .rmdir          = fuse_rmdir,
-       .rename2        = fuse_rename2,
+       .rename         = fuse_rename2,
        .link           = fuse_link,
        .setattr        = fuse_setattr,
        .create         = fuse_create,
 
        .mkdir = gfs2_mkdir,
        .rmdir = gfs2_unlink,
        .mknod = gfs2_mknod,
-       .rename2 = gfs2_rename2,
+       .rename = gfs2_rename2,
        .permission = gfs2_permission,
        .setattr = gfs2_setattr,
        .getattr = gfs2_getattr,
 
        .unlink         = hfs_remove,
        .mkdir          = hfs_mkdir,
        .rmdir          = hfs_remove,
-       .rename2        = hfs_rename,
+       .rename         = hfs_rename,
        .setattr        = hfs_inode_setattr,
 };
 
        .rmdir                  = hfsplus_rmdir,
        .symlink                = hfsplus_symlink,
        .mknod                  = hfsplus_mknod,
-       .rename2                = hfsplus_rename,
+       .rename                 = hfsplus_rename,
        .setxattr               = generic_setxattr,
        .getxattr               = generic_getxattr,
        .listxattr              = hfsplus_listxattr,
 
        .mkdir          = hostfs_mkdir,
        .rmdir          = hostfs_rmdir,
        .mknod          = hostfs_mknod,
-       .rename2        = hostfs_rename2,
+       .rename         = hostfs_rename2,
        .permission     = hostfs_permission,
        .setattr        = hostfs_setattr,
 };
 
        .mkdir          = hpfs_mkdir,
        .rmdir          = hpfs_rmdir,
        .mknod          = hpfs_mknod,
-       .rename2        = hpfs_rename,
+       .rename         = hpfs_rename,
        .setattr        = hpfs_setattr,
 };
 
        .mkdir          = hugetlbfs_mkdir,
        .rmdir          = simple_rmdir,
        .mknod          = hugetlbfs_mknod,
-       .rename2        = simple_rename,
+       .rename         = simple_rename,
        .setattr        = hugetlbfs_setattr,
 };
 
 
        .mkdir =        jffs2_mkdir,
        .rmdir =        jffs2_rmdir,
        .mknod =        jffs2_mknod,
-       .rename2 =      jffs2_rename,
+       .rename =       jffs2_rename,
        .get_acl =      jffs2_get_acl,
        .set_acl =      jffs2_set_acl,
        .setattr =      jffs2_setattr,
 
        .mkdir          = jfs_mkdir,
        .rmdir          = jfs_rmdir,
        .mknod          = jfs_mknod,
-       .rename2        = jfs_rename,
+       .rename         = jfs_rename,
        .setxattr       = generic_setxattr,
        .getxattr       = generic_getxattr,
        .listxattr      = jfs_listxattr,
 
 
        .mkdir          = kernfs_iop_mkdir,
        .rmdir          = kernfs_iop_rmdir,
-       .rename2        = kernfs_iop_rename,
+       .rename         = kernfs_iop_rename,
 };
 
 static struct kernfs_node *kernfs_leftmost_descendant(struct kernfs_node *pos)
 
        .lookup         = logfs_lookup,
        .mkdir          = logfs_mkdir,
        .mknod          = logfs_mknod,
-       .rename2        = logfs_rename,
+       .rename         = logfs_rename,
        .rmdir          = logfs_rmdir,
        .symlink        = logfs_symlink,
        .unlink         = logfs_unlink,
 
        .mkdir          = minix_mkdir,
        .rmdir          = minix_rmdir,
        .mknod          = minix_mknod,
-       .rename2        = minix_rename,
+       .rename         = minix_rename,
        .getattr        = minix_getattr,
        .tmpfile        = minix_tmpfile,
 };
 
        if (error)
                return error;
 
-       if (!old_dir->i_op->rename2)
+       if (!old_dir->i_op->rename)
                return -EPERM;
 
        /*
                if (error)
                        goto out;
        }
-       error = old_dir->i_op->rename2(old_dir, old_dentry,
+       error = old_dir->i_op->rename(old_dir, old_dentry,
                                       new_dir, new_dentry, flags);
        if (error)
                goto out;
 
        .mkdir          = ncp_mkdir,
        .rmdir          = ncp_rmdir,
        .mknod          = ncp_mknod,
-       .rename2        = ncp_rename,
+       .rename         = ncp_rename,
        .setattr        = ncp_notify_change,
 };
 
 
        .mkdir          = nfs_mkdir,
        .rmdir          = nfs_rmdir,
        .mknod          = nfs_mknod,
-       .rename2        = nfs_rename,
+       .rename         = nfs_rename,
        .permission     = nfs_permission,
        .getattr        = nfs_getattr,
        .setattr        = nfs_setattr,
 
        .mkdir          = nfs_mkdir,
        .rmdir          = nfs_rmdir,
        .mknod          = nfs_mknod,
-       .rename2        = nfs_rename,
+       .rename         = nfs_rename,
        .permission     = nfs_permission,
        .getattr        = nfs_getattr,
        .setattr        = nfs_setattr,
 
        .mkdir          = nfs_mkdir,
        .rmdir          = nfs_rmdir,
        .mknod          = nfs_mknod,
-       .rename2        = nfs_rename,
+       .rename         = nfs_rename,
        .permission     = nfs_permission,
        .getattr        = nfs_getattr,
        .setattr        = nfs_setattr,
 
        .mkdir          = nilfs_mkdir,
        .rmdir          = nilfs_rmdir,
        .mknod          = nilfs_mknod,
-       .rename2        = nilfs_rename,
+       .rename         = nilfs_rename,
        .setattr        = nilfs_setattr,
        .permission     = nilfs_permission,
        .fiemap         = nilfs_fiemap,
 
        .symlink        = ocfs2_symlink,
        .mkdir          = ocfs2_mkdir,
        .mknod          = ocfs2_mknod,
-       .rename2        = ocfs2_rename,
+       .rename         = ocfs2_rename,
        .setattr        = ocfs2_setattr,
        .getattr        = ocfs2_getattr,
        .permission     = ocfs2_permission,
 
 const struct inode_operations omfs_dir_inops = {
        .lookup = omfs_lookup,
        .mkdir = omfs_mkdir,
-       .rename2 = omfs_rename,
+       .rename = omfs_rename,
        .create = omfs_create,
        .unlink = omfs_remove,
        .rmdir = omfs_remove,
 
        .symlink = orangefs_symlink,
        .mkdir = orangefs_mkdir,
        .rmdir = orangefs_unlink,
-       .rename2 = orangefs_rename,
+       .rename = orangefs_rename,
        .setattr = orangefs_setattr,
        .getattr = orangefs_getattr,
        .setxattr = generic_setxattr,
 
        .symlink        = ovl_symlink,
        .unlink         = ovl_unlink,
        .rmdir          = ovl_rmdir,
-       .rename2        = ovl_rename2,
+       .rename         = ovl_rename2,
        .link           = ovl_link,
        .setattr        = ovl_setattr,
        .create         = ovl_create,
 
 {
        int err;
 
-       pr_debug("rename2(%pd2, %pd2, 0x%x)\n",
+       pr_debug("rename(%pd2, %pd2, 0x%x)\n",
                 olddentry, newdentry, flags);
 
        err = vfs_rename(olddir, olddentry, newdir, newdentry, NULL, flags);
 
        if (err) {
-               pr_debug("...rename2(%pd2, %pd2, ...) = %i\n",
+               pr_debug("...rename(%pd2, %pd2, ...) = %i\n",
                         olddentry, newdentry, err);
        }
        return err;
 
        .mkdir          = ramfs_mkdir,
        .rmdir          = simple_rmdir,
        .mknod          = ramfs_mknod,
-       .rename2        = simple_rename,
+       .rename         = simple_rename,
 };
 
 static const struct super_operations ramfs_ops = {
 
        .mkdir = reiserfs_mkdir,
        .rmdir = reiserfs_rmdir,
        .mknod = reiserfs_mknod,
-       .rename2 = reiserfs_rename,
+       .rename = reiserfs_rename,
        .setattr = reiserfs_setattr,
        .setxattr = generic_setxattr,
        .getxattr = generic_getxattr,
 
        .mkdir          = sysv_mkdir,
        .rmdir          = sysv_rmdir,
        .mknod          = sysv_mknod,
-       .rename2        = sysv_rename,
+       .rename         = sysv_rename,
        .getattr        = sysv_getattr,
 };
 
        .mkdir       = ubifs_mkdir,
        .rmdir       = ubifs_rmdir,
        .mknod       = ubifs_mknod,
-       .rename2     = ubifs_rename,
+       .rename     = ubifs_rename,
        .setattr     = ubifs_setattr,
        .getattr     = ubifs_getattr,
        .setxattr    = generic_setxattr,
 
        .mkdir                          = udf_mkdir,
        .rmdir                          = udf_rmdir,
        .mknod                          = udf_mknod,
-       .rename2                        = udf_rename,
+       .rename                         = udf_rename,
        .tmpfile                        = udf_tmpfile,
 };
 
        .mkdir          = ufs_mkdir,
        .rmdir          = ufs_rmdir,
        .mknod          = ufs_mknod,
-       .rename2        = ufs_rename,
+       .rename         = ufs_rename,
 };
 
         */
        .rmdir                  = xfs_vn_unlink,
        .mknod                  = xfs_vn_mknod,
-       .rename2                = xfs_vn_rename,
+       .rename                 = xfs_vn_rename,
        .get_acl                = xfs_get_acl,
        .set_acl                = xfs_set_acl,
        .getattr                = xfs_vn_getattr,
         */
        .rmdir                  = xfs_vn_unlink,
        .mknod                  = xfs_vn_mknod,
-       .rename2                = xfs_vn_rename,
+       .rename                 = xfs_vn_rename,
        .get_acl                = xfs_get_acl,
        .set_acl                = xfs_set_acl,
        .getattr                = xfs_vn_getattr,
 
        int (*mkdir) (struct inode *,struct dentry *,umode_t);
        int (*rmdir) (struct inode *,struct dentry *);
        int (*mknod) (struct inode *,struct dentry *,umode_t,dev_t);
-       int (*rename2) (struct inode *, struct dentry *,
+       int (*rename) (struct inode *, struct dentry *,
                        struct inode *, struct dentry *, unsigned int);
        int (*setattr) (struct dentry *, struct iattr *);
        int (*getattr) (struct vfsmount *mnt, struct dentry *, struct kstat *);
 
        .mknod          = bpf_mkobj,
        .mkdir          = bpf_mkdir,
        .rmdir          = simple_rmdir,
-       .rename2        = simple_rename,
+       .rename         = simple_rename,
        .link           = simple_link,
        .unlink         = simple_unlink,
 };
 
        .mkdir          = shmem_mkdir,
        .rmdir          = shmem_rmdir,
        .mknod          = shmem_mknod,
-       .rename2        = shmem_rename2,
+       .rename         = shmem_rename2,
        .tmpfile        = shmem_tmpfile,
 #endif
 #ifdef CONFIG_TMPFS_XATTR
 
                 * Use filesystem name if filesystem does not support rename()
                 * operation.
                 */
-               if (!inode->i_op->rename2)
+               if (!inode->i_op->rename)
                        goto prepend_filesystem_name;
        }
        /* Prepend device name. */
                 * or dentry without vfsmount.
                 */
                if (!path->mnt ||
-                   (!inode->i_op->rename2))
+                   (!inode->i_op->rename))
                        pos = tomoyo_get_local_path(path->dentry, buf,
                                                    buf_len - 1);
                /* Get absolute name for the rest. */