Merge remote-tracking branch 'ovl/rename2' into for-linus

diff --git a/arch/powerpc/platforms/cell/spufs/inode.c b/arch/powerpc/platforms/cell/spufs/inode.c
index 2975754..5364d4a 100644 (file)
--- a/arch/powerpc/platforms/cell/spufs/inode.c
+++ b/arch/powerpc/platforms/cell/spufs/inode.c
@@ -103,7 +103,7 @@ spufs_new_inode(struct super_block *sb, umode_t mode)
        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);
 out:
        return inode;
 }

diff --git a/arch/s390/hypfs/inode.c b/arch/s390/hypfs/inode.c
index 255c7ee..09bccb2 100644 (file)
--- a/arch/s390/hypfs/inode.c
+++ b/arch/s390/hypfs/inode.c
@@ -51,7 +51,7 @@ static void hypfs_update_update(struct super_block *sb)
        struct inode *inode = d_inode(sb_info->update_file);
 
        sb_info->last_update = get_seconds();
-       inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
+       inode->i_atime = inode->i_mtime = inode->i_ctime = current_time(inode);
 }
 
 /* directory tree removal functions */
@@ -99,7 +99,7 @@ static struct inode *hypfs_make_inode(struct super_block *sb, umode_t mode)
                ret->i_mode = mode;
                ret->i_uid = hypfs_info->uid;
                ret->i_gid = hypfs_info->gid;
-               ret->i_atime = ret->i_mtime = ret->i_ctime = CURRENT_TIME;
+               ret->i_atime = ret->i_mtime = ret->i_ctime = current_time(ret);
                if (S_ISDIR(mode))
                        set_nlink(ret, 2);
        }

diff --git a/drivers/char/sonypi.c b/drivers/char/sonypi.c
index e496dae..719c5b4 100644 (file)
--- a/drivers/char/sonypi.c
+++ b/drivers/char/sonypi.c
@@ -934,7 +934,7 @@ static ssize_t sonypi_misc_read(struct file *file, char __user *buf,
 
        if (ret > 0) {
                struct inode *inode = file_inode(file);
-               inode->i_atime = current_fs_time(inode->i_sb);
+               inode->i_atime = current_time(inode);
        }
 
        return ret;

diff --git a/drivers/infiniband/hw/qib/qib_fs.c b/drivers/infiniband/hw/qib/qib_fs.c
index c3edc03..f1e66ef 100644 (file)
--- a/drivers/infiniband/hw/qib/qib_fs.c
+++ b/drivers/infiniband/hw/qib/qib_fs.c
@@ -64,7 +64,7 @@ static int qibfs_mknod(struct inode *dir, struct dentry *dentry,
        inode->i_uid = GLOBAL_ROOT_UID;
        inode->i_gid = GLOBAL_ROOT_GID;
        inode->i_blocks = 0;
-       inode->i_atime = CURRENT_TIME;
+       inode->i_atime = current_time(inode);
        inode->i_mtime = inode->i_atime;
        inode->i_ctime = inode->i_atime;
        inode->i_private = data;

diff --git a/drivers/misc/ibmasm/ibmasmfs.c b/drivers/misc/ibmasm/ibmasmfs.c
index 9c677f3..520f584 100644 (file)
--- a/drivers/misc/ibmasm/ibmasmfs.c
+++ b/drivers/misc/ibmasm/ibmasmfs.c
@@ -144,7 +144,7 @@ static struct inode *ibmasmfs_make_inode(struct super_block *sb, int mode)
        if (ret) {
                ret->i_ino = get_next_ino();
                ret->i_mode = mode;
-               ret->i_atime = ret->i_mtime = ret->i_ctime = CURRENT_TIME;
+               ret->i_atime = ret->i_mtime = ret->i_ctime = current_time(ret);
        }
        return ret;
 }

diff --git a/drivers/oprofile/oprofilefs.c b/drivers/oprofile/oprofilefs.c
index a0e5260..134398e 100644 (file)
--- a/drivers/oprofile/oprofilefs.c
+++ b/drivers/oprofile/oprofilefs.c
@@ -30,7 +30,7 @@ static struct inode *oprofilefs_get_inode(struct super_block *sb, int mode)
        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);
        }
        return inode;
 }

