redonkable
/
alistair23-linux
1
0
Fork 0
Code Releases Activity

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>
hifive-unleashed-5.1
Deepa Dinamani 2016-09-14 07:48:04 -07:00 committed by Al Viro
parent 2554c72edb
commit 078cd8279e
76 changed files with 182 additions and 182 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
arch/powerpc/platforms/cell/spufs/inode.c
View File

@ -103,7 +103,7 @@ spufs_new_inode(struct super_block *sb, umode_t mode)
inode->i_mode = mode; inode->i_mode = mode;
inode->i_uid = current_fsuid(); inode->i_uid = current_fsuid();
inode->i_gid = current_fsgid(); 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: out:
return inode; return inode;
} }

4
arch/s390/hypfs/inode.c
View File

@ -51,7 +51,7 @@ static void hypfs_update_update(struct super_block *sb)
struct inode *inode = d_inode(sb_info->update_file); struct inode *inode = d_inode(sb_info->update_file);
sb_info->last_update = get_seconds(); 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 */ /* 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_mode = mode;
ret->i_uid = hypfs_info->uid; ret->i_uid = hypfs_info->uid;
ret->i_gid = hypfs_info->gid; 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)) if (S_ISDIR(mode))
set_nlink(ret, 2); set_nlink(ret, 2);
} }

2
drivers/infiniband/hw/qib/qib_fs.c
View File

@ -64,7 +64,7 @@ static int qibfs_mknod(struct inode *dir, struct dentry *dentry,
inode->i_uid = GLOBAL_ROOT_UID; inode->i_uid = GLOBAL_ROOT_UID;
inode->i_gid = GLOBAL_ROOT_GID; inode->i_gid = GLOBAL_ROOT_GID;
inode->i_blocks = 0; inode->i_blocks = 0;
inode->i_atime = CURRENT_TIME; inode->i_atime = current_time(inode);
inode->i_mtime = inode->i_atime; inode->i_mtime = inode->i_atime;
inode->i_ctime = inode->i_atime; inode->i_ctime = inode->i_atime;
inode->i_private = data; inode->i_private = data;

2
drivers/misc/ibmasm/ibmasmfs.c
View File

@ -144,7 +144,7 @@ static struct inode *ibmasmfs_make_inode(struct super_block *sb, int mode)
if (ret) { if (ret) {
ret->i_ino = get_next_ino(); ret->i_ino = get_next_ino();
ret->i_mode = mode; 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; return ret;
} }

2
drivers/oprofile/oprofilefs.c
View File

@ -30,7 +30,7 @@ static struct inode *oprofilefs_get_inode(struct super_block *sb, int mode)
if (inode) { if (inode) {
inode->i_ino = get_next_ino(); inode->i_ino = get_next_ino();
inode->i_mode = mode; 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; return inode;
} }

18
drivers/usb/core/devio.c
View File

@ -2409,21 +2409,21 @@ static long usbdev_do_ioctl(struct file *file, unsigned int cmd,
snoop(&dev->dev, "%s: CONTROL\n", __func__); snoop(&dev->dev, "%s: CONTROL\n", __func__);
ret = proc_control(ps, p); ret = proc_control(ps, p);
if (ret >= 0) if (ret >= 0)
inode->i_mtime = CURRENT_TIME; inode->i_mtime = current_time(inode);
break; break;
case USBDEVFS_BULK: case USBDEVFS_BULK:
snoop(&dev->dev, "%s: BULK\n", __func__); snoop(&dev->dev, "%s: BULK\n", __func__);
ret = proc_bulk(ps, p); ret = proc_bulk(ps, p);
if (ret >= 0) if (ret >= 0)
inode->i_mtime = CURRENT_TIME; inode->i_mtime = current_time(inode);
break; break;
case USBDEVFS_RESETEP: case USBDEVFS_RESETEP:
snoop(&dev->dev, "%s: RESETEP\n", __func__); snoop(&dev->dev, "%s: RESETEP\n", __func__);
ret = proc_resetep(ps, p); ret = proc_resetep(ps, p);
if (ret >= 0) if (ret >= 0)
inode->i_mtime = CURRENT_TIME; inode->i_mtime = current_time(inode);
break; break;
case USBDEVFS_RESET: 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__); snoop(&dev->dev, "%s: CLEAR_HALT\n", __func__);
ret = proc_clearhalt(ps, p); ret = proc_clearhalt(ps, p);
if (ret >= 0) if (ret >= 0)
inode->i_mtime = CURRENT_TIME; inode->i_mtime = current_time(inode);
break; break;
case USBDEVFS_GETDRIVER: 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__); snoop(&dev->dev, "%s: SUBMITURB\n", __func__);
ret = proc_submiturb(ps, p); ret = proc_submiturb(ps, p);
if (ret >= 0) if (ret >= 0)
inode->i_mtime = CURRENT_TIME; inode->i_mtime = current_time(inode);
break; break;
#ifdef CONFIG_COMPAT #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__); snoop(&dev->dev, "%s: CONTROL32\n", __func__);
ret = proc_control_compat(ps, p); ret = proc_control_compat(ps, p);
if (ret >= 0) if (ret >= 0)
inode->i_mtime = CURRENT_TIME; inode->i_mtime = current_time(inode);
break; break;
case USBDEVFS_BULK32: case USBDEVFS_BULK32:
snoop(&dev->dev, "%s: BULK32\n", __func__); snoop(&dev->dev, "%s: BULK32\n", __func__);
ret = proc_bulk_compat(ps, p); ret = proc_bulk_compat(ps, p);
if (ret >= 0) if (ret >= 0)
inode->i_mtime = CURRENT_TIME; inode->i_mtime = current_time(inode);
break; break;
case USBDEVFS_DISCSIGNAL32: 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__); snoop(&dev->dev, "%s: SUBMITURB32\n", __func__);
ret = proc_submiturb_compat(ps, p); ret = proc_submiturb_compat(ps, p);
if (ret >= 0) if (ret >= 0)
inode->i_mtime = CURRENT_TIME; inode->i_mtime = current_time(inode);
break; break;
case USBDEVFS_IOCTL32: case USBDEVFS_IOCTL32:
@ -2552,7 +2552,7 @@ static long usbdev_do_ioctl(struct file *file, unsigned int cmd,
done: done:
usb_unlock_device(dev); usb_unlock_device(dev);
if (ret >= 0) if (ret >= 0)
inode->i_atime = CURRENT_TIME; inode->i_atime = current_time(inode);
return ret; return ret;
} }

8
drivers/usb/gadget/function/f_fs.c
View File

@ -1193,15 +1193,15 @@ ffs_sb_make_inode(struct super_block *sb, void *data,
inode = new_inode(sb); inode = new_inode(sb);
if (likely(inode)) { if (likely(inode)) {
struct timespec current_time = CURRENT_TIME; struct timespec ts = current_time(inode);
inode->i_ino = get_next_ino(); inode->i_ino = get_next_ino();
inode->i_mode = perms->mode; inode->i_mode = perms->mode;
inode->i_uid = perms->uid; inode->i_uid = perms->uid;
inode->i_gid = perms->gid; inode->i_gid = perms->gid;
inode->i_atime = current_time; inode->i_atime = ts;
inode->i_mtime = current_time; inode->i_mtime = ts;
inode->i_ctime = current_time; inode->i_ctime = ts;
inode->i_private = data; inode->i_private = data;
if (fops) if (fops)
inode->i_fop = fops; inode->i_fop = fops;

2
drivers/usb/gadget/legacy/inode.c
View File

@ -1913,7 +1913,7 @@ gadgetfs_make_inode (struct super_block *sb,
inode->i_uid = make_kuid(&init_user_ns, default_uid); inode->i_uid = make_kuid(&init_user_ns, default_uid);
inode->i_gid = make_kgid(&init_user_ns, default_gid); inode->i_gid = make_kgid(&init_user_ns, default_gid);
inode->i_atime = inode->i_mtime = inode->i_ctime inode->i_atime = inode->i_mtime = inode->i_ctime
= CURRENT_TIME; = current_time(inode);
inode->i_private = data; inode->i_private = data;
inode->i_fop = fops; inode->i_fop = fops;
} }

2
fs/9p/vfs_inode.c
View File

@ -276,7 +276,7 @@ int v9fs_init_inode(struct v9fs_session_info *v9ses,
inode_init_owner(inode, NULL, mode); inode_init_owner(inode, NULL, mode);
inode->i_blocks = 0; inode->i_blocks = 0;
inode->i_rdev = rdev; 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; inode->i_mapping->a_ops = &v9fs_addr_operations;
switch (mode & S_IFMT) { switch (mode & S_IFMT) {

2
fs/adfs/inode.c
View File

@ -199,7 +199,7 @@ adfs_adfs2unix_time(struct timespec *tv, struct inode *inode)
return; return;
cur_time: cur_time:
*tv = CURRENT_TIME; *tv = current_time(inode);
return; return;
too_early: too_early:

2
fs/autofs4/inode.c
View File

@ -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_uid = d_inode(sb->s_root)->i_uid;
inode->i_gid = d_inode(sb->s_root)->i_gid; 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(); inode->i_ino = get_next_ino();
if (S_ISDIR(mode)) { if (S_ISDIR(mode)) {

6
fs/autofs4/root.c
View File

@ -591,7 +591,7 @@ static int autofs4_dir_symlink(struct inode *dir,
if (p_ino && !IS_ROOT(dentry)) if (p_ino && !IS_ROOT(dentry))
atomic_inc(&p_ino->count); atomic_inc(&p_ino->count);
dir->i_mtime = CURRENT_TIME; dir->i_mtime = current_time(dir);
return 0; return 0;
} }
@ -631,7 +631,7 @@ static int autofs4_dir_unlink(struct inode *dir, struct dentry *dentry)
d_inode(dentry)->i_size = 0; d_inode(dentry)->i_size = 0;
clear_nlink(d_inode(dentry)); clear_nlink(d_inode(dentry));
dir->i_mtime = CURRENT_TIME; dir->i_mtime = current_time(dir);
spin_lock(&sbi->lookup_lock); spin_lock(&sbi->lookup_lock);
__autofs4_add_expiring(dentry); __autofs4_add_expiring(dentry);
@ -762,7 +762,7 @@ static int autofs4_dir_mkdir(struct inode *dir,
if (p_ino && !IS_ROOT(dentry)) if (p_ino && !IS_ROOT(dentry))
atomic_inc(&p_ino->count); atomic_inc(&p_ino->count);
inc_nlink(dir); inc_nlink(dir);
dir->i_mtime = CURRENT_TIME; dir->i_mtime = current_time(dir);
return 0; return 0;
} }

6
fs/devpts/inode.c
View File

@ -305,7 +305,7 @@ static int mknod_ptmx(struct super_block *sb)
} }
inode->i_ino = 2; 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; mode = S_IFCHR|opts->ptmxmode;
init_special_inode(inode, mode, MKDEV(TTYAUX_MAJOR, 2)); 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) if (!inode)
goto fail; goto fail;
inode->i_ino = 1; 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_mode = S_IFDIR | S_IRUGO | S_IXUGO | S_IWUSR;
inode->i_op = &simple_dir_inode_operations; inode->i_op = &simple_dir_inode_operations;
inode->i_fop = &simple_dir_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_ino = index + 3;
inode->i_uid = opts->setuid ? opts->uid : current_fsuid(); inode->i_uid = opts->setuid ? opts->uid : current_fsuid();
inode->i_gid = opts->setgid ? opts->gid : current_fsgid(); 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)); init_special_inode(inode, S_IFCHR|opts->mode, MKDEV(UNIX98_PTY_SLAVE_MAJOR, index));
sprintf(s, "%d", index); sprintf(s, "%d", index);

2
fs/efivarfs/inode.c
View File

@ -24,7 +24,7 @@ struct inode *efivarfs_get_inode(struct super_block *sb,
if (inode) { if (inode) {
inode->i_ino = get_next_ino(); inode->i_ino = get_next_ino();
inode->i_mode = mode; 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; inode->i_flags = is_removable ? 0 : S_IMMUTABLE;
switch (mode & S_IFMT) { switch (mode & S_IFMT) {
case S_IFREG: case S_IFREG:

6
fs/exofs/dir.c
View File

@ -416,7 +416,7 @@ int exofs_set_link(struct inode *dir, struct exofs_dir_entry *de,
if (likely(!err)) if (likely(!err))
err = exofs_commit_chunk(page, pos, len); err = exofs_commit_chunk(page, pos, len);
exofs_put_page(page); 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); mark_inode_dirty(dir);
return err; return err;
} }
@ -503,7 +503,7 @@ got_it:
de->inode_no = cpu_to_le64(inode->i_ino); de->inode_no = cpu_to_le64(inode->i_ino);
exofs_set_de_type(de, inode); exofs_set_de_type(de, inode);
err = exofs_commit_chunk(page, pos, rec_len); 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); mark_inode_dirty(dir);
sbi->s_numfiles++; sbi->s_numfiles++;
@ -554,7 +554,7 @@ int exofs_delete_entry(struct exofs_dir_entry *dir, struct page *page)
dir->inode_no = 0; dir->inode_no = 0;
if (likely(!err)) if (likely(!err))
err = exofs_commit_chunk(page, pos, to - from); 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); mark_inode_dirty(inode);
sbi->s_numfiles--; sbi->s_numfiles--;
out: out:

4
fs/exofs/inode.c
View File

@ -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; struct exofs_sb_info *sbi = inode->i_sb->s_fs_info;
int ret; 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); ret = ore_truncate(&sbi->layout, &oi->oc, (u64)newsize);
if (likely(!ret)) 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_init_owner(inode, dir, mode);
inode->i_ino = sbi->s_nextid++; inode->i_ino = sbi->s_nextid++;
inode->i_blkbits = EXOFS_BLKSHIFT; 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; oi->i_commit_size = inode->i_size = 0;
spin_lock(&sbi->s_next_gen_lock); spin_lock(&sbi->s_next_gen_lock);
inode->i_generation = sbi->s_next_generation++; inode->i_generation = sbi->s_next_generation++;

6
fs/exofs/namei.c
View File

@ -142,7 +142,7 @@ static int exofs_link(struct dentry *old_dentry, struct inode *dir,
{ {
struct inode *inode = d_inode(old_dentry); struct inode *inode = d_inode(old_dentry);
inode->i_ctime = CURRENT_TIME; inode->i_ctime = current_time(inode);
inode_inc_link_count(inode); inode_inc_link_count(inode);
ihold(inode); ihold(inode);
@ -261,7 +261,7 @@ static int exofs_rename(struct inode *old_dir, struct dentry *old_dentry,
if (!new_de) if (!new_de)
goto out_dir; goto out_dir;
err = exofs_set_link(new_dir, new_de, new_page, old_inode); 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) if (dir_de)
drop_nlink(new_inode); drop_nlink(new_inode);
inode_dec_link_count(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); 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); exofs_delete_entry(old_de, old_page);
mark_inode_dirty(old_inode); mark_inode_dirty(old_inode);

2
fs/ext2/super.c
View File

@ -1543,7 +1543,7 @@ out:
if (inode->i_size < off+len-towrite) if (inode->i_size < off+len-towrite)
i_size_write(inode, off+len-towrite); i_size_write(inode, off+len-towrite);
inode->i_version++; inode->i_version++;
inode->i_mtime = inode->i_ctime = CURRENT_TIME; inode->i_mtime = inode->i_ctime = current_time(inode);
mark_inode_dirty(inode); mark_inode_dirty(inode);
return len - towrite; return len - towrite;
} }

8
fs/f2fs/dir.c
View File

@ -299,7 +299,7 @@ void f2fs_set_link(struct inode *dir, struct f2fs_dir_entry *de,
f2fs_dentry_kunmap(dir, page); f2fs_dentry_kunmap(dir, page);
set_page_dirty(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_mark_inode_dirty_sync(dir);
f2fs_put_page(page, 1); 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); f2fs_i_links_write(dir, true);
clear_inode_flag(inode, FI_NEW_INODE); 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); f2fs_mark_inode_dirty_sync(dir);
if (F2FS_I(dir)->i_current_depth != current_depth) 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)) if (S_ISDIR(inode->i_mode))
f2fs_i_links_write(dir, false); f2fs_i_links_write(dir, false);
inode->i_ctime = CURRENT_TIME; inode->i_ctime = current_time(inode);
f2fs_i_links_write(inode, false); f2fs_i_links_write(inode, false);
if (S_ISDIR(inode->i_mode)) { 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 */ kunmap(page); /* kunmap - pair of f2fs_find_entry */
set_page_dirty(page); 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); f2fs_mark_inode_dirty_sync(dir);
if (inode) if (inode)

