fs: Replace CURRENT_TIME with current_time() for inode timestamps

CURRENT_TIME macro is not appropriate for filesystems as it
doesn't use the right granularity for filesystem timestamps.
Use current_time() instead.

CURRENT_TIME is also not y2038 safe.

This is also in preparation for the patch that transitions
vfs timestamps to use 64 bit time and hence make them
y2038 safe. As part of the effort current_time() will be
extended to do range checks. Hence, it is necessary for all
file system timestamps to use current_time(). Also,
current_time() will be transitioned along with vfs to be
y2038 safe.

Note that whenever a single call to current_time() is used
to change timestamps in different inodes, it is because they
share the same time granularity.

Signed-off-by: Deepa Dinamani <deepa.kernel@gmail.com>
Reviewed-by: Arnd Bergmann <arnd@arndb.de>
Acked-by: Felipe Balbi <balbi@kernel.org>
Acked-by: Steven Whitehouse <swhiteho@redhat.com>
Acked-by: Ryusuke Konishi <konishi.ryusuke@lab.ntt.co.jp>
Acked-by: David Sterba <dsterba@suse.com>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>

diff --git a/arch/powerpc/platforms/cell/spufs/inode.c b/arch/powerpc/platforms/cell/spufs/inode.c
index 2975754c65ea9514e4d7d10284a2beb42d6dd3cb..5364d4a542493880bc7b14d75c57b04cf2a5469d 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 255c7eec44810420ae1b4d7608142db58fbad7e7..09bccb224d03c7fcf91a80fd44a6564e65297b4d 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/infiniband/hw/qib/qib_fs.c b/drivers/infiniband/hw/qib/qib_fs.c
index c3edc033f7c4ca674380930f958c3b6b60c0cb0f..f1e66efea98a87f1a5327cbb638c51a7688bc3cc 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 9c677f3f3c26023c81f93c948e0388e41e8e1a52..520f5843908023e7ae654b913f45ee9dd581751f 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 a0e5260bd006df0818d4ef2bd9296b50152bf1ac..134398e0231be380c0af84e960e95b838cd2dce2 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/usb/core/devio.c b/drivers/usb/core/devio.c
index 09c8d9ca61aea24d7b3d6669baacd0b43b7f04f6..4016dae7433b7e43e109ee264e5d533e44c0a33a 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 5c8429f23a892782febdb3c650efa8c168705227..2f3fa4dde6951865ea4790cfb07b7260843b2e26 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 16104b5ebdcb73962edc506c5c5cb3e4c7b78108..bd82dd12deffd25aa9ae8528d60a898bdfa7551b 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 8b1999b528e9b4b048b136afc3aff6022bc23dee..44fa598e63498f704eb91afa68e7ad7cb702830c 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 335055d828e45d082f24558ac5b1c155dac1fefb..860f3ec90c22f76c71f08c5756c17c265818f969 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/autofs4/inode.c b/fs/autofs4/inode.c
index 61b21051bd5ad9322a58ef1caa7cccc09d25ba2b..ca9cbd6362e00144d0d3f2b59c9bbd85933e663e 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 fa84bb8832e0baefc79c07759e9f7f518e023988..623510e84c968c8e8cc2f34c23d1b897f75246b7 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/devpts/inode.c b/fs/devpts/inode.c
index 79a5941c2474622d7888c8e8c3bc925eabdb77e1..9156c91def48493b8252874f5b27d2232f8fcecb 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 1d73fc6dba13bc49fe9bdefefd0370a27ff0f86e..be5a33691f69d5b64c96db9ad0f35439223b19df 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 f69a1b5826a5c70975a8ebbc4520a143d0ba188c..79101651fe9ed2a6ccb3682ba39c590755b5bb00 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 9dc4c6dbf3c99f012cb965e1aaba357fff6ce194..4327f71d302dba690635f6c0cc072a90debf1258 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 622a686bb08b5e3429a316f4e849f94f42fdb8db..80c8114d76a60d937bd58062fabbe2b705d4a229 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);
 