diff --git a/drivers/platform/x86/sony-laptop.c b/drivers/platform/x86/sony-laptop.c
index 1dba359..c890a49 100644 (file)
--- a/drivers/platform/x86/sony-laptop.c
+++ b/drivers/platform/x86/sony-laptop.c
@@ -4116,7 +4116,7 @@ static ssize_t sonypi_misc_read(struct file *file, char __user *buf,
 
        if (ret > 0) {
                struct inode *inode = file_inode(file);
-               inode->i_atime = current_fs_time(inode->i_sb);
+               inode->i_atime = current_time(inode);
        }
 
        return ret;

diff --git a/drivers/usb/core/devio.c b/drivers/usb/core/devio.c
index 09c8d9c..4016dae 100644 (file)
--- a/drivers/usb/core/devio.c
+++ b/drivers/usb/core/devio.c
@@ -2409,21 +2409,21 @@ static long usbdev_do_ioctl(struct file *file, unsigned int cmd,
                snoop(&dev->dev, "%s: CONTROL\n", __func__);
                ret = proc_control(ps, p);
                if (ret >= 0)
-                       inode->i_mtime = CURRENT_TIME;
+                       inode->i_mtime = current_time(inode);
                break;
 
        case USBDEVFS_BULK:
                snoop(&dev->dev, "%s: BULK\n", __func__);
                ret = proc_bulk(ps, p);
                if (ret >= 0)
-                       inode->i_mtime = CURRENT_TIME;
+                       inode->i_mtime = current_time(inode);
                break;
 
        case USBDEVFS_RESETEP:
                snoop(&dev->dev, "%s: RESETEP\n", __func__);
                ret = proc_resetep(ps, p);
                if (ret >= 0)
-                       inode->i_mtime = CURRENT_TIME;
+                       inode->i_mtime = current_time(inode);
                break;
 
        case USBDEVFS_RESET:
@@ -2435,7 +2435,7 @@ static long usbdev_do_ioctl(struct file *file, unsigned int cmd,
                snoop(&dev->dev, "%s: CLEAR_HALT\n", __func__);
                ret = proc_clearhalt(ps, p);
                if (ret >= 0)
-                       inode->i_mtime = CURRENT_TIME;
+                       inode->i_mtime = current_time(inode);
                break;
 
        case USBDEVFS_GETDRIVER:
@@ -2462,7 +2462,7 @@ static long usbdev_do_ioctl(struct file *file, unsigned int cmd,
                snoop(&dev->dev, "%s: SUBMITURB\n", __func__);
                ret = proc_submiturb(ps, p);
                if (ret >= 0)
-                       inode->i_mtime = CURRENT_TIME;
+                       inode->i_mtime = current_time(inode);
                break;
 
 #ifdef CONFIG_COMPAT
@@ -2470,14 +2470,14 @@ static long usbdev_do_ioctl(struct file *file, unsigned int cmd,
                snoop(&dev->dev, "%s: CONTROL32\n", __func__);
                ret = proc_control_compat(ps, p);
                if (ret >= 0)
-                       inode->i_mtime = CURRENT_TIME;
+                       inode->i_mtime = current_time(inode);
                break;
 
        case USBDEVFS_BULK32:
                snoop(&dev->dev, "%s: BULK32\n", __func__);
                ret = proc_bulk_compat(ps, p);
                if (ret >= 0)
-                       inode->i_mtime = CURRENT_TIME;
+                       inode->i_mtime = current_time(inode);
                break;
 
        case USBDEVFS_DISCSIGNAL32:
@@ -2489,7 +2489,7 @@ static long usbdev_do_ioctl(struct file *file, unsigned int cmd,
                snoop(&dev->dev, "%s: SUBMITURB32\n", __func__);
                ret = proc_submiturb_compat(ps, p);
                if (ret >= 0)
-                       inode->i_mtime = CURRENT_TIME;
+                       inode->i_mtime = current_time(inode);
                break;
 
        case USBDEVFS_IOCTL32:
@@ -2552,7 +2552,7 @@ static long usbdev_do_ioctl(struct file *file, unsigned int cmd,
  done:
        usb_unlock_device(dev);
        if (ret >= 0)
-               inode->i_atime = CURRENT_TIME;
+               inode->i_atime = current_time(inode);
        return ret;
 }
 

diff --git a/drivers/usb/gadget/function/f_fs.c b/drivers/usb/gadget/function/f_fs.c
index 5c8429f..2f3fa4d 100644 (file)
--- a/drivers/usb/gadget/function/f_fs.c
+++ b/drivers/usb/gadget/function/f_fs.c
@@ -1193,15 +1193,15 @@ ffs_sb_make_inode(struct super_block *sb, void *data,
        inode = new_inode(sb);
 
        if (likely(inode)) {
-               struct timespec current_time = CURRENT_TIME;
+               struct timespec ts = current_time(inode);
 
                inode->i_ino     = get_next_ino();
                inode->i_mode    = perms->mode;
                inode->i_uid     = perms->uid;
                inode->i_gid     = perms->gid;
-               inode->i_atime   = current_time;
-               inode->i_mtime   = current_time;
-               inode->i_ctime   = current_time;
+               inode->i_atime   = ts;
+               inode->i_mtime   = ts;
+               inode->i_ctime   = ts;
                inode->i_private = data;
                if (fops)
                        inode->i_fop = fops;

diff --git a/drivers/usb/gadget/legacy/inode.c b/drivers/usb/gadget/legacy/inode.c
index 16104b5..bd82dd1 100644 (file)
--- a/drivers/usb/gadget/legacy/inode.c
+++ b/drivers/usb/gadget/legacy/inode.c
@@ -1913,7 +1913,7 @@ gadgetfs_make_inode (struct super_block *sb,
                inode->i_uid = make_kuid(&init_user_ns, default_uid);
                inode->i_gid = make_kgid(&init_user_ns, default_gid);
                inode->i_atime = inode->i_mtime = inode->i_ctime
-                               = CURRENT_TIME;
+                               = current_time(inode);
                inode->i_private = data;
                inode->i_fop = fops;
        }

diff --git a/fs/9p/vfs_inode.c b/fs/9p/vfs_inode.c
index 0ad3c6c..8bea369 100644 (file)
--- 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) {

diff --git a/fs/adfs/inode.c b/fs/adfs/inode.c
index 335055d..860f3ec 100644 (file)
--- 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/amigaffs.c b/fs/affs/amigaffs.c
index d8f217c..0ec65c1 100644 (file)
--- 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 0fdb0f5..ed120ec 100644 (file)
--- 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/attr.c b/fs/attr.c
index 42bb42b..236d113 100644 (file)
--- a/fs/attr.c
+++ b/fs/attr.c
@@ -209,7 +209,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 61b2105..ca9cbd6 100644 (file)
--- 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 fa84bb8..623510e 100644 (file)
--- 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 536d2a3..9fc451e 100644 (file)
--- a/fs/bad_inode.c
+++ b/fs/bad_inode.c
@@ -173,7 +173,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_fop = &bad_file_ops;   
 }

diff --git a/fs/bfs/dir.c b/fs/bfs/dir.c
index 5e3369f..3e5ac30 100644 (file)
--- 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);
@@ -253,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);
@@ -304,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 6103a63..9b4688a 100644 (file)
--- 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 fea31a4..dad53ce 100644 (file)
--- 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 c666020..a240270 100644 (file)
--- 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);
 
@@ -9492,7 +9492,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);
@@ -9860,7 +9860,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);
@@ -9885,7 +9885,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;
@@ -10403,7 +10403,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) &&

diff --git a/fs/btrfs/ioctl.c b/fs/btrfs/ioctl.c
index 7fd939b..b182197 100644 (file)
--- 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 95d4191..c294313 100644 (file)
--- 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 d1a177a..fccbf55 100644 (file)
--- 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/ceph/file.c b/fs/ceph/file.c
index 0f5375d..a37a343 100644 (file)
--- 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 dd3a6db..ca1ccf7 100644 (file)
--- a/fs/ceph/inode.c
+++ b/fs/ceph/inode.c
@@ -2080,7 +2080,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 adc2318..40b7032 100644 (file)
--- 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/file.c b/fs/cifs/file.c
index 579e41b..00b6bf0 100644 (file)
--- 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)
@@ -3571,7 +3571,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 82aceae..c0474ac 100644 (file)
--- 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
 }
 