8
fs/f2fs/file.c
View File

@ -631,7 +631,7 @@ int f2fs_truncate(struct inode *inode)
if (err) if (err)
return 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); f2fs_mark_inode_dirty_sync(inode);
return 0; return 0;
} }
@ -708,7 +708,7 @@ int f2fs_setattr(struct dentry *dentry, struct iattr *attr)
if (err) if (err)
return 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) { 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_mark_inode_dirty_sync(inode);
f2fs_update_time(F2FS_I_SB(inode), REQ_TIME); 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; fi->i_flags = flags;
inode_unlock(inode); inode_unlock(inode);
inode->i_ctime = CURRENT_TIME; inode->i_ctime = current_time(inode);
f2fs_set_inode_flags(inode); f2fs_set_inode_flags(inode);
out: out:
mnt_drop_write_file(filp); mnt_drop_write_file(filp);

2
fs/f2fs/inline.c
View File

@ -569,7 +569,7 @@ void f2fs_delete_inline_entry(struct f2fs_dir_entry *dentry, struct page *page,
set_page_dirty(page); set_page_dirty(page);
f2fs_put_page(page, 1); 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); f2fs_mark_inode_dirty_sync(dir);
if (inode) if (inode)

12
fs/f2fs/namei.c
View File

@ -46,7 +46,7 @@ static struct inode *f2fs_new_inode(struct inode *dir, umode_t mode)
inode->i_ino = ino; inode->i_ino = ino;
inode->i_blocks = 0; 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++; inode->i_generation = sbi->s_next_generation++;
err = insert_inode_locked(inode); 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); f2fs_balance_fs(sbi, true);
inode->i_ctime = CURRENT_TIME; inode->i_ctime = current_time(inode);
ihold(inode); ihold(inode);
set_inode_flag(inode, FI_INC_LINK); 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); 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); down_write(&F2FS_I(new_inode)->i_sem);
if (old_dir_entry) if (old_dir_entry)
f2fs_i_links_write(new_inode, false); 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); file_set_enc_name(old_inode);
up_write(&F2FS_I(old_inode)->i_sem); 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_mark_inode_dirty_sync(old_inode);
f2fs_delete_entry(old_entry, old_page, old_dir, NULL); 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); file_lost_pino(old_inode);
up_write(&F2FS_I(old_inode)->i_sem); 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) { if (old_nlink) {
down_write(&F2FS_I(old_dir)->i_sem); down_write(&F2FS_I(old_dir)->i_sem);
f2fs_i_links_write(old_dir, old_nlink > 0); 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); file_lost_pino(new_inode);
up_write(&F2FS_I(new_inode)->i_sem); 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) { if (new_nlink) {
down_write(&F2FS_I(new_dir)->i_sem); down_write(&F2FS_I(new_dir)->i_sem);
f2fs_i_links_write(new_dir, new_nlink > 0); f2fs_i_links_write(new_dir, new_nlink > 0);

2
fs/fuse/control.c
View File

@ -220,7 +220,7 @@ static struct dentry *fuse_ctl_add_dentry(struct dentry *parent,
inode->i_mode = mode; inode->i_mode = mode;
inode->i_uid = fc->user_id; inode->i_uid = fc->user_id;
inode->i_gid = fc->group_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 */ /* setting ->i_op to NULL is not allowed */
if (iop) if (iop)
inode->i_op = iop; inode->i_op = iop;

8
fs/gfs2/bmap.c
View File

@ -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, gfs2_quota_change(ip, -(s64)btotal, ip->i_inode.i_uid,
ip->i_inode.i_gid); 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); 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); 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); gfs2_dinode_out(ip, dibh->b_data);
if (journaled) if (journaled)
@ -1142,7 +1142,7 @@ static int trunc_end(struct gfs2_inode *ip)
gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode)); gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode));
gfs2_ordered_del_inode(ip); 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; ip->i_diskflags &= ~GFS2_DIF_TRUNC_IN_PROG;
gfs2_trans_add_meta(ip->i_gl, dibh); 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; goto do_end_trans;
i_size_write(inode, size); 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_trans_add_meta(ip->i_gl, dibh);
gfs2_dinode_out(ip, dibh->b_data); gfs2_dinode_out(ip, dibh->b_data);
brelse(dibh); brelse(dibh);