@@ -261,7 +261,7 @@ static int exofs_rename(struct inode *old_dir, struct dentry *old_dentry,
                if (!new_de)
                        goto out_dir;
                err = exofs_set_link(new_dir, new_de, new_page, old_inode);
-               new_inode->i_ctime = CURRENT_TIME;
+               new_inode->i_ctime = current_time(new_inode);
                if (dir_de)
                        drop_nlink(new_inode);
                inode_dec_link_count(new_inode);
@@ -275,7 +275,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/super.c b/fs/ext2/super.c
index 1d9379568aa833b1fdd48a8ff112d343e3a7f773..6cb042b53b5ba671b1027973d690d9aac9b78cc3 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/f2fs/dir.c b/fs/f2fs/dir.c
index 9054aeac80152ba952eb2f362d3bb106280b115e..8e5309c532df2660a111d442753df6c28a4a5540 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 28f4f4cbb8d84d0b07c22e3952d09b9eb1e1bf8c..b831d7662005339fb896cfd4ea7e5af27ed524f6 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 ccea8735de593cdeb015e1b9c138bf437414a92d..b4af15b26a12b84d60bc852a0dbdc4ca5da99e2b 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 73fa356f8fbb0da2cc6782a310026d6fba3dbdeb..dfb622ad86dc706760d4b520f760d52049fb537e 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/fuse/control.c b/fs/fuse/control.c
index f863ac6647ac35506681b3a68923f09e5492b5ea..6e22748b0704c509edad6a0e93d0a6626601137b 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/gfs2/bmap.c b/fs/gfs2/bmap.c
index 6e2bec1cd28944eecd3d59f22f8a25ccf2facc4e..945342202a5eb4b1902696413bdc7ed39a858157 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 fcb59b23f1e38dd6ecd8cc90a14985f618347373..f75c9aef9f9483712027f291762f5f019efa8cca 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 e4da0ecd32852bb95d5bb3db8ae9cc71991f40f2..a197a219eed99c655d55e0e94590e187cb23d288 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 77930ca25303d9c1e040de629ff10bf449574420..422e640a5a9d52c0621801627eb30555b3e96ae0 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 3a28535040841151a9d246d104f7e145aa5b28f8..a4a577088d19c32d31071cd60f518452750103ab 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/hugetlbfs/inode.c b/fs/hugetlbfs/inode.c
index 4ea71eba40a57a3dd1c2e32460021878e12f56d3..3053e200ec950af0d97f436ddc61b395507fb111 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/jfs/acl.c b/fs/jfs/acl.c
index 21fa92ba2c191664fb2851da022f76a5e5d62388..4c1a6b5670df9e42eb7875ec2a5b410a442ea7cb 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 ad3e7b1effc4b0793b261a5808fa6f6e56e1be44..054cc761b426fa510a33df464bd788342576f3fc 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 5e33cb9a190d8077fbf742a3480f611c6273f9ac..375dd257a34fe343b1b25a0176b4dd863aeae0c4 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 814b0c58016cc162518b5a2692026353696572af..b05d0b4c68f60196121cbab5a3359db62b9e043e 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
@@ -1215,7 +1215,7 @@ static int jfs_rename(struct inode *old_dir, struct dentry *old_dentry,
                        tblk->xflag |= COMMIT_DELETE;
                        tblk->u.ip = new_ip;
                } else {
-                       new_ip->i_ctime = CURRENT_TIME;
+                       new_ip->i_ctime = current_time(new_ip);
                        mark_inode_dirty(new_ip);
                }
        } else {
@@ -1278,7 +1278,7 @@ 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);
@@ -1293,7 +1293,7 @@ static int jfs_rename(struct inode *old_dir, struct dentry *old_dentry,
 
        if (old_dir != new_dir) {
                iplist[ipcount++] = new_dir;
-               old_dir->i_ctime = old_dir->i_mtime = CURRENT_TIME;
+               old_dir->i_ctime = old_dir->i_mtime = current_time(old_dir);
                mark_inode_dirty(old_dir);
        }
 
@@ -1426,7 +1426,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 cec8814a3b8becb58cc9b640c3867312e44c2d5a..85671f7f8518f566dcae6c2aa193e05f891b296c 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 0bf3c33aedff9ecca4bbcaa11f04685b00671322..c60f3d32ee911192c0cd8dae3b7cb11c0f416411 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/libfs.c b/fs/libfs.c
index 74dc8b9e7f53ab394113783c96fb754c045735fa..cc9f7ef2a1ceb7770335f7f23d5a9a00c87b3c08 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;
@@ -369,7 +369,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;
 }