diff --git a/fs/coda/file.c b/fs/coda/file.c
index f47c748..42be8a6 100644 (file)
--- a/fs/coda/file.c
+++ b/fs/coda/file.c
@@ -75,7 +75,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 57e81cb..71dbe7e 100644 (file)
--- 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 0387968..ad718e5 100644 (file)
--- 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 5ac27c9..f17fcf8 100644 (file)
--- 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;
 }

diff --git a/fs/devpts/inode.c b/fs/devpts/inode.c
index 79a5941..9156c91 100644 (file)
--- a/fs/devpts/inode.c
+++ b/fs/devpts/inode.c
@@ -305,7 +305,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));
@@ -411,7 +411,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;
@@ -559,7 +559,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/efivarfs/inode.c b/fs/efivarfs/inode.c
index 1d73fc6..be5a336 100644 (file)
--- 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 f69a1b5..7910165 100644 (file)
--- 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 9dc4c6d..4327f71 100644 (file)
--- 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 53d8382..7295cd7 100644 (file)
--- 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);
 
@@ -265,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);
@@ -279,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);

diff --git a/fs/ext2/acl.c b/fs/ext2/acl.c
index 42f1d18..80c1e57 100644 (file)
--- a/fs/ext2/acl.c
+++ b/fs/ext2/acl.c
@@ -194,7 +194,7 @@ ext2_set_acl(struct inode *inode, struct posix_acl *acl, int type)
                                if (error < 0)
                                        return error;
                                else {
-                                       inode->i_ctime = CURRENT_TIME_SEC;
+                                       inode->i_ctime = current_time(inode);
                                        mark_inode_dirty(inode);
                                        if (error == 0)
                                                acl = NULL;

diff --git a/fs/ext2/dir.c b/fs/ext2/dir.c
index 61ad490..d9650c9 100644 (file)
--- 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 efe5fb2..43dc9c5 100644 (file)
--- a/fs/ext2/ialloc.c
+++ b/fs/ext2/ialloc.c
@@ -551,7 +551,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 d5c7d09..b66a658 100644 (file)
--- a/fs/ext2/inode.c
+++ b/fs/ext2/inode.c
@@ -594,7 +594,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);
 }
 