12
fs/gfs2/dir.c
View File

@ -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); memcpy(dibh->b_data + offset + sizeof(struct gfs2_dinode), buf, size);
if (ip->i_inode.i_size < offset + size) if (ip->i_inode.i_size < offset + size)
i_size_write(&ip->i_inode, 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); gfs2_dinode_out(ip, dibh->b_data);
brelse(dibh); brelse(dibh);
@ -233,7 +233,7 @@ out:
if (ip->i_inode.i_size < offset + copied) if (ip->i_inode.i_size < offset + copied)
i_size_write(&ip->i_inode, 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_trans_add_meta(ip->i_gl, dibh);
gfs2_dinode_out(ip, dibh->b_data); 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_leaf *leaf;
struct gfs2_dirent *dent; struct gfs2_dirent *dent;
struct qstr name = { .name = "" }; struct qstr name = { .name = "" };
struct timespec tv = CURRENT_TIME; struct timespec tv = current_time(inode);
error = gfs2_alloc_blocks(ip, &bn, &n, 0, NULL); error = gfs2_alloc_blocks(ip, &bn, &n, 0, NULL);
if (error) if (error)
@ -1816,7 +1816,7 @@ int gfs2_dir_add(struct inode *inode, const struct qstr *name,
gfs2_inum_out(nip, dent); gfs2_inum_out(nip, dent);
dent->de_type = cpu_to_be16(IF2DT(nip->i_inode.i_mode)); dent->de_type = cpu_to_be16(IF2DT(nip->i_inode.i_mode));
dent->de_rahead = cpu_to_be16(gfs2_inode_ra_len(nip)); 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) { if (ip->i_diskflags & GFS2_DIF_EXHASH) {
leaf = (struct gfs2_leaf *)bh->b_data; leaf = (struct gfs2_leaf *)bh->b_data;
be16_add_cpu(&leaf->lf_entries, 1); 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; const struct qstr *name = &dentry->d_name;
struct gfs2_dirent *dent, *prev = NULL; struct gfs2_dirent *dent, *prev = NULL;
struct buffer_head *bh; 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 /* Returns _either_ the entry (if its first in block) or the
previous entry otherwise */ 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); 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); gfs2_dinode_out(dip, bh->b_data);
brelse(bh); brelse(bh);
return 0; return 0;

8
fs/gfs2/inode.c
View File

@ -652,7 +652,7 @@ static int gfs2_create_inode(struct inode *dir, struct dentry *dentry,
set_nlink(inode, S_ISDIR(mode) ? 2 : 1); set_nlink(inode, S_ISDIR(mode) ? 2 : 1);
inode->i_rdev = dev; inode->i_rdev = dev;
inode->i_size = size; 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); gfs2_set_inode_blocks(inode, 1);
munge_mode_uid_gid(dip, inode); munge_mode_uid_gid(dip, inode);
check_and_update_goal(dip); 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); gfs2_trans_add_meta(ip->i_gl, dibh);
inc_nlink(&ip->i_inode); inc_nlink(&ip->i_inode);
ip->i_inode.i_ctime = CURRENT_TIME; ip->i_inode.i_ctime = current_time(&ip->i_inode);
ihold(inode); ihold(inode);
d_instantiate(dentry, inode); d_instantiate(dentry, inode);
mark_inode_dirty(inode); mark_inode_dirty(inode);
@ -1063,7 +1063,7 @@ static int gfs2_unlink_inode(struct gfs2_inode *dip,
return error; return error;
ip->i_entries = 0; ip->i_entries = 0;
inode->i_ctime = CURRENT_TIME; inode->i_ctime = current_time(inode);
if (S_ISDIR(inode->i_mode)) if (S_ISDIR(inode->i_mode))
clear_nlink(inode); clear_nlink(inode);
else 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); error = gfs2_meta_inode_buffer(ip, &dibh);
if (error) if (error)
return 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_trans_add_meta(ip->i_gl, dibh);
gfs2_dinode_out(ip, dibh->b_data); gfs2_dinode_out(ip, dibh->b_data);
brelse(dibh); brelse(dibh);

