Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs

Pull more vfs updates from Al Viro:
 ">rename2() work from Miklos + current_time() from Deepa"

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs:
  fs: Replace current_fs_time() with current_time()
  fs: Replace CURRENT_TIME_SEC with current_time() for inode timestamps
  fs: Replace CURRENT_TIME with current_time() for inode timestamps
  fs: proc: Delete inode time initializations in proc_alloc_inode()
  vfs: Add current_time() api
  vfs: add note about i_op->rename changes to porting
  fs: rename "rename2" i_op to "rename"
  vfs: remove unused i_op->rename
  fs: make remaining filesystems use .rename2
  libfs: support RENAME_NOREPLACE in simple_rename()
  fs: support RENAME_NOREPLACE for local filesystems
  ncpfs: fix unused variable warning

158 files changed, 520 insertions, 381 deletions

diff --git a/fs/9p/v9fs.h b/fs/9p/v9fs.h
index 6877050384a1..443d12e02043 100644
--- a/fs/9p/v9fs.h
+++ b/fs/9p/v9fs.h
@@ -148,7 +148,8 @@ extern struct dentry *v9fs_vfs_lookup(struct inode *dir, struct dentry *dentry,
 extern int v9fs_vfs_unlink(struct inode *i, struct dentry *d);
 extern int v9fs_vfs_rmdir(struct inode *i, struct dentry *d);
 extern int v9fs_vfs_rename(struct inode *old_dir, struct dentry *old_dentry,
-                        struct inode *new_dir, struct dentry *new_dentry);
+                           struct inode *new_dir, struct dentry *new_dentry,
+                           unsigned int flags);
 extern struct inode *v9fs_inode_from_fid(struct v9fs_session_info *v9ses,
                                          struct p9_fid *fid,
                                          struct super_block *sb, int new);