@@ -1236,7 +1236,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 b386af2..9d61742 100644 (file)
--- 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 be32e20..7d66b20 100644 (file)
--- 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);
 
@@ -376,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);
@@ -392,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 1d93795..6cb042b 100644 (file)
--- 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 b7f896f..fbdb8f1 100644 (file)
--- 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/f2fs/dir.c b/fs/f2fs/dir.c
index 9054aea..8e5309c 100644 (file)
--- a/fs/f2fs/dir.c
+++ b/fs/f2fs/dir.c
@@ -299,7 +299,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);
 }
@@ -451,7 +451,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)
@@ -656,7 +656,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)) {
@@ -703,7 +703,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 28f4f4c..b831d76 100644 (file)
--- 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);
                }
        }
 
@@ -1395,7 +1395,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);
        }
@@ -1487,7 +1487,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 ccea873..b4af15b 100644 (file)
--- a/fs/f2fs/inline.c
+++ b/fs/f2fs/inline.c
@@ -569,7 +569,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 08e3d1d..71e36a7 100644 (file)
--- 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);
@@ -177,7 +177,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);
@@ -718,7 +718,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);
@@ -772,7 +772,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);
@@ -927,7 +927,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);
@@ -942,7 +942,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);

diff --git a/fs/f2fs/xattr.c b/fs/f2fs/xattr.c
index c8898b5..62f76ea 100644 (file)
--- a/fs/f2fs/xattr.c
+++ b/fs/f2fs/xattr.c
@@ -541,7 +541,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 663e428..81cecbe 100644 (file)
--- 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 f701856..fc71ff5 100644 (file)
--- 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 da04c02..338d2f7 100644 (file)
--- 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 a8f6aa9..7d6a105 100644 (file)
--- 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;

diff --git a/fs/fat/namei_vfat.c b/fs/fat/namei_vfat.c
index c5e48b8..bf46a2d 100644 (file)
--- a/fs/fat/namei_vfat.c
+++ b/fs/fat/namei_vfat.c
@@ -777,7 +777,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;
@@ -821,7 +821,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);
        dentry->d_time = dir->i_version;
 out:
@@ -847,7 +847,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);
        dentry->d_time = dir->i_version;
 out:
@@ -866,7 +866,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;
@@ -935,7 +935,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 f863ac6..6e22748 100644 (file)
--- 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 4bfeaa7..215b4be 100644 (file)
--- a/fs/fuse/dir.c
+++ b/fs/fuse/dir.c
@@ -637,7 +637,7 @@ static int fuse_symlink(struct inode *dir, struct dentry *entry,
 static inline 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);
        }
 }

diff --git a/fs/gfs2/bmap.c b/fs/gfs2/bmap.c
index 6e2bec1..9453422 100644 (file)
--- 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 fcb59b2..f75c9ae 100644 (file)
--- 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 56825cc..abc74e1 100644 (file)
--- a/fs/gfs2/inode.c
+++ b/fs/gfs2/inode.c
@@ -652,7 +652,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);
@@ -979,7 +979,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);
@@ -1063,7 +1063,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
@@ -1326,7 +1326,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);

diff --git a/fs/gfs2/quota.c b/fs/gfs2/quota.c
index 77930ca..422e640 100644 (file)
--- 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 3a28535..a4a5770 100644 (file)
--- 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 8f4afd3..8a66405 100644 (file)
--- 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 4f7a1b6..5de5c48 100644 (file)
--- 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;

diff --git a/fs/hfs/inode.c b/fs/hfs/inode.c
index c6a3241..b8b57ec 100644 (file)
--- a/fs/hfs/inode.c
+++ b/fs/hfs/inode.c
@@ -193,7 +193,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 142534d..a5e00f7 100644 (file)
--- 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 0635779..3cf0887 100644 (file)
--- 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:

diff --git a/fs/hfsplus/inode.c b/fs/hfsplus/inode.c
index 19462d7..c350cfb 100644 (file)
--- a/fs/hfsplus/inode.c
+++ b/fs/hfsplus/inode.c
@@ -369,7 +369,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 32a49e2..99627f8 100644 (file)
--- 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/hugetlbfs/inode.c b/fs/hugetlbfs/inode.c
index 4ea71eb..3053e20 100644 (file)
--- a/fs/hugetlbfs/inode.c
+++ b/fs/hugetlbfs/inode.c
@@ -657,7 +657,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;
@@ -702,7 +702,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;
@@ -741,7 +741,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);
                /*
@@ -790,7 +790,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;
@@ -827,7 +827,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 7e3ef3a..cadf75f 100644 (file)
--- a/fs/inode.c
+++ b/fs/inode.c
@@ -1636,7 +1636,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(mnt, inode, now))
                return false;
@@ -1670,7 +1670,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:
@@ -1793,7 +1793,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;
 
@@ -2049,3 +2049,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 bc2693d..8fd0a78 100644 (file)
--- a/fs/jffs2/acl.c
+++ b/fs/jffs2/acl.c
@@ -242,7 +242,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/fs.c b/fs/jffs2/fs.c
index ae2ebb2..2478e0b 100644 (file)
--- 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 21fa92b..4c1a6b5 100644 (file)
--- 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_equiv_mode(acl, &inode->i_mode);
                        if (rc < 0)
                                return rc;
-                       inode->i_ctime = CURRENT_TIME;
+                       inode->i_ctime = current_time(inode);
                        mark_inode_dirty(inode);
                        if (rc == 0)
                                acl = NULL;

diff --git a/fs/jfs/inode.c b/fs/jfs/inode.c
index ad3e7b1..054cc76 100644 (file)
--- 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 5e33cb9..375dd25 100644 (file)
--- 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 1d88df6..d1d7c43 100644 (file)
--- 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
@@ -1218,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 {
@@ -1281,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 */
@@ -1296,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);
        }
 
@@ -1429,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 cec8814..85671f7 100644 (file)
--- 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 0bf3c33..c60f3d3 100644 (file)
--- 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/inode.c b/fs/kernfs/inode.c
index 63b925d..43f6848 100644 (file)
--- a/fs/kernfs/inode.c
+++ b/fs/kernfs/inode.c
@@ -241,7 +241,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 4758353..d8ee308 100644 (file)
--- a/fs/libfs.c
+++ b/fs/libfs.c
@@ -265,7 +265,7 @@ struct dentry *mount_pseudo(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);
@@ -295,7 +295,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);
@@ -329,7 +329,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;
@@ -373,7 +373,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;
 }
@@ -524,7 +524,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);
@@ -550,7 +550,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);
@@ -1096,7 +1096,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 ee1b15f..b5152b0 100644 (file)
--- a/fs/locks.c
+++ b/fs/locks.c
@@ -1539,7 +1539,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 be37b90..c87ea52 100644 (file)
--- 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);
 }

diff --git a/fs/logfs/file.c b/fs/logfs/file.c
index f01ddfb..dae4f31 100644 (file)
--- 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 db9cfc5..f440a15 100644 (file)
--- 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 3fb8c6d..bf19bf4 100644 (file)
--- 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 742942a..c2c3fd3 100644 (file)
--- 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 31dcd51..7edc9b3 100644 (file)
--- 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 a731cab..4c57c9a 100644 (file)
--- 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 f7811d5..1e0f11f 100644 (file)
--- 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);
@@ -223,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/nfsd/blocklayout.c b/fs/nfsd/blocklayout.c
index 5a17084..0780ff8 100644 (file)
--- 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 908ebbf..582831a 100644 (file)
--- 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 af04f55..bf08403 100644 (file)
--- 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 f1d7989..1d2c3d7 100644 (file)
--- 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 ea94049..2b71c60 100644 (file)
--- 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);
 
@@ -395,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);
@@ -414,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 8f20d60..2b731bc 100644 (file)
--- a/fs/nsfs.c
+++ b/fs/nsfs.c
@@ -82,7 +82,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 e01287c..6b7588a 100644 (file)
--- 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 d15d492..d3c0096 100644 (file)
--- 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 2162434..acf0012 100644 (file)
--- 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 f165f86..f72712f 100644 (file)
--- 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 98d3654..3a22be4 100644 (file)
--- a/fs/ocfs2/aops.c
+++ b/fs/ocfs2/aops.c
@@ -2020,7 +2020,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 e1adf28..e7054e2 100644 (file)
--- 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 ef474cd..f0d9763 100644 (file)
--- 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 0b055bf..63bfc3b 100644 (file)
--- 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 e3d05d9..4e8f32e 100644 (file)
--- 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 7fb6a7f..0e0e387 100644 (file)
--- 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);
 
@@ -1541,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),
@@ -1590,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 92bbe93..1923851 100644 (file)
--- 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 5bb44f7..cb157a3 100644 (file)
--- 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 e81f06b..b714652 100644 (file)
--- 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);
@@ -399,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 3d935c8..df7ea85 100644 (file)
--- 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 c7a8699..c003a66 100644 (file)
--- 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 526040e..e799bb4 100644 (file)
--- a/fs/orangefs/file.c
+++ b/fs/orangefs/file.c
@@ -358,7 +358,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 28a0557..113d928 100644 (file)
--- a/fs/orangefs/inode.c
+++ b/fs/orangefs/inode.c
@@ -438,7 +438,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 5f015c5..0dfa868 100644 (file)
--- a/fs/orangefs/namei.c
+++ b/fs/orangefs/namei.c
@@ -81,7 +81,7 @@ static int orangefs_create(struct inode *dir,
                     dentry->d_name.name);
 
        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->d_name.name);
 
        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);