2
fs/gfs2/quota.c
View File

@ -854,7 +854,7 @@ static int gfs2_adjust_quota(struct gfs2_inode *ip, loff_t loc,
size = loc + sizeof(struct gfs2_quota); size = loc + sizeof(struct gfs2_quota);
if (size > inode->i_size) if (size > inode->i_size)
i_size_write(inode, 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); mark_inode_dirty(inode);
set_bit(QDF_REFRESH, &qd->qd_flags); set_bit(QDF_REFRESH, &qd->qd_flags);
} }

8
fs/gfs2/xattr.c
View File

@ -309,7 +309,7 @@ static int ea_dealloc_unstuffed(struct gfs2_inode *ip, struct buffer_head *bh,
error = gfs2_meta_inode_buffer(ip, &dibh); error = gfs2_meta_inode_buffer(ip, &dibh);
if (!error) { 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_trans_add_meta(ip->i_gl, dibh);
gfs2_dinode_out(ip, dibh->b_data); gfs2_dinode_out(ip, dibh->b_data);
brelse(dibh); 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); error = gfs2_meta_inode_buffer(ip, &dibh);
if (!error) { 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_trans_add_meta(ip->i_gl, dibh);
gfs2_dinode_out(ip, dibh->b_data); gfs2_dinode_out(ip, dibh->b_data);
brelse(dibh); 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); error = gfs2_meta_inode_buffer(ip, &dibh);
if (error) if (error)
goto out; 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_trans_add_meta(ip->i_gl, dibh);
gfs2_dinode_out(ip, dibh->b_data); gfs2_dinode_out(ip, dibh->b_data);
brelse(dibh); 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); error = gfs2_meta_inode_buffer(ip, &dibh);
if (!error) { 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_trans_add_meta(ip->i_gl, dibh);
gfs2_dinode_out(ip, dibh->b_data); gfs2_dinode_out(ip, dibh->b_data);
brelse(dibh); brelse(dibh);

10
fs/hugetlbfs/inode.c
View File

@ -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) if (!(mode & FALLOC_FL_KEEP_SIZE) && offset + len > inode->i_size)
i_size_write(inode, offset + len); i_size_write(inode, offset + len);
inode->i_ctime = CURRENT_TIME; inode->i_ctime = current_time(inode);
out: out:
inode_unlock(inode); inode_unlock(inode);
return error; 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_mode = S_IFDIR | config->mode;
inode->i_uid = config->uid; inode->i_uid = config->uid;
inode->i_gid = config->gid; 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); info = HUGETLBFS_I(inode);
mpol_shared_policy_init(&info->policy, NULL); mpol_shared_policy_init(&info->policy, NULL);
inode->i_op = &hugetlbfs_dir_inode_operations; 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, lockdep_set_class(&inode->i_mapping->i_mmap_rwsem,
&hugetlbfs_i_mmap_rwsem_key); &hugetlbfs_i_mmap_rwsem_key);
inode->i_mapping->a_ops = &hugetlbfs_aops; 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; inode->i_mapping->private_data = resv_map;
info = HUGETLBFS_I(inode); 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); inode = hugetlbfs_get_inode(dir->i_sb, dir, mode, dev);
if (inode) { if (inode) {
dir->i_ctime = dir->i_mtime = CURRENT_TIME; dir->i_ctime = dir->i_mtime = current_time(dir);
d_instantiate(dentry, inode); d_instantiate(dentry, inode);
dget(dentry); /* Extra count - pin the dentry in core */ dget(dentry); /* Extra count - pin the dentry in core */
error = 0; error = 0;
@ -827,7 +827,7 @@ static int hugetlbfs_symlink(struct inode *dir,
} else } else
iput(inode); iput(inode);
} }
dir->i_ctime = dir->i_mtime = CURRENT_TIME; dir->i_ctime = dir->i_mtime = current_time(dir);
return error; return error;
} }

2
fs/jfs/acl.c
View File

@ -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); rc = posix_acl_equiv_mode(acl, &inode->i_mode);
if (rc < 0) if (rc < 0)
return rc; return rc;
inode->i_ctime = CURRENT_TIME; inode->i_ctime = current_time(inode);
mark_inode_dirty(inode); mark_inode_dirty(inode);
if (rc == 0) if (rc == 0)
acl = NULL; acl = NULL;

2
fs/jfs/inode.c
View File

@ -403,7 +403,7 @@ void jfs_truncate_nolock(struct inode *ip, loff_t length)
break; break;
} }
ip->i_mtime = ip->i_ctime = CURRENT_TIME; ip->i_mtime = ip->i_ctime = current_time(ip);
mark_inode_dirty(ip); mark_inode_dirty(ip);
txCommit(tid, 1, &ip, 0); txCommit(tid, 1, &ip, 0);

2
fs/jfs/jfs_inode.c
View File

@ -131,7 +131,7 @@ struct inode *ialloc(struct inode *parent, umode_t mode)
jfs_inode->mode2 |= inode->i_mode; jfs_inode->mode2 |= inode->i_mode;
inode->i_blocks = 0; 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; jfs_inode->otime = inode->i_ctime.tv_sec;
inode->i_generation = JFS_SBI(sb)->gengen++; inode->i_generation = JFS_SBI(sb)->gengen++;

22
fs/jfs/namei.c
View File