diff --git a/fs/9p/vfs_inode.c b/fs/9p/vfs_inode.c
index aa639bb1f289..30ca770c5e0b 100644
--- a/fs/9p/vfs_inode.c
+++ b/fs/9p/vfs_inode.c
@@ -276,7 +276,7 @@ int v9fs_init_inode(struct v9fs_session_info *v9ses,
         inode_init_owner(inode, NULL, mode);
         inode->i_blocks = 0;
         inode->i_rdev = rdev;
-        inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
+        inode->i_atime = inode->i_mtime = inode->i_ctime = current_time(inode);
         inode->i_mapping->a_ops = &v9fs_addr_operations;
 
         switch (mode & S_IFMT) {
@@ -955,7 +955,8 @@ int v9fs_vfs_rmdir(struct inode *i, struct dentry *d)
 
 int
 v9fs_vfs_rename(struct inode *old_dir, struct dentry *old_dentry,
-                struct inode *new_dir, struct dentry *new_dentry)
+                struct inode *new_dir, struct dentry *new_dentry,
+                unsigned int flags)
 {
         int retval;
         struct inode *old_inode;
@@ -966,6 +967,9 @@ v9fs_vfs_rename(struct inode *old_dir, struct dentry *old_dentry,
         struct p9_fid *newdirfid;
         struct p9_wstat wstat;
 
+        if (flags)
+                return -EINVAL;
+
         p9_debug(P9_DEBUG_VFS, "\n");
         retval = 0;
         old_inode = d_inode(old_dentry);
diff --git a/fs/adfs/inode.c b/fs/adfs/inode.c
index f57baaa511aa..8dbd36f5e581 100644
--- a/fs/adfs/inode.c
+++ b/fs/adfs/inode.c
@@ -199,7 +199,7 @@ adfs_adfs2unix_time(struct timespec *tv, struct inode *inode)
         return;
 
  cur_time:
-        *tv = CURRENT_TIME;
+        *tv = current_time(inode);
         return;
 
  too_early:
diff --git a/fs/affs/affs.h b/fs/affs/affs.h
index cc2b2efc9211..2f088773f1c0 100644
--- a/fs/affs/affs.h
+++ b/fs/affs/affs.h
@@ -173,7 +173,8 @@ extern int	affs_link(struct dentry *olddentry, struct inode *dir,
 extern int      affs_symlink(struct inode *dir, struct dentry *dentry,
                              const char *symname);
 extern int      affs_rename(struct inode *old_dir, struct dentry *old_dentry,
-                            struct inode *new_dir, struct dentry *new_dentry);
+                            struct inode *new_dir, struct dentry *new_dentry,
+                            unsigned int flags);
 
 /* inode.c */
 
diff --git a/fs/affs/amigaffs.c b/fs/affs/amigaffs.c
index d8f217c711d3..0ec65c133b93 100644
--- a/fs/affs/amigaffs.c
+++ b/fs/affs/amigaffs.c
@@ -58,7 +58,7 @@ affs_insert_hash(struct inode *dir, struct buffer_head *bh)
         mark_buffer_dirty_inode(dir_bh, dir);
         affs_brelse(dir_bh);
 
-        dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC;
+        dir->i_mtime = dir->i_ctime = current_time(dir);
         dir->i_version++;
         mark_inode_dirty(dir);
 
@@ -112,7 +112,7 @@ affs_remove_hash(struct inode *dir, struct buffer_head *rem_bh)
 
         affs_brelse(bh);
 
-        dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC;
+        dir->i_mtime = dir->i_ctime = current_time(dir);
         dir->i_version++;
         mark_inode_dirty(dir);
 
@@ -313,7 +313,7 @@ affs_remove_header(struct dentry *dentry)
         else
                 clear_nlink(inode);
         affs_unlock_link(inode);
-        inode->i_ctime = CURRENT_TIME_SEC;
+        inode->i_ctime = current_time(inode);
         mark_inode_dirty(inode);
 
 done:
diff --git a/fs/affs/inode.c b/fs/affs/inode.c
index 1aa243502c7f..fe4e1290dbb5 100644
--- a/fs/affs/inode.c
+++ b/fs/affs/inode.c
@@ -309,7 +309,7 @@ affs_new_inode(struct inode *dir)
         inode->i_gid     = current_fsgid();
         inode->i_ino     = block;
         set_nlink(inode, 1);
-        inode->i_mtime   = inode->i_atime = inode->i_ctime = CURRENT_TIME_SEC;
+        inode->i_mtime   = inode->i_atime = inode->i_ctime = current_time(inode);
         atomic_set(&AFFS_I(inode)->i_opencnt, 0);
         AFFS_I(inode)->i_blkcnt = 0;
         AFFS_I(inode)->i_lc = NULL;
diff --git a/fs/affs/namei.c b/fs/affs/namei.c
index a2d68f828d53..29186d29a3b6 100644
--- a/fs/affs/namei.c
+++ b/fs/affs/namei.c
@@ -414,12 +414,16 @@ affs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry)
 
 int
 affs_rename(struct inode *old_dir, struct dentry *old_dentry,
-            struct inode *new_dir, struct dentry *new_dentry)
+            struct inode *new_dir, struct dentry *new_dentry,
+            unsigned int flags)
 {
         struct super_block *sb = old_dir->i_sb;
         struct buffer_head *bh = NULL;
         int retval;
 
+        if (flags & ~RENAME_NOREPLACE)
+                return -EINVAL;
+
         pr_debug("%s(old=%lu,\"%pd\" to new=%lu,\"%pd\")\n", __func__,
                  old_dir->i_ino, old_dentry, new_dir->i_ino, new_dentry);
 
diff --git a/fs/afs/dir.c b/fs/afs/dir.c
index eba541004d90..51a241e09fbb 100644
--- a/fs/afs/dir.c
+++ b/fs/afs/dir.c
@@ -38,7 +38,8 @@ static int afs_link(struct dentry *from, struct inode *dir,
 static int afs_symlink(struct inode *dir, struct dentry *dentry,
                        const char *content);
 static int afs_rename(struct inode *old_dir, struct dentry *old_dentry,
-                      struct inode *new_dir, struct dentry *new_dentry);
+                      struct inode *new_dir, struct dentry *new_dentry,
+                      unsigned int flags);
 
 const struct file_operations afs_dir_file_operations = {
         .open           = afs_dir_open,
@@ -1083,12 +1084,16 @@ error:
  * rename a file in an AFS filesystem and/or move it between directories
  */
 static int afs_rename(struct inode *old_dir, struct dentry *old_dentry,
-                      struct inode *new_dir, struct dentry *new_dentry)
+                      struct inode *new_dir, struct dentry *new_dentry,
+                      unsigned int flags)
 {
         struct afs_vnode *orig_dvnode, *new_dvnode, *vnode;
         struct key *key;
         int ret;
 
+        if (flags)
+                return -EINVAL;
+
         vnode = AFS_FS_I(d_inode(old_dentry));
         orig_dvnode = AFS_FS_I(old_dir);
         new_dvnode = AFS_FS_I(new_dir);
diff --git a/fs/attr.c b/fs/attr.c
index a19a64d41e7e..c902b3d53508 100644
--- a/fs/attr.c
+++ b/fs/attr.c
@@ -237,7 +237,7 @@ int notify_change(struct dentry * dentry, struct iattr * attr, struct inode **de
                         inode->i_flags &= ~S_NOSEC;
         }
 
-        now = current_fs_time(inode->i_sb);
+        now = current_time(inode);
 
         attr->ia_ctime = now;
         if (!(ia_valid & ATTR_ATIME_SET))
diff --git a/fs/autofs4/inode.c b/fs/autofs4/inode.c
index 61b21051bd5a..ca9cbd6362e0 100644
--- a/fs/autofs4/inode.c
+++ b/fs/autofs4/inode.c
@@ -359,7 +359,7 @@ struct inode *autofs4_get_inode(struct super_block *sb, umode_t mode)
                 inode->i_uid = d_inode(sb->s_root)->i_uid;
                 inode->i_gid = d_inode(sb->s_root)->i_gid;
         }
-        inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
+        inode->i_atime = inode->i_mtime = inode->i_ctime = current_time(inode);
         inode->i_ino = get_next_ino();
 
         if (S_ISDIR(mode)) {
diff --git a/fs/autofs4/root.c b/fs/autofs4/root.c
index fa84bb8832e0..623510e84c96 100644
--- a/fs/autofs4/root.c
+++ b/fs/autofs4/root.c
@@ -591,7 +591,7 @@ static int autofs4_dir_symlink(struct inode *dir,
         if (p_ino && !IS_ROOT(dentry))
                 atomic_inc(&p_ino->count);
 
-        dir->i_mtime = CURRENT_TIME;
+        dir->i_mtime = current_time(dir);
 
         return 0;
 }
@@ -631,7 +631,7 @@ static int autofs4_dir_unlink(struct inode *dir, struct dentry *dentry)
         d_inode(dentry)->i_size = 0;
         clear_nlink(d_inode(dentry));
 
-        dir->i_mtime = CURRENT_TIME;
+        dir->i_mtime = current_time(dir);
 
         spin_lock(&sbi->lookup_lock);
         __autofs4_add_expiring(dentry);
@@ -762,7 +762,7 @@ static int autofs4_dir_mkdir(struct inode *dir,
         if (p_ino && !IS_ROOT(dentry))
                 atomic_inc(&p_ino->count);
         inc_nlink(dir);
-        dir->i_mtime = CURRENT_TIME;
+        dir->i_mtime = current_time(dir);
 
         return 0;
 }
diff --git a/fs/bad_inode.c b/fs/bad_inode.c
index 7bb153c33459..8712062275b8 100644
--- a/fs/bad_inode.c
+++ b/fs/bad_inode.c
@@ -116,7 +116,7 @@ static const struct inode_operations bad_inode_ops =
         .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 */
@@ -153,7 +153,7 @@ void make_bad_inode(struct inode *inode)
 
         inode->i_mode = S_IFREG;
         inode->i_atime = inode->i_mtime = inode->i_ctime =
-                current_fs_time(inode->i_sb);
+                current_time(inode);
         inode->i_op = &bad_inode_ops;   
         inode->i_opflags &= ~IOP_XATTR;
         inode->i_fop = &bad_file_ops;   
diff --git a/fs/bfs/dir.c b/fs/bfs/dir.c
index 34a5bc2f1290..3e5ac30e8b6f 100644
--- a/fs/bfs/dir.c
+++ b/fs/bfs/dir.c
@@ -97,7 +97,7 @@ static int bfs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
         set_bit(ino, info->si_imap);
         info->si_freei--;
         inode_init_owner(inode, dir, mode);
-        inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME_SEC;
+        inode->i_mtime = inode->i_atime = inode->i_ctime = current_time(inode);
         inode->i_blocks = 0;
         inode->i_op = &bfs_file_inops;
         inode->i_fop = &bfs_file_operations;
@@ -165,7 +165,7 @@ static int bfs_link(struct dentry *old, struct inode *dir,
                 return err;
         }
         inc_nlink(inode);
-        inode->i_ctime = CURRENT_TIME_SEC;
+        inode->i_ctime = current_time(inode);
         mark_inode_dirty(inode);
         ihold(inode);
         d_instantiate(new, inode);
@@ -194,7 +194,7 @@ static int bfs_unlink(struct inode *dir, struct dentry *dentry)
         }
         de->ino = 0;
         mark_buffer_dirty_inode(bh, dir);
-        dir->i_ctime = dir->i_mtime = CURRENT_TIME_SEC;
+        dir->i_ctime = dir->i_mtime = current_time(dir);
         mark_inode_dirty(dir);
         inode->i_ctime = dir->i_ctime;
         inode_dec_link_count(inode);
@@ -207,7 +207,8 @@ out_brelse:
 }
 
 static int bfs_rename(struct inode *old_dir, struct dentry *old_dentry,
-                        struct inode *new_dir, struct dentry *new_dentry)
+                      struct inode *new_dir, struct dentry *new_dentry,
+                      unsigned int flags)
 {
         struct inode *old_inode, *new_inode;
         struct buffer_head *old_bh, *new_bh;
@@ -215,6 +216,9 @@ static int bfs_rename(struct inode *old_dir, struct dentry *old_dentry,
         struct bfs_sb_info *info;
         int error = -ENOENT;
 
+        if (flags & ~RENAME_NOREPLACE)
+                return -EINVAL;
+
         old_bh = new_bh = NULL;
         old_inode = d_inode(old_dentry);
         if (S_ISDIR(old_inode->i_mode))
@@ -249,10 +253,10 @@ static int bfs_rename(struct inode *old_dir, struct dentry *old_dentry,
                         goto end_rename;
         }
         old_de->ino = 0;
-        old_dir->i_ctime = old_dir->i_mtime = CURRENT_TIME_SEC;
+        old_dir->i_ctime = old_dir->i_mtime = current_time(old_dir);
         mark_inode_dirty(old_dir);
         if (new_inode) {
-                new_inode->i_ctime = CURRENT_TIME_SEC;
+                new_inode->i_ctime = current_time(new_inode);
                 inode_dec_link_count(new_inode);
         }
         mark_buffer_dirty_inode(old_bh, old_dir);
@@ -300,9 +304,9 @@ static int bfs_add_entry(struct inode *dir, const unsigned char *name,
                                 pos = (block - sblock) * BFS_BSIZE + off;
                                 if (pos >= dir->i_size) {
                                         dir->i_size += BFS_DIRENT_SIZE;
-                                        dir->i_ctime = CURRENT_TIME_SEC;
+                                        dir->i_ctime = current_time(dir);
                                 }
-                                dir->i_mtime = CURRENT_TIME_SEC;
+                                dir->i_mtime = current_time(dir);
                                 mark_inode_dirty(dir);
                                 de->ino = cpu_to_le16((u16)ino);
                                 for (i = 0; i < BFS_NAMELEN; i++)
diff --git a/fs/binfmt_misc.c b/fs/binfmt_misc.c
index 6103a6362ccd..9b4688ab1d8e 100644
--- a/fs/binfmt_misc.c
+++ b/fs/binfmt_misc.c
@@ -584,7 +584,7 @@ static struct inode *bm_get_inode(struct super_block *sb, int mode)
                 inode->i_ino = get_next_ino();
                 inode->i_mode = mode;
                 inode->i_atime = inode->i_mtime = inode->i_ctime =
-                        current_fs_time(inode->i_sb);
+                        current_time(inode);
         }
         return inode;
 }
diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c
index 4843cb994835..36f4589e349c 100644
--- a/fs/btrfs/file.c
+++ b/fs/btrfs/file.c
@@ -1757,7 +1757,7 @@ static void update_time_for_write(struct inode *inode)
         if (IS_NOCMTIME(inode))
                 return;
 
-        now = current_fs_time(inode->i_sb);
+        now = current_time(inode);
         if (!timespec_equal(&inode->i_mtime, &now))
                 inode->i_mtime = now;
 
@@ -2578,7 +2578,7 @@ out_trans:
                 goto out_free;
 
         inode_inc_iversion(inode);
-        inode->i_mtime = inode->i_ctime = current_fs_time(inode->i_sb);
+        inode->i_mtime = inode->i_ctime = current_time(inode);
 
         trans->block_rsv = &root->fs_info->trans_block_rsv;
         ret = btrfs_update_inode(trans, root, inode);
@@ -2842,7 +2842,7 @@ static long btrfs_fallocate(struct file *file, int mode,
                 if (IS_ERR(trans)) {
                         ret = PTR_ERR(trans);
                 } else {
-                        inode->i_ctime = current_fs_time(inode->i_sb);
+                        inode->i_ctime = current_time(inode);
                         i_size_write(inode, actual_end);
                         btrfs_ordered_update_i_size(inode, actual_end, NULL);
                         ret = btrfs_update_inode(trans, root, inode);
diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index 994fe5af160b..22a7ca43c7cd 100644
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -4059,7 +4059,7 @@ err:
         inode_inc_iversion(inode);
         inode_inc_iversion(dir);
         inode->i_ctime = dir->i_mtime =
-                dir->i_ctime = current_fs_time(inode->i_sb);
+                dir->i_ctime = current_time(inode);
         ret = btrfs_update_inode(trans, root, dir);
 out:
         return ret;
@@ -4202,7 +4202,7 @@ int btrfs_unlink_subvol(struct btrfs_trans_handle *trans,
 
         btrfs_i_size_write(dir, dir->i_size - name_len * 2);
         inode_inc_iversion(dir);
-        dir->i_mtime = dir->i_ctime = current_fs_time(dir->i_sb);
+        dir->i_mtime = dir->i_ctime = current_time(dir);
         ret = btrfs_update_inode_fallback(trans, root, dir);
         if (ret)
                 btrfs_abort_transaction(trans, ret);
@@ -4965,7 +4965,7 @@ static int btrfs_setsize(struct inode *inode, struct iattr *attr)
                 inode_inc_iversion(inode);
                 if (!(mask & (ATTR_CTIME | ATTR_MTIME)))
                         inode->i_ctime = inode->i_mtime =
-                                current_fs_time(inode->i_sb);
+                                current_time(inode);
         }
 
         if (newsize > oldsize) {
@@ -5672,7 +5672,7 @@ static struct inode *new_simple_dir(struct super_block *s,
         inode->i_op = &btrfs_dir_ro_inode_operations;
         inode->i_fop = &simple_dir_operations;
         inode->i_mode = S_IFDIR | S_IRUGO | S_IWUSR | S_IXUGO;
-        inode->i_mtime = current_fs_time(inode->i_sb);
+        inode->i_mtime = current_time(inode);
         inode->i_atime = inode->i_mtime;
         inode->i_ctime = inode->i_mtime;
         BTRFS_I(inode)->i_otime = inode->i_mtime;
@@ -6258,7 +6258,7 @@ static struct inode *btrfs_new_inode(struct btrfs_trans_handle *trans,
         inode_init_owner(inode, dir, mode);
         inode_set_bytes(inode, 0);
 
-        inode->i_mtime = current_fs_time(inode->i_sb);
+        inode->i_mtime = current_time(inode);
         inode->i_atime = inode->i_mtime;
         inode->i_ctime = inode->i_mtime;
         BTRFS_I(inode)->i_otime = inode->i_mtime;
@@ -6372,7 +6372,7 @@ int btrfs_add_link(struct btrfs_trans_handle *trans,
                            name_len * 2);
         inode_inc_iversion(parent_inode);
         parent_inode->i_mtime = parent_inode->i_ctime =
-                current_fs_time(parent_inode->i_sb);
+                current_time(parent_inode);
         ret = btrfs_update_inode(trans, root, parent_inode);
         if (ret)
                 btrfs_abort_transaction(trans, ret);
@@ -6590,7 +6590,7 @@ static int btrfs_link(struct dentry *old_dentry, struct inode *dir,
         BTRFS_I(inode)->dir_index = 0ULL;
         inc_nlink(inode);
         inode_inc_iversion(inode);
-        inode->i_ctime = current_fs_time(inode->i_sb);
+        inode->i_ctime = current_time(inode);
         ihold(inode);
         set_bit(BTRFS_INODE_COPY_EVERYTHING, &BTRFS_I(inode)->runtime_flags);
 
@@ -9493,7 +9493,7 @@ static int btrfs_rename_exchange(struct inode *old_dir,
         struct btrfs_root *dest = BTRFS_I(new_dir)->root;
         struct inode *new_inode = new_dentry->d_inode;
         struct inode *old_inode = old_dentry->d_inode;
-        struct timespec ctime = CURRENT_TIME;
+        struct timespec ctime = current_time(old_inode);
         struct dentry *parent;
         u64 old_ino = btrfs_ino(old_inode);
         u64 new_ino = btrfs_ino(new_inode);
@@ -9861,7 +9861,7 @@ static int btrfs_rename(struct inode *old_dir, struct dentry *old_dentry,
         inode_inc_iversion(old_inode);
         old_dir->i_ctime = old_dir->i_mtime =
         new_dir->i_ctime = new_dir->i_mtime =
-        old_inode->i_ctime = current_fs_time(old_dir->i_sb);
+        old_inode->i_ctime = current_time(old_dir);
 
         if (old_dentry->d_parent != new_dentry->d_parent)
                 btrfs_record_unlink_dir(trans, old_dir, old_inode, 1);
@@ -9886,7 +9886,7 @@ static int btrfs_rename(struct inode *old_dir, struct dentry *old_dentry,
 
         if (new_inode) {
                 inode_inc_iversion(new_inode);
-                new_inode->i_ctime = current_fs_time(new_inode->i_sb);
+                new_inode->i_ctime = current_time(new_inode);
                 if (unlikely(btrfs_ino(new_inode) ==
                              BTRFS_EMPTY_SUBVOL_DIR_OBJECTID)) {
                         root_objectid = BTRFS_I(new_inode)->location.objectid;
@@ -10404,7 +10404,7 @@ next:
                 *alloc_hint = ins.objectid + ins.offset;
 
                 inode_inc_iversion(inode);
-                inode->i_ctime = current_fs_time(inode->i_sb);
+                inode->i_ctime = current_time(inode);
                 BTRFS_I(inode)->flags |= BTRFS_INODE_PREALLOC;
                 if (!(mode & FALLOC_FL_KEEP_SIZE) &&
                     (actual_len > inode->i_size) &&
@@ -10552,7 +10552,7 @@ static const struct inode_operations btrfs_dir_inode_operations = {
         .link           = btrfs_link,
         .mkdir          = btrfs_mkdir,
         .rmdir          = btrfs_rmdir,
-        .rename2        = btrfs_rename2,
+        .rename         = btrfs_rename2,
         .symlink        = btrfs_symlink,
         .setattr        = btrfs_setattr,
         .mknod          = btrfs_mknod,
diff --git a/fs/btrfs/ioctl.c b/fs/btrfs/ioctl.c
index 7fd939bfbd99..b182197f7091 100644
--- a/fs/btrfs/ioctl.c
+++ b/fs/btrfs/ioctl.c
@@ -349,7 +349,7 @@ static int btrfs_ioctl_setflags(struct file *file, void __user *arg)
 
         btrfs_update_iflags(inode);
         inode_inc_iversion(inode);
-        inode->i_ctime = current_fs_time(inode->i_sb);
+        inode->i_ctime = current_time(inode);
         ret = btrfs_update_inode(trans, root, inode);
 
         btrfs_end_transaction(trans, root);
@@ -445,7 +445,7 @@ static noinline int create_subvol(struct inode *dir,
         struct btrfs_root *root = BTRFS_I(dir)->root;
         struct btrfs_root *new_root;
         struct btrfs_block_rsv block_rsv;
-        struct timespec cur_time = current_fs_time(dir->i_sb);
+        struct timespec cur_time = current_time(dir);
         struct inode *inode;
         int ret;
         int err;
@@ -3291,7 +3291,7 @@ static int clone_finish_inode_update(struct btrfs_trans_handle *trans,
 
         inode_inc_iversion(inode);
         if (!no_time_update)
-                inode->i_mtime = inode->i_ctime = current_fs_time(inode->i_sb);
+                inode->i_mtime = inode->i_ctime = current_time(inode);
         /*
          * We round up to the block size at eof when determining which
          * extents to clone above, but shouldn't round up the file size.
@@ -5106,7 +5106,7 @@ static long _btrfs_ioctl_set_received_subvol(struct file *file,
         struct btrfs_root *root = BTRFS_I(inode)->root;
         struct btrfs_root_item *root_item = &root->root_item;
         struct btrfs_trans_handle *trans;
-        struct timespec ct = current_fs_time(inode->i_sb);
+        struct timespec ct = current_time(inode);
         int ret = 0;
         int received_uuid_changed;
 
diff --git a/fs/btrfs/transaction.c b/fs/btrfs/transaction.c
index 95d41919d034..c294313ea2c8 100644
--- a/fs/btrfs/transaction.c
+++ b/fs/btrfs/transaction.c
@@ -1474,7 +1474,7 @@ static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans,
         parent_root = BTRFS_I(parent_inode)->root;
         record_root_in_trans(trans, parent_root, 0);
 
-        cur_time = current_fs_time(parent_inode->i_sb);
+        cur_time = current_time(parent_inode);
 
         /*
          * insert the directory item
@@ -1630,7 +1630,7 @@ static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans,
         btrfs_i_size_write(parent_inode, parent_inode->i_size +
                                          dentry->d_name.len * 2);
         parent_inode->i_mtime = parent_inode->i_ctime =
-                current_fs_time(parent_inode->i_sb);
+                current_time(parent_inode);
         ret = btrfs_update_inode_fallback(trans, parent_root, parent_inode);
         if (ret) {
                 btrfs_abort_transaction(trans, ret);
diff --git a/fs/btrfs/xattr.c b/fs/btrfs/xattr.c
index d1a177a3dbe8..fccbf5567e78 100644
--- a/fs/btrfs/xattr.c
+++ b/fs/btrfs/xattr.c
@@ -252,7 +252,7 @@ int __btrfs_setxattr(struct btrfs_trans_handle *trans,
                 goto out;
 
         inode_inc_iversion(inode);
-        inode->i_ctime = current_fs_time(inode->i_sb);
+        inode->i_ctime = current_time(inode);
         set_bit(BTRFS_INODE_COPY_EVERYTHING, &BTRFS_I(inode)->runtime_flags);
         ret = btrfs_update_inode(trans, root, inode);
         BUG_ON(ret);
diff --git a/fs/cachefiles/namei.c b/fs/cachefiles/namei.c
index 339c910da916..41df8a27d7eb 100644
--- a/fs/cachefiles/namei.c
+++ b/fs/cachefiles/namei.c
@@ -804,8 +804,7 @@ struct dentry *cachefiles_get_directory(struct cachefiles_cache *cache,
             !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->rename &&
-             !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;
diff --git a/fs/ceph/dir.c b/fs/ceph/dir.c
index e33bd0933396..78180d151730 100644
--- a/fs/ceph/dir.c
+++ b/fs/ceph/dir.c
@@ -1061,7 +1061,8 @@ out:
 }
 
 static int ceph_rename(struct inode *old_dir, struct dentry *old_dentry,
-                       struct inode *new_dir, struct dentry *new_dentry)
+                       struct inode *new_dir, struct dentry *new_dentry,
+                       unsigned int flags)
 {
         struct ceph_fs_client *fsc = ceph_sb_to_client(old_dir->i_sb);
         struct ceph_mds_client *mdsc = fsc->mdsc;
@@ -1069,6 +1070,9 @@ static int ceph_rename(struct inode *old_dir, struct dentry *old_dentry,
         int op = CEPH_MDS_OP_RENAME;
         int err;
 
+        if (flags)
+                return -EINVAL;
+
         if (ceph_snap(old_dir) != ceph_snap(new_dir))
                 return -EXDEV;
         if (ceph_snap(old_dir) != CEPH_NOSNAP) {
diff --git a/fs/ceph/file.c b/fs/ceph/file.c
index 395c7fcb1cea..7bf08825cc11 100644
--- a/fs/ceph/file.c
+++ b/fs/ceph/file.c
@@ -886,7 +886,7 @@ ceph_direct_read_write(struct kiocb *iocb, struct iov_iter *iter,
         int num_pages = 0;
         int flags;
         int ret;
-        struct timespec mtime = current_fs_time(inode->i_sb);
+        struct timespec mtime = current_time(inode);
         size_t count = iov_iter_count(iter);
         loff_t pos = iocb->ki_pos;
         bool write = iov_iter_rw(iter) == WRITE;
@@ -1091,7 +1091,7 @@ ceph_sync_write(struct kiocb *iocb, struct iov_iter *from, loff_t pos,
         int flags;
         int check_caps = 0;
         int ret;
-        struct timespec mtime = current_fs_time(inode->i_sb);
+        struct timespec mtime = current_time(inode);
         size_t count = iov_iter_count(from);
 
         if (ceph_snap(file_inode(file)) != CEPH_NOSNAP)
diff --git a/fs/ceph/inode.c b/fs/ceph/inode.c
index da00b11d4a7a..bca1b49c1c4b 100644
--- a/fs/ceph/inode.c
+++ b/fs/ceph/inode.c
@@ -2067,7 +2067,7 @@ int __ceph_setattr(struct inode *inode, struct iattr *attr)
         if (dirtied) {
                 inode_dirty_flags = __ceph_mark_dirty_caps(ci, dirtied,
                                                            &prealloc_cf);
-                inode->i_ctime = current_fs_time(inode->i_sb);
+                inode->i_ctime = current_time(inode);
         }
 
         release &= issued;
diff --git a/fs/ceph/xattr.c b/fs/ceph/xattr.c
index adc231892b0d..40b703217977 100644
--- a/fs/ceph/xattr.c
+++ b/fs/ceph/xattr.c
@@ -1034,7 +1034,7 @@ retry:
                 dirty = __ceph_mark_dirty_caps(ci, CEPH_CAP_XATTR_EXCL,
                                                &prealloc_cf);
                 ci->i_xattrs.dirty = true;
-                inode->i_ctime = current_fs_time(inode->i_sb);
+                inode->i_ctime = current_time(inode);
         }
 
         spin_unlock(&ci->i_ceph_lock);
diff --git a/fs/cifs/cifsfs.c b/fs/cifs/cifsfs.c
index 34aac1c73ee1..cca04e710421 100644
--- a/fs/cifs/cifsfs.c
+++ b/fs/cifs/cifsfs.c
@@ -896,7 +896,7 @@ const struct inode_operations cifs_dir_inode_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,
diff --git a/fs/cifs/file.c b/fs/cifs/file.c
index 42b99af74e0a..a95fe8b1afe9 100644
--- a/fs/cifs/file.c
+++ b/fs/cifs/file.c
@@ -1878,7 +1878,7 @@ static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
                                            write_data, to - from, &offset);
                 cifsFileInfo_put(open_file);
                 /* Does mm or vfs already set times? */
-                inode->i_atime = inode->i_mtime = current_fs_time(inode->i_sb);
+                inode->i_atime = inode->i_mtime = current_time(inode);
                 if ((bytes_written > 0) && (offset))
                         rc = 0;
                 else if (bytes_written < 0)
@@ -3565,7 +3565,7 @@ static int cifs_readpage_worker(struct file *file, struct page *page,
                 cifs_dbg(FYI, "Bytes read %d\n", rc);
 
         file_inode(file)->i_atime =
-                current_fs_time(file_inode(file)->i_sb);
+                current_time(file_inode(file));
 
         if (PAGE_SIZE > rc)
                 memset(read_data + rc, 0, PAGE_SIZE - rc);
diff --git a/fs/coda/dir.c b/fs/coda/dir.c
index 6fb8672c0892..c0474ac6cbf2 100644
--- a/fs/coda/dir.c
+++ b/fs/coda/dir.c
@@ -109,7 +109,7 @@ static inline void coda_dir_update_mtime(struct inode *dir)
         /* optimistically we can also act as if our nose bleeds. The
          * granularity of the mtime is coarse anyways so we might actually be
          * right most of the time. Note: we only do this for directories. */
-        dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC;
+        dir->i_mtime = dir->i_ctime = current_time(dir);
 #endif
 }
 
@@ -291,7 +291,8 @@ static int coda_rmdir(struct inode *dir, struct dentry *de)
 
 /* rename */
 static int coda_rename(struct inode *old_dir, struct dentry *old_dentry,
-                       struct inode *new_dir, struct dentry *new_dentry)
+                       struct inode *new_dir, struct dentry *new_dentry,
+                       unsigned int flags)
 {
         const char *old_name = old_dentry->d_name.name;
         const char *new_name = new_dentry->d_name.name;
@@ -299,6 +300,9 @@ static int coda_rename(struct inode *old_dir, struct dentry *old_dentry,
         int new_length = new_dentry->d_name.len;
         int error;
 
+        if (flags)
+                return -EINVAL;
+
         error = venus_rename(old_dir->i_sb, coda_i2f(old_dir),
                              coda_i2f(new_dir), old_length, new_length,
                              (const char *) old_name, (const char *)new_name);
diff --git a/fs/coda/file.c b/fs/coda/file.c
index 8415d4f8d1a1..6e0154eb6fcc 100644
--- a/fs/coda/file.c
+++ b/fs/coda/file.c
@@ -54,7 +54,7 @@ coda_file_write_iter(struct kiocb *iocb, struct iov_iter *to)
         ret = vfs_iter_write(cfi->cfi_container, to, &iocb->ki_pos);
         coda_inode->i_size = file_inode(host_file)->i_size;
         coda_inode->i_blocks = (coda_inode->i_size + 511) >> 9;
-        coda_inode->i_mtime = coda_inode->i_ctime = CURRENT_TIME_SEC;
+        coda_inode->i_mtime = coda_inode->i_ctime = current_time(coda_inode);
         inode_unlock(coda_inode);
         file_end_write(host_file);
         return ret;
diff --git a/fs/coda/inode.c b/fs/coda/inode.c
index 57e81cbba0fa..71dbe7e287ce 100644
--- a/fs/coda/inode.c
+++ b/fs/coda/inode.c
@@ -271,7 +271,7 @@ int coda_setattr(struct dentry *de, struct iattr *iattr)
 
         memset(&vattr, 0, sizeof(vattr)); 
 
-        inode->i_ctime = CURRENT_TIME_SEC;
+        inode->i_ctime = current_time(inode);
         coda_iattr_to_vattr(iattr, &vattr);
         vattr.va_type = C_VNON; /* cannot set type */
 
diff --git a/fs/configfs/inode.c b/fs/configfs/inode.c
index 0387968e6f47..ad718e5e37bb 100644
--- a/fs/configfs/inode.c
+++ b/fs/configfs/inode.c
@@ -76,7 +76,7 @@ int configfs_setattr(struct dentry * dentry, struct iattr * iattr)
                 sd_iattr->ia_uid = GLOBAL_ROOT_UID;
                 sd_iattr->ia_gid = GLOBAL_ROOT_GID;
                 sd_iattr->ia_atime = sd_iattr->ia_mtime =
-                        sd_iattr->ia_ctime = current_fs_time(inode->i_sb);
+                        sd_iattr->ia_ctime = current_time(inode);
                 sd->s_iattr = sd_iattr;
         }
         /* attributes were changed atleast once in past */
@@ -113,7 +113,7 @@ static inline void set_default_inode_attr(struct inode * inode, umode_t mode)
 {
         inode->i_mode = mode;
         inode->i_atime = inode->i_mtime =
-                inode->i_ctime = current_fs_time(inode->i_sb);
+                inode->i_ctime = current_time(inode);
 }
 
 static inline void set_inode_attr(struct inode * inode, struct iattr * iattr)
@@ -197,7 +197,7 @@ int configfs_create(struct dentry * dentry, umode_t mode, void (*init)(struct in
                 return -ENOMEM;
 
         p_inode = d_inode(dentry->d_parent);
-        p_inode->i_mtime = p_inode->i_ctime = current_fs_time(p_inode->i_sb);
+        p_inode->i_mtime = p_inode->i_ctime = current_time(p_inode);
         configfs_set_inode_lock_class(sd, inode);
 
         init(inode);
diff --git a/fs/debugfs/inode.c b/fs/debugfs/inode.c
index 72361baf9da7..f17fcf89e18e 100644
--- a/fs/debugfs/inode.c
+++ b/fs/debugfs/inode.c
@@ -45,7 +45,7 @@ static struct inode *debugfs_get_inode(struct super_block *sb)
         if (inode) {
                 inode->i_ino = get_next_ino();
                 inode->i_atime = inode->i_mtime =
-                        inode->i_ctime = current_fs_time(sb);
+                        inode->i_ctime = current_time(inode);
         }
         return inode;
 }
@@ -748,7 +748,7 @@ struct dentry *debugfs_rename(struct dentry *old_dir, struct dentry *old_dentry,
         old_name = fsnotify_oldname_init(old_dentry->d_name.name);
 
         error = simple_rename(d_inode(old_dir), old_dentry, d_inode(new_dir),
-                dentry);
+                              dentry, 0);
         if (error) {
                 fsnotify_oldname_free(old_name);
                 goto exit;
diff --git a/fs/devpts/inode.c b/fs/devpts/inode.c
index 442d1a7e671b..108df2e3602c 100644
--- a/fs/devpts/inode.c
+++ b/fs/devpts/inode.c
@@ -300,7 +300,7 @@ static int mknod_ptmx(struct super_block *sb)
         }
 
         inode->i_ino = 2;
-        inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
+        inode->i_mtime = inode->i_atime = inode->i_ctime = current_time(inode);
 
         mode = S_IFCHR|opts->ptmxmode;
         init_special_inode(inode, mode, MKDEV(TTYAUX_MAJOR, 2));
@@ -412,7 +412,7 @@ devpts_fill_super(struct super_block *s, void *data, int silent)
         if (!inode)
                 goto fail;
         inode->i_ino = 1;
-        inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
+        inode->i_mtime = inode->i_atime = inode->i_ctime = current_time(inode);
         inode->i_mode = S_IFDIR | S_IRUGO | S_IXUGO | S_IWUSR;
         inode->i_op = &simple_dir_inode_operations;
         inode->i_fop = &simple_dir_operations;
@@ -540,7 +540,7 @@ struct dentry *devpts_pty_new(struct pts_fs_info *fsi, int index, void *priv)
         inode->i_ino = index + 3;
         inode->i_uid = opts->setuid ? opts->uid : current_fsuid();
         inode->i_gid = opts->setgid ? opts->gid : current_fsgid();
-        inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
+        inode->i_mtime = inode->i_atime = inode->i_ctime = current_time(inode);
         init_special_inode(inode, S_IFCHR|opts->mode, MKDEV(UNIX98_PTY_SLAVE_MAJOR, index));
 
         sprintf(s, "%d", index);
diff --git a/fs/ecryptfs/inode.c b/fs/ecryptfs/inode.c
index ddccec3124d7..cf390dceddd2 100644
--- a/fs/ecryptfs/inode.c
+++ b/fs/ecryptfs/inode.c
@@ -577,7 +577,8 @@ out:
 
 static int
 ecryptfs_rename(struct inode *old_dir, struct dentry *old_dentry,
-                struct inode *new_dir, struct dentry *new_dentry)
+                struct inode *new_dir, struct dentry *new_dentry,
+                unsigned int flags)
 {
         int rc;
         struct dentry *lower_old_dentry;
@@ -587,6 +588,9 @@ ecryptfs_rename(struct inode *old_dir, struct dentry *old_dentry,
         struct dentry *trap = NULL;
         struct inode *target_inode;
 
+        if (flags)
+                return -EINVAL;
+
         lower_old_dentry = ecryptfs_dentry_to_lower(old_dentry);
         lower_new_dentry = ecryptfs_dentry_to_lower(new_dentry);
         dget(lower_old_dentry);
diff --git a/fs/efivarfs/inode.c b/fs/efivarfs/inode.c
index cbb50cadcffc..71fccccf317e 100644
--- a/fs/efivarfs/inode.c
+++ b/fs/efivarfs/inode.c
@@ -24,7 +24,7 @@ struct inode *efivarfs_get_inode(struct super_block *sb,
         if (inode) {
                 inode->i_ino = get_next_ino();
                 inode->i_mode = mode;
-                inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
+                inode->i_atime = inode->i_mtime = inode->i_ctime = current_time(inode);
                 inode->i_flags = is_removable ? 0 : S_IMMUTABLE;
                 switch (mode & S_IFMT) {
                 case S_IFREG:
diff --git a/fs/exofs/dir.c b/fs/exofs/dir.c
index f69a1b5826a5..79101651fe9e 100644
--- a/fs/exofs/dir.c
+++ b/fs/exofs/dir.c
@@ -416,7 +416,7 @@ int exofs_set_link(struct inode *dir, struct exofs_dir_entry *de,
         if (likely(!err))
                 err = exofs_commit_chunk(page, pos, len);
         exofs_put_page(page);
-        dir->i_mtime = dir->i_ctime = CURRENT_TIME;
+        dir->i_mtime = dir->i_ctime = current_time(dir);
         mark_inode_dirty(dir);
         return err;
 }
@@ -503,7 +503,7 @@ got_it:
         de->inode_no = cpu_to_le64(inode->i_ino);
         exofs_set_de_type(de, inode);
         err = exofs_commit_chunk(page, pos, rec_len);
-        dir->i_mtime = dir->i_ctime = CURRENT_TIME;
+        dir->i_mtime = dir->i_ctime = current_time(dir);
         mark_inode_dirty(dir);
         sbi->s_numfiles++;
 
@@ -554,7 +554,7 @@ int exofs_delete_entry(struct exofs_dir_entry *dir, struct page *page)
         dir->inode_no = 0;
         if (likely(!err))
                 err = exofs_commit_chunk(page, pos, to - from);
-        inode->i_ctime = inode->i_mtime = CURRENT_TIME;
+        inode->i_ctime = inode->i_mtime = current_time(inode);
         mark_inode_dirty(inode);
         sbi->s_numfiles--;
 out:
diff --git a/fs/exofs/inode.c b/fs/exofs/inode.c
index 5e68daee5fe4..d42ff527ab21 100644
--- a/fs/exofs/inode.c
+++ b/fs/exofs/inode.c
@@ -1007,7 +1007,7 @@ static int _do_truncate(struct inode *inode, loff_t newsize)
         struct exofs_sb_info *sbi = inode->i_sb->s_fs_info;
         int ret;
 
-        inode->i_mtime = inode->i_ctime = CURRENT_TIME;
+        inode->i_mtime = inode->i_ctime = current_time(inode);
 
         ret = ore_truncate(&sbi->layout, &oi->oc, (u64)newsize);
         if (likely(!ret))
@@ -1313,7 +1313,7 @@ struct inode *exofs_new_inode(struct inode *dir, umode_t mode)
         inode_init_owner(inode, dir, mode);
         inode->i_ino = sbi->s_nextid++;
         inode->i_blkbits = EXOFS_BLKSHIFT;
-        inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
+        inode->i_mtime = inode->i_atime = inode->i_ctime = current_time(inode);
         oi->i_commit_size = inode->i_size = 0;
         spin_lock(&sbi->s_next_gen_lock);
         inode->i_generation = sbi->s_next_generation++;
diff --git a/fs/exofs/namei.c b/fs/exofs/namei.c
index 622a686bb08b..7295cd722770 100644
--- a/fs/exofs/namei.c
+++ b/fs/exofs/namei.c
@@ -142,7 +142,7 @@ static int exofs_link(struct dentry *old_dentry, struct inode *dir,
 {
         struct inode *inode = d_inode(old_dentry);
 
-        inode->i_ctime = CURRENT_TIME;
+        inode->i_ctime = current_time(inode);
         inode_inc_link_count(inode);
         ihold(inode);
 
@@ -227,7 +227,8 @@ static int exofs_rmdir(struct inode *dir, struct dentry *dentry)
 }
 
 static int exofs_rename(struct inode *old_dir, struct dentry *old_dentry,
-                struct inode *new_dir, struct dentry *new_dentry)
+                        struct inode *new_dir, struct dentry *new_dentry,
+                        unsigned int flags)
 {
         struct inode *old_inode = d_inode(old_dentry);
         struct inode *new_inode = d_inode(new_dentry);
@@ -237,6 +238,9 @@ static int exofs_rename(struct inode *old_dir, struct dentry *old_dentry,
         struct exofs_dir_entry *old_de;
         int err = -ENOENT;
 
+        if (flags & ~RENAME_NOREPLACE)
+                return -EINVAL;
+
         old_de = exofs_find_entry(old_dir, old_dentry, &old_page);
         if (!old_de)
                 goto out;
@@ -261,7 +265,7 @@ static int exofs_rename(struct inode *old_dir, struct dentry *old_dentry,
                 if (!new_de)
                         goto out_dir;
                 err = exofs_set_link(new_dir, new_de, new_page, old_inode);
-                new_inode->i_ctime = CURRENT_TIME;
+                new_inode->i_ctime = current_time(new_inode);
                 if (dir_de)
                         drop_nlink(new_inode);
                 inode_dec_link_count(new_inode);
@@ -275,7 +279,7 @@ static int exofs_rename(struct inode *old_dir, struct dentry *old_dentry,
                         inode_inc_link_count(new_dir);
         }
 
-        old_inode->i_ctime = CURRENT_TIME;
+        old_inode->i_ctime = current_time(old_inode);
 
         exofs_delete_entry(old_de, old_page);
         mark_inode_dirty(old_inode);
@@ -310,7 +314,7 @@ const struct inode_operations exofs_dir_inode_operations = {
         .mkdir          = exofs_mkdir,
         .rmdir          = exofs_rmdir,
         .mknod          = exofs_mknod,
-        .rename         = exofs_rename,
+        .rename         = exofs_rename,
         .setattr        = exofs_setattr,
 };
 
diff --git a/fs/ext2/acl.c b/fs/ext2/acl.c
index e725aa0890e0..79dafa71effd 100644
--- a/fs/ext2/acl.c
+++ b/fs/ext2/acl.c
@@ -193,7 +193,7 @@ ext2_set_acl(struct inode *inode, struct posix_acl *acl, int type)
                                 error = posix_acl_update_mode(inode, &inode->i_mode, &acl);
                                 if (error)
                                         return error;
-                                inode->i_ctime = CURRENT_TIME_SEC;
+                                inode->i_ctime = current_time(inode);
                                 mark_inode_dirty(inode);
                         }
                         break;
diff --git a/fs/ext2/dir.c b/fs/ext2/dir.c
index 61ad490ed67b..d9650c9508e4 100644
--- a/fs/ext2/dir.c
+++ b/fs/ext2/dir.c
@@ -471,7 +471,7 @@ void ext2_set_link(struct inode *dir, struct ext2_dir_entry_2 *de,
         err = ext2_commit_chunk(page, pos, len);
         ext2_put_page(page);
         if (update_times)
-                dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC;
+                dir->i_mtime = dir->i_ctime = current_time(dir);
         EXT2_I(dir)->i_flags &= ~EXT2_BTREE_FL;
         mark_inode_dirty(dir);
 }
@@ -561,7 +561,7 @@ got_it:
         de->inode = cpu_to_le32(inode->i_ino);
         ext2_set_de_type (de, inode);
         err = ext2_commit_chunk(page, pos, rec_len);
-        dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC;
+        dir->i_mtime = dir->i_ctime = current_time(dir);
         EXT2_I(dir)->i_flags &= ~EXT2_BTREE_FL;
         mark_inode_dirty(dir);
         /* OFFSET_CACHE */
@@ -610,7 +610,7 @@ int ext2_delete_entry (struct ext2_dir_entry_2 * dir, struct page * page )
                 pde->rec_len = ext2_rec_len_to_disk(to - from);
         dir->inode = 0;
         err = ext2_commit_chunk(page, pos, to - from);
-        inode->i_ctime = inode->i_mtime = CURRENT_TIME_SEC;
+        inode->i_ctime = inode->i_mtime = current_time(inode);
         EXT2_I(inode)->i_flags &= ~EXT2_BTREE_FL;
         mark_inode_dirty(inode);
 out:
diff --git a/fs/ext2/ialloc.c b/fs/ext2/ialloc.c
index 04e73a99902b..395fc074c0db 100644
--- a/fs/ext2/ialloc.c
+++ b/fs/ext2/ialloc.c
@@ -556,7 +556,7 @@ got:
 
         inode->i_ino = ino;
         inode->i_blocks = 0;
-        inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME_SEC;
+        inode->i_mtime = inode->i_atime = inode->i_ctime = current_time(inode);
         memset(ei->i_data, 0, sizeof(ei->i_data));
         ei->i_flags =
                 ext2_mask_flags(mode, EXT2_I(dir)->i_flags & EXT2_FL_INHERITED);
diff --git a/fs/ext2/inode.c b/fs/ext2/inode.c
index 6831534924e1..d831e24dc885 100644
--- a/fs/ext2/inode.c
+++ b/fs/ext2/inode.c
@@ -595,7 +595,7 @@ static void ext2_splice_branch(struct inode *inode,
         if (where->bh)
                 mark_buffer_dirty_inode(where->bh, inode);
 
-        inode->i_ctime = CURRENT_TIME_SEC;
+        inode->i_ctime = current_time(inode);
         mark_inode_dirty(inode);
 }
 
@@ -1308,7 +1308,7 @@ static int ext2_setsize(struct inode *inode, loff_t newsize)
         __ext2_truncate_blocks(inode, newsize);
         dax_sem_up_write(EXT2_I(inode));
 
-        inode->i_mtime = inode->i_ctime = CURRENT_TIME_SEC;
+        inode->i_mtime = inode->i_ctime = current_time(inode);
         if (inode_needs_sync(inode)) {
                 sync_mapping_buffers(inode->i_mapping);
                 sync_inode_metadata(inode, 1);
diff --git a/fs/ext2/ioctl.c b/fs/ext2/ioctl.c
index b386af2e45f4..9d617423e936 100644
--- a/fs/ext2/ioctl.c
+++ b/fs/ext2/ioctl.c
@@ -79,7 +79,7 @@ long ext2_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
                 ei->i_flags = flags;
 
                 ext2_set_inode_flags(inode);
-                inode->i_ctime = CURRENT_TIME_SEC;
+                inode->i_ctime = current_time(inode);
                 inode_unlock(inode);
 
                 mark_inode_dirty(inode);
@@ -103,7 +103,7 @@ setflags_out:
                 }
 
                 inode_lock(inode);
-                inode->i_ctime = CURRENT_TIME_SEC;
+                inode->i_ctime = current_time(inode);
                 inode->i_generation = generation;
                 inode_unlock(inode);
 
diff --git a/fs/ext2/namei.c b/fs/ext2/namei.c
index ff32ea799496..814e405a2da6 100644
--- a/fs/ext2/namei.c
+++ b/fs/ext2/namei.c
@@ -221,7 +221,7 @@ static int ext2_link (struct dentry * old_dentry, struct inode * dir,
         if (err)
                 return err;
 
-        inode->i_ctime = CURRENT_TIME_SEC;
+        inode->i_ctime = current_time(inode);
         inode_inc_link_count(inode);
         ihold(inode);
 
@@ -328,7 +328,8 @@ static int ext2_rmdir (struct inode * dir, struct dentry *dentry)
 }
 
 static int ext2_rename (struct inode * old_dir, struct dentry * old_dentry,
-        struct inode * new_dir, struct dentry * new_dentry )
+                        struct inode * new_dir, struct dentry * new_dentry,
+                        unsigned int flags)
 {
         struct inode * old_inode = d_inode(old_dentry);
         struct inode * new_inode = d_inode(new_dentry);
@@ -338,6 +339,9 @@ static int ext2_rename (struct inode * old_dir, struct dentry * old_dentry,
         struct ext2_dir_entry_2 * old_de;
         int err;
 
+        if (flags & ~RENAME_NOREPLACE)
+                return -EINVAL;
+
         err = dquot_initialize(old_dir);
         if (err)
                 goto out;
@@ -372,7 +376,7 @@ static int ext2_rename (struct inode * old_dir, struct dentry * old_dentry,
                 if (!new_de)
                         goto out_dir;
                 ext2_set_link(new_dir, new_de, new_page, old_inode, 1);
-                new_inode->i_ctime = CURRENT_TIME_SEC;
+                new_inode->i_ctime = current_time(new_inode);
                 if (dir_de)
                         drop_nlink(new_inode);
                 inode_dec_link_count(new_inode);
@@ -388,7 +392,7 @@ static int ext2_rename (struct inode * old_dir, struct dentry * old_dentry,
          * Like most other Unix systems, set the ctime for inodes on a
          * rename.
          */
-        old_inode->i_ctime = CURRENT_TIME_SEC;
+        old_inode->i_ctime = current_time(old_inode);
         mark_inode_dirty(old_inode);
 
         ext2_delete_entry (old_de, old_page);
diff --git a/fs/ext2/super.c b/fs/ext2/super.c
index 1d9379568aa8..6cb042b53b5b 100644
--- a/fs/ext2/super.c
+++ b/fs/ext2/super.c
@@ -1543,7 +1543,7 @@ out:
         if (inode->i_size < off+len-towrite)
                 i_size_write(inode, off+len-towrite);
         inode->i_version++;
-        inode->i_mtime = inode->i_ctime = CURRENT_TIME;
+        inode->i_mtime = inode->i_ctime = current_time(inode);
         mark_inode_dirty(inode);
         return len - towrite;
 }
diff --git a/fs/ext2/xattr.c b/fs/ext2/xattr.c
index b7f896f3f7a7..fbdb8f171893 100644
--- a/fs/ext2/xattr.c
+++ b/fs/ext2/xattr.c
@@ -691,7 +691,7 @@ ext2_xattr_set2(struct inode *inode, struct buffer_head *old_bh,
 
         /* Update the inode. */
         EXT2_I(inode)->i_file_acl = new_bh ? new_bh->b_blocknr : 0;
-        inode->i_ctime = CURRENT_TIME_SEC;
+        inode->i_ctime = current_time(inode);
         if (IS_SYNC(inode)) {
                 error = sync_inode_metadata(inode, 1);
                 /* In case sync failed due to ENOSPC the inode was actually
diff --git a/fs/ext4/namei.c b/fs/ext4/namei.c
index a73a9196b929..f92f10d4f66a 100644
--- a/fs/ext4/namei.c
+++ b/fs/ext4/namei.c
@@ -3878,7 +3878,7 @@ const struct inode_operations ext4_dir_inode_operations = {
         .rmdir          = ext4_rmdir,
         .mknod          = ext4_mknod,
         .tmpfile        = ext4_tmpfile,
-        .rename2        = ext4_rename2,
+        .rename         = ext4_rename2,
         .setattr        = ext4_setattr,
         .listxattr      = ext4_listxattr,
         .get_acl        = ext4_get_acl,
diff --git a/fs/f2fs/dir.c b/fs/f2fs/dir.c
index 12b5836a1033..369f4513be37 100644
--- a/fs/f2fs/dir.c
+++ b/fs/f2fs/dir.c
@@ -312,7 +312,7 @@ void f2fs_set_link(struct inode *dir, struct f2fs_dir_entry *de,
         f2fs_dentry_kunmap(dir, page);
         set_page_dirty(page);
 
-        dir->i_mtime = dir->i_ctime = CURRENT_TIME;
+        dir->i_mtime = dir->i_ctime = current_time(dir);
         f2fs_mark_inode_dirty_sync(dir);
         f2fs_put_page(page, 1);
 }
@@ -465,7 +465,7 @@ void update_parent_metadata(struct inode *dir, struct inode *inode,
                         f2fs_i_links_write(dir, true);
                 clear_inode_flag(inode, FI_NEW_INODE);
         }
-        dir->i_mtime = dir->i_ctime = CURRENT_TIME;
+        dir->i_mtime = dir->i_ctime = current_time(dir);
         f2fs_mark_inode_dirty_sync(dir);
 
         if (F2FS_I(dir)->i_current_depth != current_depth)
@@ -683,7 +683,7 @@ void f2fs_drop_nlink(struct inode *dir, struct inode *inode)
 
         if (S_ISDIR(inode->i_mode))
                 f2fs_i_links_write(dir, false);
-        inode->i_ctime = CURRENT_TIME;
+        inode->i_ctime = current_time(inode);
 
         f2fs_i_links_write(inode, false);
         if (S_ISDIR(inode->i_mode)) {
@@ -730,7 +730,7 @@ void f2fs_delete_entry(struct f2fs_dir_entry *dentry, struct page *page,
         kunmap(page); /* kunmap - pair of f2fs_find_entry */
         set_page_dirty(page);
 
-        dir->i_ctime = dir->i_mtime = CURRENT_TIME;
+        dir->i_ctime = dir->i_mtime = current_time(dir);
         f2fs_mark_inode_dirty_sync(dir);
 
         if (inode)
diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
index acdf4b929f97..c7865073cd26 100644
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -631,7 +631,7 @@ int f2fs_truncate(struct inode *inode)
         if (err)
                 return err;
 
-        inode->i_mtime = inode->i_ctime = CURRENT_TIME;
+        inode->i_mtime = inode->i_ctime = current_time(inode);
         f2fs_mark_inode_dirty_sync(inode);
         return 0;
 }
@@ -708,7 +708,7 @@ int f2fs_setattr(struct dentry *dentry, struct iattr *attr)
                                 if (err)
                                         return err;
                         }
-                        inode->i_mtime = inode->i_ctime = CURRENT_TIME;
+                        inode->i_mtime = inode->i_ctime = current_time(inode);
                 }
         }
 
@@ -1392,7 +1392,7 @@ static long f2fs_fallocate(struct file *file, int mode,
         }
 
         if (!ret) {
-                inode->i_mtime = inode->i_ctime = CURRENT_TIME;
+                inode->i_mtime = inode->i_ctime = current_time(inode);
                 f2fs_mark_inode_dirty_sync(inode);
                 f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
         }
@@ -1484,7 +1484,7 @@ static int f2fs_ioc_setflags(struct file *filp, unsigned long arg)
         fi->i_flags = flags;
         inode_unlock(inode);
 
-        inode->i_ctime = CURRENT_TIME;
+        inode->i_ctime = current_time(inode);
         f2fs_set_inode_flags(inode);
 out:
         mnt_drop_write_file(filp);
diff --git a/fs/f2fs/inline.c b/fs/f2fs/inline.c
index 34234d84a38b..5f1a67f756af 100644
--- a/fs/f2fs/inline.c
+++ b/fs/f2fs/inline.c
@@ -572,7 +572,7 @@ void f2fs_delete_inline_entry(struct f2fs_dir_entry *dentry, struct page *page,
         set_page_dirty(page);
         f2fs_put_page(page, 1);
 
-        dir->i_ctime = dir->i_mtime = CURRENT_TIME;
+        dir->i_ctime = dir->i_mtime = current_time(dir);
         f2fs_mark_inode_dirty_sync(dir);
 
         if (inode)
diff --git a/fs/f2fs/namei.c b/fs/f2fs/namei.c
index e80ed0302c22..489fa0d5f914 100644
--- a/fs/f2fs/namei.c
+++ b/fs/f2fs/namei.c
@@ -46,7 +46,7 @@ static struct inode *f2fs_new_inode(struct inode *dir, umode_t mode)
 
         inode->i_ino = ino;
         inode->i_blocks = 0;
-        inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
+        inode->i_mtime = inode->i_atime = inode->i_ctime = current_time(inode);
         inode->i_generation = sbi->s_next_generation++;
 
         err = insert_inode_locked(inode);
@@ -182,7 +182,7 @@ static int f2fs_link(struct dentry *old_dentry, struct inode *dir,
 
         f2fs_balance_fs(sbi, true);
 
-        inode->i_ctime = CURRENT_TIME;
+        inode->i_ctime = current_time(inode);
         ihold(inode);
 
         set_inode_flag(inode, FI_INC_LINK);
@@ -723,7 +723,7 @@ static int f2fs_rename(struct inode *old_dir, struct dentry *old_dentry,
 
                 f2fs_set_link(new_dir, new_entry, new_page, old_inode);
 
-                new_inode->i_ctime = CURRENT_TIME;
+                new_inode->i_ctime = current_time(new_inode);
                 down_write(&F2FS_I(new_inode)->i_sem);
                 if (old_dir_entry)
                         f2fs_i_links_write(new_inode, false);
@@ -777,7 +777,7 @@ static int f2fs_rename(struct inode *old_dir, struct dentry *old_dentry,
                 file_set_enc_name(old_inode);
         up_write(&F2FS_I(old_inode)->i_sem);
 
-        old_inode->i_ctime = CURRENT_TIME;
+        old_inode->i_ctime = current_time(old_inode);
         f2fs_mark_inode_dirty_sync(old_inode);
 
         f2fs_delete_entry(old_entry, old_page, old_dir, NULL);
@@ -932,7 +932,7 @@ static int f2fs_cross_rename(struct inode *old_dir, struct dentry *old_dentry,
         file_lost_pino(old_inode);
         up_write(&F2FS_I(old_inode)->i_sem);
 
-        old_dir->i_ctime = CURRENT_TIME;
+        old_dir->i_ctime = current_time(old_dir);
         if (old_nlink) {
                 down_write(&F2FS_I(old_dir)->i_sem);
                 f2fs_i_links_write(old_dir, old_nlink > 0);
@@ -947,7 +947,7 @@ static int f2fs_cross_rename(struct inode *old_dir, struct dentry *old_dentry,
         file_lost_pino(new_inode);
         up_write(&F2FS_I(new_inode)->i_sem);
 
-        new_dir->i_ctime = CURRENT_TIME;
+        new_dir->i_ctime = current_time(new_dir);
         if (new_nlink) {
                 down_write(&F2FS_I(new_dir)->i_sem);
                 f2fs_i_links_write(new_dir, new_nlink > 0);
@@ -1093,7 +1093,7 @@ const struct inode_operations f2fs_dir_inode_operations = {
         .mkdir          = f2fs_mkdir,
         .rmdir          = f2fs_rmdir,
         .mknod          = f2fs_mknod,
-        .rename2        = f2fs_rename2,
+        .rename         = f2fs_rename2,
         .tmpfile        = f2fs_tmpfile,
         .getattr        = f2fs_getattr,
         .setattr        = f2fs_setattr,
diff --git a/fs/f2fs/xattr.c b/fs/f2fs/xattr.c
index 1f74876233b6..3e1c0280f866 100644
--- a/fs/f2fs/xattr.c
+++ b/fs/f2fs/xattr.c
@@ -548,7 +548,7 @@ static int __f2fs_setxattr(struct inode *inode, int index,
 
         if (is_inode_flag_set(inode, FI_ACL_MODE)) {
                 inode->i_mode = F2FS_I(inode)->i_acl_mode;
-                inode->i_ctime = CURRENT_TIME;
+                inode->i_ctime = current_time(inode);
                 clear_inode_flag(inode, FI_ACL_MODE);
         }
         if (index == F2FS_XATTR_INDEX_ENCRYPTION &&
diff --git a/fs/fat/dir.c b/fs/fat/dir.c
index 663e428596c6..81cecbe6d7cf 100644
--- a/fs/fat/dir.c
+++ b/fs/fat/dir.c
@@ -1071,7 +1071,7 @@ int fat_remove_entries(struct inode *dir, struct fat_slot_info *sinfo)
                 }
         }
 
-        dir->i_mtime = dir->i_atime = CURRENT_TIME_SEC;
+        dir->i_mtime = dir->i_atime = current_time(dir);
         if (IS_DIRSYNC(dir))
                 (void)fat_sync_inode(dir);
         else
diff --git a/fs/fat/file.c b/fs/fat/file.c
index c09ab4e108e5..3d04b124bce0 100644
--- a/fs/fat/file.c
+++ b/fs/fat/file.c
@@ -63,7 +63,7 @@ static int fat_ioctl_set_attributes(struct file *file, u32 __user *user_attr)
 
         /* Equivalent to a chmod() */
         ia.ia_valid = ATTR_MODE | ATTR_CTIME;
-        ia.ia_ctime = current_fs_time(inode->i_sb);
+        ia.ia_ctime = current_time(inode);
         if (is_dir)
                 ia.ia_mode = fat_make_mode(sbi, attr, S_IRWXUGO);
         else {
@@ -194,7 +194,7 @@ static int fat_cont_expand(struct inode *inode, loff_t size)
         if (err)
                 goto out;
 
-        inode->i_ctime = inode->i_mtime = CURRENT_TIME_SEC;
+        inode->i_ctime = inode->i_mtime = current_time(inode);
         mark_inode_dirty(inode);
         if (IS_SYNC(inode)) {
                 int err2;
@@ -297,7 +297,7 @@ static int fat_free(struct inode *inode, int skip)
                 MSDOS_I(inode)->i_logstart = 0;
         }
         MSDOS_I(inode)->i_attrs |= ATTR_ARCH;
-        inode->i_ctime = inode->i_mtime = CURRENT_TIME_SEC;
+        inode->i_ctime = inode->i_mtime = current_time(inode);
         if (wait) {
                 err = fat_sync_inode(inode);
                 if (err) {
diff --git a/fs/fat/inode.c b/fs/fat/inode.c
index da04c0298fab..338d2f73eb29 100644
--- a/fs/fat/inode.c
+++ b/fs/fat/inode.c
@@ -237,7 +237,7 @@ static int fat_write_end(struct file *file, struct address_space *mapping,
         if (err < len)
                 fat_write_failed(mapping, pos + len);
         if (!(err < 0) && !(MSDOS_I(inode)->i_attrs & ATTR_ARCH)) {
-                inode->i_mtime = inode->i_ctime = CURRENT_TIME_SEC;
+                inode->i_mtime = inode->i_ctime = current_time(inode);
                 MSDOS_I(inode)->i_attrs |= ATTR_ARCH;
                 mark_inode_dirty(inode);
         }
diff --git a/fs/fat/namei_msdos.c b/fs/fat/namei_msdos.c
index 664655b2c55f..7d6a105d601b 100644
--- a/fs/fat/namei_msdos.c
+++ b/fs/fat/namei_msdos.c
@@ -283,7 +283,7 @@ static int msdos_create(struct inode *dir, struct dentry *dentry, umode_t mode,
                 goto out;
         }
 
-        ts = CURRENT_TIME_SEC;
+        ts = current_time(dir);
         err = msdos_add_entry(dir, msdos_name, 0, is_hid, 0, &ts, &sinfo);
         if (err)
                 goto out;
@@ -330,7 +330,7 @@ static int msdos_rmdir(struct inode *dir, struct dentry *dentry)
         drop_nlink(dir);
 
         clear_nlink(inode);
-        inode->i_ctime = CURRENT_TIME_SEC;
+        inode->i_ctime = current_time(inode);
         fat_detach(inode);
 out:
         mutex_unlock(&MSDOS_SB(sb)->s_lock);
@@ -364,7 +364,7 @@ static int msdos_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
                 goto out;
         }
 
-        ts = CURRENT_TIME_SEC;
+        ts = current_time(dir);
         cluster = fat_alloc_new_dir(dir, &ts);
         if (cluster < 0) {
                 err = cluster;
@@ -416,7 +416,7 @@ static int msdos_unlink(struct inode *dir, struct dentry *dentry)
         if (err)
                 goto out;
         clear_nlink(inode);
-        inode->i_ctime = CURRENT_TIME_SEC;
+        inode->i_ctime = current_time(inode);
         fat_detach(inode);
 out:
         mutex_unlock(&MSDOS_SB(sb)->s_lock);
@@ -481,7 +481,7 @@ static int do_msdos_rename(struct inode *old_dir, unsigned char *old_name,
                                 mark_inode_dirty(old_inode);
 
                         old_dir->i_version++;
-                        old_dir->i_ctime = old_dir->i_mtime = CURRENT_TIME_SEC;
+                        old_dir->i_ctime = old_dir->i_mtime = current_time(old_dir);
                         if (IS_DIRSYNC(old_dir))
                                 (void)fat_sync_inode(old_dir);
                         else
@@ -490,7 +490,7 @@ static int do_msdos_rename(struct inode *old_dir, unsigned char *old_name,
                 }
         }
 
-        ts = CURRENT_TIME_SEC;
+        ts = current_time(old_inode);
         if (new_inode) {
                 if (err)
                         goto out;
@@ -596,12 +596,16 @@ error_inode:
 
 /***** Rename, a wrapper for rename_same_dir & rename_diff_dir */
 static int msdos_rename(struct inode *old_dir, struct dentry *old_dentry,
-                        struct inode *new_dir, struct dentry *new_dentry)
+                        struct inode *new_dir, struct dentry *new_dentry,
+                        unsigned int flags)
 {
         struct super_block *sb = old_dir->i_sb;
         unsigned char old_msdos_name[MSDOS_NAME], new_msdos_name[MSDOS_NAME];
         int err, is_hid;
 
+        if (flags & ~RENAME_NOREPLACE)
+                return -EINVAL;
+
         mutex_lock(&MSDOS_SB(sb)->s_lock);
 
         err = msdos_format_name(old_dentry->d_name.name,
diff --git a/fs/fat/namei_vfat.c b/fs/fat/namei_vfat.c
index 4afdc3f36470..6a7152d0c250 100644
--- a/fs/fat/namei_vfat.c
+++ b/fs/fat/namei_vfat.c
@@ -788,7 +788,7 @@ static int vfat_create(struct inode *dir, struct dentry *dentry, umode_t mode,
 
         mutex_lock(&MSDOS_SB(sb)->s_lock);
 
-        ts = CURRENT_TIME_SEC;
+        ts = current_time(dir);
         err = vfat_add_entry(dir, &dentry->d_name, 0, 0, &ts, &sinfo);
         if (err)
                 goto out;
@@ -832,7 +832,7 @@ static int vfat_rmdir(struct inode *dir, struct dentry *dentry)
         drop_nlink(dir);
 
         clear_nlink(inode);
-        inode->i_mtime = inode->i_atime = CURRENT_TIME_SEC;
+        inode->i_mtime = inode->i_atime = current_time(inode);
         fat_detach(inode);
         vfat_d_version_set(dentry, dir->i_version);
 out:
@@ -858,7 +858,7 @@ static int vfat_unlink(struct inode *dir, struct dentry *dentry)
         if (err)
                 goto out;
         clear_nlink(inode);
-        inode->i_mtime = inode->i_atime = CURRENT_TIME_SEC;
+        inode->i_mtime = inode->i_atime = current_time(inode);
         fat_detach(inode);
         vfat_d_version_set(dentry, dir->i_version);
 out:
@@ -877,7 +877,7 @@ static int vfat_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
 
         mutex_lock(&MSDOS_SB(sb)->s_lock);
 
-        ts = CURRENT_TIME_SEC;
+        ts = current_time(dir);
         cluster = fat_alloc_new_dir(dir, &ts);
         if (cluster < 0) {
                 err = cluster;
@@ -914,7 +914,8 @@ out:
 }
 
 static int vfat_rename(struct inode *old_dir, struct dentry *old_dentry,
-                       struct inode *new_dir, struct dentry *new_dentry)
+                       struct inode *new_dir, struct dentry *new_dentry,
+                       unsigned int flags)
 {
         struct buffer_head *dotdot_bh;
         struct msdos_dir_entry *dotdot_de;
@@ -925,6 +926,9 @@ static int vfat_rename(struct inode *old_dir, struct dentry *old_dentry,
         int err, is_dir, update_dotdot, corrupt = 0;
         struct super_block *sb = old_dir->i_sb;
 
+        if (flags & ~RENAME_NOREPLACE)
+                return -EINVAL;
+
         old_sinfo.bh = sinfo.bh = dotdot_bh = NULL;
         old_inode = d_inode(old_dentry);
         new_inode = d_inode(new_dentry);
@@ -942,7 +946,7 @@ static int vfat_rename(struct inode *old_dir, struct dentry *old_dentry,
                 }
         }
 
-        ts = CURRENT_TIME_SEC;
+        ts = current_time(old_dir);
         if (new_inode) {
                 if (is_dir) {
                         err = fat_dir_empty(new_inode);
diff --git a/fs/fuse/control.c b/fs/fuse/control.c
index f863ac6647ac..6e22748b0704 100644
--- a/fs/fuse/control.c
+++ b/fs/fuse/control.c
@@ -220,7 +220,7 @@ static struct dentry *fuse_ctl_add_dentry(struct dentry *parent,
         inode->i_mode = mode;
         inode->i_uid = fc->user_id;
         inode->i_gid = fc->group_id;
-        inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
+        inode->i_atime = inode->i_mtime = inode->i_ctime = current_time(inode);
         /* setting ->i_op to NULL is not allowed */
         if (iop)
                 inode->i_op = iop;
diff --git a/fs/fuse/dir.c b/fs/fuse/dir.c
index 572d12410c7c..6a4d0e5418a1 100644
--- a/fs/fuse/dir.c
+++ b/fs/fuse/dir.c
@@ -647,7 +647,7 @@ static int fuse_symlink(struct inode *dir, struct dentry *entry,
 void fuse_update_ctime(struct inode *inode)
 {
         if (!IS_NOCMTIME(inode)) {
-                inode->i_ctime = current_fs_time(inode->i_sb);
+                inode->i_ctime = current_time(inode);
                 mark_inode_dirty_sync(inode);
         }
 }
@@ -1793,7 +1793,7 @@ static const struct inode_operations fuse_dir_inode_operations = {
         .symlink        = fuse_symlink,
         .unlink         = fuse_unlink,
         .rmdir          = fuse_rmdir,
-        .rename2        = fuse_rename2,
+        .rename         = fuse_rename2,
         .link           = fuse_link,
         .setattr        = fuse_setattr,
         .create         = fuse_create,
diff --git a/fs/gfs2/bmap.c b/fs/gfs2/bmap.c
index 645721f3ff00..fc5da4cbe88c 100644
--- a/fs/gfs2/bmap.c
+++ b/fs/gfs2/bmap.c
@@ -836,7 +836,7 @@ static int do_strip(struct gfs2_inode *ip, struct buffer_head *dibh,
         gfs2_quota_change(ip, -(s64)btotal, ip->i_inode.i_uid,
                           ip->i_inode.i_gid);
 
-        ip->i_inode.i_mtime = ip->i_inode.i_ctime = CURRENT_TIME;
+        ip->i_inode.i_mtime = ip->i_inode.i_ctime = current_time(&ip->i_inode);
 
         gfs2_dinode_out(ip, dibh->b_data);
 
@@ -1063,7 +1063,7 @@ static int trunc_start(struct inode *inode, u64 oldsize, u64 newsize)
         }
 
         i_size_write(inode, newsize);
-        ip->i_inode.i_mtime = ip->i_inode.i_ctime = CURRENT_TIME;
+        ip->i_inode.i_mtime = ip->i_inode.i_ctime = current_time(&ip->i_inode);
         gfs2_dinode_out(ip, dibh->b_data);
 
         if (journaled)
@@ -1142,7 +1142,7 @@ static int trunc_end(struct gfs2_inode *ip)
                 gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode));
                 gfs2_ordered_del_inode(ip);
         }
-        ip->i_inode.i_mtime = ip->i_inode.i_ctime = CURRENT_TIME;
+        ip->i_inode.i_mtime = ip->i_inode.i_ctime = current_time(&ip->i_inode);
         ip->i_diskflags &= ~GFS2_DIF_TRUNC_IN_PROG;
 
         gfs2_trans_add_meta(ip->i_gl, dibh);
@@ -1252,7 +1252,7 @@ static int do_grow(struct inode *inode, u64 size)
                 goto do_end_trans;
 
         i_size_write(inode, size);
-        ip->i_inode.i_mtime = ip->i_inode.i_ctime = CURRENT_TIME;
+        ip->i_inode.i_mtime = ip->i_inode.i_ctime = current_time(&ip->i_inode);
         gfs2_trans_add_meta(ip->i_gl, dibh);
         gfs2_dinode_out(ip, dibh->b_data);
         brelse(dibh);
diff --git a/fs/gfs2/dir.c b/fs/gfs2/dir.c
index db8fbeb62483..3cdde5f5d399 100644
--- a/fs/gfs2/dir.c
+++ b/fs/gfs2/dir.c
@@ -135,7 +135,7 @@ static int gfs2_dir_write_stuffed(struct gfs2_inode *ip, const char *buf,
         memcpy(dibh->b_data + offset + sizeof(struct gfs2_dinode), buf, size);
         if (ip->i_inode.i_size < offset + size)
                 i_size_write(&ip->i_inode, offset + size);
-        ip->i_inode.i_mtime = ip->i_inode.i_ctime = CURRENT_TIME;
+        ip->i_inode.i_mtime = ip->i_inode.i_ctime = current_time(&ip->i_inode);
         gfs2_dinode_out(ip, dibh->b_data);
 
         brelse(dibh);
@@ -233,7 +233,7 @@ out:
 
         if (ip->i_inode.i_size < offset + copied)
                 i_size_write(&ip->i_inode, offset + copied);
-        ip->i_inode.i_mtime = ip->i_inode.i_ctime = CURRENT_TIME;
+        ip->i_inode.i_mtime = ip->i_inode.i_ctime = current_time(&ip->i_inode);
 
         gfs2_trans_add_meta(ip->i_gl, dibh);
         gfs2_dinode_out(ip, dibh->b_data);
@@ -872,7 +872,7 @@ static struct gfs2_leaf *new_leaf(struct inode *inode, struct buffer_head **pbh,
         struct gfs2_leaf *leaf;
         struct gfs2_dirent *dent;
         struct qstr name = { .name = "" };
-        struct timespec tv = CURRENT_TIME;
+        struct timespec tv = current_time(inode);
 
         error = gfs2_alloc_blocks(ip, &bn, &n, 0, NULL);
         if (error)
@@ -1816,7 +1816,7 @@ int gfs2_dir_add(struct inode *inode, const struct qstr *name,
                         gfs2_inum_out(nip, dent);
                         dent->de_type = cpu_to_be16(IF2DT(nip->i_inode.i_mode));
                         dent->de_rahead = cpu_to_be16(gfs2_inode_ra_len(nip));
-                        tv = CURRENT_TIME;
+                        tv = current_time(&ip->i_inode);
                         if (ip->i_diskflags & GFS2_DIF_EXHASH) {
                                 leaf = (struct gfs2_leaf *)bh->b_data;
                                 be16_add_cpu(&leaf->lf_entries, 1);
@@ -1878,7 +1878,7 @@ int gfs2_dir_del(struct gfs2_inode *dip, const struct dentry *dentry)
         const struct qstr *name = &dentry->d_name;
         struct gfs2_dirent *dent, *prev = NULL;
         struct buffer_head *bh;
-        struct timespec tv = CURRENT_TIME;
+        struct timespec tv = current_time(&dip->i_inode);
 
         /* Returns _either_ the entry (if its first in block) or the
            previous entry otherwise */
@@ -1960,7 +1960,7 @@ int gfs2_dir_mvino(struct gfs2_inode *dip, const struct qstr *filename,
                 gfs2_trans_add_meta(dip->i_gl, bh);
         }
 
-        dip->i_inode.i_mtime = dip->i_inode.i_ctime = CURRENT_TIME;
+        dip->i_inode.i_mtime = dip->i_inode.i_ctime = current_time(&dip->i_inode);
         gfs2_dinode_out(dip, bh->b_data);
         brelse(bh);
         return 0;
diff --git a/fs/gfs2/inode.c b/fs/gfs2/inode.c
index f6c4f0058899..fe3f84995c48 100644
--- a/fs/gfs2/inode.c
+++ b/fs/gfs2/inode.c
@@ -656,7 +656,7 @@ static int gfs2_create_inode(struct inode *dir, struct dentry *dentry,
         set_nlink(inode, S_ISDIR(mode) ? 2 : 1);
         inode->i_rdev = dev;
         inode->i_size = size;
-        inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
+        inode->i_atime = inode->i_mtime = inode->i_ctime = current_time(inode);
         gfs2_set_inode_blocks(inode, 1);
         munge_mode_uid_gid(dip, inode);
         check_and_update_goal(dip);
@@ -983,7 +983,7 @@ static int gfs2_link(struct dentry *old_dentry, struct inode *dir,
 
         gfs2_trans_add_meta(ip->i_gl, dibh);
         inc_nlink(&ip->i_inode);
-        ip->i_inode.i_ctime = CURRENT_TIME;
+        ip->i_inode.i_ctime = current_time(&ip->i_inode);
         ihold(inode);
         d_instantiate(dentry, inode);
         mark_inode_dirty(inode);
@@ -1067,7 +1067,7 @@ static int gfs2_unlink_inode(struct gfs2_inode *dip,
                 return error;
 
         ip->i_entries = 0;
-        inode->i_ctime = CURRENT_TIME;
+        inode->i_ctime = current_time(inode);
         if (S_ISDIR(inode->i_mode))
                 clear_nlink(inode);
         else
@@ -1330,7 +1330,7 @@ static int update_moved_ino(struct gfs2_inode *ip, struct gfs2_inode *ndip,
         error = gfs2_meta_inode_buffer(ip, &dibh);
         if (error)
                 return error;
-        ip->i_inode.i_ctime = CURRENT_TIME;
+        ip->i_inode.i_ctime = current_time(&ip->i_inode);
         gfs2_trans_add_meta(ip->i_gl, dibh);
         gfs2_dinode_out(ip, dibh->b_data);
         brelse(dibh);
@@ -2055,7 +2055,7 @@ const struct inode_operations gfs2_dir_iops = {
         .mkdir = gfs2_mkdir,
         .rmdir = gfs2_unlink,
         .mknod = gfs2_mknod,
-        .rename2 = gfs2_rename2,
+        .rename = gfs2_rename2,
         .permission = gfs2_permission,
         .setattr = gfs2_setattr,
         .getattr = gfs2_getattr,
diff --git a/fs/gfs2/quota.c b/fs/gfs2/quota.c
index 8af2dfa09236..c2ca9566b764 100644
--- a/fs/gfs2/quota.c
+++ b/fs/gfs2/quota.c
@@ -854,7 +854,7 @@ static int gfs2_adjust_quota(struct gfs2_inode *ip, loff_t loc,
                 size = loc + sizeof(struct gfs2_quota);
                 if (size > inode->i_size)
                         i_size_write(inode, size);
-                inode->i_mtime = inode->i_atime = CURRENT_TIME;
+                inode->i_mtime = inode->i_atime = current_time(inode);
                 mark_inode_dirty(inode);
                 set_bit(QDF_REFRESH, &qd->qd_flags);
         }
diff --git a/fs/gfs2/xattr.c b/fs/gfs2/xattr.c
index 3a2853504084..a4a577088d19 100644
--- a/fs/gfs2/xattr.c
+++ b/fs/gfs2/xattr.c
@@ -309,7 +309,7 @@ static int ea_dealloc_unstuffed(struct gfs2_inode *ip, struct buffer_head *bh,
 
         error = gfs2_meta_inode_buffer(ip, &dibh);
         if (!error) {
-                ip->i_inode.i_ctime = CURRENT_TIME;
+                ip->i_inode.i_ctime = current_time(&ip->i_inode);
                 gfs2_trans_add_meta(ip->i_gl, dibh);
                 gfs2_dinode_out(ip, dibh->b_data);
                 brelse(dibh);
@@ -775,7 +775,7 @@ static int ea_alloc_skeleton(struct gfs2_inode *ip, struct gfs2_ea_request *er,
 
         error = gfs2_meta_inode_buffer(ip, &dibh);
         if (!error) {
-                ip->i_inode.i_ctime = CURRENT_TIME;
+                ip->i_inode.i_ctime = current_time(&ip->i_inode);
                 gfs2_trans_add_meta(ip->i_gl, dibh);
                 gfs2_dinode_out(ip, dibh->b_data);
                 brelse(dibh);
@@ -910,7 +910,7 @@ static int ea_set_simple_noalloc(struct gfs2_inode *ip, struct buffer_head *bh,
         error = gfs2_meta_inode_buffer(ip, &dibh);
         if (error)
                 goto out;
-        ip->i_inode.i_ctime = CURRENT_TIME;
+        ip->i_inode.i_ctime = current_time(&ip->i_inode);
         gfs2_trans_add_meta(ip->i_gl, dibh);
         gfs2_dinode_out(ip, dibh->b_data);
         brelse(dibh);
@@ -1133,7 +1133,7 @@ static int ea_remove_stuffed(struct gfs2_inode *ip, struct gfs2_ea_location *el)
 
         error = gfs2_meta_inode_buffer(ip, &dibh);
         if (!error) {
-                ip->i_inode.i_ctime = CURRENT_TIME;
+                ip->i_inode.i_ctime = current_time(&ip->i_inode);
                 gfs2_trans_add_meta(ip->i_gl, dibh);
                 gfs2_dinode_out(ip, dibh->b_data);
                 brelse(dibh);
diff --git a/fs/hfs/catalog.c b/fs/hfs/catalog.c
index 8f4afd3f5108..8a66405b0f8b 100644
--- a/fs/hfs/catalog.c
+++ b/fs/hfs/catalog.c
@@ -125,7 +125,7 @@ int hfs_cat_create(u32 cnid, struct inode *dir, const struct qstr *str, struct i
                 goto err1;
 
         dir->i_size++;
-        dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC;
+        dir->i_mtime = dir->i_ctime = current_time(dir);
         mark_inode_dirty(dir);
         hfs_find_exit(&fd);
         return 0;
@@ -261,7 +261,7 @@ int hfs_cat_delete(u32 cnid, struct inode *dir, const struct qstr *str)
         }
 
         dir->i_size--;
-        dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC;
+        dir->i_mtime = dir->i_ctime = current_time(dir);
         mark_inode_dirty(dir);
         res = 0;
 out:
@@ -321,7 +321,7 @@ int hfs_cat_move(u32 cnid, struct inode *src_dir, const struct qstr *src_name,
         if (err)
                 goto out;
         dst_dir->i_size++;
-        dst_dir->i_mtime = dst_dir->i_ctime = CURRENT_TIME_SEC;
+        dst_dir->i_mtime = dst_dir->i_ctime = current_time(dst_dir);
         mark_inode_dirty(dst_dir);
 
         /* finally remove the old entry */
@@ -333,7 +333,7 @@ int hfs_cat_move(u32 cnid, struct inode *src_dir, const struct qstr *src_name,
         if (err)
                 goto out;
         src_dir->i_size--;
-        src_dir->i_mtime = src_dir->i_ctime = CURRENT_TIME_SEC;
+        src_dir->i_mtime = src_dir->i_ctime = current_time(src_dir);
         mark_inode_dirty(src_dir);
 
         type = entry.type;
diff --git a/fs/hfs/dir.c b/fs/hfs/dir.c
index 163190ecc0d2..5de5c48b418d 100644
--- a/fs/hfs/dir.c
+++ b/fs/hfs/dir.c
@@ -268,7 +268,7 @@ static int hfs_remove(struct inode *dir, struct dentry *dentry)
         if (res)
                 return res;
         clear_nlink(inode);
-        inode->i_ctime = CURRENT_TIME_SEC;
+        inode->i_ctime = current_time(inode);
         hfs_delete_inode(inode);
         mark_inode_dirty(inode);
         return 0;
@@ -286,10 +286,14 @@ static int hfs_remove(struct inode *dir, struct dentry *dentry)
  * XXX: how do you handle must_be dir?
  */
 static int hfs_rename(struct inode *old_dir, struct dentry *old_dentry,
-                      struct inode *new_dir, struct dentry *new_dentry)
+                      struct inode *new_dir, struct dentry *new_dentry,
+                      unsigned int flags)
 {
         int res;
 
+        if (flags & ~RENAME_NOREPLACE)
+                return -EINVAL;
+
         /* Unlink destination if it already exists */
         if (d_really_is_positive(new_dentry)) {
                 res = hfs_remove(new_dir, new_dentry);
diff --git a/fs/hfs/inode.c b/fs/hfs/inode.c
index ed373261f26d..f776acf2378a 100644
--- a/fs/hfs/inode.c
+++ b/fs/hfs/inode.c
@@ -194,7 +194,7 @@ struct inode *hfs_new_inode(struct inode *dir, const struct qstr *name, umode_t
         inode->i_uid = current_fsuid();
         inode->i_gid = current_fsgid();
         set_nlink(inode, 1);
-        inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME_SEC;
+        inode->i_mtime = inode->i_atime = inode->i_ctime = current_time(inode);
         HFS_I(inode)->flags = 0;
         HFS_I(inode)->rsrc_inode = NULL;
         HFS_I(inode)->fs_blocks = 0;
diff --git a/fs/hfsplus/catalog.c b/fs/hfsplus/catalog.c
index 142534d3c2d5..a5e00f7a4c14 100644
--- a/fs/hfsplus/catalog.c
+++ b/fs/hfsplus/catalog.c
@@ -303,7 +303,7 @@ int hfsplus_create_cat(u32 cnid, struct inode *dir,
         dir->i_size++;
         if (S_ISDIR(inode->i_mode))
                 hfsplus_subfolders_inc(dir);
-        dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC;
+        dir->i_mtime = dir->i_ctime = current_time(dir);
         hfsplus_mark_inode_dirty(dir, HFSPLUS_I_CAT_DIRTY);
 
         hfs_find_exit(&fd);
@@ -400,7 +400,7 @@ int hfsplus_delete_cat(u32 cnid, struct inode *dir, const struct qstr *str)
         dir->i_size--;
         if (type == HFSPLUS_FOLDER)
                 hfsplus_subfolders_dec(dir);
-        dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC;
+        dir->i_mtime = dir->i_ctime = current_time(dir);
         hfsplus_mark_inode_dirty(dir, HFSPLUS_I_CAT_DIRTY);
 
         if (type == HFSPLUS_FILE || type == HFSPLUS_FOLDER) {
@@ -469,7 +469,7 @@ int hfsplus_rename_cat(u32 cnid,
         dst_dir->i_size++;
         if (type == HFSPLUS_FOLDER)
                 hfsplus_subfolders_inc(dst_dir);
-        dst_dir->i_mtime = dst_dir->i_ctime = CURRENT_TIME_SEC;
+        dst_dir->i_mtime = dst_dir->i_ctime = current_time(dst_dir);
 
         /* finally remove the old entry */
         err = hfsplus_cat_build_key(sb, src_fd.search_key,
@@ -486,7 +486,7 @@ int hfsplus_rename_cat(u32 cnid,
         src_dir->i_size--;
         if (type == HFSPLUS_FOLDER)
                 hfsplus_subfolders_dec(src_dir);
-        src_dir->i_mtime = src_dir->i_ctime = CURRENT_TIME_SEC;
+        src_dir->i_mtime = src_dir->i_ctime = current_time(src_dir);
 
         /* remove old thread entry */
         hfsplus_cat_build_key_with_cnid(sb, src_fd.search_key, cnid);
diff --git a/fs/hfsplus/dir.c b/fs/hfsplus/dir.c
index 9cbe43075de5..31d5e3f1fe17 100644
--- a/fs/hfsplus/dir.c
+++ b/fs/hfsplus/dir.c
@@ -347,7 +347,7 @@ static int hfsplus_link(struct dentry *src_dentry, struct inode *dst_dir,
         inc_nlink(inode);
         hfsplus_instantiate(dst_dentry, inode, cnid);
         ihold(inode);
-        inode->i_ctime = CURRENT_TIME_SEC;
+        inode->i_ctime = current_time(inode);
         mark_inode_dirty(inode);
         sbi->file_count++;
         hfsplus_mark_mdb_dirty(dst_dir->i_sb);
@@ -406,7 +406,7 @@ static int hfsplus_unlink(struct inode *dir, struct dentry *dentry)
                         hfsplus_delete_inode(inode);
         } else
                 sbi->file_count--;
-        inode->i_ctime = CURRENT_TIME_SEC;
+        inode->i_ctime = current_time(inode);
         mark_inode_dirty(inode);
 out:
         mutex_unlock(&sbi->vh_mutex);
@@ -427,7 +427,7 @@ static int hfsplus_rmdir(struct inode *dir, struct dentry *dentry)
         if (res)
                 goto out;
         clear_nlink(inode);
-        inode->i_ctime = CURRENT_TIME_SEC;
+        inode->i_ctime = current_time(inode);
         hfsplus_delete_inode(inode);
         mark_inode_dirty(inode);
 out:
@@ -530,10 +530,14 @@ static int hfsplus_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
 }
 
 static int hfsplus_rename(struct inode *old_dir, struct dentry *old_dentry,
-                          struct inode *new_dir, struct dentry *new_dentry)
+                          struct inode *new_dir, struct dentry *new_dentry,
+                          unsigned int flags)
 {
         int res;
 
+        if (flags & ~RENAME_NOREPLACE)
+                return -EINVAL;
+
         /* Unlink destination if it already exists */
         if (d_really_is_positive(new_dentry)) {
                 if (d_is_dir(new_dentry))
diff --git a/fs/hfsplus/inode.c b/fs/hfsplus/inode.c
index 10827c912c4d..2e796f8302ff 100644
--- a/fs/hfsplus/inode.c
+++ b/fs/hfsplus/inode.c
@@ -366,7 +366,7 @@ struct inode *hfsplus_new_inode(struct super_block *sb, umode_t mode)
         inode->i_uid = current_fsuid();
         inode->i_gid = current_fsgid();
         set_nlink(inode, 1);
-        inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME_SEC;
+        inode->i_mtime = inode->i_atime = inode->i_ctime = current_time(inode);
 
         hip = HFSPLUS_I(inode);
         INIT_LIST_HEAD(&hip->open_dir_list);
diff --git a/fs/hfsplus/ioctl.c b/fs/hfsplus/ioctl.c
index 32a49e292b6a..99627f8a0a18 100644
--- a/fs/hfsplus/ioctl.c
+++ b/fs/hfsplus/ioctl.c
@@ -122,7 +122,7 @@ static int hfsplus_ioctl_setflags(struct file *file, int __user *user_flags)
         else
                 hip->userflags &= ~HFSPLUS_FLG_NODUMP;
 
-        inode->i_ctime = CURRENT_TIME_SEC;
+        inode->i_ctime = current_time(inode);
         mark_inode_dirty(inode);
 
 out_unlock_inode:
diff --git a/fs/hostfs/hostfs_kern.c b/fs/hostfs/hostfs_kern.c
index 44aa96ba1df8..23e15ea53e45 100644
--- a/fs/hostfs/hostfs_kern.c
+++ b/fs/hostfs/hostfs_kern.c
@@ -885,7 +885,7 @@ static const struct inode_operations hostfs_dir_iops = {
         .mkdir          = hostfs_mkdir,
         .rmdir          = hostfs_rmdir,
         .mknod          = hostfs_mknod,
-        .rename2        = hostfs_rename2,
+        .rename         = hostfs_rename2,
         .permission     = hostfs_permission,
         .setattr        = hostfs_setattr,
 };
diff --git a/fs/hpfs/namei.c b/fs/hpfs/namei.c
index bb8d67e2740a..f30c14414518 100644
--- a/fs/hpfs/namei.c
+++ b/fs/hpfs/namei.c
@@ -507,7 +507,8 @@ const struct address_space_operations hpfs_symlink_aops = {
 };
         
 static int hpfs_rename(struct inode *old_dir, struct dentry *old_dentry,
-                struct inode *new_dir, struct dentry *new_dentry)
+                       struct inode *new_dir, struct dentry *new_dentry,
+                       unsigned int flags)
 {
         const unsigned char *old_name = old_dentry->d_name.name;
         unsigned old_len = old_dentry->d_name.len;
@@ -524,6 +525,9 @@ static int hpfs_rename(struct inode *old_dir, struct dentry *old_dentry,
         struct fnode *fnode;
         int err;
 
+        if (flags & ~RENAME_NOREPLACE)
+                return -EINVAL;
+
         if ((err = hpfs_chk_name(new_name, &new_len))) return err;
         err = 0;
         hpfs_adjust_length(old_name, &old_len);
diff --git a/fs/hugetlbfs/inode.c b/fs/hugetlbfs/inode.c
index 2c0c3a017a6a..4fb7b10f3a05 100644
--- a/fs/hugetlbfs/inode.c
+++ b/fs/hugetlbfs/inode.c
@@ -655,7 +655,7 @@ static long hugetlbfs_fallocate(struct file *file, int mode, loff_t offset,
 
         if (!(mode & FALLOC_FL_KEEP_SIZE) && offset + len > inode->i_size)
                 i_size_write(inode, offset + len);
-        inode->i_ctime = CURRENT_TIME;
+        inode->i_ctime = current_time(inode);
 out:
         inode_unlock(inode);
         return error;
@@ -700,7 +700,7 @@ static struct inode *hugetlbfs_get_root(struct super_block *sb,
                 inode->i_mode = S_IFDIR | config->mode;
                 inode->i_uid = config->uid;
                 inode->i_gid = config->gid;
-                inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
+                inode->i_atime = inode->i_mtime = inode->i_ctime = current_time(inode);
                 info = HUGETLBFS_I(inode);
                 mpol_shared_policy_init(&info->policy, NULL);
                 inode->i_op = &hugetlbfs_dir_inode_operations;
@@ -739,7 +739,7 @@ static struct inode *hugetlbfs_get_inode(struct super_block *sb,
                 lockdep_set_class(&inode->i_mapping->i_mmap_rwsem,
                                 &hugetlbfs_i_mmap_rwsem_key);
                 inode->i_mapping->a_ops = &hugetlbfs_aops;
-                inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
+                inode->i_atime = inode->i_mtime = inode->i_ctime = current_time(inode);
                 inode->i_mapping->private_data = resv_map;
                 info = HUGETLBFS_I(inode);
                 /*
@@ -788,7 +788,7 @@ static int hugetlbfs_mknod(struct inode *dir,
 
         inode = hugetlbfs_get_inode(dir->i_sb, dir, mode, dev);
         if (inode) {
-                dir->i_ctime = dir->i_mtime = CURRENT_TIME;
+                dir->i_ctime = dir->i_mtime = current_time(dir);
                 d_instantiate(dentry, inode);
                 dget(dentry);   /* Extra count - pin the dentry in core */
                 error = 0;
@@ -825,7 +825,7 @@ static int hugetlbfs_symlink(struct inode *dir,
                 } else
                         iput(inode);
         }
-        dir->i_ctime = dir->i_mtime = CURRENT_TIME;
+        dir->i_ctime = dir->i_mtime = current_time(dir);
 
         return error;
 }
diff --git a/fs/inode.c b/fs/inode.c
index 7d037591259d..88110fd0b282 100644
--- a/fs/inode.c
+++ b/fs/inode.c
@@ -1686,7 +1686,7 @@ bool __atime_needs_update(const struct path *path, struct inode *inode,
         if ((mnt->mnt_flags & MNT_NODIRATIME) && S_ISDIR(inode->i_mode))
                 return false;
 
-        now = current_fs_time(inode->i_sb);
+        now = current_time(inode);
 
         if (!relatime_need_update(path, inode, now, rcu))
                 return false;
@@ -1720,7 +1720,7 @@ void touch_atime(const struct path *path)
          * We may also fail on filesystems that have the ability to make parts
          * of the fs read only, e.g. subvolumes in Btrfs.
          */
-        now = current_fs_time(inode->i_sb);
+        now = current_time(inode);
         update_time(inode, &now, S_ATIME);
         __mnt_drop_write(mnt);
 skip_update:
@@ -1843,7 +1843,7 @@ int file_update_time(struct file *file)
         if (IS_NOCMTIME(inode))
                 return 0;
 
-        now = current_fs_time(inode->i_sb);
+        now = current_time(inode);
         if (!timespec_equal(&inode->i_mtime, &now))
                 sync_it = S_MTIME;
 
@@ -2099,3 +2099,26 @@ void inode_nohighmem(struct inode *inode)
         mapping_set_gfp_mask(inode->i_mapping, GFP_USER);
 }
 EXPORT_SYMBOL(inode_nohighmem);
+
+/**
+ * current_time - Return FS time
+ * @inode: inode.
+ *
+ * Return the current time truncated to the time granularity supported by
+ * the fs.
+ *
+ * Note that inode and inode->sb cannot be NULL.
+ * Otherwise, the function warns and returns time without truncation.
+ */
+struct timespec current_time(struct inode *inode)
+{
+        struct timespec now = current_kernel_time();
+
+        if (unlikely(!inode->i_sb)) {
+                WARN(1, "current_time() called with uninitialized super_block in the inode");
+                return now;
+        }
+
+        return timespec_trunc(now, inode->i_sb->s_time_gran);
+}
+EXPORT_SYMBOL(current_time);
diff --git a/fs/jffs2/acl.c b/fs/jffs2/acl.c
index 2a0f2a1044c1..7ebacf14837f 100644
--- a/fs/jffs2/acl.c
+++ b/fs/jffs2/acl.c
@@ -243,7 +243,7 @@ int jffs2_set_acl(struct inode *inode, struct posix_acl *acl, int type)
 
                                 attr.ia_valid = ATTR_MODE | ATTR_CTIME;
                                 attr.ia_mode = mode;
-                                attr.ia_ctime = CURRENT_TIME_SEC;
+                                attr.ia_ctime = current_time(inode);
                                 rc = jffs2_do_setattr(inode, &attr);
                                 if (rc < 0)
                                         return rc;
diff --git a/fs/jffs2/dir.c b/fs/jffs2/dir.c
index 9b242434adf2..0a754f38462e 100644
--- a/fs/jffs2/dir.c
+++ b/fs/jffs2/dir.c
@@ -35,7 +35,8 @@ static int jffs2_mkdir (struct inode *,struct dentry *,umode_t);
 static int jffs2_rmdir (struct inode *,struct dentry *);
 static int jffs2_mknod (struct inode *,struct dentry *,umode_t,dev_t);
 static int jffs2_rename (struct inode *, struct dentry *,
-                         struct inode *, struct dentry *);
+                         struct inode *, struct dentry *,
+                         unsigned int);
 
 const struct file_operations jffs2_dir_operations =
 {
@@ -756,7 +757,8 @@ static int jffs2_mknod (struct inode *dir_i, struct dentry *dentry, umode_t mode
 }
 
 static int jffs2_rename (struct inode *old_dir_i, struct dentry *old_dentry,
-                         struct inode *new_dir_i, struct dentry *new_dentry)
+                         struct inode *new_dir_i, struct dentry *new_dentry,
+                         unsigned int flags)
 {
         int ret;
         struct jffs2_sb_info *c = JFFS2_SB_INFO(old_dir_i->i_sb);
@@ -764,6 +766,9 @@ static int jffs2_rename (struct inode *old_dir_i, struct dentry *old_dentry,
         uint8_t type;
         uint32_t now;
 
+        if (flags & ~RENAME_NOREPLACE)
+                return -EINVAL;
+
         /* The VFS will check for us and prevent trying to rename a
          * file over a directory and vice versa, but if it's a directory,
          * the VFS can't check whether the victim is empty. The filesystem
diff --git a/fs/jffs2/fs.c b/fs/jffs2/fs.c
index 3773b24b4db0..567653f7c0ce 100644
--- a/fs/jffs2/fs.c
+++ b/fs/jffs2/fs.c
@@ -472,7 +472,7 @@ struct inode *jffs2_new_inode (struct inode *dir_i, umode_t mode, struct jffs2_r
         inode->i_mode = jemode_to_cpu(ri->mode);
         i_gid_write(inode, je16_to_cpu(ri->gid));
         i_uid_write(inode, je16_to_cpu(ri->uid));
-        inode->i_atime = inode->i_ctime = inode->i_mtime = CURRENT_TIME_SEC;
+        inode->i_atime = inode->i_ctime = inode->i_mtime = current_time(inode);
         ri->atime = ri->mtime = ri->ctime = cpu_to_je32(I_SEC(inode->i_mtime));
 
         inode->i_blocks = 0;
diff --git a/fs/jfs/acl.c b/fs/jfs/acl.c
index 3a1e1554a4e3..7bc186f4ed4d 100644
--- a/fs/jfs/acl.c
+++ b/fs/jfs/acl.c
@@ -81,7 +81,7 @@ static int __jfs_set_acl(tid_t tid, struct inode *inode, int type,
                         rc = posix_acl_update_mode(inode, &inode->i_mode, &acl);
                         if (rc)
                                 return rc;
-                        inode->i_ctime = CURRENT_TIME;
+                        inode->i_ctime = current_time(inode);
                         mark_inode_dirty(inode);
                 }
                 break;
diff --git a/fs/jfs/inode.c b/fs/jfs/inode.c
index ad3e7b1effc4..054cc761b426 100644
--- a/fs/jfs/inode.c
+++ b/fs/jfs/inode.c
@@ -403,7 +403,7 @@ void jfs_truncate_nolock(struct inode *ip, loff_t length)
                         break;
                 }
 
-                ip->i_mtime = ip->i_ctime = CURRENT_TIME;
+                ip->i_mtime = ip->i_ctime = current_time(ip);
                 mark_inode_dirty(ip);
 
                 txCommit(tid, 1, &ip, 0);
diff --git a/fs/jfs/jfs_inode.c b/fs/jfs/jfs_inode.c
index 5e33cb9a190d..375dd257a34f 100644
--- a/fs/jfs/jfs_inode.c
+++ b/fs/jfs/jfs_inode.c
@@ -131,7 +131,7 @@ struct inode *ialloc(struct inode *parent, umode_t mode)
         jfs_inode->mode2 |= inode->i_mode;
 
         inode->i_blocks = 0;
-        inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
+        inode->i_mtime = inode->i_atime = inode->i_ctime = current_time(inode);
         jfs_inode->otime = inode->i_ctime.tv_sec;
         inode->i_generation = JFS_SBI(sb)->gengen++;
 
diff --git a/fs/jfs/namei.c b/fs/jfs/namei.c
index e420c6088336..b41596d71858 100644
--- a/fs/jfs/namei.c
+++ b/fs/jfs/namei.c
@@ -162,7 +162,7 @@ static int jfs_create(struct inode *dip, struct dentry *dentry, umode_t mode,
 
         mark_inode_dirty(ip);
 
-        dip->i_ctime = dip->i_mtime = CURRENT_TIME;
+        dip->i_ctime = dip->i_mtime = current_time(dip);
 
         mark_inode_dirty(dip);
 
@@ -298,7 +298,7 @@ static int jfs_mkdir(struct inode *dip, struct dentry *dentry, umode_t mode)
 
         /* update parent directory inode */
         inc_nlink(dip);         /* for '..' from child directory */
-        dip->i_ctime = dip->i_mtime = CURRENT_TIME;
+        dip->i_ctime = dip->i_mtime = current_time(dip);
         mark_inode_dirty(dip);
 
         rc = txCommit(tid, 2, &iplist[0], 0);
@@ -406,7 +406,7 @@ static int jfs_rmdir(struct inode *dip, struct dentry *dentry)
         /* update parent directory's link count corresponding
          * to ".." entry of the target directory deleted
          */
-        dip->i_ctime = dip->i_mtime = CURRENT_TIME;
+        dip->i_ctime = dip->i_mtime = current_time(dip);
         inode_dec_link_count(dip);
 
         /*
@@ -528,7 +528,7 @@ static int jfs_unlink(struct inode *dip, struct dentry *dentry)
 
         ASSERT(ip->i_nlink);
 
-        ip->i_ctime = dip->i_ctime = dip->i_mtime = CURRENT_TIME;
+        ip->i_ctime = dip->i_ctime = dip->i_mtime = current_time(ip);
         mark_inode_dirty(dip);
 
         /* update target's inode */
@@ -838,8 +838,8 @@ static int jfs_link(struct dentry *old_dentry,
 
         /* update object inode */
         inc_nlink(ip);          /* for new link */
-        ip->i_ctime = CURRENT_TIME;
-        dir->i_ctime = dir->i_mtime = CURRENT_TIME;
+        ip->i_ctime = current_time(ip);
+        dir->i_ctime = dir->i_mtime = current_time(dir);
         mark_inode_dirty(dir);
         ihold(ip);
 
@@ -1039,7 +1039,7 @@ static int jfs_symlink(struct inode *dip, struct dentry *dentry,
 
         mark_inode_dirty(ip);
 
-        dip->i_ctime = dip->i_mtime = CURRENT_TIME;
+        dip->i_ctime = dip->i_mtime = current_time(dip);
         mark_inode_dirty(dip);
         /*
          * commit update of parent directory and link object
@@ -1078,7 +1078,8 @@ static int jfs_symlink(struct inode *dip, struct dentry *dentry,
  * FUNCTION:    rename a file or directory
  */
 static int jfs_rename(struct inode *old_dir, struct dentry *old_dentry,
-               struct inode *new_dir, struct dentry *new_dentry)
+                      struct inode *new_dir, struct dentry *new_dentry,
+                      unsigned int flags)
 {
         struct btstack btstack;
         ino_t ino;
@@ -1097,6 +1098,8 @@ static int jfs_rename(struct inode *old_dir, struct dentry *old_dentry,
         s64 new_size = 0;
         int commit_flag;
 
+        if (flags & ~RENAME_NOREPLACE)
+                return -EINVAL;
 
         jfs_info("jfs_rename: %pd %pd", old_dentry, new_dentry);
 
@@ -1215,7 +1218,7 @@ static int jfs_rename(struct inode *old_dir, struct dentry *old_dentry,
                         tblk->xflag |= COMMIT_DELETE;
                         tblk->u.ip = new_ip;
                 } else {
-                        new_ip->i_ctime = CURRENT_TIME;
+                        new_ip->i_ctime = current_time(new_ip);
                         mark_inode_dirty(new_ip);
                 }
         } else {
@@ -1278,10 +1281,10 @@ static int jfs_rename(struct inode *old_dir, struct dentry *old_dentry,
         /*
          * Update ctime on changed/moved inodes & mark dirty
          */
-        old_ip->i_ctime = CURRENT_TIME;
+        old_ip->i_ctime = current_time(old_ip);
         mark_inode_dirty(old_ip);
 
-        new_dir->i_ctime = new_dir->i_mtime = current_fs_time(new_dir->i_sb);
+        new_dir->i_ctime = new_dir->i_mtime = current_time(new_dir);
         mark_inode_dirty(new_dir);
 
         /* Build list of inodes modified by this transaction */
@@ -1293,7 +1296,7 @@ static int jfs_rename(struct inode *old_dir, struct dentry *old_dentry,
 
         if (old_dir != new_dir) {
                 iplist[ipcount++] = new_dir;
-                old_dir->i_ctime = old_dir->i_mtime = CURRENT_TIME;
+                old_dir->i_ctime = old_dir->i_mtime = current_time(old_dir);
                 mark_inode_dirty(old_dir);
         }
 
@@ -1426,7 +1429,7 @@ static int jfs_mknod(struct inode *dir, struct dentry *dentry,
 
         mark_inode_dirty(ip);
 
-        dir->i_ctime = dir->i_mtime = CURRENT_TIME;
+        dir->i_ctime = dir->i_mtime = current_time(dir);
 
         mark_inode_dirty(dir);
 
diff --git a/fs/jfs/super.c b/fs/jfs/super.c
index cec8814a3b8b..85671f7f8518 100644
--- a/fs/jfs/super.c
+++ b/fs/jfs/super.c
@@ -830,7 +830,7 @@ out:
         if (inode->i_size < off+len-towrite)
                 i_size_write(inode, off+len-towrite);
         inode->i_version++;
-        inode->i_mtime = inode->i_ctime = CURRENT_TIME;
+        inode->i_mtime = inode->i_ctime = current_time(inode);
         mark_inode_dirty(inode);
         inode_unlock(inode);
         return len - towrite;
diff --git a/fs/jfs/xattr.c b/fs/jfs/xattr.c
index 0bf3c33aedff..c60f3d32ee91 100644
--- a/fs/jfs/xattr.c
+++ b/fs/jfs/xattr.c
@@ -658,7 +658,7 @@ static int ea_put(tid_t tid, struct inode *inode, struct ea_buffer *ea_buf,
         if (old_blocks)
                 dquot_free_block(inode, old_blocks);
 
-        inode->i_ctime = CURRENT_TIME;
+        inode->i_ctime = current_time(inode);
 
         return 0;
 }
diff --git a/fs/kernfs/dir.c b/fs/kernfs/dir.c
index 2b23ad91a464..dcd96aac02f5 100644
--- a/fs/kernfs/dir.c
+++ b/fs/kernfs/dir.c
@@ -1096,13 +1096,17 @@ static int kernfs_iop_rmdir(struct inode *dir, struct dentry *dentry)
 }
 
 static int kernfs_iop_rename(struct inode *old_dir, struct dentry *old_dentry,
-                             struct inode *new_dir, struct dentry *new_dentry)
+                             struct inode *new_dir, struct dentry *new_dentry,
+                             unsigned int flags)
 {
         struct kernfs_node *kn  = old_dentry->d_fsdata;
         struct kernfs_node *new_parent = new_dir->i_private;
         struct kernfs_syscall_ops *scops = kernfs_root(kn)->syscall_ops;
         int ret;
 
+        if (flags)
+                return -EINVAL;
+
         if (!scops || !scops->rename)
                 return -EPERM;
 
diff --git a/fs/kernfs/inode.c b/fs/kernfs/inode.c
index 102b6f0bc7af..a1982118f92f 100644
--- a/fs/kernfs/inode.c
+++ b/fs/kernfs/inode.c
@@ -168,7 +168,7 @@ static inline void set_default_inode_attr(struct inode *inode, umode_t mode)
 {
         inode->i_mode = mode;
         inode->i_atime = inode->i_mtime =
-                inode->i_ctime = current_fs_time(inode->i_sb);
+                inode->i_ctime = current_time(inode);
 }
 
 static inline void set_inode_attr(struct inode *inode, struct iattr *iattr)
diff --git a/fs/libfs.c b/fs/libfs.c
index a6d89f151771..48826d4da189 100644
--- a/fs/libfs.c
+++ b/fs/libfs.c
@@ -266,7 +266,7 @@ struct dentry *mount_pseudo_xattr(struct file_system_type *fs_type, char *name,
          */
         root->i_ino = 1;
         root->i_mode = S_IFDIR | S_IRUSR | S_IWUSR;
-        root->i_atime = root->i_mtime = root->i_ctime = CURRENT_TIME;
+        root->i_atime = root->i_mtime = root->i_ctime = current_time(root);
         dentry = __d_alloc(s, &d_name);
         if (!dentry) {
                 iput(root);
@@ -296,7 +296,7 @@ int simple_link(struct dentry *old_dentry, struct inode *dir, struct dentry *den
 {
         struct inode *inode = d_inode(old_dentry);
 
-        inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME;
+        inode->i_ctime = dir->i_ctime = dir->i_mtime = current_time(inode);
         inc_nlink(inode);
         ihold(inode);
         dget(dentry);
@@ -330,7 +330,7 @@ int simple_unlink(struct inode *dir, struct dentry *dentry)
 {
         struct inode *inode = d_inode(dentry);
 
-        inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME;
+        inode->i_ctime = dir->i_ctime = dir->i_mtime = current_time(inode);
         drop_nlink(inode);
         dput(dentry);
         return 0;
@@ -350,11 +350,15 @@ int simple_rmdir(struct inode *dir, struct dentry *dentry)
 EXPORT_SYMBOL(simple_rmdir);
 
 int simple_rename(struct inode *old_dir, struct dentry *old_dentry,
-                struct inode *new_dir, struct dentry *new_dentry)
+                  struct inode *new_dir, struct dentry *new_dentry,
+                  unsigned int flags)
 {
         struct inode *inode = d_inode(old_dentry);
         int they_are_dirs = d_is_dir(old_dentry);
 
+        if (flags & ~RENAME_NOREPLACE)
+                return -EINVAL;
+
         if (!simple_empty(new_dentry))
                 return -ENOTEMPTY;
 
@@ -370,7 +374,7 @@ int simple_rename(struct inode *old_dir, struct dentry *old_dentry,
         }
 
         old_dir->i_ctime = old_dir->i_mtime = new_dir->i_ctime =
-                new_dir->i_mtime = inode->i_ctime = CURRENT_TIME;
+                new_dir->i_mtime = inode->i_ctime = current_time(old_dir);
 
         return 0;
 }
@@ -521,7 +525,7 @@ int simple_fill_super(struct super_block *s, unsigned long magic,
          */
         inode->i_ino = 1;
         inode->i_mode = S_IFDIR | 0755;
-        inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
+        inode->i_atime = inode->i_mtime = inode->i_ctime = current_time(inode);
         inode->i_op = &simple_dir_inode_operations;
         inode->i_fop = &simple_dir_operations;
         set_nlink(inode, 2);
@@ -547,7 +551,7 @@ int simple_fill_super(struct super_block *s, unsigned long magic,
                         goto out;
                 }
                 inode->i_mode = S_IFREG | files->mode;
-                inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
+                inode->i_atime = inode->i_mtime = inode->i_ctime = current_time(inode);
                 inode->i_fop = files->ops;
                 inode->i_ino = i;
                 d_add(dentry, inode);
@@ -1093,7 +1097,7 @@ struct inode *alloc_anon_inode(struct super_block *s)
         inode->i_uid = current_fsuid();
         inode->i_gid = current_fsgid();
         inode->i_flags |= S_PRIVATE;
-        inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
+        inode->i_atime = inode->i_mtime = inode->i_ctime = current_time(inode);
         return inode;
 }
 EXPORT_SYMBOL(alloc_anon_inode);
diff --git a/fs/locks.c b/fs/locks.c
index 8cc218d7a039..ce93b416b490 100644
--- a/fs/locks.c
+++ b/fs/locks.c
@@ -1569,7 +1569,7 @@ void lease_get_mtime(struct inode *inode, struct timespec *time)
         }
 
         if (has_lease)
-                *time = current_fs_time(inode->i_sb);
+                *time = current_time(inode);
         else
                 *time = inode->i_mtime;
 }
diff --git a/fs/logfs/dir.c b/fs/logfs/dir.c
index 9568064ecadf..c87ea52de3d9 100644
--- a/fs/logfs/dir.c
+++ b/fs/logfs/dir.c
@@ -226,7 +226,7 @@ static int logfs_unlink(struct inode *dir, struct dentry *dentry)
         ta->state = UNLINK_1;
         ta->ino = inode->i_ino;
 
-        inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME;
+        inode->i_ctime = dir->i_ctime = dir->i_mtime = current_time(inode);
 
         page = logfs_get_dd_page(dir, dentry);
         if (!page) {
@@ -540,7 +540,7 @@ static int logfs_link(struct dentry *old_dentry, struct inode *dir,
 {
         struct inode *inode = d_inode(old_dentry);
 
-        inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME;
+        inode->i_ctime = dir->i_ctime = dir->i_mtime = current_time(inode);
         ihold(inode);
         inc_nlink(inode);
         mark_inode_dirty_sync(inode);
@@ -573,7 +573,7 @@ static int logfs_delete_dd(struct inode *dir, loff_t pos)
          * (crc-protected) journal.
          */
         BUG_ON(beyond_eof(dir, pos));
-        dir->i_ctime = dir->i_mtime = CURRENT_TIME;
+        dir->i_ctime = dir->i_mtime = current_time(dir);
         log_dir(" Delete dentry (%lx, %llx)\n", dir->i_ino, pos);
         return logfs_delete(dir, pos, NULL);
 }
@@ -718,8 +718,12 @@ out:
 }
 
 static int logfs_rename(struct inode *old_dir, struct dentry *old_dentry,
-                        struct inode *new_dir, struct dentry *new_dentry)
+                        struct inode *new_dir, struct dentry *new_dentry,
+                        unsigned int flags)
 {
+        if (flags & ~RENAME_NOREPLACE)
+                return -EINVAL;
+
         if (d_really_is_positive(new_dentry))
                 return logfs_rename_target(old_dir, old_dentry,
                                            new_dir, new_dentry);
diff --git a/fs/logfs/file.c b/fs/logfs/file.c
index 5d9fe466bbc9..1db04930ad57 100644
--- a/fs/logfs/file.c
+++ b/fs/logfs/file.c
@@ -211,7 +211,7 @@ long logfs_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
                 li->li_flags = flags;
                 inode_unlock(inode);
 
-                inode->i_ctime = CURRENT_TIME;
+                inode->i_ctime = current_time(inode);
                 mark_inode_dirty_sync(inode);
                 return 0;
 
diff --git a/fs/logfs/inode.c b/fs/logfs/inode.c
index db9cfc598883..f440a1525da8 100644
--- a/fs/logfs/inode.c
+++ b/fs/logfs/inode.c
@@ -213,8 +213,8 @@ static void logfs_init_inode(struct super_block *sb, struct inode *inode)
         i_gid_write(inode, 0);
         inode->i_size   = 0;
         inode->i_blocks = 0;
-        inode->i_ctime  = CURRENT_TIME;
-        inode->i_mtime  = CURRENT_TIME;
+        inode->i_ctime  = current_time(inode);
+        inode->i_mtime  = current_time(inode);
         li->li_refcount = 1;
         INIT_LIST_HEAD(&li->li_freeing_list);
 
diff --git a/fs/logfs/readwrite.c b/fs/logfs/readwrite.c
index 3fb8c6d67303..bf19bf4a243f 100644
--- a/fs/logfs/readwrite.c
+++ b/fs/logfs/readwrite.c
@@ -1546,7 +1546,7 @@ static int __logfs_write_buf(struct inode *inode, struct page *page, long flags)
         int err;
 
         flags |= WF_WRITE | WF_DELETE;
-        inode->i_ctime = inode->i_mtime = CURRENT_TIME;
+        inode->i_ctime = inode->i_mtime = current_time(inode);
 
         logfs_unpack_index(index, &bix, &level);
         if (logfs_block(page) && logfs_block(page)->reserved_bytes)
@@ -1578,7 +1578,7 @@ static int __logfs_delete(struct inode *inode, struct page *page)
         long flags = WF_DELETE;
         int err;
 
-        inode->i_ctime = inode->i_mtime = CURRENT_TIME;
+        inode->i_ctime = inode->i_mtime = current_time(inode);
 
         if (page->index < I0_BLOCKS)
                 return logfs_write_direct(inode, page, flags);
diff --git a/fs/minix/bitmap.c b/fs/minix/bitmap.c
index 742942a983be..c2c3fd3277b5 100644
--- a/fs/minix/bitmap.c
+++ b/fs/minix/bitmap.c
@@ -253,7 +253,7 @@ struct inode *minix_new_inode(const struct inode *dir, umode_t mode, int *error)
         }
         inode_init_owner(inode, dir, mode);
         inode->i_ino = j;
-        inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME_SEC;
+        inode->i_mtime = inode->i_atime = inode->i_ctime = current_time(inode);
         inode->i_blocks = 0;
         memset(&minix_i(inode)->u, 0, sizeof(minix_i(inode)->u));
         insert_inode_hash(inode);
diff --git a/fs/minix/dir.c b/fs/minix/dir.c
index 31dcd515b9d5..7edc9b395700 100644
--- a/fs/minix/dir.c
+++ b/fs/minix/dir.c
@@ -274,7 +274,7 @@ got_it:
                 de->inode = inode->i_ino;
         }
         err = dir_commit_chunk(page, pos, sbi->s_dirsize);
-        dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC;
+        dir->i_mtime = dir->i_ctime = current_time(dir);
         mark_inode_dirty(dir);
 out_put:
         dir_put_page(page);
@@ -306,7 +306,7 @@ int minix_delete_entry(struct minix_dir_entry *de, struct page *page)
                 unlock_page(page);
         }
         dir_put_page(page);
-        inode->i_ctime = inode->i_mtime = CURRENT_TIME_SEC;
+        inode->i_ctime = inode->i_mtime = current_time(inode);
         mark_inode_dirty(inode);
         return err;
 }
@@ -430,7 +430,7 @@ void minix_set_link(struct minix_dir_entry *de, struct page *page,
                 unlock_page(page);
         }
         dir_put_page(page);
-        dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC;
+        dir->i_mtime = dir->i_ctime = current_time(dir);
         mark_inode_dirty(dir);
 }
 
diff --git a/fs/minix/itree_common.c b/fs/minix/itree_common.c
index a731cabf1540..4c57c9af6946 100644
--- a/fs/minix/itree_common.c
+++ b/fs/minix/itree_common.c
@@ -124,7 +124,7 @@ static inline int splice_branch(struct inode *inode,
 
         /* We are done with atomic stuff, now do the rest of housekeeping */
 
-        inode->i_ctime = CURRENT_TIME_SEC;
+        inode->i_ctime = current_time(inode);
 
         /* had we spliced it onto indirect block? */
         if (where->bh)
@@ -343,7 +343,7 @@ do_indirects:
                 }
                 first_whole++;
         }
-        inode->i_mtime = inode->i_ctime = CURRENT_TIME_SEC;
+        inode->i_mtime = inode->i_ctime = current_time(inode);
         mark_inode_dirty(inode);
 }
 
diff --git a/fs/minix/namei.c b/fs/minix/namei.c
index 2887d1d95ce2..1e0f11f5dac9 100644
--- a/fs/minix/namei.c
+++ b/fs/minix/namei.c
@@ -106,7 +106,7 @@ static int minix_link(struct dentry * old_dentry, struct inode * dir,
 {
         struct inode *inode = d_inode(old_dentry);
 
-        inode->i_ctime = CURRENT_TIME_SEC;
+        inode->i_ctime = current_time(inode);
         inode_inc_link_count(inode);
         ihold(inode);
         return add_nondir(dentry, inode);
@@ -185,7 +185,8 @@ static int minix_rmdir(struct inode * dir, struct dentry *dentry)
 }
 
 static int minix_rename(struct inode * old_dir, struct dentry *old_dentry,
-                           struct inode * new_dir, struct dentry *new_dentry)
+                        struct inode * new_dir, struct dentry *new_dentry,
+                        unsigned int flags)
 {
         struct inode * old_inode = d_inode(old_dentry);
         struct inode * new_inode = d_inode(new_dentry);
@@ -195,6 +196,9 @@ static int minix_rename(struct inode * old_dir, struct dentry *old_dentry,
         struct minix_dir_entry * old_de;
         int err = -ENOENT;
 
+        if (flags & ~RENAME_NOREPLACE)
+                return -EINVAL;
+
         old_de = minix_find_entry(old_dentry, &old_page);
         if (!old_de)
                 goto out;
@@ -219,7 +223,7 @@ static int minix_rename(struct inode * old_dir, struct dentry *old_dentry,
                 if (!new_de)
                         goto out_dir;
                 minix_set_link(new_de, new_page, old_inode);
-                new_inode->i_ctime = CURRENT_TIME_SEC;
+                new_inode->i_ctime = current_time(new_inode);
                 if (dir_de)
                         drop_nlink(new_inode);
                 inode_dec_link_count(new_inode);
diff --git a/fs/namei.c b/fs/namei.c
index 4bbcae1ba58e..a7f601cd521a 100644
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -4369,12 +4369,9 @@ int vfs_rename(struct inode *old_dir, struct dentry *old_dentry,
         if (error)
                 return error;
 
-        if (!old_dir->i_op->rename && !old_dir->i_op->rename2)
+        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 '..'.
@@ -4428,14 +4425,8 @@ int vfs_rename(struct inode *old_dir, struct dentry *old_dentry,
                 if (error)
                         goto out;
         }
-        if (!old_dir->i_op->rename2) {
-                error = old_dir->i_op->rename(old_dir, old_dentry,
-                                              new_dir, new_dentry);
-        } else {
-                WARN_ON(old_dir->i_op->rename != NULL);
-                error = old_dir->i_op->rename2(old_dir, old_dentry,
-                                               new_dir, new_dentry, flags);
-        }
+        error = old_dir->i_op->rename(old_dir, old_dentry,
+                                       new_dir, new_dentry, flags);
         if (error)
                 goto out;
 
diff --git a/fs/ncpfs/dir.c b/fs/ncpfs/dir.c
index 17de5c13dfae..6df2a3827574 100644
--- a/fs/ncpfs/dir.c
+++ b/fs/ncpfs/dir.c
@@ -36,7 +36,7 @@ static int ncp_unlink(struct inode *, struct dentry *);
 static int ncp_mkdir(struct inode *, struct dentry *, umode_t);
 static int ncp_rmdir(struct inode *, struct dentry *);
 static int ncp_rename(struct inode *, struct dentry *,
-                      struct inode *, struct dentry *);
+                      struct inode *, struct dentry *, unsigned int);
 static int ncp_mknod(struct inode * dir, struct dentry *dentry,
                      umode_t mode, dev_t rdev);
 #if defined(CONFIG_NCPFS_EXTRAS) || defined(CONFIG_NCPFS_NFS_NS)
@@ -133,12 +133,11 @@ ncp_hash_dentry(const struct dentry *dentry, struct qstr *this)
                 return 0;
 
         if (!ncp_case_sensitive(inode)) {
-                struct super_block *sb = dentry->d_sb;
                 struct nls_table *t;
                 unsigned long hash;
                 int i;
 
-                t = NCP_IO_TABLE(sb);
+                t = NCP_IO_TABLE(dentry->d_sb);
                 hash = init_name_hash(dentry);
                 for (i=0; i<this->len ; i++)
                         hash = partial_name_hash(ncp_tolower(t, this->name[i]),
@@ -1106,13 +1105,17 @@ static int ncp_unlink(struct inode *dir, struct dentry *dentry)
 }
 
 static int ncp_rename(struct inode *old_dir, struct dentry *old_dentry,
-                      struct inode *new_dir, struct dentry *new_dentry)
+                      struct inode *new_dir, struct dentry *new_dentry,
+                      unsigned int flags)
 {
         struct ncp_server *server = NCP_SERVER(old_dir);
         int error;
         int old_len, new_len;
         __u8 __old_name[NCP_MAXPATHLEN + 1], __new_name[NCP_MAXPATHLEN + 1];
 
+        if (flags)
+                return -EINVAL;
+
         ncp_dbg(1, "%pd2 to %pd2\n", old_dentry, new_dentry);
 
         ncp_age_dentry(server, old_dentry);
diff --git a/fs/nfs/dir.c b/fs/nfs/dir.c
index 177fefb26c18..06e0bf092ba9 100644
--- a/fs/nfs/dir.c
+++ b/fs/nfs/dir.c
@@ -2013,7 +2013,8 @@ EXPORT_SYMBOL_GPL(nfs_link);
  * the rename.
  */
 int nfs_rename(struct inode *old_dir, struct dentry *old_dentry,
-                      struct inode *new_dir, struct dentry *new_dentry)
+               struct inode *new_dir, struct dentry *new_dentry,
+               unsigned int flags)
 {
         struct inode *old_inode = d_inode(old_dentry);
         struct inode *new_inode = d_inode(new_dentry);
@@ -2021,6 +2022,9 @@ int nfs_rename(struct inode *old_dir, struct dentry *old_dentry,
         struct rpc_task *task;
         int error = -EBUSY;
 
+        if (flags)
+                return -EINVAL;
+
         dfprintk(VFS, "NFS: rename(%pd2 -> %pd2, ct=%d)\n",
                  old_dentry, new_dentry,
                  d_count(new_dentry));
diff --git a/fs/nfs/internal.h b/fs/nfs/internal.h
index 4b308a1487a5..a6acce663219 100644
--- a/fs/nfs/internal.h
+++ b/fs/nfs/internal.h
@@ -359,7 +359,8 @@ int nfs_unlink(struct inode *, struct dentry *);
 int nfs_symlink(struct inode *, struct dentry *, const char *);
 int nfs_link(struct dentry *, struct inode *, struct dentry *);
 int nfs_mknod(struct inode *, struct dentry *, umode_t, dev_t);
-int nfs_rename(struct inode *, struct dentry *, struct inode *, struct dentry *);
+int nfs_rename(struct inode *, struct dentry *,
+               struct inode *, struct dentry *, unsigned int);
 
 /* file.c */
 int nfs_file_fsync(struct file *file, loff_t start, loff_t end, int datasync);
diff --git a/fs/nfsd/blocklayout.c b/fs/nfsd/blocklayout.c
index 5a1708441510..0780ff864539 100644
--- a/fs/nfsd/blocklayout.c
+++ b/fs/nfsd/blocklayout.c
@@ -123,7 +123,7 @@ nfsd4_block_commit_blocks(struct inode *inode, struct nfsd4_layoutcommit *lcp,
 
         if (lcp->lc_mtime.tv_nsec == UTIME_NOW ||
             timespec_compare(&lcp->lc_mtime, &inode->i_mtime) < 0)
-                lcp->lc_mtime = current_fs_time(inode->i_sb);
+                lcp->lc_mtime = current_time(inode);
         iattr.ia_valid |= ATTR_ATIME | ATTR_CTIME | ATTR_MTIME;
         iattr.ia_atime = iattr.ia_ctime = iattr.ia_mtime = lcp->lc_mtime;
 
diff --git a/fs/nilfs2/dir.c b/fs/nilfs2/dir.c
index 908ebbf0ac7e..582831ab3eb9 100644
--- a/fs/nilfs2/dir.c
+++ b/fs/nilfs2/dir.c
@@ -438,7 +438,7 @@ void nilfs_set_link(struct inode *dir, struct nilfs_dir_entry *de,
         nilfs_set_de_type(de, inode);
         nilfs_commit_chunk(page, mapping, from, to);
         nilfs_put_page(page);
-        dir->i_mtime = dir->i_ctime = CURRENT_TIME;
+        dir->i_mtime = dir->i_ctime = current_time(dir);
 }
 
 /*
@@ -528,7 +528,7 @@ got_it:
         de->inode = cpu_to_le64(inode->i_ino);
         nilfs_set_de_type(de, inode);
         nilfs_commit_chunk(page, page->mapping, from, to);
-        dir->i_mtime = dir->i_ctime = CURRENT_TIME;
+        dir->i_mtime = dir->i_ctime = current_time(dir);
         nilfs_mark_inode_dirty(dir);
         /* OFFSET_CACHE */
 out_put:
@@ -576,7 +576,7 @@ int nilfs_delete_entry(struct nilfs_dir_entry *dir, struct page *page)
                 pde->rec_len = nilfs_rec_len_to_disk(to - from);
         dir->inode = 0;
         nilfs_commit_chunk(page, mapping, from, to);
-        inode->i_ctime = inode->i_mtime = CURRENT_TIME;
+        inode->i_ctime = inode->i_mtime = current_time(inode);
 out:
         nilfs_put_page(page);
         return err;
diff --git a/fs/nilfs2/inode.c b/fs/nilfs2/inode.c
index 402c325e0467..c7f4fef9ebf5 100644
--- a/fs/nilfs2/inode.c
+++ b/fs/nilfs2/inode.c
@@ -367,7 +367,7 @@ struct inode *nilfs_new_inode(struct inode *dir, umode_t mode)
         atomic64_inc(&root->inodes_count);
         inode_init_owner(inode, dir, mode);
         inode->i_ino = ino;
-        inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
+        inode->i_mtime = inode->i_atime = inode->i_ctime = current_time(inode);
 
         if (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode)) {
                 err = nilfs_bmap_read(ii->i_bmap, NULL);
@@ -749,7 +749,7 @@ void nilfs_truncate(struct inode *inode)
 
         nilfs_truncate_bmap(ii, blkoff);
 
-        inode->i_mtime = inode->i_ctime = CURRENT_TIME;
+        inode->i_mtime = inode->i_ctime = current_time(inode);
         if (IS_SYNC(inode))
                 nilfs_set_transaction_flag(NILFS_TI_SYNC);
 
diff --git a/fs/nilfs2/ioctl.c b/fs/nilfs2/ioctl.c
index f1d7989459fd..1d2c3d7711fe 100644
--- a/fs/nilfs2/ioctl.c
+++ b/fs/nilfs2/ioctl.c
@@ -174,7 +174,7 @@ static int nilfs_ioctl_setflags(struct inode *inode, struct file *filp,
                 (flags & FS_FL_USER_MODIFIABLE);
 
         nilfs_set_inode_flags(inode);
-        inode->i_ctime = CURRENT_TIME;
+        inode->i_ctime = current_time(inode);
         if (IS_SYNC(inode))
                 nilfs_set_transaction_flag(NILFS_TI_SYNC);
 
diff --git a/fs/nilfs2/namei.c b/fs/nilfs2/namei.c
index dbcf1dc93a51..2b71c60fe982 100644
--- a/fs/nilfs2/namei.c
+++ b/fs/nilfs2/namei.c
@@ -194,7 +194,7 @@ static int nilfs_link(struct dentry *old_dentry, struct inode *dir,
         if (err)
                 return err;
 
-        inode->i_ctime = CURRENT_TIME;
+        inode->i_ctime = current_time(inode);
         inode_inc_link_count(inode);
         ihold(inode);
 
@@ -350,7 +350,8 @@ static int nilfs_rmdir(struct inode *dir, struct dentry *dentry)
 }
 
 static int nilfs_rename(struct inode *old_dir, struct dentry *old_dentry,
-                        struct inode *new_dir,  struct dentry *new_dentry)
+                        struct inode *new_dir,  struct dentry *new_dentry,
+                        unsigned int flags)
 {
         struct inode *old_inode = d_inode(old_dentry);
         struct inode *new_inode = d_inode(new_dentry);
@@ -361,6 +362,9 @@ static int nilfs_rename(struct inode *old_dir, struct dentry *old_dentry,
         struct nilfs_transaction_info ti;
         int err;
 
+        if (flags & ~RENAME_NOREPLACE)
+                return -EINVAL;
+
         err = nilfs_transaction_begin(old_dir->i_sb, &ti, 1);
         if (unlikely(err))
                 return err;
@@ -391,7 +395,7 @@ static int nilfs_rename(struct inode *old_dir, struct dentry *old_dentry,
                         goto out_dir;
                 nilfs_set_link(new_dir, new_de, new_page, old_inode);
                 nilfs_mark_inode_dirty(new_dir);
-                new_inode->i_ctime = CURRENT_TIME;
+                new_inode->i_ctime = current_time(new_inode);
                 if (dir_de)
                         drop_nlink(new_inode);
                 drop_nlink(new_inode);
@@ -410,7 +414,7 @@ static int nilfs_rename(struct inode *old_dir, struct dentry *old_dentry,
          * Like most other Unix systems, set the ctime for inodes on a
          * rename.
          */
-        old_inode->i_ctime = CURRENT_TIME;
+        old_inode->i_ctime = current_time(old_inode);
 
         nilfs_delete_entry(old_de, old_page);
 
diff --git a/fs/nsfs.c b/fs/nsfs.c
index 30bb10034120..8718af895eab 100644
--- a/fs/nsfs.c
+++ b/fs/nsfs.c
@@ -78,7 +78,7 @@ slow:
                 return ERR_PTR(-ENOMEM);
         }
         inode->i_ino = ns->inum;
-        inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
+        inode->i_mtime = inode->i_atime = inode->i_ctime = current_time(inode);
         inode->i_flags |= S_IMMUTABLE;
         inode->i_mode = S_IFREG | S_IRUGO;
         inode->i_fop = &ns_file_operations;
diff --git a/fs/ntfs/inode.c b/fs/ntfs/inode.c
index 9d7a44872df5..7c410f879412 100644
--- a/fs/ntfs/inode.c
+++ b/fs/ntfs/inode.c
@@ -2813,7 +2813,7 @@ done:
          * for real.
          */
         if (!IS_NOCMTIME(VFS_I(base_ni)) && !IS_RDONLY(VFS_I(base_ni))) {
-                struct timespec now = current_fs_time(VFS_I(base_ni)->i_sb);
+                struct timespec now = current_time(VFS_I(base_ni));
                 int sync_it = 0;
 
                 if (!timespec_equal(&VFS_I(base_ni)->i_mtime, &now) ||
diff --git a/fs/ntfs/mft.c b/fs/ntfs/mft.c
index d15d492ce47b..d3c009626032 100644
--- a/fs/ntfs/mft.c
+++ b/fs/ntfs/mft.c
@@ -2692,7 +2692,7 @@ mft_rec_already_initialized:
 
                 /* Set the inode times to the current time. */
                 vi->i_atime = vi->i_mtime = vi->i_ctime =
-                        current_fs_time(vi->i_sb);
+                        current_time(vi);
                 /*
                  * Set the file size to 0, the ntfs inode sizes are set to 0 by
                  * the call to ntfs_init_big_inode() below.
diff --git a/fs/ocfs2/acl.c b/fs/ocfs2/acl.c
index 164307b99405..bed1fcb63088 100644
--- a/fs/ocfs2/acl.c
+++ b/fs/ocfs2/acl.c
@@ -201,7 +201,7 @@ static int ocfs2_acl_set_mode(struct inode *inode, struct buffer_head *di_bh,
         }
 
         inode->i_mode = new_mode;
-        inode->i_ctime = CURRENT_TIME;
+        inode->i_ctime = current_time(inode);
         di->i_mode = cpu_to_le16(inode->i_mode);
         di->i_ctime = cpu_to_le64(inode->i_ctime.tv_sec);
         di->i_ctime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec);
diff --git a/fs/ocfs2/alloc.c b/fs/ocfs2/alloc.c
index f165f867f332..f72712f6c28d 100644
--- a/fs/ocfs2/alloc.c
+++ b/fs/ocfs2/alloc.c
@@ -7293,7 +7293,7 @@ int ocfs2_truncate_inline(struct inode *inode, struct buffer_head *di_bh,
         }
 
         inode->i_blocks = ocfs2_inode_sector_count(inode);
-        inode->i_ctime = inode->i_mtime = CURRENT_TIME;
+        inode->i_ctime = inode->i_mtime = current_time(inode);
 
         di->i_ctime = di->i_mtime = cpu_to_le64(inode->i_ctime.tv_sec);
         di->i_ctime_nsec = di->i_mtime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec);
diff --git a/fs/ocfs2/aops.c b/fs/ocfs2/aops.c
index bbb4b3e5b4ff..c5c5b9748ea3 100644
--- a/fs/ocfs2/aops.c
+++ b/fs/ocfs2/aops.c
@@ -2030,7 +2030,7 @@ out_write_size:
                 }
                 inode->i_blocks = ocfs2_inode_sector_count(inode);
                 di->i_size = cpu_to_le64((u64)i_size_read(inode));
-                inode->i_mtime = inode->i_ctime = CURRENT_TIME;
+                inode->i_mtime = inode->i_ctime = current_time(inode);
                 di->i_mtime = di->i_ctime = cpu_to_le64(inode->i_mtime.tv_sec);
                 di->i_mtime_nsec = di->i_ctime_nsec = cpu_to_le32(inode->i_mtime.tv_nsec);
                 ocfs2_update_inode_fsync_trans(handle, inode, 1);
diff --git a/fs/ocfs2/dir.c b/fs/ocfs2/dir.c
index e1adf285fc31..e7054e2ac922 100644
--- a/fs/ocfs2/dir.c
+++ b/fs/ocfs2/dir.c
@@ -1677,7 +1677,7 @@ int __ocfs2_add_entry(handle_t *handle,
                                 offset, ocfs2_dir_trailer_blk_off(dir->i_sb));
 
                 if (ocfs2_dirent_would_fit(de, rec_len)) {
-                        dir->i_mtime = dir->i_ctime = CURRENT_TIME;
+                        dir->i_mtime = dir->i_ctime = current_time(dir);
                         retval = ocfs2_mark_inode_dirty(handle, dir, parent_fe_bh);
                         if (retval < 0) {
                                 mlog_errno(retval);
@@ -2990,7 +2990,7 @@ static int ocfs2_expand_inline_dir(struct inode *dir, struct buffer_head *di_bh,
         ocfs2_dinode_new_extent_list(dir, di);
 
         i_size_write(dir, sb->s_blocksize);
-        dir->i_mtime = dir->i_ctime = CURRENT_TIME;
+        dir->i_mtime = dir->i_ctime = current_time(dir);
 
         di->i_size = cpu_to_le64(sb->s_blocksize);
         di->i_ctime = di->i_mtime = cpu_to_le64(dir->i_ctime.tv_sec);
diff --git a/fs/ocfs2/dlmfs/dlmfs.c b/fs/ocfs2/dlmfs/dlmfs.c
index a0c3e03f9cd3..1079fae5aa12 100644
--- a/fs/ocfs2/dlmfs/dlmfs.c
+++ b/fs/ocfs2/dlmfs/dlmfs.c
@@ -398,7 +398,7 @@ static struct inode *dlmfs_get_root_inode(struct super_block *sb)
         if (inode) {
                 inode->i_ino = get_next_ino();
                 inode_init_owner(inode, NULL, mode);
-                inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
+                inode->i_atime = inode->i_mtime = inode->i_ctime = current_time(inode);
                 inc_nlink(inode);
 
                 inode->i_fop = &simple_dir_operations;
@@ -421,7 +421,7 @@ static struct inode *dlmfs_get_inode(struct inode *parent,
 
         inode->i_ino = get_next_ino();
         inode_init_owner(inode, parent, mode);
-        inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
+        inode->i_atime = inode->i_mtime = inode->i_ctime = current_time(inode);
 
         ip = DLMFS_I(inode);
         ip->ip_conn = DLMFS_I(parent)->ip_conn;
diff --git a/fs/ocfs2/file.c b/fs/ocfs2/file.c
index ba5c177d0ed6..000c234d7bbd 100644
--- a/fs/ocfs2/file.c
+++ b/fs/ocfs2/file.c
@@ -253,7 +253,7 @@ int ocfs2_should_update_atime(struct inode *inode,
                 return 0;
         }
 
-        now = CURRENT_TIME;
+        now = current_time(inode);
         if ((now.tv_sec - inode->i_atime.tv_sec <= osb->s_atime_quantum))
                 return 0;
         else
@@ -287,7 +287,7 @@ int ocfs2_update_inode_atime(struct inode *inode,
          * have i_mutex to guard against concurrent changes to other
          * inode fields.
          */
-        inode->i_atime = CURRENT_TIME;
+        inode->i_atime = current_time(inode);
         di->i_atime = cpu_to_le64(inode->i_atime.tv_sec);
         di->i_atime_nsec = cpu_to_le32(inode->i_atime.tv_nsec);
         ocfs2_update_inode_fsync_trans(handle, inode, 0);
@@ -308,7 +308,7 @@ int ocfs2_set_inode_size(handle_t *handle,
 
         i_size_write(inode, new_i_size);
         inode->i_blocks = ocfs2_inode_sector_count(inode);
-        inode->i_ctime = inode->i_mtime = CURRENT_TIME;
+        inode->i_ctime = inode->i_mtime = current_time(inode);
 
         status = ocfs2_mark_inode_dirty(handle, inode, fe_bh);
         if (status < 0) {
@@ -429,7 +429,7 @@ static int ocfs2_orphan_for_truncate(struct ocfs2_super *osb,
         }
 
         i_size_write(inode, new_i_size);
-        inode->i_ctime = inode->i_mtime = CURRENT_TIME;
+        inode->i_ctime = inode->i_mtime = current_time(inode);
 
         di = (struct ocfs2_dinode *) fe_bh->b_data;
         di->i_size = cpu_to_le64(new_i_size);
@@ -840,7 +840,7 @@ static int ocfs2_write_zero_page(struct inode *inode, u64 abs_from,
         i_size_write(inode, abs_to);
         inode->i_blocks = ocfs2_inode_sector_count(inode);
         di->i_size = cpu_to_le64((u64)i_size_read(inode));
-        inode->i_mtime = inode->i_ctime = CURRENT_TIME;
+        inode->i_mtime = inode->i_ctime = current_time(inode);
         di->i_mtime = di->i_ctime = cpu_to_le64(inode->i_mtime.tv_sec);
         di->i_ctime_nsec = cpu_to_le32(inode->i_mtime.tv_nsec);
         di->i_mtime_nsec = di->i_ctime_nsec;
@@ -1950,7 +1950,7 @@ static int __ocfs2_change_file_space(struct file *file, struct inode *inode,
         if (change_size && i_size_read(inode) < size)
                 i_size_write(inode, size);
 
-        inode->i_ctime = inode->i_mtime = CURRENT_TIME;
+        inode->i_ctime = inode->i_mtime = current_time(inode);
         ret = ocfs2_mark_inode_dirty(handle, inode, di_bh);
         if (ret < 0)
                 mlog_errno(ret);
diff --git a/fs/ocfs2/move_extents.c b/fs/ocfs2/move_extents.c
index e3d05d9901a3..4e8f32eb0bdb 100644
--- a/fs/ocfs2/move_extents.c
+++ b/fs/ocfs2/move_extents.c
@@ -953,7 +953,7 @@ static int ocfs2_move_extents(struct ocfs2_move_extents_context *context)
         }
 
         di = (struct ocfs2_dinode *)di_bh->b_data;
-        inode->i_ctime = CURRENT_TIME;
+        inode->i_ctime = current_time(inode);
         di->i_ctime = cpu_to_le64(inode->i_ctime.tv_sec);
         di->i_ctime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec);
         ocfs2_update_inode_fsync_trans(handle, inode, 0);
diff --git a/fs/ocfs2/namei.c b/fs/ocfs2/namei.c
index 6cc043ebb9fa..8d887c75765c 100644
--- a/fs/ocfs2/namei.c
+++ b/fs/ocfs2/namei.c
@@ -798,7 +798,7 @@ static int ocfs2_link(struct dentry *old_dentry,
         }
 
         inc_nlink(inode);
-        inode->i_ctime = CURRENT_TIME;
+        inode->i_ctime = current_time(inode);
         ocfs2_set_links_count(fe, inode->i_nlink);
         fe->i_ctime = cpu_to_le64(inode->i_ctime.tv_sec);
         fe->i_ctime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec);
@@ -1000,7 +1000,7 @@ static int ocfs2_unlink(struct inode *dir,
         ocfs2_set_links_count(fe, inode->i_nlink);
         ocfs2_journal_dirty(handle, fe_bh);
 
-        dir->i_ctime = dir->i_mtime = CURRENT_TIME;
+        dir->i_ctime = dir->i_mtime = current_time(dir);
         if (S_ISDIR(inode->i_mode))
                 drop_nlink(dir);
 
@@ -1203,7 +1203,8 @@ static void ocfs2_double_unlock(struct inode *inode1, struct inode *inode2)
 static int ocfs2_rename(struct inode *old_dir,
                         struct dentry *old_dentry,
                         struct inode *new_dir,
-                        struct dentry *new_dentry)
+                        struct dentry *new_dentry,
+                        unsigned int flags)
 {
         int status = 0, rename_lock = 0, parents_locked = 0, target_exists = 0;
         int old_child_locked = 0, new_child_locked = 0, update_dot_dot = 0;
@@ -1228,6 +1229,9 @@ static int ocfs2_rename(struct inode *old_dir,
         struct ocfs2_dir_lookup_result target_insert = { NULL, };
         bool should_add_orphan = false;
 
+        if (flags)
+                return -EINVAL;
+
         /* At some point it might be nice to break this function up a
          * bit. */
 
@@ -1537,7 +1541,7 @@ static int ocfs2_rename(struct inode *old_dir,
                                          new_dir_bh, &target_insert);
         }
 
-        old_inode->i_ctime = CURRENT_TIME;
+        old_inode->i_ctime = current_time(old_inode);
         mark_inode_dirty(old_inode);
 
         status = ocfs2_journal_access_di(handle, INODE_CACHE(old_inode),
@@ -1586,9 +1590,9 @@ static int ocfs2_rename(struct inode *old_dir,
 
         if (new_inode) {
                 drop_nlink(new_inode);
-                new_inode->i_ctime = CURRENT_TIME;
+                new_inode->i_ctime = current_time(new_inode);
         }
-        old_dir->i_ctime = old_dir->i_mtime = CURRENT_TIME;
+        old_dir->i_ctime = old_dir->i_mtime = current_time(old_dir);
 
         if (update_dot_dot) {
                 status = ocfs2_update_entry(old_inode, handle,
diff --git a/fs/ocfs2/refcounttree.c b/fs/ocfs2/refcounttree.c
index 92bbe93bfe10..19238512a324 100644
--- a/fs/ocfs2/refcounttree.c
+++ b/fs/ocfs2/refcounttree.c
@@ -3778,7 +3778,7 @@ static int ocfs2_change_ctime(struct inode *inode,
                 goto out_commit;
         }
 
-        inode->i_ctime = CURRENT_TIME;
+        inode->i_ctime = current_time(inode);
         di->i_ctime = cpu_to_le64(inode->i_ctime.tv_sec);
         di->i_ctime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec);
 
@@ -4094,7 +4094,7 @@ static int ocfs2_complete_reflink(struct inode *s_inode,
                  * we want mtime to appear identical to the source and
                  * update ctime.
                  */
-                t_inode->i_ctime = CURRENT_TIME;
+                t_inode->i_ctime = current_time(t_inode);
 
                 di->i_ctime = cpu_to_le64(t_inode->i_ctime.tv_sec);
                 di->i_ctime_nsec = cpu_to_le32(t_inode->i_ctime.tv_nsec);
diff --git a/fs/ocfs2/xattr.c b/fs/ocfs2/xattr.c
index 5bb44f7a78ee..cb157a34a656 100644
--- a/fs/ocfs2/xattr.c
+++ b/fs/ocfs2/xattr.c
@@ -3431,7 +3431,7 @@ static int __ocfs2_xattr_set_handle(struct inode *inode,
                         goto out;
                 }
 
-                inode->i_ctime = CURRENT_TIME;
+                inode->i_ctime = current_time(inode);
                 di->i_ctime = cpu_to_le64(inode->i_ctime.tv_sec);
                 di->i_ctime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec);
                 ocfs2_journal_dirty(ctxt->handle, xis->inode_bh);
diff --git a/fs/omfs/dir.c b/fs/omfs/dir.c
index c8cbf3b60645..b7146526afff 100644
--- a/fs/omfs/dir.c
+++ b/fs/omfs/dir.c
@@ -143,7 +143,7 @@ static int omfs_add_link(struct dentry *dentry, struct inode *inode)
         mark_buffer_dirty(bh);
         brelse(bh);
 
-        dir->i_ctime = CURRENT_TIME_SEC;
+        dir->i_ctime = current_time(dir);
 
         /* mark affected inodes dirty to rebuild checksums */
         mark_inode_dirty(dir);
@@ -371,12 +371,16 @@ static bool omfs_fill_chain(struct inode *dir, struct dir_context *ctx,
 }
 
 static int omfs_rename(struct inode *old_dir, struct dentry *old_dentry,
-                struct inode *new_dir, struct dentry *new_dentry)
+                       struct inode *new_dir, struct dentry *new_dentry,
+                       unsigned int flags)
 {
         struct inode *new_inode = d_inode(new_dentry);
         struct inode *old_inode = d_inode(old_dentry);
         int err;
 
+        if (flags & ~RENAME_NOREPLACE)
+                return -EINVAL;
+
         if (new_inode) {
                 /* overwriting existing file/dir */
                 err = omfs_remove(new_dir, new_dentry);
@@ -395,7 +399,7 @@ static int omfs_rename(struct inode *old_dir, struct dentry *old_dentry,
         if (err)
                 goto out;
 
-        old_inode->i_ctime = CURRENT_TIME_SEC;
+        old_inode->i_ctime = current_time(old_inode);
         mark_inode_dirty(old_inode);
 out:
         return err;
diff --git a/fs/omfs/inode.c b/fs/omfs/inode.c
index 3d935c81789a..df7ea8543a2e 100644
--- a/fs/omfs/inode.c
+++ b/fs/omfs/inode.c
@@ -49,7 +49,7 @@ struct inode *omfs_new_inode(struct inode *dir, umode_t mode)
         inode_init_owner(inode, NULL, mode);
         inode->i_mapping->a_ops = &omfs_aops;
 
-        inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
+        inode->i_atime = inode->i_mtime = inode->i_ctime = current_time(inode);
         switch (mode & S_IFMT) {
         case S_IFDIR:
                 inode->i_op = &omfs_dir_inops;
diff --git a/fs/openpromfs/inode.c b/fs/openpromfs/inode.c
index c7a86993d97e..c003a667ed1a 100644
--- a/fs/openpromfs/inode.c
+++ b/fs/openpromfs/inode.c
@@ -355,7 +355,7 @@ static struct inode *openprom_iget(struct super_block *sb, ino_t ino)
         if (!inode)
                 return ERR_PTR(-ENOMEM);
         if (inode->i_state & I_NEW) {
-                inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
+                inode->i_mtime = inode->i_atime = inode->i_ctime = current_time(inode);
                 if (inode->i_ino == OPENPROM_ROOT_INO) {
                         inode->i_op = &openprom_inode_operations;
                         inode->i_fop = &openprom_operations;
diff --git a/fs/orangefs/file.c b/fs/orangefs/file.c
index 2aa088ab713b..66ea0cc37b18 100644
--- a/fs/orangefs/file.c
+++ b/fs/orangefs/file.c
@@ -384,7 +384,7 @@ out:
                         file_accessed(file);
                 } else {
                         SetMtimeFlag(orangefs_inode);
-                        inode->i_mtime = CURRENT_TIME;
+                        inode->i_mtime = current_time(inode);
                         mark_inode_dirty_sync(inode);
                 }
         }
diff --git a/fs/orangefs/inode.c b/fs/orangefs/inode.c
index 0e3bd7e07f88..ef3b4eb54cf2 100644
--- a/fs/orangefs/inode.c
+++ b/fs/orangefs/inode.c
@@ -435,7 +435,7 @@ struct inode *orangefs_new_inode(struct super_block *sb, struct inode *dir,
         inode->i_mode = mode;
         inode->i_uid = current_fsuid();
         inode->i_gid = current_fsgid();
-        inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
+        inode->i_atime = inode->i_mtime = inode->i_ctime = current_time(inode);
         inode->i_size = PAGE_SIZE;
         inode->i_rdev = dev;
 
diff --git a/fs/orangefs/namei.c b/fs/orangefs/namei.c
index 4d5576a21c82..d15d3d2dba62 100644
--- a/fs/orangefs/namei.c
+++ b/fs/orangefs/namei.c
@@ -81,7 +81,7 @@ static int orangefs_create(struct inode *dir,
                      dentry);
 
         SetMtimeFlag(parent);
-        dir->i_mtime = dir->i_ctime = current_fs_time(dir->i_sb);
+        dir->i_mtime = dir->i_ctime = current_time(dir);
         mark_inode_dirty_sync(dir);
         ret = 0;
 out:
@@ -254,7 +254,7 @@ static int orangefs_unlink(struct inode *dir, struct dentry *dentry)
                 drop_nlink(inode);
 
                 SetMtimeFlag(parent);
-                dir->i_mtime = dir->i_ctime = current_fs_time(dir->i_sb);
+                dir->i_mtime = dir->i_ctime = current_time(dir);
                 mark_inode_dirty_sync(dir);
         }
         return ret;
@@ -331,7 +331,7 @@ static int orangefs_symlink(struct inode *dir,
                      dentry);
 
         SetMtimeFlag(parent);
-        dir->i_mtime = dir->i_ctime = current_fs_time(dir->i_sb);
+        dir->i_mtime = dir->i_ctime = current_time(dir);
         mark_inode_dirty_sync(dir);
         ret = 0;
 out:
@@ -399,7 +399,7 @@ static int orangefs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode
          * across clients; keep constant at 1.
          */
         SetMtimeFlag(parent);
-        dir->i_mtime = dir->i_ctime = current_fs_time(dir->i_sb);
+        dir->i_mtime = dir->i_ctime = current_time(dir);
         mark_inode_dirty_sync(dir);
 out:
         op_release(new_op);
@@ -409,11 +409,15 @@ out:
 static int orangefs_rename(struct inode *old_dir,
                         struct dentry *old_dentry,
                         struct inode *new_dir,
-                        struct dentry *new_dentry)
+                        struct dentry *new_dentry,
+                        unsigned int flags)
 {
         struct orangefs_kernel_op_s *new_op;
         int ret;
 
+        if (flags)
+                return -EINVAL;
+
         gossip_debug(GOSSIP_NAME_DEBUG,
                      "orangefs_rename: called (%pd2 => %pd2) ct=%d\n",
                      old_dentry, new_dentry, d_count(new_dentry));
@@ -443,7 +447,7 @@ static int orangefs_rename(struct inode *old_dir,
                      ret);
 
         if (new_dentry->d_inode)
-                new_dentry->d_inode->i_ctime = CURRENT_TIME;
+                new_dentry->d_inode->i_ctime = current_time(new_dentry->d_inode);
 
         op_release(new_op);
         return ret;
diff --git a/fs/overlayfs/dir.c b/fs/overlayfs/dir.c
index 3a60e68ec965..5f90ddf778ba 100644
--- a/fs/overlayfs/dir.c
+++ b/fs/overlayfs/dir.c
@@ -1006,7 +1006,7 @@ const struct inode_operations ovl_dir_inode_operations = {
         .symlink        = ovl_symlink,
         .unlink         = ovl_unlink,
         .rmdir          = ovl_rmdir,
-        .rename2        = ovl_rename2,
+        .rename         = ovl_rename2,
         .link           = ovl_link,
         .setattr        = ovl_setattr,
         .create         = ovl_create,
diff --git a/fs/overlayfs/overlayfs.h b/fs/overlayfs/overlayfs.h
index 5813ccff8cd9..e218e741cb99 100644
--- a/fs/overlayfs/overlayfs.h
+++ b/fs/overlayfs/overlayfs.h
@@ -114,13 +114,13 @@ static inline int ovl_do_rename(struct inode *olddir, struct dentry *olddentry,
 {
         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;
diff --git a/fs/pipe.c b/fs/pipe.c
index 4fc422f0dea8..1f559f0608e1 100644
--- a/fs/pipe.c
+++ b/fs/pipe.c
@@ -713,7 +713,7 @@ static struct inode * get_pipe_inode(void)
         inode->i_mode = S_IFIFO | S_IRUSR | S_IWUSR;
         inode->i_uid = current_fsuid();
         inode->i_gid = current_fsgid();
-        inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
+        inode->i_atime = inode->i_mtime = inode->i_ctime = current_time(inode);
 
         return inode;
 
diff --git a/fs/posix_acl.c b/fs/posix_acl.c
index da3f760a7e88..595522022aca 100644
--- a/fs/posix_acl.c
+++ b/fs/posix_acl.c
@@ -929,7 +929,7 @@ int simple_set_acl(struct inode *inode, struct posix_acl *acl, int type)
                         acl = NULL;
         }
 
-        inode->i_ctime = CURRENT_TIME;
+        inode->i_ctime = current_time(inode);
         set_cached_acl(inode, type, acl);
         return 0;
 }
diff --git a/fs/proc/base.c b/fs/proc/base.c
index 29fd7ef97be9..c2964d890c9a 100644
--- a/fs/proc/base.c
+++ b/fs/proc/base.c
@@ -1671,7 +1671,7 @@ struct inode *proc_pid_make_inode(struct super_block * sb, struct task_struct *t
         /* Common stuff */
         ei = PROC_I(inode);
         inode->i_ino = get_next_ino();
-        inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
+        inode->i_mtime = inode->i_atime = inode->i_ctime = current_time(inode);
         inode->i_op = &proc_def_inode_operations;
 
         /*
diff --git a/fs/proc/inode.c b/fs/proc/inode.c
index c1b72388e571..e69ebe648a34 100644
--- a/fs/proc/inode.c
+++ b/fs/proc/inode.c
@@ -68,7 +68,6 @@ static struct inode *proc_alloc_inode(struct super_block *sb)
         ei->sysctl_entry = NULL;
         ei->ns_ops = NULL;
         inode = &ei->vfs_inode;
-        inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
         return inode;
 }
 
@@ -421,7 +420,7 @@ struct inode *proc_get_inode(struct super_block *sb, struct proc_dir_entry *de)
 
         if (inode) {
                 inode->i_ino = de->low_ino;
-                inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
+                inode->i_mtime = inode->i_atime = inode->i_ctime = current_time(inode);
                 PROC_I(inode)->pde = de;
 
                 if (is_empty_pde(de)) {
diff --git a/fs/proc/proc_sysctl.c b/fs/proc/proc_sysctl.c
index f908b78bce55..55313d994895 100644
--- a/fs/proc/proc_sysctl.c
+++ b/fs/proc/proc_sysctl.c
@@ -445,7 +445,7 @@ static struct inode *proc_sys_make_inode(struct super_block *sb,
         ei->sysctl = head;
         ei->sysctl_entry = table;
 
-        inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
+        inode->i_mtime = inode->i_atime = inode->i_ctime = current_time(inode);
         inode->i_mode = table->mode;
         if (!S_ISDIR(table->mode)) {
                 inode->i_mode |= S_IFREG;
diff --git a/fs/proc/self.c b/fs/proc/self.c
index b6a8d3529fea..40245954c450 100644
--- a/fs/proc/self.c
+++ b/fs/proc/self.c
@@ -56,7 +56,7 @@ int proc_setup_self(struct super_block *s)
                 struct inode *inode = new_inode_pseudo(s);
                 if (inode) {
                         inode->i_ino = self_inum;
-                        inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
+                        inode->i_mtime = inode->i_atime = inode->i_ctime = current_time(inode);
                         inode->i_mode = S_IFLNK | S_IRWXUGO;
                         inode->i_uid = GLOBAL_ROOT_UID;
                         inode->i_gid = GLOBAL_ROOT_GID;
diff --git a/fs/proc/thread_self.c b/fs/proc/thread_self.c
index e58a31e8fb2a..595b90a9766c 100644
--- a/fs/proc/thread_self.c
+++ b/fs/proc/thread_self.c
@@ -58,7 +58,7 @@ int proc_setup_thread_self(struct super_block *s)
                 struct inode *inode = new_inode_pseudo(s);
                 if (inode) {
                         inode->i_ino = thread_self_inum;
-                        inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
+                        inode->i_mtime = inode->i_atime = inode->i_ctime = current_time(inode);
                         inode->i_mode = S_IFLNK | S_IRWXUGO;
                         inode->i_uid = GLOBAL_ROOT_UID;
                         inode->i_gid = GLOBAL_ROOT_GID;
diff --git a/fs/pstore/inode.c b/fs/pstore/inode.c
index ec9ddef5ae75..1781dc50762e 100644
--- a/fs/pstore/inode.c
+++ b/fs/pstore/inode.c
@@ -230,7 +230,7 @@ static struct inode *pstore_get_inode(struct super_block *sb)
         struct inode *inode = new_inode(sb);
         if (inode) {
                 inode->i_ino = get_next_ino();
-                inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
+                inode->i_atime = inode->i_mtime = inode->i_ctime = current_time(inode);
         }
         return inode;
 }
diff --git a/fs/ramfs/inode.c b/fs/ramfs/inode.c
index 1ab6e6c2e60e..8621c039b536 100644
--- a/fs/ramfs/inode.c
+++ b/fs/ramfs/inode.c
@@ -61,7 +61,7 @@ struct inode *ramfs_get_inode(struct super_block *sb,
                 inode->i_mapping->a_ops = &ramfs_aops;
                 mapping_set_gfp_mask(inode->i_mapping, GFP_HIGHUSER);
                 mapping_set_unevictable(inode->i_mapping);
-                inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
+                inode->i_atime = inode->i_mtime = inode->i_ctime = current_time(inode);
                 switch (mode & S_IFMT) {
                 default:
                         init_special_inode(inode, mode, dev);
@@ -100,7 +100,7 @@ ramfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, dev_t dev)
                 d_instantiate(dentry, inode);
                 dget(dentry);   /* Extra count - pin the dentry in core */
                 error = 0;
-                dir->i_mtime = dir->i_ctime = CURRENT_TIME;
+                dir->i_mtime = dir->i_ctime = current_time(dir);
         }
         return error;
 }
@@ -130,7 +130,7 @@ static int ramfs_symlink(struct inode * dir, struct dentry *dentry, const char *
                 if (!error) {
                         d_instantiate(dentry, inode);
                         dget(dentry);
-                        dir->i_mtime = dir->i_ctime = CURRENT_TIME;
+                        dir->i_mtime = dir->i_ctime = current_time(dir);
                 } else
                         iput(inode);
         }
diff --git a/fs/reiserfs/inode.c b/fs/reiserfs/inode.c
index cb7f518d37ae..58b2dedb2a3a 100644
--- a/fs/reiserfs/inode.c
+++ b/fs/reiserfs/inode.c
@@ -2005,7 +2005,7 @@ int reiserfs_new_inode(struct reiserfs_transaction_handle *th,
         if (S_ISLNK(inode->i_mode))
                 inode->i_flags &= ~(S_IMMUTABLE | S_APPEND);
 
-        inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME_SEC;
+        inode->i_mtime = inode->i_atime = inode->i_ctime = current_time(inode);
         inode->i_size = i_size;
         inode->i_blocks = 0;
         inode->i_bytes = 0;
diff --git a/fs/reiserfs/ioctl.c b/fs/reiserfs/ioctl.c
index 2f1ddc908013..1f4692a505a0 100644
--- a/fs/reiserfs/ioctl.c
+++ b/fs/reiserfs/ioctl.c
@@ -94,7 +94,7 @@ long reiserfs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
                         }
                         sd_attrs_to_i_attrs(flags, inode);
                         REISERFS_I(inode)->i_attrs = flags;
-                        inode->i_ctime = CURRENT_TIME_SEC;
+                        inode->i_ctime = current_time(inode);
                         mark_inode_dirty(inode);
 setflags_out:
                         mnt_drop_write_file(filp);
@@ -115,7 +115,7 @@ setflags_out:
                         err = -EFAULT;
                         goto setversion_out;
                 }
-                inode->i_ctime = CURRENT_TIME_SEC;
+                inode->i_ctime = current_time(inode);
                 mark_inode_dirty(inode);
 setversion_out:
                 mnt_drop_write_file(filp);
diff --git a/fs/reiserfs/namei.c b/fs/reiserfs/namei.c
index fd7d0606aa96..e6a2b406af36 100644
--- a/fs/reiserfs/namei.c
+++ b/fs/reiserfs/namei.c
@@ -570,7 +570,7 @@ static int reiserfs_add_entry(struct reiserfs_transaction_handle *th,
         }
 
         dir->i_size += paste_size;
-        dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC;
+        dir->i_mtime = dir->i_ctime = current_time(dir);
         if (!S_ISDIR(inode->i_mode) && visible)
                 /* reiserfs_mkdir or reiserfs_rename will do that by itself */
                 reiserfs_update_sd(th, dir);
@@ -963,7 +963,7 @@ static int reiserfs_rmdir(struct inode *dir, struct dentry *dentry)
                                inode->i_nlink);
 
         clear_nlink(inode);
-        inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME_SEC;
+        inode->i_ctime = dir->i_ctime = dir->i_mtime = current_time(dir);
         reiserfs_update_sd(&th, inode);
 
         DEC_DIR_INODE_NLINK(dir)
@@ -1067,11 +1067,11 @@ static int reiserfs_unlink(struct inode *dir, struct dentry *dentry)
                 inc_nlink(inode);
                 goto end_unlink;
         }
-        inode->i_ctime = CURRENT_TIME_SEC;
+        inode->i_ctime = current_time(inode);
         reiserfs_update_sd(&th, inode);
 
         dir->i_size -= (de.de_entrylen + DEH_SIZE);
-        dir->i_ctime = dir->i_mtime = CURRENT_TIME_SEC;
+        dir->i_ctime = dir->i_mtime = current_time(dir);
         reiserfs_update_sd(&th, dir);
 
         if (!savelink)
@@ -1246,7 +1246,7 @@ static int reiserfs_link(struct dentry *old_dentry, struct inode *dir,
                 return err ? err : retval;
         }
 
-        inode->i_ctime = CURRENT_TIME_SEC;
+        inode->i_ctime = current_time(inode);
         reiserfs_update_sd(&th, inode);
 
         ihold(inode);
@@ -1306,7 +1306,8 @@ static void set_ino_in_dir_entry(struct reiserfs_dir_entry *de,
  * get_empty_nodes or its clones
  */
 static int reiserfs_rename(struct inode *old_dir, struct dentry *old_dentry,
-                           struct inode *new_dir, struct dentry *new_dentry)
+                           struct inode *new_dir, struct dentry *new_dentry,
+                           unsigned int flags)
 {
         int retval;
         INITIALIZE_PATH(old_entry_path);
@@ -1321,6 +1322,9 @@ static int reiserfs_rename(struct inode *old_dir, struct dentry *old_dentry,
         unsigned long savelink = 1;
         struct timespec ctime;
 
+        if (flags & ~RENAME_NOREPLACE)
+                return -EINVAL;
+
         /*
          * three balancings: (1) old name removal, (2) new name insertion
          * and (3) maybe "save" link insertion
@@ -1567,7 +1571,7 @@ static int reiserfs_rename(struct inode *old_dir, struct dentry *old_dentry,
 
         mark_de_hidden(old_de.de_deh + old_de.de_entry_num);
         journal_mark_dirty(&th, old_de.de_bh);
-        ctime = CURRENT_TIME_SEC;
+        ctime = current_time(old_dir);
         old_dir->i_ctime = old_dir->i_mtime = ctime;
         new_dir->i_ctime = new_dir->i_mtime = ctime;
         /*
diff --git a/fs/reiserfs/stree.c b/fs/reiserfs/stree.c
index 4032d1e87c8f..a97e352d05d3 100644
--- a/fs/reiserfs/stree.c
+++ b/fs/reiserfs/stree.c
@@ -1987,8 +1987,8 @@ int reiserfs_do_truncate(struct reiserfs_transaction_handle *th,
                         pathrelse(&s_search_path);
 
                         if (update_timestamps) {
-                                inode->i_mtime = CURRENT_TIME_SEC;
-                                inode->i_ctime = CURRENT_TIME_SEC;
+                                inode->i_mtime = current_time(inode);
+                                inode->i_ctime = current_time(inode);
                         }
                         reiserfs_update_sd(th, inode);
 
@@ -2012,8 +2012,8 @@ int reiserfs_do_truncate(struct reiserfs_transaction_handle *th,
 update_and_out:
         if (update_timestamps) {
                 /* this is truncate, not file closing */
-                inode->i_mtime = CURRENT_TIME_SEC;
-                inode->i_ctime = CURRENT_TIME_SEC;
+                inode->i_mtime = current_time(inode);
+                inode->i_ctime = current_time(inode);
         }
         reiserfs_update_sd(th, inode);
 
diff --git a/fs/reiserfs/super.c b/fs/reiserfs/super.c
index 74d5ddd26296..0a6ad4e71e88 100644
--- a/fs/reiserfs/super.c
+++ b/fs/reiserfs/super.c
@@ -2522,7 +2522,7 @@ out:
         if (inode->i_size < off + len - towrite)
                 i_size_write(inode, off + len - towrite);
         inode->i_version++;
-        inode->i_mtime = inode->i_ctime = CURRENT_TIME;
+        inode->i_mtime = inode->i_ctime = current_time(inode);
         mark_inode_dirty(inode);
         return len - towrite;
 }
diff --git a/fs/reiserfs/xattr.c b/fs/reiserfs/xattr.c
index a33812ae9fad..e87aa21c30de 100644
--- a/fs/reiserfs/xattr.c
+++ b/fs/reiserfs/xattr.c
@@ -450,13 +450,13 @@ int reiserfs_commit_write(struct file *f, struct page *page,
 
 static void update_ctime(struct inode *inode)
 {
-        struct timespec now = current_fs_time(inode->i_sb);
+        struct timespec now = current_time(inode);
 
         if (inode_unhashed(inode) || !inode->i_nlink ||
             timespec_equal(&inode->i_ctime, &now))
                 return;
 
-        inode->i_ctime = CURRENT_TIME_SEC;
+        inode->i_ctime = current_time(inode);
         mark_inode_dirty(inode);
 }
 
@@ -575,7 +575,7 @@ reiserfs_xattr_set_handle(struct reiserfs_transaction_handle *th,
         new_size = buffer_size + sizeof(struct reiserfs_xattr_header);
         if (!err && new_size < i_size_read(d_inode(dentry))) {
                 struct iattr newattrs = {
-                        .ia_ctime = current_fs_time(inode->i_sb),
+                        .ia_ctime = current_time(inode),
                         .ia_size = new_size,
                         .ia_valid = ATTR_SIZE | ATTR_CTIME,
                 };
diff --git a/fs/reiserfs/xattr_acl.c b/fs/reiserfs/xattr_acl.c
index 27376681c640..3d2256a425ee 100644
--- a/fs/reiserfs/xattr_acl.c
+++ b/fs/reiserfs/xattr_acl.c
@@ -273,7 +273,7 @@ __reiserfs_set_acl(struct reiserfs_transaction_handle *th, struct inode *inode,
         if (error == -ENODATA) {
                 error = 0;
                 if (type == ACL_TYPE_ACCESS) {
-                        inode->i_ctime = CURRENT_TIME_SEC;
+                        inode->i_ctime = current_time(inode);
                         mark_inode_dirty(inode);
                 }
         }
diff --git a/fs/sysv/dir.c b/fs/sysv/dir.c
index 2661b77fc8a7..5bdae85ceef7 100644
--- a/fs/sysv/dir.c
+++ b/fs/sysv/dir.c
@@ -215,7 +215,7 @@ got_it:
         memset (de->name + namelen, 0, SYSV_DIRSIZE - namelen - 2);
         de->inode = cpu_to_fs16(SYSV_SB(inode->i_sb), inode->i_ino);
         err = dir_commit_chunk(page, pos, SYSV_DIRSIZE);
-        dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC;
+        dir->i_mtime = dir->i_ctime = current_time(dir);
         mark_inode_dirty(dir);
 out_page:
         dir_put_page(page);
@@ -239,7 +239,7 @@ int sysv_delete_entry(struct sysv_dir_entry *de, struct page *page)
         de->inode = 0;
         err = dir_commit_chunk(page, pos, SYSV_DIRSIZE);
         dir_put_page(page);
-        inode->i_ctime = inode->i_mtime = CURRENT_TIME_SEC;
+        inode->i_ctime = inode->i_mtime = current_time(inode);
         mark_inode_dirty(inode);
         return err;
 }
@@ -337,7 +337,7 @@ void sysv_set_link(struct sysv_dir_entry *de, struct page *page,
         de->inode = cpu_to_fs16(SYSV_SB(inode->i_sb), inode->i_ino);
         err = dir_commit_chunk(page, pos, SYSV_DIRSIZE);
         dir_put_page(page);
-        dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC;
+        dir->i_mtime = dir->i_ctime = current_time(dir);
         mark_inode_dirty(dir);
 }
 
diff --git a/fs/sysv/ialloc.c b/fs/sysv/ialloc.c
index f9db4eb31db4..53f1b78996dd 100644
--- a/fs/sysv/ialloc.c
+++ b/fs/sysv/ialloc.c
@@ -164,7 +164,7 @@ struct inode * sysv_new_inode(const struct inode * dir, umode_t mode)
         dirty_sb(sb);
         inode_init_owner(inode, dir, mode);
         inode->i_ino = fs16_to_cpu(sbi, ino);
-        inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME_SEC;
+        inode->i_mtime = inode->i_atime = inode->i_ctime = current_time(inode);
         inode->i_blocks = 0;
         memset(SYSV_I(inode)->i_data, 0, sizeof(SYSV_I(inode)->i_data));
         SYSV_I(inode)->i_dir_start_lookup = 0;
diff --git a/fs/sysv/itree.c b/fs/sysv/itree.c
index 2fde40acf024..08d3e630b49c 100644
--- a/fs/sysv/itree.c
+++ b/fs/sysv/itree.c
@@ -178,7 +178,7 @@ static inline int splice_branch(struct inode *inode,
         *where->p = where->key;
         write_unlock(&pointers_lock);
 
-        inode->i_ctime = CURRENT_TIME_SEC;
+        inode->i_ctime = current_time(inode);
 
         /* had we spliced it onto indirect block? */
         if (where->bh)
@@ -418,7 +418,7 @@ do_indirects:
                 }
                 n++;
         }
-        inode->i_mtime = inode->i_ctime = CURRENT_TIME_SEC;
+        inode->i_mtime = inode->i_ctime = current_time(inode);
         if (IS_SYNC(inode))
                 sysv_sync_inode (inode);
         else
diff --git a/fs/sysv/namei.c b/fs/sysv/namei.c
index a42de45ce40d..d8817f139763 100644
--- a/fs/sysv/namei.c
+++ b/fs/sysv/namei.c
@@ -120,7 +120,7 @@ static int sysv_link(struct dentry * old_dentry, struct inode * dir,
 {
         struct inode *inode = d_inode(old_dentry);
 
-        inode->i_ctime = CURRENT_TIME_SEC;
+        inode->i_ctime = current_time(inode);
         inode_inc_link_count(inode);
         ihold(inode);
 
@@ -206,7 +206,8 @@ static int sysv_rmdir(struct inode * dir, struct dentry * dentry)
  * higher-level routines.
  */
 static int sysv_rename(struct inode * old_dir, struct dentry * old_dentry,
-                  struct inode * new_dir, struct dentry * new_dentry)
+                       struct inode * new_dir, struct dentry * new_dentry,
+                       unsigned int flags)
 {
         struct inode * old_inode = d_inode(old_dentry);
         struct inode * new_inode = d_inode(new_dentry);
@@ -216,6 +217,9 @@ static int sysv_rename(struct inode * old_dir, struct dentry * old_dentry,
         struct sysv_dir_entry * old_de;
         int err = -ENOENT;
 
+        if (flags & ~RENAME_NOREPLACE)
+                return -EINVAL;
+
         old_de = sysv_find_entry(old_dentry, &old_page);
         if (!old_de)
                 goto out;
@@ -240,7 +244,7 @@ static int sysv_rename(struct inode * old_dir, struct dentry * old_dentry,
                 if (!new_de)
                         goto out_dir;
                 sysv_set_link(new_de, new_page, old_inode);
-                new_inode->i_ctime = CURRENT_TIME_SEC;
+                new_inode->i_ctime = current_time(new_inode);
                 if (dir_de)
                         drop_nlink(new_inode);
                 inode_dec_link_count(new_inode);
diff --git a/fs/tracefs/inode.c b/fs/tracefs/inode.c
index ad40b64c5e2f..21d36d284735 100644
--- a/fs/tracefs/inode.c
+++ b/fs/tracefs/inode.c
@@ -133,7 +133,7 @@ static struct inode *tracefs_get_inode(struct super_block *sb)
         struct inode *inode = new_inode(sb);
         if (inode) {
                 inode->i_ino = get_next_ino();
-                inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
+                inode->i_atime = inode->i_mtime = inode->i_ctime = current_time(inode);
         }
         return inode;
 }
diff --git a/fs/ubifs/dir.c b/fs/ubifs/dir.c
index 1d55aeaebf23..64902702b17d 100644
--- a/fs/ubifs/dir.c
+++ b/fs/ubifs/dir.c
@@ -966,7 +966,8 @@ static void unlock_3_inodes(struct inode *inode1, struct inode *inode2,
 }
 
 static int ubifs_rename(struct inode *old_dir, struct dentry *old_dentry,
-                        struct inode *new_dir, struct dentry *new_dentry)
+                        struct inode *new_dir, struct dentry *new_dentry,
+                        unsigned int flags)
 {
         struct ubifs_info *c = old_dir->i_sb->s_fs_info;
         struct inode *old_inode = d_inode(old_dentry);
@@ -984,6 +985,9 @@ static int ubifs_rename(struct inode *old_dir, struct dentry *old_dentry,
         struct timespec time;
         unsigned int uninitialized_var(saved_nlink);
 
+        if (flags & ~RENAME_NOREPLACE)
+                return -EINVAL;
+
         /*
          * Budget request settings: deletion direntry, new direntry, removing
          * the old inode, and changing old and new parent directory inodes.
@@ -1179,7 +1183,7 @@ const struct inode_operations ubifs_dir_inode_operations = {
         .mkdir       = ubifs_mkdir,
         .rmdir       = ubifs_rmdir,
         .mknod       = ubifs_mknod,
-        .rename      = ubifs_rename,
+        .rename     = ubifs_rename,
         .setattr     = ubifs_setattr,
         .getattr     = ubifs_getattr,
         .listxattr   = ubifs_listxattr,
diff --git a/fs/udf/ialloc.c b/fs/udf/ialloc.c
index e77db621ec89..c1ed18a10ce4 100644
--- a/fs/udf/ialloc.c
+++ b/fs/udf/ialloc.c
@@ -121,7 +121,7 @@ struct inode *udf_new_inode(struct inode *dir, umode_t mode)
         else
                 iinfo->i_alloc_type = ICBTAG_FLAG_AD_LONG;
         inode->i_mtime = inode->i_atime = inode->i_ctime =
-                iinfo->i_crtime = current_fs_time(inode->i_sb);
+                iinfo->i_crtime = current_time(inode);
         if (unlikely(insert_inode_locked(inode) < 0)) {
                 make_bad_inode(inode);
                 iput(inode);
diff --git a/fs/udf/inode.c b/fs/udf/inode.c
index 55aa587bbc38..aad46401ede5 100644
--- a/fs/udf/inode.c
+++ b/fs/udf/inode.c
@@ -886,7 +886,7 @@ static sector_t inode_getblk(struct inode *inode, sector_t block,
         *new = 1;
         iinfo->i_next_alloc_block = block;
         iinfo->i_next_alloc_goal = newblocknum;
-        inode->i_ctime = current_fs_time(inode->i_sb);
+        inode->i_ctime = current_time(inode);
 
         if (IS_SYNC(inode))
                 udf_sync_inode(inode);
@@ -1268,7 +1268,7 @@ set_size:
                 up_write(&iinfo->i_data_sem);
         }
 update_time:
-        inode->i_mtime = inode->i_ctime = current_fs_time(inode->i_sb);
+        inode->i_mtime = inode->i_ctime = current_time(inode);
         if (IS_SYNC(inode))
                 udf_sync_inode(inode);
         else
diff --git a/fs/udf/namei.c b/fs/udf/namei.c
index c3e5c9679371..2d65e280748b 100644
--- a/fs/udf/namei.c
+++ b/fs/udf/namei.c
@@ -616,7 +616,7 @@ static int udf_add_nondir(struct dentry *dentry, struct inode *inode)
         *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
                 cpu_to_le32(iinfo->i_unique & 0x00000000FFFFFFFFUL);
         udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL);
-        dir->i_ctime = dir->i_mtime = current_fs_time(dir->i_sb);
+        dir->i_ctime = dir->i_mtime = current_time(dir);
         mark_inode_dirty(dir);
         if (fibh.sbh != fibh.ebh)
                 brelse(fibh.ebh);
@@ -730,7 +730,7 @@ static int udf_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
         cfi.fileCharacteristics |= FID_FILE_CHAR_DIRECTORY;
         udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL);
         inc_nlink(dir);
-        dir->i_ctime = dir->i_mtime = current_fs_time(dir->i_sb);
+        dir->i_ctime = dir->i_mtime = current_time(dir);
         mark_inode_dirty(dir);
         unlock_new_inode(inode);
         d_instantiate(dentry, inode);
@@ -845,7 +845,7 @@ static int udf_rmdir(struct inode *dir, struct dentry *dentry)
         inode->i_size = 0;
         inode_dec_link_count(dir);
         inode->i_ctime = dir->i_ctime = dir->i_mtime =
-                                                current_fs_time(dir->i_sb);
+                                                current_time(inode);
         mark_inode_dirty(dir);
 
 end_rmdir:
@@ -888,7 +888,7 @@ static int udf_unlink(struct inode *dir, struct dentry *dentry)
         retval = udf_delete_entry(dir, fi, &fibh, &cfi);
         if (retval)
                 goto end_unlink;
-        dir->i_ctime = dir->i_mtime = current_fs_time(dir->i_sb);
+        dir->i_ctime = dir->i_mtime = current_time(dir);
         mark_inode_dirty(dir);
         inode_dec_link_count(inode);
         inode->i_ctime = dir->i_ctime;
@@ -1079,9 +1079,9 @@ static int udf_link(struct dentry *old_dentry, struct inode *dir,
                 brelse(fibh.ebh);
         brelse(fibh.sbh);
         inc_nlink(inode);
-        inode->i_ctime = current_fs_time(inode->i_sb);
+        inode->i_ctime = current_time(inode);
         mark_inode_dirty(inode);
-        dir->i_ctime = dir->i_mtime = current_fs_time(dir->i_sb);
+        dir->i_ctime = dir->i_mtime = current_time(dir);
         mark_inode_dirty(dir);
         ihold(inode);
         d_instantiate(dentry, inode);
@@ -1093,7 +1093,8 @@ static int udf_link(struct dentry *old_dentry, struct inode *dir,
  * higher-level routines.
  */
 static int udf_rename(struct inode *old_dir, struct dentry *old_dentry,
-                      struct inode *new_dir, struct dentry *new_dentry)
+                      struct inode *new_dir, struct dentry *new_dentry,
+                      unsigned int flags)
 {
         struct inode *old_inode = d_inode(old_dentry);
         struct inode *new_inode = d_inode(new_dentry);
@@ -1105,6 +1106,9 @@ static int udf_rename(struct inode *old_dir, struct dentry *old_dentry,
         struct kernel_lb_addr tloc;
         struct udf_inode_info *old_iinfo = UDF_I(old_inode);
 
+        if (flags & ~RENAME_NOREPLACE)
+                return -EINVAL;
+
         ofi = udf_find_entry(old_dir, &old_dentry->d_name, &ofibh, &ocfi);
         if (IS_ERR(ofi)) {
                 retval = PTR_ERR(ofi);
@@ -1172,7 +1176,7 @@ static int udf_rename(struct inode *old_dir, struct dentry *old_dentry,
          * Like most other Unix systems, set the ctime for inodes on a
          * rename.
          */
-        old_inode->i_ctime = current_fs_time(old_inode->i_sb);
+        old_inode->i_ctime = current_time(old_inode);
         mark_inode_dirty(old_inode);
 
         /*
@@ -1188,11 +1192,11 @@ static int udf_rename(struct inode *old_dir, struct dentry *old_dentry,
         udf_delete_entry(old_dir, ofi, &ofibh, &ocfi);
 
         if (new_inode) {
-                new_inode->i_ctime = current_fs_time(new_inode->i_sb);
+                new_inode->i_ctime = current_time(new_inode);
                 inode_dec_link_count(new_inode);
         }
-        old_dir->i_ctime = old_dir->i_mtime = current_fs_time(old_dir->i_sb);
-        new_dir->i_ctime = new_dir->i_mtime = current_fs_time(new_dir->i_sb);
+        old_dir->i_ctime = old_dir->i_mtime = current_time(old_dir);
+        new_dir->i_ctime = new_dir->i_mtime = current_time(new_dir);
         mark_inode_dirty(old_dir);
         mark_inode_dirty(new_dir);
 
diff --git a/fs/ufs/dir.c b/fs/ufs/dir.c
index fa3bda1a860f..de01b8f2aa78 100644
--- a/fs/ufs/dir.c
+++ b/fs/ufs/dir.c
@@ -100,7 +100,7 @@ void ufs_set_link(struct inode *dir, struct ufs_dir_entry *de,
         err = ufs_commit_chunk(page, pos, len);
         ufs_put_page(page);
         if (update_times)
-                dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC;
+                dir->i_mtime = dir->i_ctime = current_time(dir);
         mark_inode_dirty(dir);
 }
 
@@ -389,7 +389,7 @@ got_it:
         ufs_set_de_type(sb, de, inode->i_mode);
 
         err = ufs_commit_chunk(page, pos, rec_len);
-        dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC;
+        dir->i_mtime = dir->i_ctime = current_time(dir);
 
         mark_inode_dirty(dir);
         /* OFFSET_CACHE */
@@ -530,7 +530,7 @@ int ufs_delete_entry(struct inode *inode, struct ufs_dir_entry *dir,
                 pde->d_reclen = cpu_to_fs16(sb, to - from);
         dir->d_ino = 0;
         err = ufs_commit_chunk(page, pos, to - from);
-        inode->i_ctime = inode->i_mtime = CURRENT_TIME_SEC;
+        inode->i_ctime = inode->i_mtime = current_time(inode);
         mark_inode_dirty(inode);
 out:
         ufs_put_page(page);
diff --git a/fs/ufs/ialloc.c b/fs/ufs/ialloc.c
index fd0203ce1f7f..9774555b3721 100644
--- a/fs/ufs/ialloc.c
+++ b/fs/ufs/ialloc.c
@@ -290,7 +290,7 @@ cg_found:
         inode_init_owner(inode, dir, mode);
         inode->i_blocks = 0;
         inode->i_generation = 0;
-        inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME_SEC;
+        inode->i_mtime = inode->i_atime = inode->i_ctime = current_time(inode);
         ufsi->i_flags = UFS_I(dir)->i_flags;
         ufsi->i_lastfrag = 0;
         ufsi->i_shadow = 0;
diff --git a/fs/ufs/inode.c b/fs/ufs/inode.c
index e4a4d248a0f5..190d64be22ed 100644
--- a/fs/ufs/inode.c
+++ b/fs/ufs/inode.c
@@ -293,7 +293,7 @@ ufs_inode_getfrag(struct inode *inode, unsigned index,
 
         if (new)
                 *new = 1;
-        inode->i_ctime = CURRENT_TIME_SEC;
+        inode->i_ctime = current_time(inode);
         if (IS_SYNC(inode))
                 ufs_sync_inode (inode);
         mark_inode_dirty(inode);
@@ -375,7 +375,7 @@ ufs_inode_getblock(struct inode *inode, u64 ind_block,
         mark_buffer_dirty(bh);
         if (IS_SYNC(inode))
                 sync_dirty_buffer(bh);
-        inode->i_ctime = CURRENT_TIME_SEC;
+        inode->i_ctime = current_time(inode);
         mark_inode_dirty(inode);
 out:
         brelse (bh);
@@ -1185,7 +1185,7 @@ static int ufs_truncate(struct inode *inode, loff_t size)
         truncate_setsize(inode, size);
 
         __ufs_truncate_blocks(inode);
-        inode->i_mtime = inode->i_ctime = CURRENT_TIME_SEC;
+        inode->i_mtime = inode->i_ctime = current_time(inode);
         mark_inode_dirty(inode);
 out:
         UFSD("EXIT: err %d\n", err);
diff --git a/fs/ufs/namei.c b/fs/ufs/namei.c
index a1559f762805..8eca4eda8450 100644
--- a/fs/ufs/namei.c
+++ b/fs/ufs/namei.c
@@ -153,7 +153,7 @@ static int ufs_link (struct dentry * old_dentry, struct inode * dir,
         struct inode *inode = d_inode(old_dentry);
         int error;
 
-        inode->i_ctime = CURRENT_TIME_SEC;
+        inode->i_ctime = current_time(inode);
         inode_inc_link_count(inode);
         ihold(inode);
 
@@ -245,7 +245,8 @@ static int ufs_rmdir (struct inode * dir, struct dentry *dentry)
 }
 
 static int ufs_rename(struct inode *old_dir, struct dentry *old_dentry,
-                      struct inode *new_dir, struct dentry *new_dentry)
+                      struct inode *new_dir, struct dentry *new_dentry,
+                      unsigned int flags)
 {
         struct inode *old_inode = d_inode(old_dentry);
         struct inode *new_inode = d_inode(new_dentry);
@@ -255,6 +256,9 @@ static int ufs_rename(struct inode *old_dir, struct dentry *old_dentry,
         struct ufs_dir_entry *old_de;
         int err = -ENOENT;
 
+        if (flags & ~RENAME_NOREPLACE)
+                return -EINVAL;
+
         old_de = ufs_find_entry(old_dir, &old_dentry->d_name, &old_page);
         if (!old_de)
                 goto out;
@@ -279,7 +283,7 @@ static int ufs_rename(struct inode *old_dir, struct dentry *old_dentry,
                 if (!new_de)
                         goto out_dir;
                 ufs_set_link(new_dir, new_de, new_page, old_inode, 1);
-                new_inode->i_ctime = CURRENT_TIME_SEC;
+                new_inode->i_ctime = current_time(new_inode);
                 if (dir_de)
                         drop_nlink(new_inode);
                 inode_dec_link_count(new_inode);
@@ -295,7 +299,7 @@ static int ufs_rename(struct inode *old_dir, struct dentry *old_dentry,
          * Like most other Unix systems, set the ctime for inodes on a
          * rename.
          */
-        old_inode->i_ctime = CURRENT_TIME_SEC;
+        old_inode->i_ctime = current_time(old_inode);
 
         ufs_delete_entry(old_dir, old_de, old_page);
         mark_inode_dirty(old_inode);
diff --git a/fs/xfs/xfs_acl.c b/fs/xfs/xfs_acl.c
index 8a0dec89ca56..b468e041f207 100644
--- a/fs/xfs/xfs_acl.c
+++ b/fs/xfs/xfs_acl.c
@@ -236,7 +236,7 @@ xfs_set_mode(struct inode *inode, umode_t mode)
 
                 iattr.ia_valid = ATTR_MODE | ATTR_CTIME;
                 iattr.ia_mode = mode;
-                iattr.ia_ctime = current_fs_time(inode->i_sb);
+                iattr.ia_ctime = current_time(inode);
 
                 error = xfs_setattr_nonsize(XFS_I(inode), &iattr, XFS_ATTR_NOACL);
         }
diff --git a/fs/xfs/xfs_inode.c b/fs/xfs/xfs_inode.c
index df22e1254c98..624e1dfa716b 100644
--- a/fs/xfs/xfs_inode.c
+++ b/fs/xfs/xfs_inode.c
@@ -821,7 +821,7 @@ xfs_ialloc(
         ip->i_d.di_nextents = 0;
         ASSERT(ip->i_d.di_nblocks == 0);
 
-        tv = current_fs_time(mp->m_super);
+        tv = current_time(inode);
         inode->i_mtime = tv;
         inode->i_atime = tv;
         inode->i_ctime = tv;
diff --git a/fs/xfs/xfs_iops.c b/fs/xfs/xfs_iops.c
index a7404c5aafe2..c5da95eb79b8 100644
--- a/fs/xfs/xfs_iops.c
+++ b/fs/xfs/xfs_iops.c
@@ -896,7 +896,7 @@ xfs_setattr_size(
         if (newsize != oldsize &&
             !(iattr->ia_valid & (ATTR_CTIME | ATTR_MTIME))) {
                 iattr->ia_ctime = iattr->ia_mtime =
-                        current_fs_time(inode->i_sb);
+                        current_time(inode);
                 iattr->ia_valid |= ATTR_CTIME | ATTR_MTIME;
         }
 
@@ -1086,7 +1086,7 @@ static const struct inode_operations xfs_dir_inode_operations = {
          */
         .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,
@@ -1111,7 +1111,7 @@ static const struct inode_operations xfs_dir_ci_inode_operations = {
          */
         .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,
diff --git a/fs/xfs/xfs_trans_inode.c b/fs/xfs/xfs_trans_inode.c
index 11a3af08b5c7..dab8daa676f9 100644
--- a/fs/xfs/xfs_trans_inode.c
+++ b/fs/xfs/xfs_trans_inode.c
@@ -73,7 +73,7 @@ xfs_trans_ichgtime(
         ASSERT(tp);
         ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
 
-        tv = current_fs_time(inode->i_sb);
+        tv = current_time(inode);
 
         if (flags & XFS_ICHGTIME_MOD)
                 inode->i_mtime = tv;