@@ -447,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/pipe.c b/fs/pipe.c
index 4ebe6b2..5c7c8b7 100644 (file)
--- a/fs/pipe.c
+++ b/fs/pipe.c
@@ -716,7 +716,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 59d47ab..ad0799c 100644 (file)
--- a/fs/posix_acl.c
+++ b/fs/posix_acl.c
@@ -897,7 +897,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 ac0df4d..029161d 100644 (file)
--- a/fs/proc/base.c
+++ b/fs/proc/base.c
@@ -1664,7 +1664,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 c1b7238..e69ebe6 100644 (file)
--- 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 1b93650..f9e2f7a 100644 (file)
--- a/fs/proc/proc_sysctl.c
+++ b/fs/proc/proc_sysctl.c
@@ -444,7 +444,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 b6a8d35..4024595 100644 (file)
--- 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 e58a31e..595b90a 100644 (file)
--- 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 ec9ddef..1781dc5 100644 (file)
--- 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 1ab6e6c..8621c03 100644 (file)
--- 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 c2c59f9..f0609c8 100644 (file)
--- 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 2f1ddc9..1f4692a 100644 (file)
--- 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 586260e..f9a0a2b 100644 (file)
--- 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);
@@ -1571,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 4032d1e..a97e352 100644 (file)
--- 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 7a4a85a..44edbf4 100644 (file)
--- a/fs/reiserfs/super.c
+++ b/fs/reiserfs/super.c
@@ -2512,7 +2512,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 a33812a..e87aa21 100644 (file)
--- 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 dbed42f..c6eaab0 100644 (file)
--- a/fs/reiserfs/xattr_acl.c
+++ b/fs/reiserfs/xattr_acl.c
@@ -277,7 +277,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 2661b77..5bdae85 100644 (file)
--- 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 f9db4eb..53f1b78 100644 (file)
--- 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 2fde40a..08d3e63 100644 (file)
--- 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 30bf678..d8817f1 100644 (file)
--- 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);
 
@@ -244,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 ad40b64..21d36d2 100644 (file)
--- 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/udf/ialloc.c b/fs/udf/ialloc.c
index e77db62..c1ed18a 100644 (file)
--- 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 55aa587..aad4640 100644 (file)
--- 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 17e9d4a..2d65e28 100644 (file)
--- 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);
@@ -1176,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);
 
        /*
@@ -1192,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 fa3bda1..de01b8f 100644 (file)
--- 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 fd0203c..9774555 100644 (file)
--- 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 9f49431..edd3c0a 100644 (file)
--- 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 f2f11c3..8eca4ed 100644 (file)
--- 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);
 
@@ -283,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);
@@ -299,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 b6e527b..74f7c68 100644 (file)
--- 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 e08eaea..020110b 100644 (file)
--- 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 a66c781..d8ac286 100644 (file)
--- a/fs/xfs/xfs_iops.c
+++ b/fs/xfs/xfs_iops.c
@@ -882,7 +882,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;
        }
 

diff --git a/fs/xfs/xfs_trans_inode.c b/fs/xfs/xfs_trans_inode.c
index 11a3af0..dab8daa 100644 (file)
--- 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;

diff --git a/include/linux/fs.h b/include/linux/fs.h
index cf7e621..17d5a35 100644 (file)
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -1459,6 +1459,7 @@ static inline void i_gid_write(struct inode *inode, gid_t gid)
 }
 
 extern struct timespec current_fs_time(struct super_block *sb);
+extern struct timespec current_time(struct inode *inode);
 
 /*
  * Snapshotting support.

diff --git a/ipc/mqueue.c b/ipc/mqueue.c
index 0b13ace..8cbd6e6 100644 (file)
--- a/ipc/mqueue.c
+++ b/ipc/mqueue.c
@@ -225,7 +225,7 @@ static struct inode *mqueue_get_inode(struct super_block *sb,
        inode->i_mode = mode;
        inode->i_uid = current_fsuid();
        inode->i_gid = current_fsgid();
-       inode->i_mtime = inode->i_ctime = inode->i_atime = CURRENT_TIME;
+       inode->i_mtime = inode->i_ctime = inode->i_atime = current_time(inode);
 
        if (S_ISREG(mode)) {
                struct mqueue_inode_info *info;
@@ -446,7 +446,7 @@ static int mqueue_create(struct inode *dir, struct dentry *dentry,
 
        put_ipc_ns(ipc_ns);
        dir->i_size += DIRENT_SIZE;
-       dir->i_ctime = dir->i_mtime = dir->i_atime = CURRENT_TIME;
+       dir->i_ctime = dir->i_mtime = dir->i_atime = current_time(dir);
 
        d_instantiate(dentry, inode);
        dget(dentry);
@@ -462,7 +462,7 @@ static int mqueue_unlink(struct inode *dir, struct dentry *dentry)
 {
        struct inode *inode = d_inode(dentry);
 
-       dir->i_ctime = dir->i_mtime = dir->i_atime = CURRENT_TIME;
+       dir->i_ctime = dir->i_mtime = dir->i_atime = current_time(dir);
        dir->i_size -= DIRENT_SIZE;
        drop_nlink(inode);
        dput(dentry);
@@ -500,7 +500,7 @@ static ssize_t mqueue_read_file(struct file *filp, char __user *u_data,
        if (ret <= 0)
                return ret;
 
-       file_inode(filp)->i_atime = file_inode(filp)->i_ctime = CURRENT_TIME;
+       file_inode(filp)->i_atime = file_inode(filp)->i_ctime = current_time(file_inode(filp));
        return ret;
 }
 
@@ -1060,7 +1060,7 @@ SYSCALL_DEFINE5(mq_timedsend, mqd_t, mqdes, const char __user *, u_msg_ptr,
                        __do_notify(info);
                }
                inode->i_atime = inode->i_mtime = inode->i_ctime =
-                               CURRENT_TIME;
+                               current_time(inode);
        }
 out_unlock:
        spin_unlock(&info->lock);
@@ -1156,7 +1156,7 @@ SYSCALL_DEFINE5(mq_timedreceive, mqd_t, mqdes, char __user *, u_msg_ptr,
                msg_ptr = msg_get(info);
 
                inode->i_atime = inode->i_mtime = inode->i_ctime =
-                               CURRENT_TIME;
+                               current_time(inode);
 
                /* There is now free space in queue. */
                pipelined_receive(&wake_q, info);