@ -162,7 +162,7 @@ static int jfs_create(struct inode *dip, struct dentry *dentry, umode_t mode,
mark_inode_dirty(ip); 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); 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 */ /* update parent directory inode */
inc_nlink(dip); /* for '..' from child directory */ 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); mark_inode_dirty(dip);
rc = txCommit(tid, 2, &iplist[0], 0); 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 /* update parent directory's link count corresponding
* to ".." entry of the target directory deleted * 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); inode_dec_link_count(dip);
/* /*
@ -528,7 +528,7 @@ static int jfs_unlink(struct inode *dip, struct dentry *dentry)
ASSERT(ip->i_nlink); 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); mark_inode_dirty(dip);
/* update target's inode */ /* update target's inode */
@ -838,8 +838,8 @@ static int jfs_link(struct dentry *old_dentry,
/* update object inode */ /* update object inode */
inc_nlink(ip); /* for new link */ inc_nlink(ip); /* for new link */
ip->i_ctime = CURRENT_TIME; ip->i_ctime = current_time(ip);
dir->i_ctime = dir->i_mtime = CURRENT_TIME; dir->i_ctime = dir->i_mtime = current_time(dir);
mark_inode_dirty(dir); mark_inode_dirty(dir);
ihold(ip); ihold(ip);
@ -1039,7 +1039,7 @@ static int jfs_symlink(struct inode *dip, struct dentry *dentry,
mark_inode_dirty(ip); 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); mark_inode_dirty(dip);
/* /*
* commit update of parent directory and link object * 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->xflag |= COMMIT_DELETE;
tblk->u.ip = new_ip; tblk->u.ip = new_ip;
} else { } else {
new_ip->i_ctime = CURRENT_TIME; new_ip->i_ctime = current_time(new_ip);
mark_inode_dirty(new_ip); mark_inode_dirty(new_ip);
} }
} else { } 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 * 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); 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_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) { if (old_dir != new_dir) {
iplist[ipcount++] = 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); mark_inode_dirty(old_dir);
} }
@ -1426,7 +1426,7 @@ static int jfs_mknod(struct inode *dir, struct dentry *dentry,
mark_inode_dirty(ip); 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); mark_inode_dirty(dir);

2
fs/jfs/super.c
View File

@ -830,7 +830,7 @@ out:
if (inode->i_size < off+len-towrite) if (inode->i_size < off+len-towrite)
i_size_write(inode, off+len-towrite); i_size_write(inode, off+len-towrite);
inode->i_version++; inode->i_version++;
inode->i_mtime = inode->i_ctime = CURRENT_TIME; inode->i_mtime = inode->i_ctime = current_time(inode);
mark_inode_dirty(inode); mark_inode_dirty(inode);
inode_unlock(inode); inode_unlock(inode);
return len - towrite; return len - towrite;

2
fs/jfs/xattr.c
View File

@ -658,7 +658,7 @@ static int ea_put(tid_t tid, struct inode *inode, struct ea_buffer *ea_buf,
if (old_blocks) if (old_blocks)
dquot_free_block(inode, old_blocks); dquot_free_block(inode, old_blocks);
inode->i_ctime = CURRENT_TIME; inode->i_ctime = current_time(inode);
return 0; return 0;
} }

14
fs/libfs.c
View File

@ -265,7 +265,7 @@ struct dentry *mount_pseudo(struct file_system_type *fs_type, char *name,
*/ */
root->i_ino = 1; root->i_ino = 1;
root->i_mode = S_IFDIR | S_IRUSR | S_IWUSR; 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); dentry = __d_alloc(s, &d_name);
if (!dentry) { if (!dentry) {
iput(root); 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); 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); inc_nlink(inode);
ihold(inode); ihold(inode);
dget(dentry); dget(dentry);
@ -329,7 +329,7 @@ int simple_unlink(struct inode *dir, struct dentry *dentry)
{ {
struct inode *inode = d_inode(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); drop_nlink(inode);
dput(dentry); dput(dentry);
return 0; 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 = 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; return 0;
} }
@ -520,7 +520,7 @@ int simple_fill_super(struct super_block *s, unsigned long magic,
*/ */
inode->i_ino = 1; inode->i_ino = 1;
inode->i_mode = S_IFDIR | 0755; 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_op = &simple_dir_inode_operations;
inode->i_fop = &simple_dir_operations; inode->i_fop = &simple_dir_operations;
set_nlink(inode, 2); set_nlink(inode, 2);
@ -546,7 +546,7 @@ int simple_fill_super(struct super_block *s, unsigned long magic,
goto out; goto out;
} }
inode->i_mode = S_IFREG | files->mode; 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_fop = files->ops;
inode->i_ino = i; inode->i_ino = i;
d_add(dentry, inode); d_add(dentry, inode);
@ -1092,7 +1092,7 @@ struct inode *alloc_anon_inode(struct super_block *s)
inode->i_uid = current_fsuid(); inode->i_uid = current_fsuid();
inode->i_gid = current_fsgid(); inode->i_gid = current_fsgid();
inode->i_flags |= S_PRIVATE; 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; return inode;
} }
EXPORT_SYMBOL(alloc_anon_inode); EXPORT_SYMBOL(alloc_anon_inode);

6
fs/logfs/dir.c
View File

@ -226,7 +226,7 @@ static int logfs_unlink(struct inode *dir, struct dentry *dentry)
ta->state = UNLINK_1; ta->state = UNLINK_1;
ta->ino = inode->i_ino; 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); page = logfs_get_dd_page(dir, dentry);
if (!page) { if (!page) {
@ -540,7 +540,7 @@ static int logfs_link(struct dentry *old_dentry, struct inode *dir,
{ {
struct inode *inode = d_inode(old_dentry); 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); ihold(inode);
inc_nlink(inode); inc_nlink(inode);
mark_inode_dirty_sync(inode); mark_inode_dirty_sync(inode);
@ -573,7 +573,7 @@ static int logfs_delete_dd(struct inode *dir, loff_t pos)
* (crc-protected) journal. * (crc-protected) journal.
*/ */
BUG_ON(beyond_eof(dir, pos)); 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); log_dir(" Delete dentry (%lx, %llx)\n", dir->i_ino, pos);
return logfs_delete(dir, pos, NULL); return logfs_delete(dir, pos, NULL);
} }

2
fs/logfs/file.c
View File

@ -211,7 +211,7 @@ long logfs_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
li->li_flags = flags; li->li_flags = flags;
inode_unlock(inode); inode_unlock(inode);
inode->i_ctime = CURRENT_TIME; inode->i_ctime = current_time(inode);
mark_inode_dirty_sync(inode); mark_inode_dirty_sync(inode);
return 0; return 0;

4
fs/logfs/inode.c
View File

@ -213,8 +213,8 @@ static void logfs_init_inode(struct super_block *sb, struct inode *inode)
i_gid_write(inode, 0); i_gid_write(inode, 0);
inode->i_size = 0; inode->i_size = 0;
inode->i_blocks = 0; inode->i_blocks = 0;
inode->i_ctime = CURRENT_TIME; inode->i_ctime = current_time(inode);
inode->i_mtime = CURRENT_TIME; inode->i_mtime = current_time(inode);
li->li_refcount = 1; li->li_refcount = 1;
INIT_LIST_HEAD(&li->li_freeing_list); INIT_LIST_HEAD(&li->li_freeing_list);

4
fs/logfs/readwrite.c
View File

@ -1546,7 +1546,7 @@ static int __logfs_write_buf(struct inode *inode, struct page *page, long flags)
int err; int err;
flags |= WF_WRITE | WF_DELETE; 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); logfs_unpack_index(index, &bix, &level);
if (logfs_block(page) && logfs_block(page)->reserved_bytes) 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; long flags = WF_DELETE;
int err; int err;
inode->i_ctime = inode->i_mtime = CURRENT_TIME; inode->i_ctime = inode->i_mtime = current_time(inode);
if (page->index < I0_BLOCKS) if (page->index < I0_BLOCKS)
return logfs_write_direct(inode, page, flags); return logfs_write_direct(inode, page, flags);

6
fs/nilfs2/dir.c
View File

@ -438,7 +438,7 @@ void nilfs_set_link(struct inode *dir, struct nilfs_dir_entry *de,
nilfs_set_de_type(de, inode); nilfs_set_de_type(de, inode);
nilfs_commit_chunk(page, mapping, from, to); nilfs_commit_chunk(page, mapping, from, to);
nilfs_put_page(page); 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); de->inode = cpu_to_le64(inode->i_ino);
nilfs_set_de_type(de, inode); nilfs_set_de_type(de, inode);
nilfs_commit_chunk(page, page->mapping, from, to); 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); nilfs_mark_inode_dirty(dir);
/* OFFSET_CACHE */ /* OFFSET_CACHE */
out_put: 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); pde->rec_len = nilfs_rec_len_to_disk(to - from);
dir->inode = 0; dir->inode = 0;
nilfs_commit_chunk(page, mapping, from, to); 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: out:
nilfs_put_page(page); nilfs_put_page(page);
return err; return err;