@@ -520,7 +520,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);
@@ -546,7 +546,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);
@@ -1092,7 +1092,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/logfs/dir.c b/fs/logfs/dir.c
index 9568064ecadf263a59428d607d8e69e118be881e..a284dd8689a8158ae05a539c8f5a590727c2a78a 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 f01ddfb1a03b6ecc5d122b0bd94c6e301a1f6fa3..dae4f312ffbadda110e1a9006e5301c776cbf00d 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 db9cfc5988836f125ef0adf1fce387bc726f53dd..f440a1525da898f5f80834347ea4fd548275101d 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 3fb8c6d67303e9ed6a842152dfdc3c648009decb..bf19bf4a243f9b434c1d1843716fa3d88472f543 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/nilfs2/dir.c b/fs/nilfs2/dir.c
index 908ebbf0ac7eafc7c79db65c0dbf490b9e1496f6..582831ab3eb95dee645907bf4be2402f62087748 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 af04f553d7c9d8b83acb9d5181f45948694b0af5..bf084035f83c633144abe22487ecb6548ef05855 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 f1d7989459fdbafdaf40a8654af923c67e8f7560..1d2c3d7711feb94dea6ce3a0a1540a41a1bef1d2 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 dbcf1dc93a511de88502b342d2b3e7beaa675791..ace5ebf3b2a80b5cf2c999eee958e88797cfaf73 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);
 
@@ -391,7 +391,7 @@ static int nilfs_rename(struct inode *old_dir, struct dentry *old_dentry,
                        goto out_dir;
                nilfs_set_link(new_dir, new_de, new_page, old_inode);
                nilfs_mark_inode_dirty(new_dir);
-               new_inode->i_ctime = CURRENT_TIME;
+               new_inode->i_ctime = current_time(new_inode);
                if (dir_de)
                        drop_nlink(new_inode);
                drop_nlink(new_inode);
@@ -410,7 +410,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 8f20d6016e205d341b82e31025961e8c9f6c6963..2b731bc2ae6de7e3dabe99436182e7254349e9f0 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/ocfs2/acl.c b/fs/ocfs2/acl.c
index 2162434728c022ab4651904b778c21d958ca802d..acf0012bfc9a9ee909372baa7c825d2ec92bdc79 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 7dabbc31060e466e0959f5a8ec09b0028662cd6b..498e71141b5386558af2fa44e37a8faf06f9bdec 100644 (file)
--- a/fs/ocfs2/alloc.c
+++ b/fs/ocfs2/alloc.c
@@ -7311,7 +7311,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 98d36548153dc3696619b2923e2eecce35bd6bbc..3a22be483af58216cf2d96140bfaaee891b344ad 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 e1adf285fc3142ab8c0856ea0a28d766c914ce3f..e7054e2ac9227dc4687a98beea6e005c2d03d988 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 ef474cdd640479d1e9b3b48204f12dc5c6a7704f..f0d9763db1263e808c5f575ddb5c88835f884cfd 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 4e7b0dc22450564cd86064061d7d84e8461f2bbf..9adcac9dfda14086eb6fd1d418fe30f0b8cbf671 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;
@@ -1936,7 +1936,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 e3d05d9901a3da26b123865545446f5ef96b08a5..4e8f32eb0bdb2f3e9aa90806ebf748290343d8c0 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 a8f1225e6d9b767f5551bca0699f8e5e8f045e4c..e2747d8d05521844b24d82bc8272f8eda3878366 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);
 
@@ -1537,7 +1537,7 @@ static int ocfs2_rename(struct inode *old_dir,
                                         new_dir_bh, &target_insert);
        }
 