@@ -1277,7 +1277,7 @@ retry:
        if (u_notification == NULL) {
                if (info->notify_owner == task_tgid(current)) {
                        remove_notification(info);
-                       inode->i_atime = inode->i_ctime = CURRENT_TIME;
+                       inode->i_atime = inode->i_ctime = current_time(inode);
                }
        } else if (info->notify_owner != NULL) {
                ret = -EBUSY;
@@ -1302,7 +1302,7 @@ retry:
 
                info->notify_owner = get_pid(task_tgid(current));
                info->notify_user_ns = get_user_ns(current_user_ns());
-               inode->i_atime = inode->i_ctime = CURRENT_TIME;
+               inode->i_atime = inode->i_ctime = current_time(inode);
        }
        spin_unlock(&info->lock);
 out_fput:
@@ -1359,7 +1359,7 @@ SYSCALL_DEFINE3(mq_getsetattr, mqd_t, mqdes,
                        f.file->f_flags &= ~O_NONBLOCK;
                spin_unlock(&f.file->f_lock);
 
-               inode->i_atime = inode->i_ctime = CURRENT_TIME;
+               inode->i_atime = inode->i_ctime = current_time(inode);
        }
 
        spin_unlock(&info->lock);

diff --git a/kernel/bpf/inode.c b/kernel/bpf/inode.c
index 5967b87..1ed8473 100644 (file)
--- a/kernel/bpf/inode.c
+++ b/kernel/bpf/inode.c
@@ -97,7 +97,7 @@ static struct inode *bpf_get_inode(struct super_block *sb,
                return ERR_PTR(-ENOSPC);
 
        inode->i_ino = get_next_ino();
-       inode->i_atime = CURRENT_TIME;
+       inode->i_atime = current_time(inode);
        inode->i_mtime = inode->i_atime;
        inode->i_ctime = inode->i_atime;
 

diff --git a/mm/shmem.c b/mm/shmem.c
index efbef23..e7e8f8c 100644 (file)
--- a/mm/shmem.c
+++ b/mm/shmem.c
@@ -934,7 +934,7 @@ static void shmem_undo_range(struct inode *inode, loff_t lstart, loff_t lend,
 void shmem_truncate_range(struct inode *inode, loff_t lstart, loff_t lend)
 {
        shmem_undo_range(inode, lstart, lend, false);
-       inode->i_ctime = inode->i_mtime = CURRENT_TIME;
+       inode->i_ctime = inode->i_mtime = current_time(inode);
 }
 EXPORT_SYMBOL_GPL(shmem_truncate_range);
 
@@ -979,7 +979,7 @@ static int shmem_setattr(struct dentry *dentry, struct iattr *attr)
                        if (error)
                                return error;
                        i_size_write(inode, newsize);
-                       inode->i_ctime = inode->i_mtime = CURRENT_TIME;
+                       inode->i_ctime = inode->i_mtime = current_time(inode);
                }
                if (newsize <= oldsize) {
                        loff_t holebegin = round_up(newsize, PAGE_SIZE);
@@ -2083,7 +2083,7 @@ static struct inode *shmem_get_inode(struct super_block *sb, const struct inode
                inode->i_ino = get_next_ino();
                inode_init_owner(inode, dir, mode);
                inode->i_blocks = 0;
-               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_generation = get_seconds();
                info = SHMEM_I(inode);
                memset(info, 0, (char *)inode - (char *)info);
@@ -2854,7 +2854,7 @@ static long shmem_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);
 undone:
        spin_lock(&inode->i_lock);
        inode->i_private = NULL;
@@ -2907,7 +2907,7 @@ shmem_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, dev_t dev)
 
                error = 0;
                dir->i_size += BOGO_DIRENT_SIZE;
-               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 */
        }