4
fs/nilfs2/inode.c
View File

@ -367,7 +367,7 @@ struct inode *nilfs_new_inode(struct inode *dir, umode_t mode)
atomic64_inc(&root->inodes_count); atomic64_inc(&root->inodes_count);
inode_init_owner(inode, dir, mode); inode_init_owner(inode, dir, mode);
inode->i_ino = ino; 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)) { if (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode)) {
err = nilfs_bmap_read(ii->i_bmap, NULL); err = nilfs_bmap_read(ii->i_bmap, NULL);
@ -749,7 +749,7 @@ void nilfs_truncate(struct inode *inode)
nilfs_truncate_bmap(ii, blkoff); 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)) if (IS_SYNC(inode))
nilfs_set_transaction_flag(NILFS_TI_SYNC); nilfs_set_transaction_flag(NILFS_TI_SYNC);

2
fs/nilfs2/ioctl.c
View File

@ -174,7 +174,7 @@ static int nilfs_ioctl_setflags(struct inode *inode, struct file *filp,
(flags & FS_FL_USER_MODIFIABLE); (flags & FS_FL_USER_MODIFIABLE);
nilfs_set_inode_flags(inode); nilfs_set_inode_flags(inode);
inode->i_ctime = CURRENT_TIME; inode->i_ctime = current_time(inode);
if (IS_SYNC(inode)) if (IS_SYNC(inode))
nilfs_set_transaction_flag(NILFS_TI_SYNC); nilfs_set_transaction_flag(NILFS_TI_SYNC);

6
fs/nilfs2/namei.c
View File

@ -194,7 +194,7 @@ static int nilfs_link(struct dentry *old_dentry, struct inode *dir,
if (err) if (err)
return err; return err;
inode->i_ctime = CURRENT_TIME; inode->i_ctime = current_time(inode);
inode_inc_link_count(inode); inode_inc_link_count(inode);
ihold(inode); ihold(inode);
@ -391,7 +391,7 @@ static int nilfs_rename(struct inode *old_dir, struct dentry *old_dentry,
goto out_dir; goto out_dir;
nilfs_set_link(new_dir, new_de, new_page, old_inode); nilfs_set_link(new_dir, new_de, new_page, old_inode);
nilfs_mark_inode_dirty(new_dir); nilfs_mark_inode_dirty(new_dir);
new_inode->i_ctime = CURRENT_TIME; new_inode->i_ctime = current_time(new_inode);
if (dir_de) if (dir_de)
drop_nlink(new_inode); drop_nlink(new_inode);
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 * Like most other Unix systems, set the ctime for inodes on a
* rename. * rename.
*/ */
old_inode->i_ctime = CURRENT_TIME; old_inode->i_ctime = current_time(old_inode);
nilfs_delete_entry(old_de, old_page); nilfs_delete_entry(old_de, old_page);

2
fs/nsfs.c
View File

@ -82,7 +82,7 @@ slow:
return ERR_PTR(-ENOMEM); return ERR_PTR(-ENOMEM);
} }
inode->i_ino = ns->inum; 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_flags |= S_IMMUTABLE;
inode->i_mode = S_IFREG | S_IRUGO; inode->i_mode = S_IFREG | S_IRUGO;
inode->i_fop = &ns_file_operations; inode->i_fop = &ns_file_operations;

2
fs/ocfs2/acl.c
View File

@ -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_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_mode = cpu_to_le16(inode->i_mode);
di->i_ctime = cpu_to_le64(inode->i_ctime.tv_sec); di->i_ctime = cpu_to_le64(inode->i_ctime.tv_sec);
di->i_ctime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec); di->i_ctime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec);

2
fs/ocfs2/alloc.c
View File

@ -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_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 = 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); di->i_ctime_nsec = di->i_mtime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec);

2
fs/ocfs2/aops.c
View File

@ -2020,7 +2020,7 @@ out_write_size:
} }
inode->i_blocks = ocfs2_inode_sector_count(inode); inode->i_blocks = ocfs2_inode_sector_count(inode);
di->i_size = cpu_to_le64((u64)i_size_read(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 = 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); di->i_mtime_nsec = di->i_ctime_nsec = cpu_to_le32(inode->i_mtime.tv_nsec);
ocfs2_update_inode_fsync_trans(handle, inode, 1); ocfs2_update_inode_fsync_trans(handle, inode, 1);

4
fs/ocfs2/dir.c
View File

@ -1677,7 +1677,7 @@ int __ocfs2_add_entry(handle_t *handle,
offset, ocfs2_dir_trailer_blk_off(dir->i_sb)); offset, ocfs2_dir_trailer_blk_off(dir->i_sb));
if (ocfs2_dirent_would_fit(de, rec_len)) { 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); retval = ocfs2_mark_inode_dirty(handle, dir, parent_fe_bh);
if (retval < 0) { if (retval < 0) {
mlog_errno(retval); 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); ocfs2_dinode_new_extent_list(dir, di);
i_size_write(dir, sb->s_blocksize); 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_size = cpu_to_le64(sb->s_blocksize);
di->i_ctime = di->i_mtime = cpu_to_le64(dir->i_ctime.tv_sec); di->i_ctime = di->i_mtime = cpu_to_le64(dir->i_ctime.tv_sec);

4
fs/ocfs2/dlmfs/dlmfs.c
View File

@ -398,7 +398,7 @@ static struct inode *dlmfs_get_root_inode(struct super_block *sb)
if (inode) { if (inode) {
inode->i_ino = get_next_ino(); inode->i_ino = get_next_ino();
inode_init_owner(inode, NULL, mode); 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); inc_nlink(inode);
inode->i_fop = &simple_dir_operations; 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->i_ino = get_next_ino();
inode_init_owner(inode, parent, mode); 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 = DLMFS_I(inode);
ip->ip_conn = DLMFS_I(parent)->ip_conn; ip->ip_conn = DLMFS_I(parent)->ip_conn;

12
fs/ocfs2/file.c
View File

@ -253,7 +253,7 @@ int ocfs2_should_update_atime(struct inode *inode,
return 0; return 0;
} }
now = CURRENT_TIME; now = current_time(inode);
if ((now.tv_sec - inode->i_atime.tv_sec <= osb->s_atime_quantum)) if ((now.tv_sec - inode->i_atime.tv_sec <= osb->s_atime_quantum))
return 0; return 0;
else else
@ -287,7 +287,7 @@ int ocfs2_update_inode_atime(struct inode *inode,
* have i_mutex to guard against concurrent changes to other * have i_mutex to guard against concurrent changes to other
* inode fields. * 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 = cpu_to_le64(inode->i_atime.tv_sec);
di->i_atime_nsec = cpu_to_le32(inode->i_atime.tv_nsec); di->i_atime_nsec = cpu_to_le32(inode->i_atime.tv_nsec);
ocfs2_update_inode_fsync_trans(handle, inode, 0); 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); i_size_write(inode, new_i_size);
inode->i_blocks = ocfs2_inode_sector_count(inode); 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); status = ocfs2_mark_inode_dirty(handle, inode, fe_bh);
if (status < 0) { if (status < 0) {
@ -429,7 +429,7 @@ static int ocfs2_orphan_for_truncate(struct ocfs2_super *osb,
} }
i_size_write(inode, new_i_size); 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 = (struct ocfs2_dinode *) fe_bh->b_data;
di->i_size = cpu_to_le64(new_i_size); 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); i_size_write(inode, abs_to);
inode->i_blocks = ocfs2_inode_sector_count(inode); inode->i_blocks = ocfs2_inode_sector_count(inode);
di->i_size = cpu_to_le64((u64)i_size_read(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 = 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_ctime_nsec = cpu_to_le32(inode->i_mtime.tv_nsec);
di->i_mtime_nsec = di->i_ctime_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) if (change_size && i_size_read(inode) < size)
i_size_write(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); ret = ocfs2_mark_inode_dirty(handle, inode, di_bh);
if (ret < 0) if (ret < 0)
mlog_errno(ret); mlog_errno(ret);

2
fs/ocfs2/move_extents.c
View File

@ -953,7 +953,7 @@ static int ocfs2_move_extents(struct ocfs2_move_extents_context *context)
} }
di = (struct ocfs2_dinode *)di_bh->b_data; 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 = cpu_to_le64(inode->i_ctime.tv_sec);
di->i_ctime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec); di->i_ctime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec);
ocfs2_update_inode_fsync_trans(handle, inode, 0); ocfs2_update_inode_fsync_trans(handle, inode, 0);