-       old_inode->i_ctime = CURRENT_TIME;
+       old_inode->i_ctime = current_time(old_inode);
        mark_inode_dirty(old_inode);
 
        status = ocfs2_journal_access_di(handle, INODE_CACHE(old_inode),
@@ -1586,9 +1586,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 92bbe93bfe1077332286d5a16fb5ea759c66c466..19238512a324ab3beef32fee2e2a0d675d0796f8 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 5bb44f7a78ee812e2deacf76cd1a9d633705f709..cb157a34a65679dff7f298ddacbd4a5c217c35b2 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/inode.c b/fs/omfs/inode.c
index 3d935c81789aaab13e33e52fab88b408fbccd6f2..df7ea8543a2ef00e90010812c3d35e672608033d 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 c7a86993d97e3d3ee6c2d817659ee8809a616a80..c003a667ed1a626dddd9c831f355f783902c55d5 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 526040e09f78746d3f0d8d275be6ce6217a861cd..e799bb4474f6c6c6921de103769b020d5a96c84f 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 28a0557a69be8bc82795c2136d122f4da77ab2dc..113d928d1223c6b1c3eeacc7338c6c7f823b485f 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/pipe.c b/fs/pipe.c
index 4ebe6b2e5217c2e26c7185bcf4254d8af3b55872..5c7c8b7726b83586860168886e41b2b9fcacd4af 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 59d47ab0791af5ce96200c18ecaeee53800cd35a..ad0799c8b59b936addb3fc2fd575d291cfc63c28 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 ac0df4dde823866b54480c7062d5188887009365..029161d85355660d913e639a52bd8f23df2edd6f 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 ce1f1a91990203d8c0d93d4a45dbac2c81537c37..e69ebe648a34bd69b1a0242fbdb5bb737edee2e9 100644 (file)
--- a/fs/proc/inode.c
+++ b/fs/proc/inode.c
@@ -420,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 1b93650dda2fc5f51cb9c0d42c94efcc2f561a92..f9e2f7a31abd74bd10d864752c3c158de1cd5d60 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 b6a8d3529fea9714fb25d063e9505b198201e7ab..40245954c4501e838b15a00b68b7105ab9ab759a 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 e58a31e8fb2a186aaa2d3dee62811f090e2ade57..595b90a9766c98c93014418486397f0e508873f1 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 ec9ddef5ae755d87ccd3359e49289e532f6a2d0f..1781dc50762e2fe03391e8efa8c0ff5577cd7cf6 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 1ab6e6c2e60e72f14c3749cf4a3bff657b5b3244..8621c039b5365c9e422019ea33ca5848e454ed13 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/tracefs/inode.c b/fs/tracefs/inode.c
index ad40b64c5e2f4295688ec1b3522319b5d1b9b1b1..21d36d28473562d4a40f75134ae3916b11c8041c 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/ipc/mqueue.c b/ipc/mqueue.c
index 0b13ace266f2d06ee423d8d0d42f9e1946de698a..8cbd6e6894d514d2078c4af3bcb4e77c68a73abf 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 5967b870a895b2fb4c3882abe10132bc903d7fd4..1ed8473ec537c5aa13feb483c0fc44d2b6ad35ad 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 fd8b2b5741b141a7bc4457d93929c100d988a639..28ae88bbeffaa66f2ca597bb5aa70ea124e88008 100644 (file)
--- a/mm/shmem.c
+++ b/mm/shmem.c
@@ -933,7 +933,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);
 
@@ -978,7 +978,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);
@@ -2082,7 +2082,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);
@@ -2853,7 +2853,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;
@@ -2906,7 +2906,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 */
        }
@@ -2974,7 +2974,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 */
@@ -2991,7 +2991,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;
@@ -3024,7 +3024,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;
 }
@@ -3098,7 +3098,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;
 }
 
@@ -3153,7 +3153,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 84f98cbe31c3cf4ce4b19a2ca9e47f6d69783116..61a504fb1ae2556c02c831b37ba9e3f598530426 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 729e595119eded446298c84386dd4ba1511aafd1..5923d5665209df45ef37e116f147f9cac2f846d3 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 e3df905ab5b163fc4d423c8c7dff6d9609c63ba7..9cb979d2b01331535a90c2e804696123aba4b56f 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 0765c5b053b52ce44819292acbef59319ffe8a6f..72c145dd799f175c09b98a9e6c9fa52fca4009b5 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;
 }