@@ -2975,7 +2975,7 @@ static int shmem_link(struct dentry *old_dentry, struct inode *dir, struct dentr
                goto out;
 
        dir->i_size += BOGO_DIRENT_SIZE;
-       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);   /* New dentry reference */
        dget(dentry);           /* Extra pinning count for the created dentry */
@@ -2992,7 +2992,7 @@ static int shmem_unlink(struct inode *dir, struct dentry *dentry)
                shmem_free_inode(inode->i_sb);
 
        dir->i_size -= BOGO_DIRENT_SIZE;
-       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);   /* Undo the count from "create" - this does all the work */
        return 0;
@@ -3025,7 +3025,7 @@ static int shmem_exchange(struct inode *old_dir, struct dentry *old_dentry, stru
        old_dir->i_ctime = old_dir->i_mtime =
        new_dir->i_ctime = new_dir->i_mtime =
        d_inode(old_dentry)->i_ctime =
-       d_inode(new_dentry)->i_ctime = CURRENT_TIME;
+       d_inode(new_dentry)->i_ctime = current_time(old_dir);
 
        return 0;
 }
@@ -3099,7 +3099,7 @@ static int shmem_rename2(struct inode *old_dir, struct dentry *old_dentry, struc
        new_dir->i_size += BOGO_DIRENT_SIZE;
        old_dir->i_ctime = old_dir->i_mtime =
        new_dir->i_ctime = new_dir->i_mtime =
-       inode->i_ctime = CURRENT_TIME;
+       inode->i_ctime = current_time(old_dir);
        return 0;
 }
 
@@ -3154,7 +3154,7 @@ static int shmem_symlink(struct inode *dir, struct dentry *dentry, const char *s
                put_page(page);
        }
        dir->i_size += BOGO_DIRENT_SIZE;
-       dir->i_ctime = dir->i_mtime = CURRENT_TIME;
+       dir->i_ctime = dir->i_mtime = current_time(dir);
        d_instantiate(dentry, inode);
        dget(dentry);
        return 0;

diff --git a/net/sunrpc/rpc_pipe.c b/net/sunrpc/rpc_pipe.c
index 84f98cb..61a504f 100644 (file)
--- a/net/sunrpc/rpc_pipe.c
+++ b/net/sunrpc/rpc_pipe.c
@@ -477,7 +477,7 @@ rpc_get_inode(struct super_block *sb, umode_t mode)
                return NULL;
        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);
        switch (mode & S_IFMT) {
        case S_IFDIR:
                inode->i_fop = &simple_dir_operations;

diff --git a/security/apparmor/apparmorfs.c b/security/apparmor/apparmorfs.c
index 729e595..5923d56 100644 (file)
--- a/security/apparmor/apparmorfs.c
+++ b/security/apparmor/apparmorfs.c
@@ -381,7 +381,7 @@ void __aa_fs_profile_migrate_dents(struct aa_profile *old,
        for (i = 0; i < AAFS_PROF_SIZEOF; i++) {
                new->dents[i] = old->dents[i];
                if (new->dents[i])
-                       new->dents[i]->d_inode->i_mtime = CURRENT_TIME;
+                       new->dents[i]->d_inode->i_mtime = current_time(new->dents[i]->d_inode);
                old->dents[i] = NULL;
        }
 }

diff --git a/security/inode.c b/security/inode.c
index e3df905..9cb979d 100644 (file)
--- a/security/inode.c
+++ b/security/inode.c
@@ -117,7 +117,7 @@ struct dentry *securityfs_create_file(const char *name, umode_t mode,
 
        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_private = data;
        if (is_dir) {
                inode->i_op = &simple_dir_inode_operations;

diff --git a/security/selinux/selinuxfs.c b/security/selinux/selinuxfs.c
index 0765c5b..72c145d 100644 (file)
--- a/security/selinux/selinuxfs.c
+++ b/security/selinux/selinuxfs.c
@@ -1089,7 +1089,7 @@ static struct inode *sel_make_inode(struct super_block *sb, int mode)
 
        if (ret) {
                ret->i_mode = mode;
-               ret->i_atime = ret->i_mtime = ret->i_ctime = CURRENT_TIME;
+               ret->i_atime = ret->i_mtime = ret->i_ctime = current_time(ret);
        }
        return ret;
 }