10
fs/ocfs2/namei.c
View File

@ -798,7 +798,7 @@ static int ocfs2_link(struct dentry *old_dentry,
} }
inc_nlink(inode); inc_nlink(inode);
inode->i_ctime = CURRENT_TIME; inode->i_ctime = current_time(inode);
ocfs2_set_links_count(fe, inode->i_nlink); ocfs2_set_links_count(fe, inode->i_nlink);
fe->i_ctime = cpu_to_le64(inode->i_ctime.tv_sec); fe->i_ctime = cpu_to_le64(inode->i_ctime.tv_sec);
fe->i_ctime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec); 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_set_links_count(fe, inode->i_nlink);
ocfs2_journal_dirty(handle, fe_bh); 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)) if (S_ISDIR(inode->i_mode))
drop_nlink(dir); drop_nlink(dir);
@ -1537,7 +1537,7 @@ static int ocfs2_rename(struct inode *old_dir,
new_dir_bh, &target_insert); new_dir_bh, &target_insert);
} }
old_inode->i_ctime = CURRENT_TIME; old_inode->i_ctime = current_time(old_inode);
mark_inode_dirty(old_inode); mark_inode_dirty(old_inode);
status = ocfs2_journal_access_di(handle, INODE_CACHE(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) { if (new_inode) {
drop_nlink(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) { if (update_dot_dot) {
status = ocfs2_update_entry(old_inode, handle, status = ocfs2_update_entry(old_inode, handle,

4
fs/ocfs2/refcounttree.c
View File

@ -3778,7 +3778,7 @@ static int ocfs2_change_ctime(struct inode *inode,
goto out_commit; 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 = cpu_to_le64(inode->i_ctime.tv_sec);
di->i_ctime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec); 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 * we want mtime to appear identical to the source and
* update ctime. * 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 = cpu_to_le64(t_inode->i_ctime.tv_sec);
di->i_ctime_nsec = cpu_to_le32(t_inode->i_ctime.tv_nsec); di->i_ctime_nsec = cpu_to_le32(t_inode->i_ctime.tv_nsec);

2
fs/ocfs2/xattr.c
View File

@ -3431,7 +3431,7 @@ static int __ocfs2_xattr_set_handle(struct inode *inode,
goto out; 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 = cpu_to_le64(inode->i_ctime.tv_sec);
di->i_ctime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec); di->i_ctime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec);
ocfs2_journal_dirty(ctxt->handle, xis->inode_bh); ocfs2_journal_dirty(ctxt->handle, xis->inode_bh);

2
fs/omfs/inode.c
View File

@ -49,7 +49,7 @@ struct inode *omfs_new_inode(struct inode *dir, umode_t mode)
inode_init_owner(inode, NULL, mode); inode_init_owner(inode, NULL, mode);
inode->i_mapping->a_ops = &omfs_aops; 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) { switch (mode & S_IFMT) {
case S_IFDIR: case S_IFDIR:
inode->i_op = &omfs_dir_inops; inode->i_op = &omfs_dir_inops;

2
fs/openpromfs/inode.c
View File

@ -355,7 +355,7 @@ static struct inode *openprom_iget(struct super_block *sb, ino_t ino)
if (!inode) if (!inode)
return ERR_PTR(-ENOMEM); return ERR_PTR(-ENOMEM);
if (inode->i_state & I_NEW) { 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) { if (inode->i_ino == OPENPROM_ROOT_INO) {
inode->i_op = &openprom_inode_operations; inode->i_op = &openprom_inode_operations;
inode->i_fop = &openprom_operations; inode->i_fop = &openprom_operations;

2
fs/orangefs/file.c
View File

@ -358,7 +358,7 @@ out:
file_accessed(file); file_accessed(file);
} else { } else {
SetMtimeFlag(orangefs_inode); SetMtimeFlag(orangefs_inode);
inode->i_mtime = CURRENT_TIME; inode->i_mtime = current_time(inode);
mark_inode_dirty_sync(inode); mark_inode_dirty_sync(inode);
} }
} }

2
fs/orangefs/inode.c
View File

@ -438,7 +438,7 @@ struct inode *orangefs_new_inode(struct super_block *sb, struct inode *dir,
inode->i_mode = mode; inode->i_mode = mode;
inode->i_uid = current_fsuid(); inode->i_uid = current_fsuid();
inode->i_gid = current_fsgid(); 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_size = PAGE_SIZE;
inode->i_rdev = dev; inode->i_rdev = dev;

2
fs/pipe.c
View File

@ -716,7 +716,7 @@ static struct inode * get_pipe_inode(void)
inode->i_mode = S_IFIFO | S_IRUSR | S_IWUSR; inode->i_mode = S_IFIFO | S_IRUSR | S_IWUSR;
inode->i_uid = current_fsuid(); inode->i_uid = current_fsuid();
inode->i_gid = current_fsgid(); 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; return inode;

2
fs/posix_acl.c
View File

@ -897,7 +897,7 @@ int simple_set_acl(struct inode *inode, struct posix_acl *acl, int type)
acl = NULL; acl = NULL;
} }
inode->i_ctime = CURRENT_TIME; inode->i_ctime = current_time(inode);
set_cached_acl(inode, type, acl); set_cached_acl(inode, type, acl);
return 0; return 0;
} }

2
fs/proc/base.c
View File

@ -1664,7 +1664,7 @@ struct inode *proc_pid_make_inode(struct super_block * sb, struct task_struct *t
/* Common stuff */ /* Common stuff */
ei = PROC_I(inode); ei = PROC_I(inode);
inode->i_ino = get_next_ino(); 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; inode->i_op = &proc_def_inode_operations;
/* /*

2
fs/proc/inode.c
View File

@ -420,7 +420,7 @@ struct inode *proc_get_inode(struct super_block *sb, struct proc_dir_entry *de)
if (inode) { if (inode) {
inode->i_ino = de->low_ino; 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; PROC_I(inode)->pde = de;
if (is_empty_pde(de)) { if (is_empty_pde(de)) {

2
fs/proc/proc_sysctl.c
View File

@ -444,7 +444,7 @@ static struct inode *proc_sys_make_inode(struct super_block *sb,
ei->sysctl = head; ei->sysctl = head;
ei->sysctl_entry = table; 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; inode->i_mode = table->mode;
if (!S_ISDIR(table->mode)) { if (!S_ISDIR(table->mode)) {
inode->i_mode |= S_IFREG; inode->i_mode |= S_IFREG;

2
fs/proc/self.c
View File

@ -56,7 +56,7 @@ int proc_setup_self(struct super_block *s)
struct inode *inode = new_inode_pseudo(s); struct inode *inode = new_inode_pseudo(s);
if (inode) { if (inode) {
inode->i_ino = self_inum; 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_mode = S_IFLNK | S_IRWXUGO;
inode->i_uid = GLOBAL_ROOT_UID; inode->i_uid = GLOBAL_ROOT_UID;
inode->i_gid = GLOBAL_ROOT_GID; inode->i_gid = GLOBAL_ROOT_GID;

2
fs/proc/thread_self.c
View File

@ -58,7 +58,7 @@ int proc_setup_thread_self(struct super_block *s)
struct inode *inode = new_inode_pseudo(s); struct inode *inode = new_inode_pseudo(s);
if (inode) { if (inode) {
inode->i_ino = thread_self_inum; 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_mode = S_IFLNK | S_IRWXUGO;
inode->i_uid = GLOBAL_ROOT_UID; inode->i_uid = GLOBAL_ROOT_UID;
inode->i_gid = GLOBAL_ROOT_GID; inode->i_gid = GLOBAL_ROOT_GID;

2
fs/pstore/inode.c
View File

@ -230,7 +230,7 @@ static struct inode *pstore_get_inode(struct super_block *sb)
struct inode *inode = new_inode(sb); struct inode *inode = new_inode(sb);
if (inode) { if (inode) {
inode->i_ino = get_next_ino(); 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; return inode;
} }

6
fs/ramfs/inode.c
View File

@ -61,7 +61,7 @@ struct inode *ramfs_get_inode(struct super_block *sb,
inode->i_mapping->a_ops = &ramfs_aops; inode->i_mapping->a_ops = &ramfs_aops;
mapping_set_gfp_mask(inode->i_mapping, GFP_HIGHUSER); mapping_set_gfp_mask(inode->i_mapping, GFP_HIGHUSER);
mapping_set_unevictable(inode->i_mapping); 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) { switch (mode & S_IFMT) {
default: default:
init_special_inode(inode, mode, dev); 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); d_instantiate(dentry, inode);
dget(dentry); /* Extra count - pin the dentry in core */ dget(dentry); /* Extra count - pin the dentry in core */
error = 0; error = 0;
dir->i_mtime = dir->i_ctime = CURRENT_TIME; dir->i_mtime = dir->i_ctime = current_time(dir);
} }
return error; return error;
} }
@ -130,7 +130,7 @@ static int ramfs_symlink(struct inode * dir, struct dentry *dentry, const char *
if (!error) { if (!error) {
d_instantiate(dentry, inode); d_instantiate(dentry, inode);
dget(dentry); dget(dentry);
dir->i_mtime = dir->i_ctime = CURRENT_TIME; dir->i_mtime = dir->i_ctime = current_time(dir);
} else } else
iput(inode); iput(inode);
} }

2
fs/tracefs/inode.c
View File

@ -133,7 +133,7 @@ static struct inode *tracefs_get_inode(struct super_block *sb)
struct inode *inode = new_inode(sb); struct inode *inode = new_inode(sb);
if (inode) { if (inode) {
inode->i_ino = get_next_ino(); 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; return inode;
} }

18
ipc/mqueue.c
View File

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

2
kernel/bpf/inode.c
View File

@ -97,7 +97,7 @@ static struct inode *bpf_get_inode(struct super_block *sb,
return ERR_PTR(-ENOSPC); return ERR_PTR(-ENOSPC);
inode->i_ino = get_next_ino(); 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_mtime = inode->i_atime;
inode->i_ctime = inode->i_atime; inode->i_ctime = inode->i_atime;

20
mm/shmem.c
View File

@ -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) void shmem_truncate_range(struct inode *inode, loff_t lstart, loff_t lend)
{ {
shmem_undo_range(inode, lstart, lend, false); 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); EXPORT_SYMBOL_GPL(shmem_truncate_range);
@ -978,7 +978,7 @@ static int shmem_setattr(struct dentry *dentry, struct iattr *attr)
if (error) if (error)
return error; return error;
i_size_write(inode, newsize); 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) { if (newsize <= oldsize) {
loff_t holebegin = round_up(newsize, PAGE_SIZE); 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->i_ino = get_next_ino();
inode_init_owner(inode, dir, mode); inode_init_owner(inode, dir, mode);
inode->i_blocks = 0; 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(); inode->i_generation = get_seconds();
info = SHMEM_I(inode); info = SHMEM_I(inode);
memset(info, 0, (char *)inode - (char *)info); 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) if (!(mode & FALLOC_FL_KEEP_SIZE) && offset + len > inode->i_size)
i_size_write(inode, offset + len); i_size_write(inode, offset + len);
inode->i_ctime = CURRENT_TIME; inode->i_ctime = current_time(inode);
undone: undone:
spin_lock(&inode->i_lock); spin_lock(&inode->i_lock);
inode->i_private = NULL; inode->i_private = NULL;
@ -2906,7 +2906,7 @@ shmem_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, dev_t dev)
error = 0; error = 0;
dir->i_size += BOGO_DIRENT_SIZE; 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); d_instantiate(dentry, inode);
dget(dentry); /* Extra count - pin the dentry in core */ 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; goto out;
dir->i_size += BOGO_DIRENT_SIZE; 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); inc_nlink(inode);
ihold(inode); /* New dentry reference */ ihold(inode); /* New dentry reference */
dget(dentry); /* Extra pinning count for the created dentry */ 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); shmem_free_inode(inode->i_sb);
dir->i_size -= BOGO_DIRENT_SIZE; 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); drop_nlink(inode);
dput(dentry); /* Undo the count from "create" - this does all the work */ dput(dentry); /* Undo the count from "create" - this does all the work */
return 0; 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 = old_dir->i_ctime = old_dir->i_mtime =
new_dir->i_ctime = new_dir->i_mtime = new_dir->i_ctime = new_dir->i_mtime =
d_inode(old_dentry)->i_ctime = 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; 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; new_dir->i_size += BOGO_DIRENT_SIZE;
old_dir->i_ctime = old_dir->i_mtime = old_dir->i_ctime = old_dir->i_mtime =
new_dir->i_ctime = new_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; return 0;
} }
@ -3153,7 +3153,7 @@ static int shmem_symlink(struct inode *dir, struct dentry *dentry, const char *s
put_page(page); put_page(page);
} }
dir->i_size += BOGO_DIRENT_SIZE; 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); d_instantiate(dentry, inode);
dget(dentry); dget(dentry);
return 0; return 0;

2
net/sunrpc/rpc_pipe.c
View File

@ -477,7 +477,7 @@ rpc_get_inode(struct super_block *sb, umode_t mode)
return NULL; return NULL;
inode->i_ino = get_next_ino(); inode->i_ino = get_next_ino();
inode->i_mode = mode; 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) { switch (mode & S_IFMT) {
case S_IFDIR: case S_IFDIR:
inode->i_fop = &simple_dir_operations; inode->i_fop = &simple_dir_operations;

2
security/apparmor/apparmorfs.c
View File

@ -381,7 +381,7 @@ void __aa_fs_profile_migrate_dents(struct aa_profile *old,
for (i = 0; i < AAFS_PROF_SIZEOF; i++) { for (i = 0; i < AAFS_PROF_SIZEOF; i++) {
new->dents[i] = old->dents[i]; new->dents[i] = old->dents[i];
if (new->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; old->dents[i] = NULL;
} }
} }

2
security/inode.c
View File

@ -117,7 +117,7 @@ struct dentry *securityfs_create_file(const char *name, umode_t mode,
inode->i_ino = get_next_ino(); inode->i_ino = get_next_ino();
inode->i_mode = mode; 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; inode->i_private = data;
if (is_dir) { if (is_dir) {
inode->i_op = &simple_dir_inode_operations; inode->i_op = &simple_dir_inode_operations;

2
security/selinux/selinuxfs.c
View File

@ -1089,7 +1089,7 @@ static struct inode *sel_make_inode(struct super_block *sb, int mode)
if (ret) { if (ret) {
ret->i_mode = mode; 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; return ret;
} }