Minki/linux
1
0
Fork 1
mirror of https://github.com/torvalds/linux.git synced 2024-11-24 21:21:41 +00:00
Code Issues Packages Projects Releases Wiki Activity

vfs-6.7.ctime

Browse Source 
-----BEGIN PGP SIGNATURE-----
 
 iHUEABYKAB0WIQRAhzRXHqcMeLMyaSiRxhvAZXjcogUCZTppYgAKCRCRxhvAZXjc
 okIHAP9anLz1QDyMLH12ASuHjgBc0Of3jcB6NB97IWGpL4O21gEA46ohaD+vcJuC
 YkBLU3lXqQ87nfu28ExFAzh10hG2jwM=
 =m4pB
 -----END PGP SIGNATURE-----

Merge tag 'vfs-6.7.ctime' of gitolite.kernel.org:pub/scm/linux/kernel/git/vfs/vfs

Pull vfs inode time accessor updates from Christian Brauner:
 "This finishes the conversion of all inode time fields to accessor
  functions as discussed on list. Changing timestamps manually as we
  used to do before is error prone. Using accessors function makes this
  robust.

  It does not contain the switch of the time fields to discrete 64 bit
  integers to replace struct timespec and free up space in struct inode.
  But after this, the switch can be trivially made and the patch should
  only affect the vfs if we decide to do it"

* tag 'vfs-6.7.ctime' of gitolite.kernel.org:pub/scm/linux/kernel/git/vfs/vfs: (86 commits)
  fs: rename inode i_atime and i_mtime fields
  security: convert to new timestamp accessors
  selinux: convert to new timestamp accessors
  apparmor: convert to new timestamp accessors
  sunrpc: convert to new timestamp accessors
  mm: convert to new timestamp accessors
  bpf: convert to new timestamp accessors
  ipc: convert to new timestamp accessors
  linux: convert to new timestamp accessors
  zonefs: convert to new timestamp accessors
  xfs: convert to new timestamp accessors
  vboxsf: convert to new timestamp accessors
  ufs: convert to new timestamp accessors
  udf: convert to new timestamp accessors
  ubifs: convert to new timestamp accessors
  tracefs: convert to new timestamp accessors
  sysv: convert to new timestamp accessors
  squashfs: convert to new timestamp accessors
  server: convert to new timestamp accessors
  client: convert to new timestamp accessors
  ...
This commit is contained in:
Linus Torvalds 2023-10-30 09:47:13 -10:00
commit 14ab6d425e
215 changed files with 1194 additions and 983 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

@ -86,7 +86,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_set_ctime_current(inode); simple_inode_init_ts(inode);
out: out:
return inode; return inode;
} }

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

@ -53,7 +53,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 = ktime_get_seconds(); sb_info->last_update = ktime_get_seconds();
inode->i_atime = inode->i_mtime = inode_set_ctime_current(inode); simple_inode_init_ts(inode);
} }
/* directory tree removal functions */ /* directory tree removal functions */
@ -101,7 +101,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 = inode_set_ctime_current(ret); simple_inode_init_ts(ret);
if (S_ISDIR(mode)) if (S_ISDIR(mode))
set_nlink(ret, 2); set_nlink(ret, 2);
} }

8
drivers/android/binderfs.c
View File

@ -152,7 +152,7 @@ static int binderfs_binder_device_create(struct inode *ref_inode,
goto err; goto err;
inode->i_ino = minor + INODE_OFFSET; inode->i_ino = minor + INODE_OFFSET;
inode->i_mtime = inode->i_atime = inode_set_ctime_current(inode); simple_inode_init_ts(inode);
init_special_inode(inode, S_IFCHR | 0600, init_special_inode(inode, S_IFCHR | 0600,
MKDEV(MAJOR(binderfs_dev), minor)); MKDEV(MAJOR(binderfs_dev), minor));
inode->i_fop = &binder_fops; inode->i_fop = &binder_fops;
@ -431,7 +431,7 @@ static int binderfs_binder_ctl_create(struct super_block *sb)
} }
inode->i_ino = SECOND_INODE; inode->i_ino = SECOND_INODE;
inode->i_mtime = inode->i_atime = inode_set_ctime_current(inode); simple_inode_init_ts(inode);
init_special_inode(inode, S_IFCHR | 0600, init_special_inode(inode, S_IFCHR | 0600,
MKDEV(MAJOR(binderfs_dev), minor)); MKDEV(MAJOR(binderfs_dev), minor));
inode->i_fop = &binder_ctl_fops; inode->i_fop = &binder_ctl_fops;
@ -473,7 +473,7 @@ static struct inode *binderfs_make_inode(struct super_block *sb, int mode)
if (ret) { if (ret) {
ret->i_ino = iunique(sb, BINDERFS_MAX_MINOR + INODE_OFFSET); ret->i_ino = iunique(sb, BINDERFS_MAX_MINOR + INODE_OFFSET);
ret->i_mode = mode; ret->i_mode = mode;
ret->i_atime = ret->i_mtime = inode_set_ctime_current(ret); simple_inode_init_ts(ret);
} }
return ret; return ret;
} }
@ -702,7 +702,7 @@ static int binderfs_fill_super(struct super_block *sb, struct fs_context *fc)
inode->i_ino = FIRST_INODE; inode->i_ino = FIRST_INODE;
inode->i_fop = &simple_dir_operations; inode->i_fop = &simple_dir_operations;
inode->i_mode = S_IFDIR | 0755; inode->i_mode = S_IFDIR | 0755;
inode->i_mtime = inode->i_atime = inode_set_ctime_current(inode); simple_inode_init_ts(inode);
inode->i_op = &binderfs_dir_inode_operations; inode->i_op = &binderfs_dir_inode_operations;
set_nlink(inode, 2); set_nlink(inode, 2);

2
drivers/char/sonypi.c
View File

@ -920,7 +920,7 @@ static ssize_t sonypi_misc_read(struct file *file, char __user *buf,
if (ret > 0) { if (ret > 0) {
struct inode *inode = file_inode(file); struct inode *inode = file_inode(file);
inode->i_atime = current_time(inode); inode_set_atime_to_ts(inode, current_time(inode));
} }
return ret; return ret;

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

@ -64,8 +64,8 @@ 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 = inode_set_ctime_current(inode); simple_inode_init_ts(inode);
inode->i_mtime = inode->i_atime;
inode->i_private = data; inode->i_private = data;
if (S_ISDIR(mode)) { if (S_ISDIR(mode)) {
inode->i_op = &simple_dir_inode_operations; inode->i_op = &simple_dir_inode_operations;

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

@ -139,7 +139,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 = inode_set_ctime_current(ret); simple_inode_init_ts(ret);
} }
return ret; return ret;
} }

2
drivers/misc/ibmvmc.c
View File

@ -1124,7 +1124,7 @@ static ssize_t ibmvmc_write(struct file *file, const char *buffer,
goto out; goto out;
inode = file_inode(file); inode = file_inode(file);
inode->i_mtime = inode_set_ctime_current(inode); inode_set_mtime_to_ts(inode, inode_set_ctime_current(inode));
mark_inode_dirty(inode); mark_inode_dirty(inode);
dev_dbg(adapter->dev, "write: file = 0x%lx, count = 0x%lx\n", dev_dbg(adapter->dev, "write: file = 0x%lx, count = 0x%lx\n",

2
drivers/platform/x86/sony-laptop.c
View File

@ -4092,7 +4092,7 @@ static ssize_t sonypi_misc_read(struct file *file, char __user *buf,
if (ret > 0) { if (ret > 0) {
struct inode *inode = file_inode(file); struct inode *inode = file_inode(file);
inode->i_atime = current_time(inode); inode_set_atime_to_ts(inode, current_time(inode));
} }
return ret; return ret;

10
drivers/tty/tty_io.c
View File

@ -818,7 +818,7 @@ static void tty_update_time(struct tty_struct *tty, bool mtime)
spin_lock(&tty->files_lock); spin_lock(&tty->files_lock);
list_for_each_entry(priv, &tty->tty_files, list) { list_for_each_entry(priv, &tty->tty_files, list) {
struct inode *inode = file_inode(priv->file); struct inode *inode = file_inode(priv->file);
struct timespec64 *time = mtime ? &inode->i_mtime : &inode->i_atime; struct timespec64 time = mtime ? inode_get_mtime(inode) : inode_get_atime(inode);
/* /*
* We only care if the two values differ in anything other than the * We only care if the two values differ in anything other than the
@ -826,8 +826,12 @@ static void tty_update_time(struct tty_struct *tty, bool mtime)
* the time of the tty device, otherwise it could be construded as a * the time of the tty device, otherwise it could be construded as a
* security leak to let userspace know the exact timing of the tty. * security leak to let userspace know the exact timing of the tty.
*/ */
if ((sec ^ time->tv_sec) & ~7) if ((sec ^ time.tv_sec) & ~7) {
time->tv_sec = sec; if (mtime)
inode_set_mtime(inode, sec, 0);
else
inode_set_atime(inode, sec, 0);
}
} }
spin_unlock(&tty->files_lock); spin_unlock(&tty->files_lock);
} }

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

@ -2642,21 +2642,24 @@ 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 = inode_set_ctime_current(inode); inode_set_mtime_to_ts(inode,
inode_set_ctime_current(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 = inode_set_ctime_current(inode); inode_set_mtime_to_ts(inode,
inode_set_ctime_current(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 = inode_set_ctime_current(inode); inode_set_mtime_to_ts(inode,
inode_set_ctime_current(inode));
break; break;
case USBDEVFS_RESET: case USBDEVFS_RESET:
@ -2668,7 +2671,8 @@ 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 = inode_set_ctime_current(inode); inode_set_mtime_to_ts(inode,
inode_set_ctime_current(inode));
break; break;
case USBDEVFS_GETDRIVER: case USBDEVFS_GETDRIVER:
@ -2695,7 +2699,8 @@ 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 = inode_set_ctime_current(inode); inode_set_mtime_to_ts(inode,
inode_set_ctime_current(inode));
break; break;
#ifdef CONFIG_COMPAT #ifdef CONFIG_COMPAT
@ -2703,14 +2708,16 @@ 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 = inode_set_ctime_current(inode); inode_set_mtime_to_ts(inode,
inode_set_ctime_current(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 = inode_set_ctime_current(inode); inode_set_mtime_to_ts(inode,
inode_set_ctime_current(inode));
break; break;
case USBDEVFS_DISCSIGNAL32: case USBDEVFS_DISCSIGNAL32:
@ -2722,7 +2729,8 @@ 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 = inode_set_ctime_current(inode); inode_set_mtime_to_ts(inode,
inode_set_ctime_current(inode));
break; break;
case USBDEVFS_IOCTL32: case USBDEVFS_IOCTL32:
@ -2804,7 +2812,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); inode_set_atime_to_ts(inode, current_time(inode));
return ret; return ret;
} }

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

@ -1383,8 +1383,8 @@ ffs_sb_make_inode(struct super_block *sb, void *data,
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 = ts; inode_set_atime_to_ts(inode, ts);
inode->i_mtime = ts; inode_set_mtime_to_ts(inode, 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

@ -1969,7 +1969,7 @@ gadgetfs_make_inode (struct super_block *sb,
inode->i_mode = mode; inode->i_mode = mode;
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_set_ctime_current(inode); simple_inode_init_ts(inode);
inode->i_private = data; inode->i_private = data;
inode->i_fop = fops; inode->i_fop = fops;
} }

6
fs/9p/vfs_inode.c
View File

@ -260,7 +260,7 @@ int v9fs_init_inode(struct v9fs_session_info *v9ses,
inode_init_owner(&nop_mnt_idmap, inode, NULL, mode); inode_init_owner(&nop_mnt_idmap, 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_set_ctime_current(inode); simple_inode_init_ts(inode);
inode->i_mapping->a_ops = &v9fs_addr_operations; inode->i_mapping->a_ops = &v9fs_addr_operations;
inode->i_private = NULL; inode->i_private = NULL;
@ -1150,8 +1150,8 @@ v9fs_stat2inode(struct p9_wstat *stat, struct inode *inode,
set_nlink(inode, 1); set_nlink(inode, 1);
inode->i_atime.tv_sec = stat->atime; inode_set_atime(inode, stat->atime, 0);
inode->i_mtime.tv_sec = stat->mtime; inode_set_mtime(inode, stat->mtime, 0);
inode_set_ctime(inode, stat->mtime, 0); inode_set_ctime(inode, stat->mtime, 0);
inode->i_uid = v9ses->dfltuid; inode->i_uid = v9ses->dfltuid;

16
fs/9p/vfs_inode_dotl.c
View File

@ -641,10 +641,10 @@ v9fs_stat2inode_dotl(struct p9_stat_dotl *stat, struct inode *inode,
struct v9fs_inode *v9inode = V9FS_I(inode); struct v9fs_inode *v9inode = V9FS_I(inode);
if ((stat->st_result_mask & P9_STATS_BASIC) == P9_STATS_BASIC) { if ((stat->st_result_mask & P9_STATS_BASIC) == P9_STATS_BASIC) {
inode->i_atime.tv_sec = stat->st_atime_sec; inode_set_atime(inode, stat->st_atime_sec,
inode->i_atime.tv_nsec = stat->st_atime_nsec; stat->st_atime_nsec);
inode->i_mtime.tv_sec = stat->st_mtime_sec; inode_set_mtime(inode, stat->st_mtime_sec,
inode->i_mtime.tv_nsec = stat->st_mtime_nsec; stat->st_mtime_nsec);
inode_set_ctime(inode, stat->st_ctime_sec, inode_set_ctime(inode, stat->st_ctime_sec,
stat->st_ctime_nsec); stat->st_ctime_nsec);
inode->i_uid = stat->st_uid; inode->i_uid = stat->st_uid;
@ -660,12 +660,12 @@ v9fs_stat2inode_dotl(struct p9_stat_dotl *stat, struct inode *inode,
inode->i_blocks = stat->st_blocks; inode->i_blocks = stat->st_blocks;
} else { } else {
if (stat->st_result_mask & P9_STATS_ATIME) { if (stat->st_result_mask & P9_STATS_ATIME) {
inode->i_atime.tv_sec = stat->st_atime_sec; inode_set_atime(inode, stat->st_atime_sec,
inode->i_atime.tv_nsec = stat->st_atime_nsec; stat->st_atime_nsec);
} }
if (stat->st_result_mask & P9_STATS_MTIME) { if (stat->st_result_mask & P9_STATS_MTIME) {
inode->i_mtime.tv_sec = stat->st_mtime_sec; inode_set_mtime(inode, stat->st_mtime_sec,
inode->i_mtime.tv_nsec = stat->st_mtime_nsec; stat->st_mtime_nsec);
} }
if (stat->st_result_mask & P9_STATS_CTIME) { if (stat->st_result_mask & P9_STATS_CTIME) {
inode_set_ctime(inode, stat->st_ctime_sec, inode_set_ctime(inode, stat->st_ctime_sec,

13
fs/adfs/inode.c
View File

@ -242,6 +242,7 @@ struct inode *
adfs_iget(struct super_block *sb, struct object_info *obj) adfs_iget(struct super_block *sb, struct object_info *obj)
{ {
struct inode *inode; struct inode *inode;
struct timespec64 ts;
inode = new_inode(sb); inode = new_inode(sb);
if (!inode) if (!inode)
@ -268,9 +269,10 @@ adfs_iget(struct super_block *sb, struct object_info *obj)
ADFS_I(inode)->attr = obj->attr; ADFS_I(inode)->attr = obj->attr;
inode->i_mode = adfs_atts2mode(sb, inode); inode->i_mode = adfs_atts2mode(sb, inode);
adfs_adfs2unix_time(&inode->i_mtime, inode); adfs_adfs2unix_time(&ts, inode);
inode->i_atime = inode->i_mtime; inode_set_atime_to_ts(inode, ts);
inode_set_ctime_to_ts(inode, inode->i_mtime); inode_set_mtime_to_ts(inode, ts);
inode_set_ctime_to_ts(inode, ts);
if (S_ISDIR(inode->i_mode)) { if (S_ISDIR(inode->i_mode)) {
inode->i_op = &adfs_dir_inode_operations; inode->i_op = &adfs_dir_inode_operations;
@ -321,7 +323,8 @@ adfs_notify_change(struct mnt_idmap *idmap, struct dentry *dentry,
if (ia_valid & ATTR_MTIME && adfs_inode_is_stamped(inode)) { if (ia_valid & ATTR_MTIME && adfs_inode_is_stamped(inode)) {
adfs_unix2adfs_time(inode, &attr->ia_mtime); adfs_unix2adfs_time(inode, &attr->ia_mtime);
adfs_adfs2unix_time(&inode->i_mtime, inode); adfs_adfs2unix_time(&attr->ia_mtime, inode);
inode_set_mtime_to_ts(inode, attr->ia_mtime);
} }
/* /*
@ -329,7 +332,7 @@ adfs_notify_change(struct mnt_idmap *idmap, struct dentry *dentry,
* have the ability to represent them in our filesystem? * have the ability to represent them in our filesystem?
*/ */
if (ia_valid & ATTR_ATIME) if (ia_valid & ATTR_ATIME)
inode->i_atime = attr->ia_atime; inode_set_atime_to_ts(inode, attr->ia_atime);
if (ia_valid & ATTR_CTIME) if (ia_valid & ATTR_CTIME)
inode_set_ctime_to_ts(inode, attr->ia_ctime); inode_set_ctime_to_ts(inode, attr->ia_ctime);
if (ia_valid & ATTR_MODE) { if (ia_valid & ATTR_MODE) {

4
fs/affs/amigaffs.c
View File

@ -60,7 +60,7 @@ affs_insert_hash(struct inode *dir, struct buffer_head *bh)
mark_buffer_dirty_inode(dir_bh, dir); mark_buffer_dirty_inode(dir_bh, dir);
affs_brelse(dir_bh); affs_brelse(dir_bh);
dir->i_mtime = inode_set_ctime_current(dir); inode_set_mtime_to_ts(dir, inode_set_ctime_current(dir));
inode_inc_iversion(dir); inode_inc_iversion(dir);
mark_inode_dirty(dir); mark_inode_dirty(dir);
@ -114,7 +114,7 @@ affs_remove_hash(struct inode *dir, struct buffer_head *rem_bh)
affs_brelse(bh); affs_brelse(bh);
dir->i_mtime = inode_set_ctime_current(dir); inode_set_mtime_to_ts(dir, inode_set_ctime_current(dir));
inode_inc_iversion(dir); inode_inc_iversion(dir);
mark_inode_dirty(dir); mark_inode_dirty(dir);

17
fs/affs/inode.c
View File

@ -149,13 +149,9 @@ struct inode *affs_iget(struct super_block *sb, unsigned long ino)
break; break;
} }
inode->i_mtime.tv_sec = inode->i_atime.tv_sec = inode_set_mtime(inode,
inode_set_ctime(inode, inode_set_atime(inode, inode_set_ctime(inode, (be32_to_cpu(tail->change.days) * 86400LL + be32_to_cpu(tail->change.mins) * 60 + be32_to_cpu(tail->change.ticks) / 50 + AFFS_EPOCH_DELTA) + sys_tz.tz_minuteswest * 60, 0).tv_sec, 0).tv_sec,
(be32_to_cpu(tail->change.days) * 86400LL + 0);
be32_to_cpu(tail->change.mins) * 60 +
be32_to_cpu(tail->change.ticks) / 50 + AFFS_EPOCH_DELTA)
+ sys_tz.tz_minuteswest * 60, 0).tv_sec;
inode->i_mtime.tv_nsec = inode->i_atime.tv_nsec = 0;
affs_brelse(bh); affs_brelse(bh);
unlock_new_inode(inode); unlock_new_inode(inode);
return inode; return inode;
@ -187,12 +183,13 @@ affs_write_inode(struct inode *inode, struct writeback_control *wbc)
} }
tail = AFFS_TAIL(sb, bh); tail = AFFS_TAIL(sb, bh);
if (tail->stype == cpu_to_be32(ST_ROOT)) { if (tail->stype == cpu_to_be32(ST_ROOT)) {
affs_secs_to_datestamp(inode->i_mtime.tv_sec, affs_secs_to_datestamp(inode_get_mtime_sec(inode),
&AFFS_ROOT_TAIL(sb, bh)->root_change); &AFFS_ROOT_TAIL(sb, bh)->root_change);
} else { } else {
tail->protect = cpu_to_be32(AFFS_I(inode)->i_protect); tail->protect = cpu_to_be32(AFFS_I(inode)->i_protect);
tail->size = cpu_to_be32(inode->i_size); tail->size = cpu_to_be32(inode->i_size);
affs_secs_to_datestamp(inode->i_mtime.tv_sec, &tail->change); affs_secs_to_datestamp(inode_get_mtime_sec(inode),
&tail->change);
if (!(inode->i_ino == AFFS_SB(sb)->s_root_block)) { if (!(inode->i_ino == AFFS_SB(sb)->s_root_block)) {
uid = i_uid_read(inode); uid = i_uid_read(inode);
gid = i_gid_read(inode); gid = i_gid_read(inode);
@ -314,7 +311,7 @@ affs_new_inode(struct inode *dir)
inode->i_gid = current_fsgid(); inode->i_gid = current_fsgid();
inode->i_ino = block; inode->i_ino = block;
set_nlink(inode, 1); set_nlink(inode, 1);
inode->i_mtime = inode->i_atime = inode_set_ctime_current(inode); simple_inode_init_ts(inode);
atomic_set(&AFFS_I(inode)->i_opencnt, 0); atomic_set(&AFFS_I(inode)->i_opencnt, 0);
AFFS_I(inode)->i_blkcnt = 0; AFFS_I(inode)->i_blkcnt = 0;
AFFS_I(inode)->i_lc = NULL; AFFS_I(inode)->i_lc = NULL;

2
fs/afs/dynroot.c
View File

@ -88,7 +88,7 @@ struct inode *afs_iget_pseudo_dir(struct super_block *sb, bool root)
set_nlink(inode, 2); set_nlink(inode, 2);
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_atime = inode->i_mtime = inode_set_ctime_current(inode); simple_inode_init_ts(inode);
inode->i_blocks = 0; inode->i_blocks = 0;
inode->i_generation = 0; inode->i_generation = 0;

8
fs/afs/inode.c
View File

@ -91,8 +91,8 @@ static int afs_inode_init_from_status(struct afs_operation *op,
t = status->mtime_client; t = status->mtime_client;
inode_set_ctime_to_ts(inode, t); inode_set_ctime_to_ts(inode, t);
inode->i_mtime = t; inode_set_mtime_to_ts(inode, t);
inode->i_atime = t; inode_set_atime_to_ts(inode, t);
inode->i_flags |= S_NOATIME; inode->i_flags |= S_NOATIME;
inode->i_uid = make_kuid(&init_user_ns, status->owner); inode->i_uid = make_kuid(&init_user_ns, status->owner);
inode->i_gid = make_kgid(&init_user_ns, status->group); inode->i_gid = make_kgid(&init_user_ns, status->group);
@ -204,7 +204,7 @@ static void afs_apply_status(struct afs_operation *op,
} }
t = status->mtime_client; t = status->mtime_client;
inode->i_mtime = t; inode_set_mtime_to_ts(inode, t);
if (vp->update_ctime) if (vp->update_ctime)
inode_set_ctime_to_ts(inode, op->ctime); inode_set_ctime_to_ts(inode, op->ctime);
@ -253,7 +253,7 @@ static void afs_apply_status(struct afs_operation *op,
if (change_size) { if (change_size) {
afs_set_i_size(vnode, status->size); afs_set_i_size(vnode, status->size);
inode_set_ctime_to_ts(inode, t); inode_set_ctime_to_ts(inode, t);
inode->i_atime = t; inode_set_atime_to_ts(inode, t);
} }
} }
} }

2
fs/afs/write.c
View File

@ -424,7 +424,7 @@ try_next_key:
op->store.write_iter = iter; op->store.write_iter = iter;
op->store.i_size = max(pos + size, vnode->netfs.remote_i_size); op->store.i_size = max(pos + size, vnode->netfs.remote_i_size);
op->mtime = vnode->netfs.inode.i_mtime; op->mtime = inode_get_mtime(&vnode->netfs.inode);
afs_wait_for_operation(op); afs_wait_for_operation(op);

4
fs/attr.c
View File

@ -308,9 +308,9 @@ void setattr_copy(struct mnt_idmap *idmap, struct inode *inode,
i_uid_update(idmap, attr, inode); i_uid_update(idmap, attr, inode);
i_gid_update(idmap, attr, inode); i_gid_update(idmap, attr, inode);
if (ia_valid & ATTR_ATIME) if (ia_valid & ATTR_ATIME)
inode->i_atime = attr->ia_atime; inode_set_atime_to_ts(inode, attr->ia_atime);
if (ia_valid & ATTR_MTIME) if (ia_valid & ATTR_MTIME)
inode->i_mtime = attr->ia_mtime; inode_set_mtime_to_ts(inode, attr->ia_mtime);
if (ia_valid & ATTR_CTIME) if (ia_valid & ATTR_CTIME)
inode_set_ctime_to_ts(inode, attr->ia_ctime); inode_set_ctime_to_ts(inode, attr->ia_ctime);
if (ia_valid & ATTR_MODE) { if (ia_valid & ATTR_MODE) {

2
fs/autofs/inode.c
View File

@ -459,7 +459,7 @@ struct inode *autofs_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_set_ctime_current(inode); simple_inode_init_ts(inode);
inode->i_ino = get_next_ino(); inode->i_ino = get_next_ino();
if (S_ISDIR(mode)) { if (S_ISDIR(mode)) {

6
fs/autofs/root.c
View File

@ -600,7 +600,7 @@ static int autofs_dir_symlink(struct mnt_idmap *idmap,
p_ino = autofs_dentry_ino(dentry->d_parent); p_ino = autofs_dentry_ino(dentry->d_parent);
p_ino->count++; p_ino->count++;
dir->i_mtime = inode_set_ctime_current(dir); inode_set_mtime_to_ts(dir, inode_set_ctime_current(dir));
return 0; return 0;
} }
@ -633,7 +633,7 @@ static int autofs_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 = inode_set_ctime_current(dir); inode_set_mtime_to_ts(dir, inode_set_ctime_current(dir));
spin_lock(&sbi->lookup_lock); spin_lock(&sbi->lookup_lock);
__autofs_add_expiring(dentry); __autofs_add_expiring(dentry);
@ -749,7 +749,7 @@ static int autofs_dir_mkdir(struct mnt_idmap *idmap,
p_ino = autofs_dentry_ino(dentry->d_parent); p_ino = autofs_dentry_ino(dentry->d_parent);
p_ino->count++; p_ino->count++;
inc_nlink(dir); inc_nlink(dir);
dir->i_mtime = inode_set_ctime_current(dir); inode_set_mtime_to_ts(dir, inode_set_ctime_current(dir));
return 0; return 0;
} }

2
fs/bad_inode.c
View File

@ -208,7 +208,7 @@ void make_bad_inode(struct inode *inode)
remove_inode_hash(inode); remove_inode_hash(inode);
inode->i_mode = S_IFREG; inode->i_mode = S_IFREG;
inode->i_atime = inode->i_mtime = inode_set_ctime_current(inode); simple_inode_init_ts(inode);
inode->i_op = &bad_inode_ops; inode->i_op = &bad_inode_ops;
inode->i_opflags &= ~IOP_XATTR; inode->i_opflags &= ~IOP_XATTR;
inode->i_fop = &bad_file_ops; inode->i_fop = &bad_file_ops;

10
fs/befs/linuxvfs.c
View File

@ -360,11 +360,11 @@ static struct inode *befs_iget(struct super_block *sb, unsigned long ino)
* for indexing purposes. (PFD, page 54) * for indexing purposes. (PFD, page 54)
*/ */
inode->i_mtime.tv_sec = inode_set_mtime(inode,
fs64_to_cpu(sb, raw_inode->last_modified_time) >> 16; fs64_to_cpu(sb, raw_inode->last_modified_time) >> 16,
inode->i_mtime.tv_nsec = 0; /* lower 16 bits are not a time */ 0);/* lower 16 bits are not a time */
inode_set_ctime_to_ts(inode, inode->i_mtime); inode_set_ctime_to_ts(inode, inode_get_mtime(inode));
inode->i_atime = inode->i_mtime; inode_set_atime_to_ts(inode, inode_get_mtime(inode));
befs_ino->i_inode_num = fsrun_to_cpu(sb, raw_inode->inode_num); befs_ino->i_inode_num = fsrun_to_cpu(sb, raw_inode->inode_num);
befs_ino->i_parent = fsrun_to_cpu(sb, raw_inode->parent); befs_ino->i_parent = fsrun_to_cpu(sb, raw_inode->parent);

9
fs/bfs/dir.c
View File

@ -97,7 +97,7 @@ static int bfs_create(struct mnt_idmap *idmap, struct inode *dir,
set_bit(ino, info->si_imap); set_bit(ino, info->si_imap);
info->si_freei--; info->si_freei--;
inode_init_owner(&nop_mnt_idmap, inode, dir, mode); inode_init_owner(&nop_mnt_idmap, inode, dir, mode);
inode->i_mtime = inode->i_atime = inode_set_ctime_current(inode); simple_inode_init_ts(inode);
inode->i_blocks = 0; inode->i_blocks = 0;
inode->i_op = &bfs_file_inops; inode->i_op = &bfs_file_inops;
inode->i_fop = &bfs_file_operations; inode->i_fop = &bfs_file_operations;
@ -187,7 +187,7 @@ static int bfs_unlink(struct inode *dir, struct dentry *dentry)
} }
de->ino = 0; de->ino = 0;
mark_buffer_dirty_inode(bh, dir); mark_buffer_dirty_inode(bh, dir);
dir->i_mtime = inode_set_ctime_current(dir); inode_set_mtime_to_ts(dir, inode_set_ctime_current(dir));
mark_inode_dirty(dir); mark_inode_dirty(dir);
inode_set_ctime_to_ts(inode, inode_get_ctime(dir)); inode_set_ctime_to_ts(inode, inode_get_ctime(dir));
inode_dec_link_count(inode); inode_dec_link_count(inode);
@ -240,7 +240,7 @@ static int bfs_rename(struct mnt_idmap *idmap, struct inode *old_dir,
goto end_rename; goto end_rename;
} }
old_de->ino = 0; old_de->ino = 0;
old_dir->i_mtime = inode_set_ctime_current(old_dir); inode_set_mtime_to_ts(old_dir, inode_set_ctime_current(old_dir));
mark_inode_dirty(old_dir); mark_inode_dirty(old_dir);
if (new_inode) { if (new_inode) {
inode_set_ctime_current(new_inode); inode_set_ctime_current(new_inode);
@ -294,7 +294,8 @@ static int bfs_add_entry(struct inode *dir, const struct qstr *child, int ino)
dir->i_size += BFS_DIRENT_SIZE; dir->i_size += BFS_DIRENT_SIZE;
inode_set_ctime_current(dir); inode_set_ctime_current(dir);
} }
dir->i_mtime = inode_set_ctime_current(dir); inode_set_mtime_to_ts(dir,
inode_set_ctime_current(dir));
mark_inode_dirty(dir); mark_inode_dirty(dir);
de->ino = cpu_to_le16((u16)ino); de->ino = cpu_to_le16((u16)ino);
for (i = 0; i < BFS_NAMELEN; i++) for (i = 0; i < BFS_NAMELEN; i++)

12
fs/bfs/inode.c
View File

@ -80,11 +80,9 @@ struct inode *bfs_iget(struct super_block *sb, unsigned long ino)
set_nlink(inode, le32_to_cpu(di->i_nlink)); set_nlink(inode, le32_to_cpu(di->i_nlink));
inode->i_size = BFS_FILESIZE(di); inode->i_size = BFS_FILESIZE(di);
inode->i_blocks = BFS_FILEBLOCKS(di); inode->i_blocks = BFS_FILEBLOCKS(di);
inode->i_atime.tv_sec = le32_to_cpu(di->i_atime); inode_set_atime(inode, le32_to_cpu(di->i_atime), 0);
inode->i_mtime.tv_sec = le32_to_cpu(di->i_mtime); inode_set_mtime(inode, le32_to_cpu(di->i_mtime), 0);
inode_set_ctime(inode, le32_to_cpu(di->i_ctime), 0); inode_set_ctime(inode, le32_to_cpu(di->i_ctime), 0);
inode->i_atime.tv_nsec = 0;
inode->i_mtime.tv_nsec = 0;
brelse(bh); brelse(bh);
unlock_new_inode(inode); unlock_new_inode(inode);
@ -140,9 +138,9 @@ static int bfs_write_inode(struct inode *inode, struct writeback_control *wbc)
di->i_uid = cpu_to_le32(i_uid_read(inode)); di->i_uid = cpu_to_le32(i_uid_read(inode));
di->i_gid = cpu_to_le32(i_gid_read(inode)); di->i_gid = cpu_to_le32(i_gid_read(inode));
di->i_nlink = cpu_to_le32(inode->i_nlink); di->i_nlink = cpu_to_le32(inode->i_nlink);
di->i_atime = cpu_to_le32(inode->i_atime.tv_sec); di->i_atime = cpu_to_le32(inode_get_atime_sec(inode));
di->i_mtime = cpu_to_le32(inode->i_mtime.tv_sec); di->i_mtime = cpu_to_le32(inode_get_mtime_sec(inode));
di->i_ctime = cpu_to_le32(inode_get_ctime(inode).tv_sec); di->i_ctime = cpu_to_le32(inode_get_ctime_sec(inode));
i_sblock = BFS_I(inode)->i_sblock; i_sblock = BFS_I(inode)->i_sblock;
di->i_sblock = cpu_to_le32(i_sblock); di->i_sblock = cpu_to_le32(i_sblock);
di->i_eblock = cpu_to_le32(BFS_I(inode)->i_eblock); di->i_eblock = cpu_to_le32(BFS_I(inode)->i_eblock);

2
fs/binfmt_misc.c
View File

@ -547,7 +547,7 @@ static struct inode *bm_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_set_ctime_current(inode); simple_inode_init_ts(inode);
} }
return inode; return inode;
} }

20
fs/btrfs/delayed-inode.c
View File

@ -1834,19 +1834,19 @@ static void fill_stack_inode_item(struct btrfs_trans_handle *trans,
btrfs_set_stack_inode_block_group(inode_item, 0); btrfs_set_stack_inode_block_group(inode_item, 0);
btrfs_set_stack_timespec_sec(&inode_item->atime, btrfs_set_stack_timespec_sec(&inode_item->atime,
inode->i_atime.tv_sec); inode_get_atime_sec(inode));
btrfs_set_stack_timespec_nsec(&inode_item->atime, btrfs_set_stack_timespec_nsec(&inode_item->atime,
inode->i_atime.tv_nsec); inode_get_atime_nsec(inode));
btrfs_set_stack_timespec_sec(&inode_item->mtime, btrfs_set_stack_timespec_sec(&inode_item->mtime,
inode->i_mtime.tv_sec); inode_get_mtime_sec(inode));
btrfs_set_stack_timespec_nsec(&inode_item->mtime, btrfs_set_stack_timespec_nsec(&inode_item->mtime,
inode->i_mtime.tv_nsec); inode_get_mtime_nsec(inode));
btrfs_set_stack_timespec_sec(&inode_item->ctime, btrfs_set_stack_timespec_sec(&inode_item->ctime,
inode_get_ctime(inode).tv_sec); inode_get_ctime_sec(inode));
btrfs_set_stack_timespec_nsec(&inode_item->ctime, btrfs_set_stack_timespec_nsec(&inode_item->ctime,
inode_get_ctime(inode).tv_nsec); inode_get_ctime_nsec(inode));
btrfs_set_stack_timespec_sec(&inode_item->otime, btrfs_set_stack_timespec_sec(&inode_item->otime,
BTRFS_I(inode)->i_otime.tv_sec); BTRFS_I(inode)->i_otime.tv_sec);
@ -1891,11 +1891,11 @@ int btrfs_fill_inode(struct inode *inode, u32 *rdev)
btrfs_inode_split_flags(btrfs_stack_inode_flags(inode_item), btrfs_inode_split_flags(btrfs_stack_inode_flags(inode_item),
&BTRFS_I(inode)->flags, &BTRFS_I(inode)->ro_flags); &BTRFS_I(inode)->flags, &BTRFS_I(inode)->ro_flags);
inode->i_atime.tv_sec = btrfs_stack_timespec_sec(&inode_item->atime); inode_set_atime(inode, btrfs_stack_timespec_sec(&inode_item->atime),
inode->i_atime.tv_nsec = btrfs_stack_timespec_nsec(&inode_item->atime); btrfs_stack_timespec_nsec(&inode_item->atime));
inode->i_mtime.tv_sec = btrfs_stack_timespec_sec(&inode_item->mtime); inode_set_mtime(inode, btrfs_stack_timespec_sec(&inode_item->mtime),
inode->i_mtime.tv_nsec = btrfs_stack_timespec_nsec(&inode_item->mtime); btrfs_stack_timespec_nsec(&inode_item->mtime));
inode_set_ctime(inode, btrfs_stack_timespec_sec(&inode_item->ctime), inode_set_ctime(inode, btrfs_stack_timespec_sec(&inode_item->ctime),
btrfs_stack_timespec_nsec(&inode_item->ctime)); btrfs_stack_timespec_nsec(&inode_item->ctime));

18
fs/btrfs/file.c
View File

@ -1108,17 +1108,18 @@ void btrfs_check_nocow_unlock(struct btrfs_inode *inode)
static void update_time_for_write(struct inode *inode) static void update_time_for_write(struct inode *inode)
{ {
struct timespec64 now, ctime; struct timespec64 now, ts;
if (IS_NOCMTIME(inode)) if (IS_NOCMTIME(inode))
return; return;
now = current_time(inode); now = current_time(inode);
if (!timespec64_equal(&inode->i_mtime, &now)) ts = inode_get_mtime(inode);
inode->i_mtime = now; if (!timespec64_equal(&ts, &now))
inode_set_mtime_to_ts(inode, now);
ctime = inode_get_ctime(inode); ts = inode_get_ctime(inode);
if (!timespec64_equal(&ctime, &now)) if (!timespec64_equal(&ts, &now))
inode_set_ctime_to_ts(inode, now); inode_set_ctime_to_ts(inode, now);
if (IS_I_VERSION(inode)) if (IS_I_VERSION(inode))
@ -2473,7 +2474,8 @@ int btrfs_replace_file_extents(struct btrfs_inode *inode,
inode_inc_iversion(&inode->vfs_inode); inode_inc_iversion(&inode->vfs_inode);
if (!extent_info || extent_info->update_times) if (!extent_info || extent_info->update_times)
inode->vfs_inode.i_mtime = inode_set_ctime_current(&inode->vfs_inode); inode_set_mtime_to_ts(&inode->vfs_inode,
inode_set_ctime_current(&inode->vfs_inode));
ret = btrfs_update_inode(trans, root, inode); ret = btrfs_update_inode(trans, root, inode);
if (ret) if (ret)
@ -2714,7 +2716,7 @@ static int btrfs_punch_hole(struct file *file, loff_t offset, loff_t len)
ASSERT(trans != NULL); ASSERT(trans != NULL);
inode_inc_iversion(inode); inode_inc_iversion(inode);
inode->i_mtime = inode_set_ctime_current(inode); inode_set_mtime_to_ts(inode, inode_set_ctime_current(inode));
ret = btrfs_update_inode(trans, root, BTRFS_I(inode)); ret = btrfs_update_inode(trans, root, BTRFS_I(inode));
updated_inode = true; updated_inode = true;
btrfs_end_transaction(trans); btrfs_end_transaction(trans);
@ -2734,7 +2736,7 @@ out_only_mutex:
struct timespec64 now = inode_set_ctime_current(inode); struct timespec64 now = inode_set_ctime_current(inode);
inode_inc_iversion(inode); inode_inc_iversion(inode);
inode->i_mtime = now; inode_set_mtime_to_ts(inode, now);
trans = btrfs_start_transaction(root, 1); trans = btrfs_start_transaction(root, 1);
if (IS_ERR(trans)) { if (IS_ERR(trans)) {
ret = PTR_ERR(trans); ret = PTR_ERR(trans);

43
fs/btrfs/inode.c
View File

@ -3754,11 +3754,11 @@ static int btrfs_read_locked_inode(struct inode *inode,
btrfs_inode_set_file_extent_range(BTRFS_I(inode), 0, btrfs_inode_set_file_extent_range(BTRFS_I(inode), 0,
round_up(i_size_read(inode), fs_info->sectorsize)); round_up(i_size_read(inode), fs_info->sectorsize));
inode->i_atime.tv_sec = btrfs_timespec_sec(leaf, &inode_item->atime); inode_set_atime(inode, btrfs_timespec_sec(leaf, &inode_item->atime),
inode->i_atime.tv_nsec = btrfs_timespec_nsec(leaf, &inode_item->atime); btrfs_timespec_nsec(leaf, &inode_item->atime));
inode->i_mtime.tv_sec = btrfs_timespec_sec(leaf, &inode_item->mtime); inode_set_mtime(inode, btrfs_timespec_sec(leaf, &inode_item->mtime),
inode->i_mtime.tv_nsec = btrfs_timespec_nsec(leaf, &inode_item->mtime); btrfs_timespec_nsec(leaf, &inode_item->mtime));
inode_set_ctime(inode, btrfs_timespec_sec(leaf, &inode_item->ctime), inode_set_ctime(inode, btrfs_timespec_sec(leaf, &inode_item->ctime),
btrfs_timespec_nsec(leaf, &inode_item->ctime)); btrfs_timespec_nsec(leaf, &inode_item->ctime));
@ -3922,19 +3922,19 @@ static void fill_inode_item(struct btrfs_trans_handle *trans,
btrfs_set_token_inode_nlink(&token, item, inode->i_nlink); btrfs_set_token_inode_nlink(&token, item, inode->i_nlink);
btrfs_set_token_timespec_sec(&token, &item->atime, btrfs_set_token_timespec_sec(&token, &item->atime,
inode->i_atime.tv_sec); inode_get_atime_sec(inode));
btrfs_set_token_timespec_nsec(&token, &item->atime, btrfs_set_token_timespec_nsec(&token, &item->atime,
inode->i_atime.tv_nsec); inode_get_atime_nsec(inode));
btrfs_set_token_timespec_sec(&token, &item->mtime, btrfs_set_token_timespec_sec(&token, &item->mtime,
inode->i_mtime.tv_sec); inode_get_mtime_sec(inode));
btrfs_set_token_timespec_nsec(&token, &item->mtime, btrfs_set_token_timespec_nsec(&token, &item->mtime,
inode->i_mtime.tv_nsec); inode_get_mtime_nsec(inode));
btrfs_set_token_timespec_sec(&token, &item->ctime, btrfs_set_token_timespec_sec(&token, &item->ctime,
inode_get_ctime(inode).tv_sec); inode_get_ctime_sec(inode));
btrfs_set_token_timespec_nsec(&token, &item->ctime, btrfs_set_token_timespec_nsec(&token, &item->ctime,
inode_get_ctime(inode).tv_nsec); inode_get_ctime_nsec(inode));
btrfs_set_token_timespec_sec(&token, &item->otime, btrfs_set_token_timespec_sec(&token, &item->otime,
BTRFS_I(inode)->i_otime.tv_sec); BTRFS_I(inode)->i_otime.tv_sec);
@ -4132,8 +4132,7 @@ err:
btrfs_i_size_write(dir, dir->vfs_inode.i_size - name->len * 2); btrfs_i_size_write(dir, dir->vfs_inode.i_size - name->len * 2);
inode_inc_iversion(&inode->vfs_inode); inode_inc_iversion(&inode->vfs_inode);
inode_inc_iversion(&dir->vfs_inode); inode_inc_iversion(&dir->vfs_inode);
inode_set_ctime_current(&inode->vfs_inode); inode_set_mtime_to_ts(&dir->vfs_inode, inode_set_ctime_current(&dir->vfs_inode));
dir->vfs_inode.i_mtime = inode_set_ctime_current(&dir->vfs_inode);
ret = btrfs_update_inode(trans, root, dir); ret = btrfs_update_inode(trans, root, dir);
out: out:
return ret; return ret;
@ -4306,7 +4305,7 @@ static int btrfs_unlink_subvol(struct btrfs_trans_handle *trans,
btrfs_i_size_write(dir, dir->vfs_inode.i_size - fname.disk_name.len * 2); btrfs_i_size_write(dir, dir->vfs_inode.i_size - fname.disk_name.len * 2);
inode_inc_iversion(&dir->vfs_inode); inode_inc_iversion(&dir->vfs_inode);
dir->vfs_inode.i_mtime = inode_set_ctime_current(&dir->vfs_inode); inode_set_mtime_to_ts(&dir->vfs_inode, inode_set_ctime_current(&dir->vfs_inode));
ret = btrfs_update_inode_fallback(trans, root, dir); ret = btrfs_update_inode_fallback(trans, root, dir);
if (ret) if (ret)
btrfs_abort_transaction(trans, ret); btrfs_abort_transaction(trans, ret);
@ -4956,7 +4955,8 @@ static int btrfs_setsize(struct inode *inode, struct iattr *attr)
if (newsize != oldsize) { if (newsize != oldsize) {
inode_inc_iversion(inode); inode_inc_iversion(inode);
if (!(mask & (ATTR_CTIME | ATTR_MTIME))) { if (!(mask & (ATTR_CTIME | ATTR_MTIME))) {
inode->i_mtime = inode_set_ctime_current(inode); inode_set_mtime_to_ts(inode,
inode_set_ctime_current(inode));
} }
} }
@ -5600,9 +5600,9 @@ static struct inode *new_simple_dir(struct inode *dir,
inode->i_opflags &= ~IOP_XATTR; inode->i_opflags &= ~IOP_XATTR;
inode->i_fop = &simple_dir_operations; inode->i_fop = &simple_dir_operations;
inode->i_mode = S_IFDIR | S_IRUGO | S_IWUSR | S_IXUGO; inode->i_mode = S_IFDIR | S_IRUGO | S_IWUSR | S_IXUGO;
inode->i_mtime = inode_set_ctime_current(inode); inode_set_mtime_to_ts(inode, inode_set_ctime_current(inode));
inode->i_atime = dir->i_atime; inode_set_atime_to_ts(inode, inode_get_atime(dir));
BTRFS_I(inode)->i_otime = inode->i_mtime; BTRFS_I(inode)->i_otime = inode_get_mtime(inode);
inode->i_uid = dir->i_uid; inode->i_uid = dir->i_uid;
inode->i_gid = dir->i_gid; inode->i_gid = dir->i_gid;
@ -6277,9 +6277,8 @@ int btrfs_create_new_inode(struct btrfs_trans_handle *trans,
goto discard; goto discard;
} }
inode->i_mtime = inode_set_ctime_current(inode); simple_inode_init_ts(inode);
inode->i_atime = inode->i_mtime; BTRFS_I(inode)->i_otime = inode_get_mtime(inode);
BTRFS_I(inode)->i_otime = inode->i_mtime;
/* /*
* We're going to fill the inode item now, so at this point the inode * We're going to fill the inode item now, so at this point the inode
@ -6444,8 +6443,8 @@ int btrfs_add_link(struct btrfs_trans_handle *trans,
* values (the ones it had when the fsync was done). * values (the ones it had when the fsync was done).
*/ */
if (!test_bit(BTRFS_FS_LOG_RECOVERING, &root->fs_info->flags)) if (!test_bit(BTRFS_FS_LOG_RECOVERING, &root->fs_info->flags))
parent_inode->vfs_inode.i_mtime = inode_set_mtime_to_ts(&parent_inode->vfs_inode,
inode_set_ctime_current(&parent_inode->vfs_inode); inode_set_ctime_current(&parent_inode->vfs_inode));
ret = btrfs_update_inode(trans, root, parent_inode); ret = btrfs_update_inode(trans, root, parent_inode);
if (ret) if (ret)

2
fs/btrfs/reflink.c
View File

@ -30,7 +30,7 @@ static int clone_finish_inode_update(struct btrfs_trans_handle *trans,
inode_inc_iversion(inode); inode_inc_iversion(inode);
if (!no_time_update) { if (!no_time_update) {
inode->i_mtime = inode_set_ctime_current(inode); inode_set_mtime_to_ts(inode, inode_set_ctime_current(inode));
} }
/* /*
* We round up to the block size at eof when determining which * We round up to the block size at eof when determining which

3
fs/btrfs/transaction.c
View File

@ -1860,7 +1860,8 @@ static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans,
btrfs_i_size_write(BTRFS_I(parent_inode), parent_inode->i_size + btrfs_i_size_write(BTRFS_I(parent_inode), parent_inode->i_size +
fname.disk_name.len * 2); fname.disk_name.len * 2);
parent_inode->i_mtime = inode_set_ctime_current(parent_inode); inode_set_mtime_to_ts(parent_inode,
inode_set_ctime_current(parent_inode));
ret = btrfs_update_inode_fallback(trans, parent_root, BTRFS_I(parent_inode)); ret = btrfs_update_inode_fallback(trans, parent_root, BTRFS_I(parent_inode));
if (ret) { if (ret) {
btrfs_abort_transaction(trans, ret); btrfs_abort_transaction(trans, ret);

12
fs/btrfs/tree-log.c
View File

@ -4138,19 +4138,19 @@ static void fill_inode_item(struct btrfs_trans_handle *trans,
btrfs_set_token_inode_nlink(&token, item, inode->i_nlink); btrfs_set_token_inode_nlink(&token, item, inode->i_nlink);
btrfs_set_token_timespec_sec(&token, &item->atime, btrfs_set_token_timespec_sec(&token, &item->atime,
inode->i_atime.tv_sec); inode_get_atime_sec(inode));
btrfs_set_token_timespec_nsec(&token, &item->atime, btrfs_set_token_timespec_nsec(&token, &item->atime,
inode->i_atime.tv_nsec); inode_get_atime_nsec(inode));
btrfs_set_token_timespec_sec(&token, &item->mtime, btrfs_set_token_timespec_sec(&token, &item->mtime,
inode->i_mtime.tv_sec); inode_get_mtime_sec(inode));
btrfs_set_token_timespec_nsec(&token, &item->mtime, btrfs_set_token_timespec_nsec(&token, &item->mtime,
inode->i_mtime.tv_nsec); inode_get_mtime_nsec(inode));
btrfs_set_token_timespec_sec(&token, &item->ctime, btrfs_set_token_timespec_sec(&token, &item->ctime,
inode_get_ctime(inode).tv_sec); inode_get_ctime_sec(inode));
btrfs_set_token_timespec_nsec(&token, &item->ctime, btrfs_set_token_timespec_nsec(&token, &item->ctime,
inode_get_ctime(inode).tv_nsec); inode_get_ctime_nsec(inode));
/* /*
* We do not need to set the nbytes field, in fact during a fast fsync * We do not need to set the nbytes field, in fact during a fast fsync

10
fs/ceph/addr.c
View File

@ -750,7 +750,7 @@ static int writepage_nounlock(struct page *page, struct writeback_control *wbc)
dout("writepage %llu~%llu (%llu bytes, %sencrypted)\n", dout("writepage %llu~%llu (%llu bytes, %sencrypted)\n",
page_off, len, wlen, IS_ENCRYPTED(inode) ? "" : "not "); page_off, len, wlen, IS_ENCRYPTED(inode) ? "" : "not ");
req->r_mtime = inode->i_mtime; req->r_mtime = inode_get_mtime(inode);
ceph_osdc_start_request(osdc, req); ceph_osdc_start_request(osdc, req);
err = ceph_osdc_wait_request(osdc, req); err = ceph_osdc_wait_request(osdc, req);
@ -1327,7 +1327,7 @@ new_request:
pages = NULL; pages = NULL;
} }
req->r_mtime = inode->i_mtime; req->r_mtime = inode_get_mtime(inode);
ceph_osdc_start_request(&fsc->client->osdc, req); ceph_osdc_start_request(&fsc->client->osdc, req);
req = NULL; req = NULL;
@ -1875,7 +1875,7 @@ int ceph_uninline_data(struct file *file)
goto out_unlock; goto out_unlock;
} }
req->r_mtime = inode->i_mtime; req->r_mtime = inode_get_mtime(inode);
ceph_osdc_start_request(&fsc->client->osdc, req); ceph_osdc_start_request(&fsc->client->osdc, req);
err = ceph_osdc_wait_request(&fsc->client->osdc, req); err = ceph_osdc_wait_request(&fsc->client->osdc, req);
ceph_osdc_put_request(req); ceph_osdc_put_request(req);
@ -1917,7 +1917,7 @@ int ceph_uninline_data(struct file *file)
goto out_put_req; goto out_put_req;
} }
req->r_mtime = inode->i_mtime; req->r_mtime = inode_get_mtime(inode);
ceph_osdc_start_request(&fsc->client->osdc, req); ceph_osdc_start_request(&fsc->client->osdc, req);
err = ceph_osdc_wait_request(&fsc->client->osdc, req); err = ceph_osdc_wait_request(&fsc->client->osdc, req);
@ -2092,7 +2092,7 @@ static int __ceph_pool_perm_get(struct ceph_inode_info *ci,
0, false, true); 0, false, true);
ceph_osdc_start_request(&fsc->client->osdc, rd_req); ceph_osdc_start_request(&fsc->client->osdc, rd_req);
wr_req->r_mtime = ci->netfs.inode.i_mtime; wr_req->r_mtime = inode_get_mtime(&ci->netfs.inode);
ceph_osdc_start_request(&fsc->client->osdc, wr_req); ceph_osdc_start_request(&fsc->client->osdc, wr_req);
err = ceph_osdc_wait_request(&fsc->client->osdc, rd_req); err = ceph_osdc_wait_request(&fsc->client->osdc, rd_req);

4
fs/ceph/caps.c
View File

@ -1421,8 +1421,8 @@ static void __prep_cap(struct cap_msg_args *arg, struct ceph_cap *cap,
arg->old_xattr_buf = NULL; arg->old_xattr_buf = NULL;
} }
arg->mtime = inode->i_mtime; arg->mtime = inode_get_mtime(inode);
arg->atime = inode->i_atime; arg->atime = inode_get_atime(inode);
arg->ctime = inode_get_ctime(inode); arg->ctime = inode_get_ctime(inode);
arg->btime = ci->i_btime; arg->btime = ci->i_btime;
arg->change_attr = inode_peek_iversion_raw(inode); arg->change_attr = inode_peek_iversion_raw(inode);

2
fs/ceph/file.c
View File

@ -2489,7 +2489,7 @@ static int ceph_zero_partial_object(struct inode *inode,
goto out; goto out;
} }
req->r_mtime = inode->i_mtime; req->r_mtime = inode_get_mtime(inode);
ceph_osdc_start_request(&fsc->client->osdc, req); ceph_osdc_start_request(&fsc->client->osdc, req);
ret = ceph_osdc_wait_request(&fsc->client->osdc, req); ret = ceph_osdc_wait_request(&fsc->client->osdc, req);
if (ret == -ENOENT) if (ret == -ENOENT)

64
fs/ceph/inode.c
View File

@ -185,9 +185,9 @@ struct inode *ceph_get_snapdir(struct inode *parent)
inode->i_mode = parent->i_mode; inode->i_mode = parent->i_mode;
inode->i_uid = parent->i_uid; inode->i_uid = parent->i_uid;
inode->i_gid = parent->i_gid; inode->i_gid = parent->i_gid;
inode->i_mtime = parent->i_mtime; inode_set_mtime_to_ts(inode, inode_get_mtime(parent));
inode_set_ctime_to_ts(inode, inode_get_ctime(parent)); inode_set_ctime_to_ts(inode, inode_get_ctime(parent));
inode->i_atime = parent->i_atime; inode_set_atime_to_ts(inode, inode_get_atime(parent));
ci->i_rbytes = 0; ci->i_rbytes = 0;
ci->i_btime = ceph_inode(parent)->i_btime; ci->i_btime = ceph_inode(parent)->i_btime;
@ -835,28 +835,31 @@ void ceph_fill_file_time(struct inode *inode, int issued,
/* the MDS did a utimes() */ /* the MDS did a utimes() */
dout("mtime %lld.%09ld -> %lld.%09ld " dout("mtime %lld.%09ld -> %lld.%09ld "
"tw %d -> %d\n", "tw %d -> %d\n",
inode->i_mtime.tv_sec, inode->i_mtime.tv_nsec, inode_get_mtime_sec(inode),
inode_get_mtime_nsec(inode),
mtime->tv_sec, mtime->tv_nsec, mtime->tv_sec, mtime->tv_nsec,
ci->i_time_warp_seq, (int)time_warp_seq); ci->i_time_warp_seq, (int)time_warp_seq);
inode->i_mtime = *mtime; inode_set_mtime_to_ts(inode, *mtime);
inode->i_atime = *atime; inode_set_atime_to_ts(inode, *atime);
ci->i_time_warp_seq = time_warp_seq; ci->i_time_warp_seq = time_warp_seq;
} else if (time_warp_seq == ci->i_time_warp_seq) { } else if (time_warp_seq == ci->i_time_warp_seq) {
struct timespec64 ts;
/* nobody did utimes(); take the max */ /* nobody did utimes(); take the max */
if (timespec64_compare(mtime, &inode->i_mtime) > 0) { ts = inode_get_mtime(inode);
if (timespec64_compare(mtime, &ts) > 0) {
dout("mtime %lld.%09ld -> %lld.%09ld inc\n", dout("mtime %lld.%09ld -> %lld.%09ld inc\n",
inode->i_mtime.tv_sec, ts.tv_sec, ts.tv_nsec,
inode->i_mtime.tv_nsec,
mtime->tv_sec, mtime->tv_nsec); mtime->tv_sec, mtime->tv_nsec);
inode->i_mtime = *mtime; inode_set_mtime_to_ts(inode, *mtime);
} }
if (timespec64_compare(atime, &inode->i_atime) > 0) { ts = inode_get_atime(inode);
if (timespec64_compare(atime, &ts) > 0) {
dout("atime %lld.%09ld -> %lld.%09ld inc\n", dout("atime %lld.%09ld -> %lld.%09ld inc\n",
inode->i_atime.tv_sec, ts.tv_sec, ts.tv_nsec,
inode->i_atime.tv_nsec,
atime->tv_sec, atime->tv_nsec); atime->tv_sec, atime->tv_nsec);
inode->i_atime = *atime; inode_set_atime_to_ts(inode, *atime);
} }
} else if (issued & CEPH_CAP_FILE_EXCL) { } else if (issued & CEPH_CAP_FILE_EXCL) {
/* we did a utimes(); ignore mds values */ /* we did a utimes(); ignore mds values */
@ -867,8 +870,8 @@ void ceph_fill_file_time(struct inode *inode, int issued,
/* we have no write|excl caps; whatever the MDS says is true */ /* we have no write|excl caps; whatever the MDS says is true */
if (ceph_seq_cmp(time_warp_seq, ci->i_time_warp_seq) >= 0) { if (ceph_seq_cmp(time_warp_seq, ci->i_time_warp_seq) >= 0) {
inode_set_ctime_to_ts(inode, *ctime); inode_set_ctime_to_ts(inode, *ctime);
inode->i_mtime = *mtime; inode_set_mtime_to_ts(inode, *mtime);
inode->i_atime = *atime; inode_set_atime_to_ts(inode, *atime);
ci->i_time_warp_seq = time_warp_seq; ci->i_time_warp_seq = time_warp_seq;
} else { } else {
warn = 1; warn = 1;
@ -2551,20 +2554,22 @@ retry:
} }
if (ia_valid & ATTR_ATIME) { if (ia_valid & ATTR_ATIME) {
struct timespec64 atime = inode_get_atime(inode);
dout("setattr %p atime %lld.%ld -> %lld.%ld\n", inode, dout("setattr %p atime %lld.%ld -> %lld.%ld\n", inode,
inode->i_atime.tv_sec, inode->i_atime.tv_nsec, atime.tv_sec, atime.tv_nsec,
attr->ia_atime.tv_sec, attr->ia_atime.tv_nsec); attr->ia_atime.tv_sec, attr->ia_atime.tv_nsec);
if (issued & CEPH_CAP_FILE_EXCL) { if (issued & CEPH_CAP_FILE_EXCL) {
ci->i_time_warp_seq++; ci->i_time_warp_seq++;
inode->i_atime = attr->ia_atime; inode_set_atime_to_ts(inode, attr->ia_atime);
dirtied |= CEPH_CAP_FILE_EXCL; dirtied |= CEPH_CAP_FILE_EXCL;
} else if ((issued & CEPH_CAP_FILE_WR) && } else if ((issued & CEPH_CAP_FILE_WR) &&
timespec64_compare(&inode->i_atime, timespec64_compare(&atime,
&attr->ia_atime) < 0) { &attr->ia_atime) < 0) {
inode->i_atime = attr->ia_atime; inode_set_atime_to_ts(inode, attr->ia_atime);
dirtied |= CEPH_CAP_FILE_WR; dirtied |= CEPH_CAP_FILE_WR;
} else if ((issued & CEPH_CAP_FILE_SHARED) == 0 || } else if ((issued & CEPH_CAP_FILE_SHARED) == 0 ||
!timespec64_equal(&inode->i_atime, &attr->ia_atime)) { !timespec64_equal(&atime, &attr->ia_atime)) {
ceph_encode_timespec64(&req->r_args.setattr.atime, ceph_encode_timespec64(&req->r_args.setattr.atime,
&attr->ia_atime); &attr->ia_atime);
mask |= CEPH_SETATTR_ATIME; mask |= CEPH_SETATTR_ATIME;
@ -2624,20 +2629,21 @@ retry:
} }
} }
if (ia_valid & ATTR_MTIME) { if (ia_valid & ATTR_MTIME) {
struct timespec64 mtime = inode_get_mtime(inode);
dout("setattr %p mtime %lld.%ld -> %lld.%ld\n", inode, dout("setattr %p mtime %lld.%ld -> %lld.%ld\n", inode,
inode->i_mtime.tv_sec, inode->i_mtime.tv_nsec, mtime.tv_sec, mtime.tv_nsec,
attr->ia_mtime.tv_sec, attr->ia_mtime.tv_nsec); attr->ia_mtime.tv_sec, attr->ia_mtime.tv_nsec);
if (issued & CEPH_CAP_FILE_EXCL) { if (issued & CEPH_CAP_FILE_EXCL) {
ci->i_time_warp_seq++; ci->i_time_warp_seq++;
inode->i_mtime = attr->ia_mtime; inode_set_mtime_to_ts(inode, attr->ia_mtime);
dirtied |= CEPH_CAP_FILE_EXCL; dirtied |= CEPH_CAP_FILE_EXCL;
} else if ((issued & CEPH_CAP_FILE_WR) && } else if ((issued & CEPH_CAP_FILE_WR) &&
timespec64_compare(&inode->i_mtime, timespec64_compare(&mtime, &attr->ia_mtime) < 0) {
&attr->ia_mtime) < 0) { inode_set_mtime_to_ts(inode, attr->ia_mtime);
inode->i_mtime = attr->ia_mtime;
dirtied |= CEPH_CAP_FILE_WR; dirtied |= CEPH_CAP_FILE_WR;
} else if ((issued & CEPH_CAP_FILE_SHARED) == 0 || } else if ((issued & CEPH_CAP_FILE_SHARED) == 0 ||
!timespec64_equal(&inode->i_mtime, &attr->ia_mtime)) { !timespec64_equal(&mtime, &attr->ia_mtime)) {
ceph_encode_timespec64(&req->r_args.setattr.mtime, ceph_encode_timespec64(&req->r_args.setattr.mtime,
&attr->ia_mtime); &attr->ia_mtime);
mask |= CEPH_SETATTR_MTIME; mask |= CEPH_SETATTR_MTIME;
@ -2651,8 +2657,8 @@ retry:
bool only = (ia_valid & (ATTR_SIZE|ATTR_MTIME|ATTR_ATIME| bool only = (ia_valid & (ATTR_SIZE|ATTR_MTIME|ATTR_ATIME|
ATTR_MODE|ATTR_UID|ATTR_GID)) == 0; ATTR_MODE|ATTR_UID|ATTR_GID)) == 0;
dout("setattr %p ctime %lld.%ld -> %lld.%ld (%s)\n", inode, dout("setattr %p ctime %lld.%ld -> %lld.%ld (%s)\n", inode,
inode_get_ctime(inode).tv_sec, inode_get_ctime_sec(inode),
inode_get_ctime(inode).tv_nsec, inode_get_ctime_nsec(inode),
attr->ia_ctime.tv_sec, attr->ia_ctime.tv_nsec, attr->ia_ctime.tv_sec, attr->ia_ctime.tv_nsec,
only ? "ctime only" : "ignored"); only ? "ctime only" : "ignored");
if (only) { if (only) {

8
fs/ceph/mds_client.c
View File

@ -4353,12 +4353,16 @@ static int reconnect_caps_cb(struct inode *inode, int mds, void *arg)
rec.v2.flock_len = (__force __le32) rec.v2.flock_len = (__force __le32)
((ci->i_ceph_flags & CEPH_I_ERROR_FILELOCK) ? 0 : 1); ((ci->i_ceph_flags & CEPH_I_ERROR_FILELOCK) ? 0 : 1);
} else { } else {
struct timespec64 ts;
rec.v1.cap_id = cpu_to_le64(cap->cap_id); rec.v1.cap_id = cpu_to_le64(cap->cap_id);
rec.v1.wanted = cpu_to_le32(__ceph_caps_wanted(ci)); rec.v1.wanted = cpu_to_le32(__ceph_caps_wanted(ci));
rec.v1.issued = cpu_to_le32(cap->issued); rec.v1.issued = cpu_to_le32(cap->issued);
rec.v1.size = cpu_to_le64(i_size_read(inode)); rec.v1.size = cpu_to_le64(i_size_read(inode));
ceph_encode_timespec64(&rec.v1.mtime, &inode->i_mtime); ts = inode_get_mtime(inode);
ceph_encode_timespec64(&rec.v1.atime, &inode->i_atime); ceph_encode_timespec64(&rec.v1.mtime, &ts);
ts = inode_get_atime(inode);
ceph_encode_timespec64(&rec.v1.atime, &ts);
rec.v1.snaprealm = cpu_to_le64(ci->i_snap_realm->ino); rec.v1.snaprealm = cpu_to_le64(ci->i_snap_realm->ino);
rec.v1.pathbase = cpu_to_le64(pathbase); rec.v1.pathbase = cpu_to_le64(pathbase);
} }

4
fs/ceph/snap.c
View File

@ -658,8 +658,8 @@ int __ceph_finish_cap_snap(struct ceph_inode_info *ci,
BUG_ON(capsnap->writing); BUG_ON(capsnap->writing);
capsnap->size = i_size_read(inode); capsnap->size = i_size_read(inode);
capsnap->mtime = inode->i_mtime; capsnap->mtime = inode_get_mtime(inode);
capsnap->atime = inode->i_atime; capsnap->atime = inode_get_atime(inode);
capsnap->ctime = inode_get_ctime(inode); capsnap->ctime = inode_get_ctime(inode);
capsnap->btime = ci->i_btime; capsnap->btime = ci->i_btime;
capsnap->change_attr = inode_peek_iversion_raw(inode); capsnap->change_attr = inode_peek_iversion_raw(inode);

6
fs/coda/coda_linux.c
View File

@ -123,9 +123,11 @@ void coda_vattr_to_iattr(struct inode *inode, struct coda_vattr *attr)
if (attr->va_size != -1) if (attr->va_size != -1)
inode->i_blocks = (attr->va_size + 511) >> 9; inode->i_blocks = (attr->va_size + 511) >> 9;
if (attr->va_atime.tv_sec != -1) if (attr->va_atime.tv_sec != -1)
inode->i_atime = coda_to_timespec64(attr->va_atime); inode_set_atime_to_ts(inode,
coda_to_timespec64(attr->va_atime));
if (attr->va_mtime.tv_sec != -1) if (attr->va_mtime.tv_sec != -1)
inode->i_mtime = coda_to_timespec64(attr->va_mtime); inode_set_mtime_to_ts(inode,
coda_to_timespec64(attr->va_mtime));
if (attr->va_ctime.tv_sec != -1) if (attr->va_ctime.tv_sec != -1)
inode_set_ctime_to_ts(inode, inode_set_ctime_to_ts(inode,
coda_to_timespec64(attr->va_ctime)); coda_to_timespec64(attr->va_ctime));

2
fs/coda/dir.c
View File

@ -111,7 +111,7 @@ static inline void coda_dir_update_mtime(struct inode *dir)
/* optimistically we can also act as if our nose bleeds. The /* optimistically we can also act as if our nose bleeds. The
* granularity of the mtime is coarse anyways so we might actually be * granularity of the mtime is coarse anyways so we might actually be
* right most of the time. Note: we only do this for directories. */ * right most of the time. Note: we only do this for directories. */
dir->i_mtime = inode_set_ctime_current(dir); inode_set_mtime_to_ts(dir, inode_set_ctime_current(dir));
#endif #endif
} }

2
fs/coda/file.c
View File

@ -84,7 +84,7 @@ coda_file_write_iter(struct kiocb *iocb, struct iov_iter *to)
ret = vfs_iter_write(cfi->cfi_container, to, &iocb->ki_pos, 0); ret = vfs_iter_write(cfi->cfi_container, to, &iocb->ki_pos, 0);
coda_inode->i_size = file_inode(host_file)->i_size; coda_inode->i_size = file_inode(host_file)->i_size;
coda_inode->i_blocks = (coda_inode->i_size + 511) >> 9; coda_inode->i_blocks = (coda_inode->i_size + 511) >> 9;
coda_inode->i_mtime = inode_set_ctime_current(coda_inode); inode_set_mtime_to_ts(coda_inode, inode_set_ctime_current(coda_inode));
inode_unlock(coda_inode); inode_unlock(coda_inode);
file_end_write(host_file); file_end_write(host_file);

8
fs/configfs/inode.c
View File

@ -88,7 +88,7 @@ int configfs_setattr(struct mnt_idmap *idmap, struct dentry *dentry,
static inline void set_default_inode_attr(struct inode * inode, umode_t mode) static inline void set_default_inode_attr(struct inode * inode, umode_t mode)
{ {
inode->i_mode = mode; inode->i_mode = mode;
inode->i_atime = inode->i_mtime = inode_set_ctime_current(inode); simple_inode_init_ts(inode);
} }
static inline void set_inode_attr(struct inode * inode, struct iattr * iattr) static inline void set_inode_attr(struct inode * inode, struct iattr * iattr)
@ -96,8 +96,8 @@ static inline void set_inode_attr(struct inode * inode, struct iattr * iattr)
inode->i_mode = iattr->ia_mode; inode->i_mode = iattr->ia_mode;
inode->i_uid = iattr->ia_uid; inode->i_uid = iattr->ia_uid;
inode->i_gid = iattr->ia_gid; inode->i_gid = iattr->ia_gid;
inode->i_atime = iattr->ia_atime; inode_set_atime_to_ts(inode, iattr->ia_atime);
inode->i_mtime = iattr->ia_mtime; inode_set_mtime_to_ts(inode, iattr->ia_mtime);
inode_set_ctime_to_ts(inode, iattr->ia_ctime); inode_set_ctime_to_ts(inode, iattr->ia_ctime);
} }
@ -171,7 +171,7 @@ struct inode *configfs_create(struct dentry *dentry, umode_t mode)
return ERR_PTR(-ENOMEM); return ERR_PTR(-ENOMEM);
p_inode = d_inode(dentry->d_parent); p_inode = d_inode(dentry->d_parent);
p_inode->i_mtime = inode_set_ctime_current(p_inode); inode_set_mtime_to_ts(p_inode, inode_set_ctime_current(p_inode));
configfs_set_inode_lock_class(sd, inode); configfs_set_inode_lock_class(sd, inode);
return inode; return inode;
} }

4
fs/cramfs/inode.c
View File

@ -133,8 +133,8 @@ static struct inode *get_cramfs_inode(struct super_block *sb,
} }
/* Struct copy intentional */ /* Struct copy intentional */
inode->i_mtime = inode->i_atime = inode_set_ctime_to_ts(inode, inode_set_mtime_to_ts(inode,
zerotime); inode_set_atime_to_ts(inode, inode_set_ctime_to_ts(inode, zerotime)));
/* inode->i_nlink is left 1 - arguably wrong for directories, /* inode->i_nlink is left 1 - arguably wrong for directories,
but it's the best we can do without reading the directory but it's the best we can do without reading the directory
contents. 1 yields the right result in GNU find, even contents. 1 yields the right result in GNU find, even

2
fs/debugfs/inode.c
View File

@ -72,7 +72,7 @@ static struct inode *debugfs_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_set_ctime_current(inode); simple_inode_init_ts(inode);
} }
return inode; return inode;
} }

6
fs/devpts/inode.c
View File

@ -338,7 +338,7 @@ static int mknod_ptmx(struct super_block *sb)
} }
inode->i_ino = 2; inode->i_ino = 2;
inode->i_mtime = inode->i_atime = inode_set_ctime_current(inode); simple_inode_init_ts(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));
@ -451,7 +451,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_set_ctime_current(inode); simple_inode_init_ts(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;
@ -560,7 +560,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_set_ctime_current(inode); simple_inode_init_ts(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/file.c
View File

@ -51,7 +51,7 @@ static ssize_t efivarfs_file_write(struct file *file,
} else { } else {
inode_lock(inode); inode_lock(inode);
i_size_write(inode, datasize + sizeof(attributes)); i_size_write(inode, datasize + sizeof(attributes));
inode->i_mtime = inode_set_ctime_current(inode); inode_set_mtime_to_ts(inode, inode_set_ctime_current(inode));
inode_unlock(inode); inode_unlock(inode);
} }

2
fs/efivarfs/inode.c
View File

@ -25,7 +25,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_set_ctime_current(inode); simple_inode_init_ts(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:

5
fs/efs/inode.c
View File

@ -103,10 +103,9 @@ struct inode *efs_iget(struct super_block *super, unsigned long ino)
i_uid_write(inode, (uid_t)be16_to_cpu(efs_inode->di_uid)); i_uid_write(inode, (uid_t)be16_to_cpu(efs_inode->di_uid));
i_gid_write(inode, (gid_t)be16_to_cpu(efs_inode->di_gid)); i_gid_write(inode, (gid_t)be16_to_cpu(efs_inode->di_gid));
inode->i_size = be32_to_cpu(efs_inode->di_size); inode->i_size = be32_to_cpu(efs_inode->di_size);
inode->i_atime.tv_sec = be32_to_cpu(efs_inode->di_atime); inode_set_atime(inode, be32_to_cpu(efs_inode->di_atime), 0);
inode->i_mtime.tv_sec = be32_to_cpu(efs_inode->di_mtime); inode_set_mtime(inode, be32_to_cpu(efs_inode->di_mtime), 0);
inode_set_ctime(inode, be32_to_cpu(efs_inode->di_ctime), 0); inode_set_ctime(inode, be32_to_cpu(efs_inode->di_ctime), 0);
inode->i_atime.tv_nsec = inode->i_mtime.tv_nsec = 0;
/* this is the number of blocks in the file */ /* this is the number of blocks in the file */
if (inode->i_size == 0) { if (inode->i_size == 0) {

3
fs/erofs/inode.c
View File

@ -175,7 +175,8 @@ static void *erofs_read_inode(struct erofs_buf *buf,
vi->chunkbits = sb->s_blocksize_bits + vi->chunkbits = sb->s_blocksize_bits +
(vi->chunkformat & EROFS_CHUNK_FORMAT_BLKBITS_MASK); (vi->chunkformat & EROFS_CHUNK_FORMAT_BLKBITS_MASK);
} }
inode->i_mtime = inode->i_atime = inode_get_ctime(inode); inode_set_mtime_to_ts(inode,
inode_set_atime_to_ts(inode, inode_get_ctime(inode)));
inode->i_flags &= ~S_DAX; inode->i_flags &= ~S_DAX;
if (test_opt(&sbi->opt, DAX_ALWAYS) && S_ISREG(inode->i_mode) && if (test_opt(&sbi->opt, DAX_ALWAYS) && S_ISREG(inode->i_mode) &&

1
fs/exfat/exfat_fs.h
View File

@ -549,6 +549,7 @@ void __exfat_fs_error(struct super_block *sb, int report, const char *fmt, ...)
void exfat_get_entry_time(struct exfat_sb_info *sbi, struct timespec64 *ts, void exfat_get_entry_time(struct exfat_sb_info *sbi, struct timespec64 *ts,
u8 tz, __le16 time, __le16 date, u8 time_cs); u8 tz, __le16 time, __le16 date, u8 time_cs);
void exfat_truncate_atime(struct timespec64 *ts); void exfat_truncate_atime(struct timespec64 *ts);
void exfat_truncate_inode_atime(struct inode *inode);
void exfat_set_entry_time(struct exfat_sb_info *sbi, struct timespec64 *ts, void exfat_set_entry_time(struct exfat_sb_info *sbi, struct timespec64 *ts,
u8 *tz, __le16 *time, __le16 *date, u8 *time_cs); u8 *tz, __le16 *time, __le16 *date, u8 *time_cs);
u16 exfat_calc_chksum16(void *data, int len, u16 chksum, int type); u16 exfat_calc_chksum16(void *data, int len, u16 chksum, int type);

7
fs/exfat/file.c
View File

@ -22,7 +22,7 @@ static int exfat_cont_expand(struct inode *inode, loff_t size)
if (err) if (err)
return err; return err;
inode->i_mtime = inode_set_ctime_current(inode); inode_set_mtime_to_ts(inode, inode_set_ctime_current(inode));
mark_inode_dirty(inode); mark_inode_dirty(inode);
if (!IS_SYNC(inode)) if (!IS_SYNC(inode))
@ -290,10 +290,9 @@ int exfat_setattr(struct mnt_idmap *idmap, struct dentry *dentry,
} }
if (attr->ia_valid & ATTR_SIZE) if (attr->ia_valid & ATTR_SIZE)
inode->i_mtime = inode_set_ctime_current(inode); inode_set_mtime_to_ts(inode, inode_set_ctime_current(inode));
setattr_copy(&nop_mnt_idmap, inode, attr); exfat_truncate_inode_atime(inode);
exfat_truncate_atime(&inode->i_atime);
if (attr->ia_valid & ATTR_SIZE) { if (attr->ia_valid & ATTR_SIZE) {
error = exfat_block_truncate_page(inode, attr->ia_size); error = exfat_block_truncate_page(inode, attr->ia_size);

31
fs/exfat/inode.c
View File

@ -26,6 +26,7 @@ int __exfat_write_inode(struct inode *inode, int sync)
struct exfat_sb_info *sbi = EXFAT_SB(sb); struct exfat_sb_info *sbi = EXFAT_SB(sb);
struct exfat_inode_info *ei = EXFAT_I(inode); struct exfat_inode_info *ei = EXFAT_I(inode);
bool is_dir = (ei->type == TYPE_DIR) ? true : false; bool is_dir = (ei->type == TYPE_DIR) ? true : false;
struct timespec64 ts;
if (inode->i_ino == EXFAT_ROOT_INO) if (inode->i_ino == EXFAT_ROOT_INO)
return 0; return 0;
@ -55,16 +56,18 @@ int __exfat_write_inode(struct inode *inode, int sync)
&ep->dentry.file.create_time, &ep->dentry.file.create_time,
&ep->dentry.file.create_date, &ep->dentry.file.create_date,
&ep->dentry.file.create_time_cs); &ep->dentry.file.create_time_cs);
exfat_set_entry_time(sbi, &inode->i_mtime, exfat_set_entry_time(sbi, &ts,
&ep->dentry.file.modify_tz, &ep->dentry.file.modify_tz,
&ep->dentry.file.modify_time, &ep->dentry.file.modify_time,
&ep->dentry.file.modify_date, &ep->dentry.file.modify_date,
&ep->dentry.file.modify_time_cs); &ep->dentry.file.modify_time_cs);
exfat_set_entry_time(sbi, &inode->i_atime, inode_set_mtime_to_ts(inode, ts);
&ep->dentry.file.access_tz, exfat_set_entry_time(sbi, &ts,
&ep->dentry.file.access_time, &ep->dentry.file.access_tz,
&ep->dentry.file.access_date, &ep->dentry.file.access_time,
NULL); &ep->dentry.file.access_date,
NULL);
inode_set_atime_to_ts(inode, ts);
/* File size should be zero if there is no cluster allocated */ /* File size should be zero if there is no cluster allocated */
on_disk_size = i_size_read(inode); on_disk_size = i_size_read(inode);
@ -355,7 +358,7 @@ static void exfat_write_failed(struct address_space *mapping, loff_t to)
if (to > i_size_read(inode)) { if (to > i_size_read(inode)) {
truncate_pagecache(inode, i_size_read(inode)); truncate_pagecache(inode, i_size_read(inode));
inode->i_mtime = inode_set_ctime_current(inode); inode_set_mtime_to_ts(inode, inode_set_ctime_current(inode));
exfat_truncate(inode); exfat_truncate(inode);
} }
} }
@ -398,7 +401,7 @@ static int exfat_write_end(struct file *file, struct address_space *mapping,
exfat_write_failed(mapping, pos+len); exfat_write_failed(mapping, pos+len);
if (!(err < 0) && !(ei->attr & ATTR_ARCHIVE)) { if (!(err < 0) && !(ei->attr & ATTR_ARCHIVE)) {
inode->i_mtime = inode_set_ctime_current(inode); inode_set_mtime_to_ts(inode, inode_set_ctime_current(inode));
ei->attr |= ATTR_ARCHIVE; ei->attr |= ATTR_ARCHIVE;
mark_inode_dirty(inode); mark_inode_dirty(inode);
} }
@ -576,10 +579,10 @@ static int exfat_fill_inode(struct inode *inode, struct exfat_dir_entry *info)
exfat_save_attr(inode, info->attr); exfat_save_attr(inode, info->attr);
inode->i_blocks = round_up(i_size_read(inode), sbi->cluster_size) >> 9; inode->i_blocks = round_up(i_size_read(inode), sbi->cluster_size) >> 9;
inode->i_mtime = info->mtime; inode_set_mtime_to_ts(inode, info->mtime);
inode_set_ctime_to_ts(inode, info->mtime); inode_set_ctime_to_ts(inode, info->mtime);
ei->i_crtime = info->crtime; ei->i_crtime = info->crtime;
inode->i_atime = info->atime; inode_set_atime_to_ts(inode, info->atime);
return 0; return 0;
} }

8
fs/exfat/misc.c
View File

@ -126,6 +126,14 @@ void exfat_truncate_atime(struct timespec64 *ts)
ts->tv_nsec = 0; ts->tv_nsec = 0;
} }
void exfat_truncate_inode_atime(struct inode *inode)
{
struct timespec64 atime = inode_get_atime(inode);
exfat_truncate_atime(&atime);
inode_set_atime_to_ts(inode, atime);
}
u16 exfat_calc_chksum16(void *data, int len, u16 chksum, int type) u16 exfat_calc_chksum16(void *data, int len, u16 chksum, int type)
{ {
int i; int i;

31
fs/exfat/namei.c
View File

@ -569,7 +569,7 @@ static int exfat_create(struct mnt_idmap *idmap, struct inode *dir,
goto unlock; goto unlock;
inode_inc_iversion(dir); inode_inc_iversion(dir);
dir->i_mtime = inode_set_ctime_current(dir); inode_set_mtime_to_ts(dir, inode_set_ctime_current(dir));
if (IS_DIRSYNC(dir)) if (IS_DIRSYNC(dir))
exfat_sync_inode(dir); exfat_sync_inode(dir);
else else
@ -582,8 +582,9 @@ static int exfat_create(struct mnt_idmap *idmap, struct inode *dir,
goto unlock; goto unlock;
inode_inc_iversion(inode); inode_inc_iversion(inode);
inode->i_mtime = inode->i_atime = EXFAT_I(inode)->i_crtime = inode_set_ctime_current(inode); EXFAT_I(inode)->i_crtime = simple_inode_init_ts(inode);
exfat_truncate_atime(&inode->i_atime); exfat_truncate_inode_atime(inode);
/* timestamp is already written, so mark_inode_dirty() is unneeded. */ /* timestamp is already written, so mark_inode_dirty() is unneeded. */
d_instantiate(dentry, inode); d_instantiate(dentry, inode);
@ -816,16 +817,16 @@ static int exfat_unlink(struct inode *dir, struct dentry *dentry)
ei->dir.dir = DIR_DELETED; ei->dir.dir = DIR_DELETED;
inode_inc_iversion(dir); inode_inc_iversion(dir);
dir->i_mtime = dir->i_atime = inode_set_ctime_current(dir); simple_inode_init_ts(dir);
exfat_truncate_atime(&dir->i_atime); exfat_truncate_inode_atime(dir);
if (IS_DIRSYNC(dir)) if (IS_DIRSYNC(dir))
exfat_sync_inode(dir); exfat_sync_inode(dir);
else else
mark_inode_dirty(dir); mark_inode_dirty(dir);
clear_nlink(inode); clear_nlink(inode);
inode->i_mtime = inode->i_atime = inode_set_ctime_current(inode); simple_inode_init_ts(inode);
exfat_truncate_atime(&inode->i_atime); exfat_truncate_inode_atime(inode);
exfat_unhash_inode(inode); exfat_unhash_inode(inode);
exfat_d_version_set(dentry, inode_query_iversion(dir)); exfat_d_version_set(dentry, inode_query_iversion(dir));
unlock: unlock:
@ -851,7 +852,7 @@ static int exfat_mkdir(struct mnt_idmap *idmap, struct inode *dir,
goto unlock; goto unlock;
inode_inc_iversion(dir); inode_inc_iversion(dir);
dir->i_mtime = inode_set_ctime_current(dir); inode_set_mtime_to_ts(dir, inode_set_ctime_current(dir));
if (IS_DIRSYNC(dir)) if (IS_DIRSYNC(dir))
exfat_sync_inode(dir); exfat_sync_inode(dir);
else else
@ -865,8 +866,8 @@ static int exfat_mkdir(struct mnt_idmap *idmap, struct inode *dir,
goto unlock; goto unlock;
inode_inc_iversion(inode); inode_inc_iversion(inode);
inode->i_mtime = inode->i_atime = EXFAT_I(inode)->i_crtime = inode_set_ctime_current(inode); EXFAT_I(inode)->i_crtime = simple_inode_init_ts(inode);
exfat_truncate_atime(&inode->i_atime); exfat_truncate_inode_atime(inode);
/* timestamp is already written, so mark_inode_dirty() is unneeded. */ /* timestamp is already written, so mark_inode_dirty() is unneeded. */
d_instantiate(dentry, inode); d_instantiate(dentry, inode);
@ -977,8 +978,8 @@ static int exfat_rmdir(struct inode *dir, struct dentry *dentry)
ei->dir.dir = DIR_DELETED; ei->dir.dir = DIR_DELETED;
inode_inc_iversion(dir); inode_inc_iversion(dir);
dir->i_mtime = dir->i_atime = inode_set_ctime_current(dir); simple_inode_init_ts(dir);
exfat_truncate_atime(&dir->i_atime); exfat_truncate_inode_atime(dir);
if (IS_DIRSYNC(dir)) if (IS_DIRSYNC(dir))
exfat_sync_inode(dir); exfat_sync_inode(dir);
else else
@ -986,8 +987,8 @@ static int exfat_rmdir(struct inode *dir, struct dentry *dentry)
drop_nlink(dir); drop_nlink(dir);
clear_nlink(inode); clear_nlink(inode);
inode->i_mtime = inode->i_atime = inode_set_ctime_current(inode); simple_inode_init_ts(inode);
exfat_truncate_atime(&inode->i_atime); exfat_truncate_inode_atime(inode);
exfat_unhash_inode(inode); exfat_unhash_inode(inode);
exfat_d_version_set(dentry, inode_query_iversion(dir)); exfat_d_version_set(dentry, inode_query_iversion(dir));
unlock: unlock:
@ -1312,7 +1313,7 @@ static int exfat_rename(struct mnt_idmap *idmap,
inode_inc_iversion(new_dir); inode_inc_iversion(new_dir);
simple_rename_timestamp(old_dir, old_dentry, new_dir, new_dentry); simple_rename_timestamp(old_dir, old_dentry, new_dir, new_dentry);
EXFAT_I(new_dir)->i_crtime = current_time(new_dir); EXFAT_I(new_dir)->i_crtime = current_time(new_dir);
exfat_truncate_atime(&new_dir->i_atime); exfat_truncate_inode_atime(new_dir);
if (IS_DIRSYNC(new_dir)) if (IS_DIRSYNC(new_dir))
exfat_sync_inode(new_dir); exfat_sync_inode(new_dir);
else else

4
fs/exfat/super.c
View File

@ -370,8 +370,8 @@ static int exfat_read_root(struct inode *inode)
ei->i_size_ondisk = i_size_read(inode); ei->i_size_ondisk = i_size_read(inode);
exfat_save_attr(inode, ATTR_SUBDIR); exfat_save_attr(inode, ATTR_SUBDIR);
inode->i_mtime = inode->i_atime = ei->i_crtime = inode_set_ctime_current(inode); ei->i_crtime = simple_inode_init_ts(inode);
exfat_truncate_atime(&inode->i_atime); exfat_truncate_inode_atime(inode);
return 0; return 0;
} }

6
fs/ext2/dir.c
View File

@ -468,7 +468,7 @@ int ext2_set_link(struct inode *dir, struct ext2_dir_entry_2 *de,
ext2_set_de_type(de, inode); ext2_set_de_type(de, inode);
ext2_commit_chunk(page, pos, len); ext2_commit_chunk(page, pos, len);
if (update_times) if (update_times)
dir->i_mtime = inode_set_ctime_current(dir); inode_set_mtime_to_ts(dir, inode_set_ctime_current(dir));
EXT2_I(dir)->i_flags &= ~EXT2_BTREE_FL; EXT2_I(dir)->i_flags &= ~EXT2_BTREE_FL;
mark_inode_dirty(dir); mark_inode_dirty(dir);
return ext2_handle_dirsync(dir); return ext2_handle_dirsync(dir);
@ -555,7 +555,7 @@ got_it:
de->inode = cpu_to_le32(inode->i_ino); de->inode = cpu_to_le32(inode->i_ino);
ext2_set_de_type (de, inode); ext2_set_de_type (de, inode);
ext2_commit_chunk(page, pos, rec_len); ext2_commit_chunk(page, pos, rec_len);
dir->i_mtime = inode_set_ctime_current(dir); inode_set_mtime_to_ts(dir, inode_set_ctime_current(dir));
EXT2_I(dir)->i_flags &= ~EXT2_BTREE_FL; EXT2_I(dir)->i_flags &= ~EXT2_BTREE_FL;
mark_inode_dirty(dir); mark_inode_dirty(dir);
err = ext2_handle_dirsync(dir); err = ext2_handle_dirsync(dir);
@ -606,7 +606,7 @@ int ext2_delete_entry(struct ext2_dir_entry_2 *dir, struct page *page)
pde->rec_len = ext2_rec_len_to_disk(to - from); pde->rec_len = ext2_rec_len_to_disk(to - from);
dir->inode = 0; dir->inode = 0;
ext2_commit_chunk(page, pos, to - from); ext2_commit_chunk(page, pos, to - from);
inode->i_mtime = inode_set_ctime_current(inode); inode_set_mtime_to_ts(inode, inode_set_ctime_current(inode));
EXT2_I(inode)->i_flags &= ~EXT2_BTREE_FL; EXT2_I(inode)->i_flags &= ~EXT2_BTREE_FL;
mark_inode_dirty(inode); mark_inode_dirty(inode);
return ext2_handle_dirsync(inode); return ext2_handle_dirsync(inode);

2
fs/ext2/ialloc.c
View File

@ -546,7 +546,7 @@ got:
inode->i_ino = ino; inode->i_ino = ino;
inode->i_blocks = 0; inode->i_blocks = 0;
inode->i_mtime = inode->i_atime = inode_set_ctime_current(inode); simple_inode_init_ts(inode);
memset(ei->i_data, 0, sizeof(ei->i_data)); memset(ei->i_data, 0, sizeof(ei->i_data));
ei->i_flags = ei->i_flags =
ext2_mask_flags(mode, EXT2_I(dir)->i_flags & EXT2_FL_INHERITED); ext2_mask_flags(mode, EXT2_I(dir)->i_flags & EXT2_FL_INHERITED);

13
fs/ext2/inode.c
View File

@ -1291,7 +1291,7 @@ static int ext2_setsize(struct inode *inode, loff_t newsize)
__ext2_truncate_blocks(inode, newsize); __ext2_truncate_blocks(inode, newsize);
filemap_invalidate_unlock(inode->i_mapping); filemap_invalidate_unlock(inode->i_mapping);
inode->i_mtime = inode_set_ctime_current(inode); inode_set_mtime_to_ts(inode, inode_set_ctime_current(inode));
if (inode_needs_sync(inode)) { if (inode_needs_sync(inode)) {
sync_mapping_buffers(inode->i_mapping); sync_mapping_buffers(inode->i_mapping);
sync_inode_metadata(inode, 1); sync_inode_metadata(inode, 1);
@ -1412,10 +1412,9 @@ struct inode *ext2_iget (struct super_block *sb, unsigned long ino)
i_gid_write(inode, i_gid); i_gid_write(inode, i_gid);
set_nlink(inode, le16_to_cpu(raw_inode->i_links_count)); set_nlink(inode, le16_to_cpu(raw_inode->i_links_count));
inode->i_size = le32_to_cpu(raw_inode->i_size); inode->i_size = le32_to_cpu(raw_inode->i_size);
inode->i_atime.tv_sec = (signed)le32_to_cpu(raw_inode->i_atime); inode_set_atime(inode, (signed)le32_to_cpu(raw_inode->i_atime), 0);
inode_set_ctime(inode, (signed)le32_to_cpu(raw_inode->i_ctime), 0); inode_set_ctime(inode, (signed)le32_to_cpu(raw_inode->i_ctime), 0);
inode->i_mtime.tv_sec = (signed)le32_to_cpu(raw_inode->i_mtime); inode_set_mtime(inode, (signed)le32_to_cpu(raw_inode->i_mtime), 0);
inode->i_atime.tv_nsec = inode->i_mtime.tv_nsec = 0;
ei->i_dtime = le32_to_cpu(raw_inode->i_dtime); ei->i_dtime = le32_to_cpu(raw_inode->i_dtime);
/* We now have enough fields to check if the inode was active or not. /* We now have enough fields to check if the inode was active or not.
* This is needed because nfsd might try to access dead inodes * This is needed because nfsd might try to access dead inodes
@ -1544,9 +1543,9 @@ static int __ext2_write_inode(struct inode *inode, int do_sync)
} }
raw_inode->i_links_count = cpu_to_le16(inode->i_nlink); raw_inode->i_links_count = cpu_to_le16(inode->i_nlink);
raw_inode->i_size = cpu_to_le32(inode->i_size); raw_inode->i_size = cpu_to_le32(inode->i_size);
raw_inode->i_atime = cpu_to_le32(inode->i_atime.tv_sec); raw_inode->i_atime = cpu_to_le32(inode_get_atime_sec(inode));
raw_inode->i_ctime = cpu_to_le32(inode_get_ctime(inode).tv_sec); raw_inode->i_ctime = cpu_to_le32(inode_get_ctime_sec(inode));
raw_inode->i_mtime = cpu_to_le32(inode->i_mtime.tv_sec); raw_inode->i_mtime = cpu_to_le32(inode_get_mtime_sec(inode));
raw_inode->i_blocks = cpu_to_le32(inode->i_blocks); raw_inode->i_blocks = cpu_to_le32(inode->i_blocks);
raw_inode->i_dtime = cpu_to_le32(ei->i_dtime); raw_inode->i_dtime = cpu_to_le32(ei->i_dtime);

2
fs/ext2/super.c
View File

@ -1572,7 +1572,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_inc_iversion(inode); inode_inc_iversion(inode);
inode->i_mtime = inode_set_ctime_current(inode); inode_set_mtime_to_ts(inode, inode_set_ctime_current(inode));
mark_inode_dirty(inode); mark_inode_dirty(inode);
return len - towrite; return len - towrite;
} }

20
fs/ext4/ext4.h
View File

@ -891,10 +891,13 @@ do { \
(raw_inode)->xtime = cpu_to_le32(clamp_t(int32_t, (ts).tv_sec, S32_MIN, S32_MAX)); \ (raw_inode)->xtime = cpu_to_le32(clamp_t(int32_t, (ts).tv_sec, S32_MIN, S32_MAX)); \
} while (0) } while (0)
#define EXT4_INODE_SET_XTIME(xtime, inode, raw_inode) \ #define EXT4_INODE_SET_ATIME(inode, raw_inode) \
EXT4_INODE_SET_XTIME_VAL(xtime, inode, raw_inode, (inode)->xtime) EXT4_INODE_SET_XTIME_VAL(i_atime, inode, raw_inode, inode_get_atime(inode))
#define EXT4_INODE_SET_CTIME(inode, raw_inode) \ #define EXT4_INODE_SET_MTIME(inode, raw_inode) \
EXT4_INODE_SET_XTIME_VAL(i_mtime, inode, raw_inode, inode_get_mtime(inode))
#define EXT4_INODE_SET_CTIME(inode, raw_inode) \
EXT4_INODE_SET_XTIME_VAL(i_ctime, inode, raw_inode, inode_get_ctime(inode)) EXT4_INODE_SET_XTIME_VAL(i_ctime, inode, raw_inode, inode_get_ctime(inode))
#define EXT4_EINODE_SET_XTIME(xtime, einode, raw_inode) \ #define EXT4_EINODE_SET_XTIME(xtime, einode, raw_inode) \
@ -910,9 +913,16 @@ do { \
.tv_sec = (signed)le32_to_cpu((raw_inode)->xtime) \ .tv_sec = (signed)le32_to_cpu((raw_inode)->xtime) \
}) })
#define EXT4_INODE_GET_XTIME(xtime, inode, raw_inode) \ #define EXT4_INODE_GET_ATIME(inode, raw_inode) \
do { \ do { \
(inode)->xtime = EXT4_INODE_GET_XTIME_VAL(xtime, inode, raw_inode); \ inode_set_atime_to_ts(inode, \
EXT4_INODE_GET_XTIME_VAL(i_atime, inode, raw_inode)); \
} while (0)
#define EXT4_INODE_GET_MTIME(inode, raw_inode) \
do { \
inode_set_mtime_to_ts(inode, \
EXT4_INODE_GET_XTIME_VAL(i_mtime, inode, raw_inode)); \
} while (0) } while (0)
#define EXT4_INODE_GET_CTIME(inode, raw_inode) \ #define EXT4_INODE_GET_CTIME(inode, raw_inode) \

11
fs/ext4/extents.c
View File

@ -4481,7 +4481,8 @@ retry:
if (epos > new_size) if (epos > new_size)
epos = new_size; epos = new_size;
if (ext4_update_inode_size(inode, epos) & 0x1) if (ext4_update_inode_size(inode, epos) & 0x1)
inode->i_mtime = inode_get_ctime(inode); inode_set_mtime_to_ts(inode,
inode_get_ctime(inode));
} }
ret2 = ext4_mark_inode_dirty(handle, inode); ret2 = ext4_mark_inode_dirty(handle, inode);
ext4_update_inode_fsync_trans(handle, inode, 1); ext4_update_inode_fsync_trans(handle, inode, 1);
@ -4617,7 +4618,7 @@ static long ext4_zero_range(struct file *file, loff_t offset,
/* Now release the pages and zero block aligned part of pages */ /* Now release the pages and zero block aligned part of pages */
truncate_pagecache_range(inode, start, end - 1); truncate_pagecache_range(inode, start, end - 1);
inode->i_mtime = inode_set_ctime_current(inode); inode_set_mtime_to_ts(inode, inode_set_ctime_current(inode));
ret = ext4_alloc_file_blocks(file, lblk, max_blocks, new_size, ret = ext4_alloc_file_blocks(file, lblk, max_blocks, new_size,
flags); flags);
@ -4642,7 +4643,7 @@ static long ext4_zero_range(struct file *file, loff_t offset,
goto out_mutex; goto out_mutex;
} }
inode->i_mtime = inode_set_ctime_current(inode); inode_set_mtime_to_ts(inode, inode_set_ctime_current(inode));
if (new_size) if (new_size)
ext4_update_inode_size(inode, new_size); ext4_update_inode_size(inode, new_size);
ret = ext4_mark_inode_dirty(handle, inode); ret = ext4_mark_inode_dirty(handle, inode);
@ -5378,7 +5379,7 @@ static int ext4_collapse_range(struct file *file, loff_t offset, loff_t len)
up_write(&EXT4_I(inode)->i_data_sem); up_write(&EXT4_I(inode)->i_data_sem);
if (IS_SYNC(inode)) if (IS_SYNC(inode))
ext4_handle_sync(handle); ext4_handle_sync(handle);
inode->i_mtime = inode_set_ctime_current(inode); inode_set_mtime_to_ts(inode, inode_set_ctime_current(inode));
ret = ext4_mark_inode_dirty(handle, inode); ret = ext4_mark_inode_dirty(handle, inode);
ext4_update_inode_fsync_trans(handle, inode, 1); ext4_update_inode_fsync_trans(handle, inode, 1);
@ -5488,7 +5489,7 @@ static int ext4_insert_range(struct file *file, loff_t offset, loff_t len)
/* Expand file to avoid data loss if there is error while shifting */ /* Expand file to avoid data loss if there is error while shifting */
inode->i_size += len; inode->i_size += len;
EXT4_I(inode)->i_disksize += len; EXT4_I(inode)->i_disksize += len;
inode->i_mtime = inode_set_ctime_current(inode); inode_set_mtime_to_ts(inode, inode_set_ctime_current(inode));
ret = ext4_mark_inode_dirty(handle, inode); ret = ext4_mark_inode_dirty(handle, inode);
if (ret) if (ret)
goto out_stop; goto out_stop;

4
fs/ext4/ialloc.c
View File

@ -1250,8 +1250,8 @@ got:
inode->i_ino = ino + group * EXT4_INODES_PER_GROUP(sb); inode->i_ino = ino + group * EXT4_INODES_PER_GROUP(sb);
/* This is the optimal IO size (for stat), not the fs block size */ /* This is the optimal IO size (for stat), not the fs block size */
inode->i_blocks = 0; inode->i_blocks = 0;
inode->i_mtime = inode->i_atime = inode_set_ctime_current(inode); simple_inode_init_ts(inode);
ei->i_crtime = inode->i_mtime; ei->i_crtime = inode_get_mtime(inode);
memset(ei->i_data, 0, sizeof(ei->i_data)); memset(ei->i_data, 0, sizeof(ei->i_data));
ei->i_dir_start_lookup = 0; ei->i_dir_start_lookup = 0;

4
fs/ext4/inline.c
View File

@ -1037,7 +1037,7 @@ static int ext4_add_dirent_to_inline(handle_t *handle,
* happen is that the times are slightly out of date * happen is that the times are slightly out of date
* and/or different from the directory change time. * and/or different from the directory change time.
*/ */
dir->i_mtime = inode_set_ctime_current(dir); inode_set_mtime_to_ts(dir, inode_set_ctime_current(dir));
ext4_update_dx_flag(dir); ext4_update_dx_flag(dir);
inode_inc_iversion(dir); inode_inc_iversion(dir);
return 1; return 1;
@ -1991,7 +1991,7 @@ out:
ext4_orphan_del(handle, inode); ext4_orphan_del(handle, inode);
if (err == 0) { if (err == 0) {
inode->i_mtime = inode_set_ctime_current(inode); inode_set_mtime_to_ts(inode, inode_set_ctime_current(inode));
err = ext4_mark_inode_dirty(handle, inode); err = ext4_mark_inode_dirty(handle, inode);
if (IS_SYNC(inode)) if (IS_SYNC(inode))
ext4_handle_sync(handle); ext4_handle_sync(handle);

19
fs/ext4/inode.c
View File

@ -4020,7 +4020,7 @@ int ext4_punch_hole(struct file *file, loff_t offset, loff_t length)
if (IS_SYNC(inode)) if (IS_SYNC(inode))
ext4_handle_sync(handle); ext4_handle_sync(handle);
inode->i_mtime = inode_set_ctime_current(inode); inode_set_mtime_to_ts(inode, inode_set_ctime_current(inode));
ret2 = ext4_mark_inode_dirty(handle, inode); ret2 = ext4_mark_inode_dirty(handle, inode);
if (unlikely(ret2)) if (unlikely(ret2))
ret = ret2; ret = ret2;
@ -4180,7 +4180,7 @@ out_stop:
if (inode->i_nlink) if (inode->i_nlink)
ext4_orphan_del(handle, inode); ext4_orphan_del(handle, inode);
inode->i_mtime = inode_set_ctime_current(inode); inode_set_mtime_to_ts(inode, inode_set_ctime_current(inode));
err2 = ext4_mark_inode_dirty(handle, inode); err2 = ext4_mark_inode_dirty(handle, inode);
if (unlikely(err2 && !err)) if (unlikely(err2 && !err))
err = err2; err = err2;
@ -4284,8 +4284,8 @@ static int ext4_fill_raw_inode(struct inode *inode, struct ext4_inode *raw_inode
raw_inode->i_links_count = cpu_to_le16(inode->i_nlink); raw_inode->i_links_count = cpu_to_le16(inode->i_nlink);
EXT4_INODE_SET_CTIME(inode, raw_inode); EXT4_INODE_SET_CTIME(inode, raw_inode);
EXT4_INODE_SET_XTIME(i_mtime, inode, raw_inode); EXT4_INODE_SET_MTIME(inode, raw_inode);
EXT4_INODE_SET_XTIME(i_atime, inode, raw_inode); EXT4_INODE_SET_ATIME(inode, raw_inode);
EXT4_EINODE_SET_XTIME(i_crtime, ei, raw_inode); EXT4_EINODE_SET_XTIME(i_crtime, ei, raw_inode);
raw_inode->i_dtime = cpu_to_le32(ei->i_dtime); raw_inode->i_dtime = cpu_to_le32(ei->i_dtime);
@ -4893,8 +4893,8 @@ struct inode *__ext4_iget(struct super_block *sb, unsigned long ino,
} }
EXT4_INODE_GET_CTIME(inode, raw_inode); EXT4_INODE_GET_CTIME(inode, raw_inode);
EXT4_INODE_GET_XTIME(i_mtime, inode, raw_inode); EXT4_INODE_GET_ATIME(inode, raw_inode);
EXT4_INODE_GET_XTIME(i_atime, inode, raw_inode); EXT4_INODE_GET_MTIME(inode, raw_inode);
EXT4_EINODE_GET_XTIME(i_crtime, ei, raw_inode); EXT4_EINODE_GET_XTIME(i_crtime, ei, raw_inode);
if (likely(!test_opt2(inode->i_sb, HURD_COMPAT))) { if (likely(!test_opt2(inode->i_sb, HURD_COMPAT))) {
@ -5019,8 +5019,8 @@ static void __ext4_update_other_inode_time(struct super_block *sb,
spin_lock(&ei->i_raw_lock); spin_lock(&ei->i_raw_lock);
EXT4_INODE_SET_CTIME(inode, raw_inode); EXT4_INODE_SET_CTIME(inode, raw_inode);
EXT4_INODE_SET_XTIME(i_mtime, inode, raw_inode); EXT4_INODE_SET_MTIME(inode, raw_inode);
EXT4_INODE_SET_XTIME(i_atime, inode, raw_inode); EXT4_INODE_SET_ATIME(inode, raw_inode);
ext4_inode_csum_set(inode, raw_inode, ei); ext4_inode_csum_set(inode, raw_inode, ei);
spin_unlock(&ei->i_raw_lock); spin_unlock(&ei->i_raw_lock);
trace_ext4_other_inode_update_time(inode, orig_ino); trace_ext4_other_inode_update_time(inode, orig_ino);
@ -5413,7 +5413,8 @@ int ext4_setattr(struct mnt_idmap *idmap, struct dentry *dentry,
* update c/mtime in shrink case below * update c/mtime in shrink case below
*/ */
if (!shrink) if (!shrink)
inode->i_mtime = inode_set_ctime_current(inode); inode_set_mtime_to_ts(inode,
inode_set_ctime_current(inode));
if (shrink) if (shrink)
ext4_fc_track_range(handle, inode, ext4_fc_track_range(handle, inode,

13
fs/ext4/ioctl.c
View File

@ -312,13 +312,22 @@ static void swap_inode_data(struct inode *inode1, struct inode *inode2)
struct ext4_inode_info *ei1; struct ext4_inode_info *ei1;
struct ext4_inode_info *ei2; struct ext4_inode_info *ei2;
unsigned long tmp; unsigned long tmp;
struct timespec64 ts1, ts2;
ei1 = EXT4_I(inode1); ei1 = EXT4_I(inode1);
ei2 = EXT4_I(inode2); ei2 = EXT4_I(inode2);
swap(inode1->i_version, inode2->i_version); swap(inode1->i_version, inode2->i_version);
swap(inode1->i_atime, inode2->i_atime);
swap(inode1->i_mtime, inode2->i_mtime); ts1 = inode_get_atime(inode1);
ts2 = inode_get_atime(inode2);
inode_set_atime_to_ts(inode1, ts2);
inode_set_atime_to_ts(inode2, ts1);
ts1 = inode_get_mtime(inode1);
ts2 = inode_get_mtime(inode2);
inode_set_mtime_to_ts(inode1, ts2);
inode_set_mtime_to_ts(inode2, ts1);
memswap(ei1->i_data, ei2->i_data, sizeof(ei1->i_data)); memswap(ei1->i_data, ei2->i_data, sizeof(ei1->i_data));
tmp = ei1->i_flags & EXT4_FL_SHOULD_SWAP; tmp = ei1->i_flags & EXT4_FL_SHOULD_SWAP;

10
fs/ext4/namei.c
View File

@ -2207,7 +2207,7 @@ static int add_dirent_to_buf(handle_t *handle, struct ext4_filename *fname,
* happen is that the times are slightly out of date * happen is that the times are slightly out of date
* and/or different from the directory change time. * and/or different from the directory change time.
*/ */
dir->i_mtime = inode_set_ctime_current(dir); inode_set_mtime_to_ts(dir, inode_set_ctime_current(dir));
ext4_update_dx_flag(dir); ext4_update_dx_flag(dir);
inode_inc_iversion(dir); inode_inc_iversion(dir);
err2 = ext4_mark_inode_dirty(handle, dir); err2 = ext4_mark_inode_dirty(handle, dir);
@ -3202,7 +3202,7 @@ static int ext4_rmdir(struct inode *dir, struct dentry *dentry)
* recovery. */ * recovery. */
inode->i_size = 0; inode->i_size = 0;
ext4_orphan_add(handle, inode); ext4_orphan_add(handle, inode);
dir->i_mtime = inode_set_ctime_current(dir); inode_set_mtime_to_ts(dir, inode_set_ctime_current(dir));
inode_set_ctime_current(inode); inode_set_ctime_current(inode);
retval = ext4_mark_inode_dirty(handle, inode); retval = ext4_mark_inode_dirty(handle, inode);
if (retval) if (retval)
@ -3277,7 +3277,7 @@ int __ext4_unlink(struct inode *dir, const struct qstr *d_name,
retval = ext4_delete_entry(handle, dir, de, bh); retval = ext4_delete_entry(handle, dir, de, bh);
if (retval) if (retval)
goto out_handle; goto out_handle;
dir->i_mtime = inode_set_ctime_current(dir); inode_set_mtime_to_ts(dir, inode_set_ctime_current(dir));
ext4_update_dx_flag(dir); ext4_update_dx_flag(dir);
retval = ext4_mark_inode_dirty(handle, dir); retval = ext4_mark_inode_dirty(handle, dir);
if (retval) if (retval)
@ -3648,7 +3648,7 @@ static int ext4_setent(handle_t *handle, struct ext4_renament *ent,
if (ext4_has_feature_filetype(ent->dir->i_sb)) if (ext4_has_feature_filetype(ent->dir->i_sb))
ent->de->file_type = file_type; ent->de->file_type = file_type;
inode_inc_iversion(ent->dir); inode_inc_iversion(ent->dir);
ent->dir->i_mtime = inode_set_ctime_current(ent->dir); inode_set_mtime_to_ts(ent->dir, inode_set_ctime_current(ent->dir));
retval = ext4_mark_inode_dirty(handle, ent->dir); retval = ext4_mark_inode_dirty(handle, ent->dir);
BUFFER_TRACE(ent->bh, "call ext4_handle_dirty_metadata"); BUFFER_TRACE(ent->bh, "call ext4_handle_dirty_metadata");
if (!ent->inlined) { if (!ent->inlined) {
@ -3963,7 +3963,7 @@ static int ext4_rename(struct mnt_idmap *idmap, struct inode *old_dir,
ext4_dec_count(new.inode); ext4_dec_count(new.inode);
inode_set_ctime_current(new.inode); inode_set_ctime_current(new.inode);
} }
old.dir->i_mtime = inode_set_ctime_current(old.dir); inode_set_mtime_to_ts(old.dir, inode_set_ctime_current(old.dir));
ext4_update_dx_flag(old.dir); ext4_update_dx_flag(old.dir);
if (old.dir_bh) { if (old.dir_bh) {
retval = ext4_rename_dir_finish(handle, &old, new.dir->i_ino); retval = ext4_rename_dir_finish(handle, &old, new.dir->i_ino);

2
fs/ext4/super.c
View File

@ -7129,7 +7129,7 @@ static int ext4_quota_off(struct super_block *sb, int type)
} }
EXT4_I(inode)->i_flags &= ~(EXT4_NOATIME_FL | EXT4_IMMUTABLE_FL); EXT4_I(inode)->i_flags &= ~(EXT4_NOATIME_FL | EXT4_IMMUTABLE_FL);
inode_set_flags(inode, 0, S_NOATIME | S_IMMUTABLE); inode_set_flags(inode, 0, S_NOATIME | S_IMMUTABLE);
inode->i_mtime = inode_set_ctime_current(inode); inode_set_mtime_to_ts(inode, inode_set_ctime_current(inode));
err = ext4_mark_inode_dirty(handle, inode); err = ext4_mark_inode_dirty(handle, inode);
ext4_journal_stop(handle); ext4_journal_stop(handle);
out_unlock: out_unlock:

8
fs/ext4/xattr.c
View File

@ -356,7 +356,7 @@ ext4_xattr_inode_hash(struct ext4_sb_info *sbi, const void *buffer, size_t size)
static u64 ext4_xattr_inode_get_ref(struct inode *ea_inode) static u64 ext4_xattr_inode_get_ref(struct inode *ea_inode)
{ {
return ((u64) inode_get_ctime(ea_inode).tv_sec << 32) | return ((u64) inode_get_ctime_sec(ea_inode) << 32) |
(u32) inode_peek_iversion_raw(ea_inode); (u32) inode_peek_iversion_raw(ea_inode);
} }
@ -368,12 +368,12 @@ static void ext4_xattr_inode_set_ref(struct inode *ea_inode, u64 ref_count)
static u32 ext4_xattr_inode_get_hash(struct inode *ea_inode) static u32 ext4_xattr_inode_get_hash(struct inode *ea_inode)
{ {
return (u32)ea_inode->i_atime.tv_sec; return (u32) inode_get_atime_sec(ea_inode);
} }
static void ext4_xattr_inode_set_hash(struct inode *ea_inode, u32 hash) static void ext4_xattr_inode_set_hash(struct inode *ea_inode, u32 hash)
{ {
ea_inode->i_atime.tv_sec = hash; inode_set_atime(ea_inode, hash, 0);
} }
/* /*
@ -418,7 +418,7 @@ free_bhs:
return ret; return ret;
} }
#define EXT4_XATTR_INODE_GET_PARENT(inode) ((__u32)(inode)->i_mtime.tv_sec) #define EXT4_XATTR_INODE_GET_PARENT(inode) ((__u32)(inode_get_mtime_sec(inode)))
static int ext4_xattr_inode_iget(struct inode *parent, unsigned long ea_ino, static int ext4_xattr_inode_iget(struct inode *parent, unsigned long ea_ino,
u32 ea_inode_hash, struct inode **ea_inode) u32 ea_inode_hash, struct inode **ea_inode)

6
fs/f2fs/dir.c
View File

@ -455,7 +455,7 @@ void f2fs_set_link(struct inode *dir, struct f2fs_dir_entry *de,
de->file_type = fs_umode_to_ftype(inode->i_mode); de->file_type = fs_umode_to_ftype(inode->i_mode);
set_page_dirty(page); set_page_dirty(page);
dir->i_mtime = inode_set_ctime_current(dir); inode_set_mtime_to_ts(dir, inode_set_ctime_current(dir));
f2fs_mark_inode_dirty_sync(dir, false); f2fs_mark_inode_dirty_sync(dir, false);
f2fs_put_page(page, 1); f2fs_put_page(page, 1);
} }
@ -609,7 +609,7 @@ void f2fs_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 = inode_set_ctime_current(dir); inode_set_mtime_to_ts(dir, inode_set_ctime_current(dir));
f2fs_mark_inode_dirty_sync(dir, false); f2fs_mark_inode_dirty_sync(dir, false);
if (F2FS_I(dir)->i_current_depth != current_depth) if (F2FS_I(dir)->i_current_depth != current_depth)
@ -919,7 +919,7 @@ void f2fs_delete_entry(struct f2fs_dir_entry *dentry, struct page *page,
} }
f2fs_put_page(page, 1); f2fs_put_page(page, 1);
dir->i_mtime = inode_set_ctime_current(dir); inode_set_mtime_to_ts(dir, inode_set_ctime_current(dir));
f2fs_mark_inode_dirty_sync(dir, false); f2fs_mark_inode_dirty_sync(dir, false);
if (inode) if (inode)

10
fs/f2fs/f2fs.h
View File

@ -3318,13 +3318,15 @@ static inline void clear_file(struct inode *inode, int type)
static inline bool f2fs_is_time_consistent(struct inode *inode) static inline bool f2fs_is_time_consistent(struct inode *inode)
{ {
struct timespec64 ctime = inode_get_ctime(inode); struct timespec64 ts = inode_get_atime(inode);
if (!timespec64_equal(F2FS_I(inode)->i_disk_time, &inode->i_atime)) if (!timespec64_equal(F2FS_I(inode)->i_disk_time, &ts))
return false; return false;
if (!timespec64_equal(F2FS_I(inode)->i_disk_time + 1, &ctime)) ts = inode_get_ctime(inode);
if (!timespec64_equal(F2FS_I(inode)->i_disk_time + 1, &ts))
return false; return false;
if (!timespec64_equal(F2FS_I(inode)->i_disk_time + 2, &inode->i_mtime)) ts = inode_get_mtime(inode);
if (!timespec64_equal(F2FS_I(inode)->i_disk_time + 2, &ts))
return false; return false;
return true; return true;
} }

14
fs/f2fs/file.c
View File

@ -798,7 +798,7 @@ int f2fs_truncate(struct inode *inode)
if (err) if (err)
return err; return err;
inode->i_mtime = inode_set_ctime_current(inode); inode_set_mtime_to_ts(inode, inode_set_ctime_current(inode));
f2fs_mark_inode_dirty_sync(inode, false); f2fs_mark_inode_dirty_sync(inode, false);
return 0; return 0;
} }
@ -905,9 +905,9 @@ static void __setattr_copy(struct mnt_idmap *idmap,
i_uid_update(idmap, attr, inode); i_uid_update(idmap, attr, inode);
i_gid_update(idmap, attr, inode); i_gid_update(idmap, attr, inode);
if (ia_valid & ATTR_ATIME) if (ia_valid & ATTR_ATIME)
inode->i_atime = attr->ia_atime; inode_set_atime_to_ts(inode, attr->ia_atime);
if (ia_valid & ATTR_MTIME) if (ia_valid & ATTR_MTIME)
inode->i_mtime = attr->ia_mtime; inode_set_mtime_to_ts(inode, attr->ia_mtime);
if (ia_valid & ATTR_CTIME) if (ia_valid & ATTR_CTIME)
inode_set_ctime_to_ts(inode, attr->ia_ctime); inode_set_ctime_to_ts(inode, attr->ia_ctime);
if (ia_valid & ATTR_MODE) { if (ia_valid & ATTR_MODE) {
@ -1012,7 +1012,7 @@ int f2fs_setattr(struct mnt_idmap *idmap, struct dentry *dentry,
return err; return err;
spin_lock(&F2FS_I(inode)->i_size_lock); spin_lock(&F2FS_I(inode)->i_size_lock);
inode->i_mtime = inode_set_ctime_current(inode); inode_set_mtime_to_ts(inode, inode_set_ctime_current(inode));
F2FS_I(inode)->last_disk_size = i_size_read(inode); F2FS_I(inode)->last_disk_size = i_size_read(inode);
spin_unlock(&F2FS_I(inode)->i_size_lock); spin_unlock(&F2FS_I(inode)->i_size_lock);
} }
@ -1840,7 +1840,7 @@ static long f2fs_fallocate(struct file *file, int mode,
} }
if (!ret) { if (!ret) {
inode->i_mtime = inode_set_ctime_current(inode); inode_set_mtime_to_ts(inode, inode_set_ctime_current(inode));
f2fs_mark_inode_dirty_sync(inode, false); f2fs_mark_inode_dirty_sync(inode, false);
f2fs_update_time(F2FS_I_SB(inode), REQ_TIME); f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
} }
@ -2888,10 +2888,10 @@ out_src:
if (ret) if (ret)
goto out_unlock; goto out_unlock;
src->i_mtime = inode_set_ctime_current(src); inode_set_mtime_to_ts(src, inode_set_ctime_current(src));
f2fs_mark_inode_dirty_sync(src, false); f2fs_mark_inode_dirty_sync(src, false);
if (src != dst) { if (src != dst) {
dst->i_mtime = inode_set_ctime_current(dst); inode_set_mtime_to_ts(dst, inode_set_ctime_current(dst));
f2fs_mark_inode_dirty_sync(dst, false); f2fs_mark_inode_dirty_sync(dst, false);
} }
f2fs_update_time(sbi, REQ_TIME); f2fs_update_time(sbi, REQ_TIME);

2
fs/f2fs/inline.c
View File

@ -699,7 +699,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_mtime = inode_set_ctime_current(dir); inode_set_mtime_to_ts(dir, inode_set_ctime_current(dir));
f2fs_mark_inode_dirty_sync(dir, false); f2fs_mark_inode_dirty_sync(dir, false);
if (inode) if (inode)

24
fs/f2fs/inode.c
View File

@ -386,9 +386,9 @@ static void init_idisk_time(struct inode *inode)
{ {
struct f2fs_inode_info *fi = F2FS_I(inode); struct f2fs_inode_info *fi = F2FS_I(inode);
fi->i_disk_time[0] = inode->i_atime; fi->i_disk_time[0] = inode_get_atime(inode);
fi->i_disk_time[1] = inode_get_ctime(inode); fi->i_disk_time[1] = inode_get_ctime(inode);
fi->i_disk_time[2] = inode->i_mtime; fi->i_disk_time[2] = inode_get_mtime(inode);
} }
static int do_read_inode(struct inode *inode) static int do_read_inode(struct inode *inode)
@ -417,12 +417,12 @@ static int do_read_inode(struct inode *inode)
inode->i_size = le64_to_cpu(ri->i_size); inode->i_size = le64_to_cpu(ri->i_size);
inode->i_blocks = SECTOR_FROM_BLOCK(le64_to_cpu(ri->i_blocks) - 1); inode->i_blocks = SECTOR_FROM_BLOCK(le64_to_cpu(ri->i_blocks) - 1);
inode->i_atime.tv_sec = le64_to_cpu(ri->i_atime); inode_set_atime(inode, le64_to_cpu(ri->i_atime),
le32_to_cpu(ri->i_atime_nsec));
inode_set_ctime(inode, le64_to_cpu(ri->i_ctime), inode_set_ctime(inode, le64_to_cpu(ri->i_ctime),
le32_to_cpu(ri->i_ctime_nsec)); le32_to_cpu(ri->i_ctime_nsec));
inode->i_mtime.tv_sec = le64_to_cpu(ri->i_mtime); inode_set_mtime(inode, le64_to_cpu(ri->i_mtime),
inode->i_atime.tv_nsec = le32_to_cpu(ri->i_atime_nsec); le32_to_cpu(ri->i_mtime_nsec));
inode->i_mtime.tv_nsec = le32_to_cpu(ri->i_mtime_nsec);
inode->i_generation = le32_to_cpu(ri->i_generation); inode->i_generation = le32_to_cpu(ri->i_generation);
if (S_ISDIR(inode->i_mode)) if (S_ISDIR(inode->i_mode))
fi->i_current_depth = le32_to_cpu(ri->i_current_depth); fi->i_current_depth = le32_to_cpu(ri->i_current_depth);
@ -698,12 +698,12 @@ void f2fs_update_inode(struct inode *inode, struct page *node_page)
} }
set_raw_inline(inode, ri); set_raw_inline(inode, ri);
ri->i_atime = cpu_to_le64(inode->i_atime.tv_sec); ri->i_atime = cpu_to_le64(inode_get_atime_sec(inode));
ri->i_ctime = cpu_to_le64(inode_get_ctime(inode).tv_sec); ri->i_ctime = cpu_to_le64(inode_get_ctime_sec(inode));
ri->i_mtime = cpu_to_le64(inode->i_mtime.tv_sec); ri->i_mtime = cpu_to_le64(inode_get_mtime_sec(inode));
ri->i_atime_nsec = cpu_to_le32(inode->i_atime.tv_nsec); ri->i_atime_nsec = cpu_to_le32(inode_get_atime_nsec(inode));
ri->i_ctime_nsec = cpu_to_le32(inode_get_ctime(inode).tv_nsec); ri->i_ctime_nsec = cpu_to_le32(inode_get_ctime_nsec(inode));
ri->i_mtime_nsec = cpu_to_le32(inode->i_mtime.tv_nsec); ri->i_mtime_nsec = cpu_to_le32(inode_get_mtime_nsec(inode));
if (S_ISDIR(inode->i_mode)) if (S_ISDIR(inode->i_mode))
ri->i_current_depth = ri->i_current_depth =
cpu_to_le32(F2FS_I(inode)->i_current_depth); cpu_to_le32(F2FS_I(inode)->i_current_depth);

4
fs/f2fs/namei.c
View File

@ -243,8 +243,8 @@ static struct inode *f2fs_new_inode(struct mnt_idmap *idmap,
inode->i_ino = ino; inode->i_ino = ino;
inode->i_blocks = 0; inode->i_blocks = 0;
inode->i_mtime = inode->i_atime = inode_set_ctime_current(inode); simple_inode_init_ts(inode);
F2FS_I(inode)->i_crtime = inode->i_mtime; F2FS_I(inode)->i_crtime = inode_get_mtime(inode);
inode->i_generation = get_random_u32(); inode->i_generation = get_random_u32();
if (S_ISDIR(inode->i_mode)) if (S_ISDIR(inode->i_mode))

8
fs/f2fs/recovery.c
View File

@ -320,12 +320,12 @@ static int recover_inode(struct inode *inode, struct page *page)
} }
f2fs_i_size_write(inode, le64_to_cpu(raw->i_size)); f2fs_i_size_write(inode, le64_to_cpu(raw->i_size));
inode->i_atime.tv_sec = le64_to_cpu(raw->i_atime); inode_set_atime(inode, le64_to_cpu(raw->i_atime),
le32_to_cpu(raw->i_atime_nsec));
inode_set_ctime(inode, le64_to_cpu(raw->i_ctime), inode_set_ctime(inode, le64_to_cpu(raw->i_ctime),
le32_to_cpu(raw->i_ctime_nsec)); le32_to_cpu(raw->i_ctime_nsec));
inode->i_mtime.tv_sec = le64_to_cpu(raw->i_mtime); inode_set_mtime(inode, le64_to_cpu(raw->i_mtime),
inode->i_atime.tv_nsec = le32_to_cpu(raw->i_atime_nsec); le32_to_cpu(raw->i_mtime_nsec));
inode->i_mtime.tv_nsec = le32_to_cpu(raw->i_mtime_nsec);
F2FS_I(inode)->i_advise = raw->i_advise; F2FS_I(inode)->i_advise = raw->i_advise;
F2FS_I(inode)->i_flags = le32_to_cpu(raw->i_flags); F2FS_I(inode)->i_flags = le32_to_cpu(raw->i_flags);

2
fs/f2fs/super.c
View File

@ -2710,7 +2710,7 @@ retry:
if (len == towrite) if (len == towrite)
return err; return err;
inode->i_mtime = inode_set_ctime_current(inode); inode_set_mtime_to_ts(inode, inode_set_ctime_current(inode));
f2fs_mark_inode_dirty_sync(inode, false); f2fs_mark_inode_dirty_sync(inode, false);
return len - towrite; return len - towrite;
} }

25
fs/fat/inode.c
View File

@ -512,6 +512,7 @@ static int fat_validate_dir(struct inode *dir)
int fat_fill_inode(struct inode *inode, struct msdos_dir_entry *de) int fat_fill_inode(struct inode *inode, struct msdos_dir_entry *de)
{ {
struct msdos_sb_info *sbi = MSDOS_SB(inode->i_sb); struct msdos_sb_info *sbi = MSDOS_SB(inode->i_sb);
struct timespec64 mtime;
int error; int error;
MSDOS_I(inode)->i_pos = 0; MSDOS_I(inode)->i_pos = 0;
@ -561,14 +562,18 @@ int fat_fill_inode(struct inode *inode, struct msdos_dir_entry *de)
inode->i_blocks = ((inode->i_size + (sbi->cluster_size - 1)) inode->i_blocks = ((inode->i_size + (sbi->cluster_size - 1))
& ~((loff_t)sbi->cluster_size - 1)) >> 9; & ~((loff_t)sbi->cluster_size - 1)) >> 9;
fat_time_fat2unix(sbi, &inode->i_mtime, de->time, de->date, 0); fat_time_fat2unix(sbi, &mtime, de->time, de->date, 0);
inode_set_ctime_to_ts(inode, inode->i_mtime); inode_set_mtime_to_ts(inode, mtime);
inode_set_ctime_to_ts(inode, mtime);
if (sbi->options.isvfat) { if (sbi->options.isvfat) {
fat_time_fat2unix(sbi, &inode->i_atime, 0, de->adate, 0); struct timespec64 atime;
fat_time_fat2unix(sbi, &atime, 0, de->adate, 0);
inode_set_atime_to_ts(inode, atime);
fat_time_fat2unix(sbi, &MSDOS_I(inode)->i_crtime, de->ctime, fat_time_fat2unix(sbi, &MSDOS_I(inode)->i_crtime, de->ctime,
de->cdate, de->ctime_cs); de->cdate, de->ctime_cs);
} else } else
inode->i_atime = fat_truncate_atime(sbi, &inode->i_mtime); inode_set_atime_to_ts(inode, fat_truncate_atime(sbi, &mtime));
return 0; return 0;
} }
@ -849,6 +854,7 @@ static int __fat_write_inode(struct inode *inode, int wait)
struct msdos_sb_info *sbi = MSDOS_SB(sb); struct msdos_sb_info *sbi = MSDOS_SB(sb);
struct buffer_head *bh; struct buffer_head *bh;
struct msdos_dir_entry *raw_entry; struct msdos_dir_entry *raw_entry;
struct timespec64 mtime;
loff_t i_pos; loff_t i_pos;
sector_t blocknr; sector_t blocknr;
int err, offset; int err, offset;
@ -882,12 +888,14 @@ retry:
raw_entry->size = cpu_to_le32(inode->i_size); raw_entry->size = cpu_to_le32(inode->i_size);
raw_entry->attr = fat_make_attrs(inode); raw_entry->attr = fat_make_attrs(inode);
fat_set_start(raw_entry, MSDOS_I(inode)->i_logstart); fat_set_start(raw_entry, MSDOS_I(inode)->i_logstart);
fat_time_unix2fat(sbi, &inode->i_mtime, &raw_entry->time, mtime = inode_get_mtime(inode);
fat_time_unix2fat(sbi, &mtime, &raw_entry->time,
&raw_entry->date, NULL); &raw_entry->date, NULL);
if (sbi->options.isvfat) { if (sbi->options.isvfat) {
struct timespec64 ts = inode_get_atime(inode);
__le16 atime; __le16 atime;
fat_time_unix2fat(sbi, &inode->i_atime, &atime,
&raw_entry->adate, NULL); fat_time_unix2fat(sbi, &ts, &atime, &raw_entry->adate, NULL);
fat_time_unix2fat(sbi, &MSDOS_I(inode)->i_crtime, &raw_entry->ctime, fat_time_unix2fat(sbi, &MSDOS_I(inode)->i_crtime, &raw_entry->ctime,
&raw_entry->cdate, &raw_entry->ctime_cs); &raw_entry->cdate, &raw_entry->ctime_cs);
} }
@ -1407,7 +1415,8 @@ static int fat_read_root(struct inode *inode)
MSDOS_I(inode)->mmu_private = inode->i_size; MSDOS_I(inode)->mmu_private = inode->i_size;
fat_save_attrs(inode, ATTR_DIR); fat_save_attrs(inode, ATTR_DIR);
inode->i_mtime = inode->i_atime = inode_set_ctime(inode, 0, 0); inode_set_mtime_to_ts(inode,
inode_set_atime_to_ts(inode, inode_set_ctime(inode, 0, 0)));
set_nlink(inode, fat_subdirs(inode)+2); set_nlink(inode, fat_subdirs(inode)+2);
return 0; return 0;

6
fs/fat/misc.c
View File

@ -325,15 +325,15 @@ int fat_truncate_time(struct inode *inode, struct timespec64 *now, int flags)
} }
if (flags & S_ATIME) if (flags & S_ATIME)
inode->i_atime = fat_truncate_atime(sbi, now); inode_set_atime_to_ts(inode, fat_truncate_atime(sbi, now));
/* /*
* ctime and mtime share the same on-disk field, and should be * ctime and mtime share the same on-disk field, and should be
* identical in memory. all mtime updates will be applied to ctime, * identical in memory. all mtime updates will be applied to ctime,
* but ctime updates are ignored. * but ctime updates are ignored.
*/ */
if (flags & S_MTIME) if (flags & S_MTIME)
inode->i_mtime = inode_set_ctime_to_ts(inode, inode_set_mtime_to_ts(inode,
fat_truncate_mtime(sbi, now)); inode_set_ctime_to_ts(inode, fat_truncate_mtime(sbi, now)));
return 0; return 0;
} }

6
fs/freevxfs/vxfs_inode.c
View File

@ -109,11 +109,9 @@ static inline void dip2vip_cpy(struct vxfs_sb_info *sbi,
set_nlink(inode, vip->vii_nlink); set_nlink(inode, vip->vii_nlink);
inode->i_size = vip->vii_size; inode->i_size = vip->vii_size;
inode->i_atime.tv_sec = vip->vii_atime; inode_set_atime(inode, vip->vii_atime, 0);
inode_set_ctime(inode, vip->vii_ctime, 0); inode_set_ctime(inode, vip->vii_ctime, 0);
inode->i_mtime.tv_sec = vip->vii_mtime; inode_set_mtime(inode, vip->vii_mtime, 0);
inode->i_atime.tv_nsec = 0;
inode->i_mtime.tv_nsec = 0;
inode->i_blocks = vip->vii_blocks; inode->i_blocks = vip->vii_blocks;
inode->i_generation = vip->vii_gen; inode->i_generation = vip->vii_gen;

2
fs/fuse/control.c
View File

@ -235,7 +235,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_set_ctime_current(inode); simple_inode_init_ts(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;

10
fs/fuse/dir.c
View File

@ -1812,12 +1812,12 @@ int fuse_flush_times(struct inode *inode, struct fuse_file *ff)
memset(&outarg, 0, sizeof(outarg)); memset(&outarg, 0, sizeof(outarg));
inarg.valid = FATTR_MTIME; inarg.valid = FATTR_MTIME;
inarg.mtime = inode->i_mtime.tv_sec; inarg.mtime = inode_get_mtime_sec(inode);
inarg.mtimensec = inode->i_mtime.tv_nsec; inarg.mtimensec = inode_get_mtime_nsec(inode);
if (fm->fc->minor >= 23) { if (fm->fc->minor >= 23) {
inarg.valid |= FATTR_CTIME; inarg.valid |= FATTR_CTIME;
inarg.ctime = inode_get_ctime(inode).tv_sec; inarg.ctime = inode_get_ctime_sec(inode);
inarg.ctimensec = inode_get_ctime(inode).tv_nsec; inarg.ctimensec = inode_get_ctime_nsec(inode);
} }
if (ff) { if (ff) {
inarg.valid |= FATTR_FH; inarg.valid |= FATTR_FH;
@ -1956,7 +1956,7 @@ int fuse_do_setattr(struct dentry *dentry, struct iattr *attr,
/* the kernel maintains i_mtime locally */ /* the kernel maintains i_mtime locally */
if (trust_local_cmtime) { if (trust_local_cmtime) {
if (attr->ia_valid & ATTR_MTIME) if (attr->ia_valid & ATTR_MTIME)
inode->i_mtime = attr->ia_mtime; inode_set_mtime_to_ts(inode, attr->ia_mtime);
if (attr->ia_valid & ATTR_CTIME) if (attr->ia_valid & ATTR_CTIME)
inode_set_ctime_to_ts(inode, attr->ia_ctime); inode_set_ctime_to_ts(inode, attr->ia_ctime);
/* FIXME: clear I_DIRTY_SYNC? */ /* FIXME: clear I_DIRTY_SYNC? */

29
fs/fuse/inode.c
View File

@ -188,12 +188,10 @@ void fuse_change_attributes_common(struct inode *inode, struct fuse_attr *attr,
attr->mtimensec = min_t(u32, attr->mtimensec, NSEC_PER_SEC - 1); attr->mtimensec = min_t(u32, attr->mtimensec, NSEC_PER_SEC - 1);
attr->ctimensec = min_t(u32, attr->ctimensec, NSEC_PER_SEC - 1); attr->ctimensec = min_t(u32, attr->ctimensec, NSEC_PER_SEC - 1);
inode->i_atime.tv_sec = attr->atime; inode_set_atime(inode, attr->atime, attr->atimensec);
inode->i_atime.tv_nsec = attr->atimensec;
/* mtime from server may be stale due to local buffered write */ /* mtime from server may be stale due to local buffered write */
if (!(cache_mask & STATX_MTIME)) { if (!(cache_mask & STATX_MTIME)) {
inode->i_mtime.tv_sec = attr->mtime; inode_set_mtime(inode, attr->mtime, attr->mtimensec);
inode->i_mtime.tv_nsec = attr->mtimensec;
} }
if (!(cache_mask & STATX_CTIME)) { if (!(cache_mask & STATX_CTIME)) {
inode_set_ctime(inode, attr->ctime, attr->ctimensec); inode_set_ctime(inode, attr->ctime, attr->ctimensec);
@ -276,12 +274,12 @@ void fuse_change_attributes(struct inode *inode, struct fuse_attr *attr,
attr->size = i_size_read(inode); attr->size = i_size_read(inode);
if (cache_mask & STATX_MTIME) { if (cache_mask & STATX_MTIME) {
attr->mtime = inode->i_mtime.tv_sec; attr->mtime = inode_get_mtime_sec(inode);
attr->mtimensec = inode->i_mtime.tv_nsec; attr->mtimensec = inode_get_mtime_nsec(inode);
} }
if (cache_mask & STATX_CTIME) { if (cache_mask & STATX_CTIME) {
attr->ctime = inode_get_ctime(inode).tv_sec; attr->ctime = inode_get_ctime_sec(inode);
attr->ctimensec = inode_get_ctime(inode).tv_nsec; attr->ctimensec = inode_get_ctime_nsec(inode);
} }
if ((attr_version != 0 && fi->attr_version > attr_version) || if ((attr_version != 0 && fi->attr_version > attr_version) ||
@ -290,7 +288,7 @@ void fuse_change_attributes(struct inode *inode, struct fuse_attr *attr,
return; return;
} }
old_mtime = inode->i_mtime; old_mtime = inode_get_mtime(inode);
fuse_change_attributes_common(inode, attr, sx, attr_valid, cache_mask); fuse_change_attributes_common(inode, attr, sx, attr_valid, cache_mask);
oldsize = inode->i_size; oldsize = inode->i_size;
@ -337,8 +335,7 @@ static void fuse_init_inode(struct inode *inode, struct fuse_attr *attr,
{ {
inode->i_mode = attr->mode & S_IFMT; inode->i_mode = attr->mode & S_IFMT;
inode->i_size = attr->size; inode->i_size = attr->size;
inode->i_mtime.tv_sec = attr->mtime; inode_set_mtime(inode, attr->mtime, attr->mtimensec);
inode->i_mtime.tv_nsec = attr->mtimensec;
inode_set_ctime(inode, attr->ctime, attr->ctimensec); inode_set_ctime(inode, attr->ctime, attr->ctimensec);
if (S_ISREG(inode->i_mode)) { if (S_ISREG(inode->i_mode)) {
fuse_init_common(inode); fuse_init_common(inode);
@ -1423,17 +1420,19 @@ EXPORT_SYMBOL_GPL(fuse_dev_free);
static void fuse_fill_attr_from_inode(struct fuse_attr *attr, static void fuse_fill_attr_from_inode(struct fuse_attr *attr,
const struct fuse_inode *fi) const struct fuse_inode *fi)
{ {
struct timespec64 atime = inode_get_atime(&fi->inode);
struct timespec64 mtime = inode_get_mtime(&fi->inode);
struct timespec64 ctime = inode_get_ctime(&fi->inode); struct timespec64 ctime = inode_get_ctime(&fi->inode);
*attr = (struct fuse_attr){ *attr = (struct fuse_attr){
.ino = fi->inode.i_ino, .ino = fi->inode.i_ino,
.size = fi->inode.i_size, .size = fi->inode.i_size,
.blocks = fi->inode.i_blocks, .blocks = fi->inode.i_blocks,
.atime = fi->inode.i_atime.tv_sec, .atime = atime.tv_sec,
.mtime = fi->inode.i_mtime.tv_sec, .mtime = mtime.tv_sec,
.ctime = ctime.tv_sec, .ctime = ctime.tv_sec,
.atimensec = fi->inode.i_atime.tv_nsec, .atimensec = atime.tv_nsec,
.mtimensec = fi->inode.i_mtime.tv_nsec, .mtimensec = mtime.tv_nsec,
.ctimensec = ctime.tv_nsec, .ctimensec = ctime.tv_nsec,
.mode = fi->inode.i_mode, .mode = fi->inode.i_mode,
.nlink = fi->inode.i_nlink, .nlink = fi->inode.i_nlink,

6
fs/fuse/readdir.c
View File

@ -476,7 +476,7 @@ retry_locked:
if (!fi->rdc.cached) { if (!fi->rdc.cached) {
/* Starting cache? Set cache mtime. */ /* Starting cache? Set cache mtime. */
if (!ctx->pos && !fi->rdc.size) { if (!ctx->pos && !fi->rdc.size) {
fi->rdc.mtime = inode->i_mtime; fi->rdc.mtime = inode_get_mtime(inode);
fi->rdc.iversion = inode_query_iversion(inode); fi->rdc.iversion = inode_query_iversion(inode);
} }
spin_unlock(&fi->rdc.lock); spin_unlock(&fi->rdc.lock);
@ -488,8 +488,10 @@ retry_locked:
* changed, and reset the cache if so. * changed, and reset the cache if so.
*/ */
if (!ctx->pos) { if (!ctx->pos) {
struct timespec64 mtime = inode_get_mtime(inode);
if (inode_peek_iversion(inode) != fi->rdc.iversion || if (inode_peek_iversion(inode) != fi->rdc.iversion ||
!timespec64_equal(&fi->rdc.mtime, &inode->i_mtime)) { !timespec64_equal(&fi->rdc.mtime, &mtime)) {
fuse_rdc_reset(inode); fuse_rdc_reset(inode);
goto retry_locked; goto retry_locked;
} }

10
fs/gfs2/bmap.c
View File

@ -1386,7 +1386,7 @@ static int trunc_start(struct inode *inode, u64 newsize)
ip->i_diskflags |= GFS2_DIF_TRUNC_IN_PROG; ip->i_diskflags |= GFS2_DIF_TRUNC_IN_PROG;
i_size_write(inode, newsize); i_size_write(inode, newsize);
ip->i_inode.i_mtime = inode_set_ctime_current(&ip->i_inode); inode_set_mtime_to_ts(&ip->i_inode, inode_set_ctime_current(&ip->i_inode));
gfs2_dinode_out(ip, dibh->b_data); gfs2_dinode_out(ip, dibh->b_data);
if (journaled) if (journaled)
@ -1583,7 +1583,7 @@ out_unlock:
/* Every transaction boundary, we rewrite the dinode /* Every transaction boundary, we rewrite the dinode
to keep its di_blocks current in case of failure. */ to keep its di_blocks current in case of failure. */
ip->i_inode.i_mtime = inode_set_ctime_current(&ip->i_inode); inode_set_mtime_to_ts(&ip->i_inode, inode_set_ctime_current(&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);
@ -1949,7 +1949,7 @@ static int punch_hole(struct gfs2_inode *ip, u64 offset, u64 length)
gfs2_statfs_change(sdp, 0, +btotal, 0); gfs2_statfs_change(sdp, 0, +btotal, 0);
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 = inode_set_ctime_current(&ip->i_inode); inode_set_mtime_to_ts(&ip->i_inode, inode_set_ctime_current(&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);
up_write(&ip->i_rw_mutex); up_write(&ip->i_rw_mutex);
@ -1992,7 +1992,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 = inode_set_ctime_current(&ip->i_inode); inode_set_mtime_to_ts(&ip->i_inode, inode_set_ctime_current(&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);
@ -2093,7 +2093,7 @@ static int do_grow(struct inode *inode, u64 size)
goto do_end_trans; goto do_end_trans;
truncate_setsize(inode, size); truncate_setsize(inode, size);
ip->i_inode.i_mtime = inode_set_ctime_current(&ip->i_inode); inode_set_mtime_to_ts(&ip->i_inode, inode_set_ctime_current(&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/gfs2/dir.c
View File

@ -130,7 +130,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 = inode_set_ctime_current(&ip->i_inode); inode_set_mtime_to_ts(&ip->i_inode, inode_set_ctime_current(&ip->i_inode));
gfs2_dinode_out(ip, dibh->b_data); gfs2_dinode_out(ip, dibh->b_data);
brelse(dibh); brelse(dibh);
@ -227,7 +227,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 = inode_set_ctime_current(&ip->i_inode); inode_set_mtime_to_ts(&ip->i_inode, inode_set_ctime_current(&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);
@ -1825,7 +1825,7 @@ int gfs2_dir_add(struct inode *inode, const struct qstr *name,
da->bh = NULL; da->bh = NULL;
brelse(bh); brelse(bh);
ip->i_entries++; ip->i_entries++;
ip->i_inode.i_mtime = tv; inode_set_mtime_to_ts(&ip->i_inode, tv);
if (S_ISDIR(nip->i_inode.i_mode)) if (S_ISDIR(nip->i_inode.i_mode))
inc_nlink(&ip->i_inode); inc_nlink(&ip->i_inode);
mark_inode_dirty(inode); mark_inode_dirty(inode);
@ -1911,7 +1911,7 @@ int gfs2_dir_del(struct gfs2_inode *dip, const struct dentry *dentry)
if (!dip->i_entries) if (!dip->i_entries)
gfs2_consist_inode(dip); gfs2_consist_inode(dip);
dip->i_entries--; dip->i_entries--;
dip->i_inode.i_mtime = tv; inode_set_mtime_to_ts(&dip->i_inode, tv);
if (d_is_dir(dentry)) if (d_is_dir(dentry))
drop_nlink(&dip->i_inode); drop_nlink(&dip->i_inode);
mark_inode_dirty(&dip->i_inode); mark_inode_dirty(&dip->i_inode);
@ -1952,7 +1952,7 @@ int gfs2_dir_mvino(struct gfs2_inode *dip, const struct qstr *filename,
dent->de_type = cpu_to_be16(new_type); dent->de_type = cpu_to_be16(new_type);
brelse(bh); brelse(bh);
dip->i_inode.i_mtime = inode_set_ctime_current(&dip->i_inode); inode_set_mtime_to_ts(&dip->i_inode, inode_set_ctime_current(&dip->i_inode));
mark_inode_dirty_sync(&dip->i_inode); mark_inode_dirty_sync(&dip->i_inode);
return 0; return 0;
} }

11
fs/gfs2/glops.c
View File

@ -403,7 +403,7 @@ static int gfs2_dinode_in(struct gfs2_inode *ip, const void *buf)
{ {
struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode); struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
const struct gfs2_dinode *str = buf; const struct gfs2_dinode *str = buf;
struct timespec64 atime; struct timespec64 atime, iatime;
u16 height, depth; u16 height, depth;
umode_t mode = be32_to_cpu(str->di_mode); umode_t mode = be32_to_cpu(str->di_mode);
struct inode *inode = &ip->i_inode; struct inode *inode = &ip->i_inode;
@ -433,10 +433,11 @@ static int gfs2_dinode_in(struct gfs2_inode *ip, const void *buf)
gfs2_set_inode_blocks(inode, be64_to_cpu(str->di_blocks)); gfs2_set_inode_blocks(inode, be64_to_cpu(str->di_blocks));
atime.tv_sec = be64_to_cpu(str->di_atime); atime.tv_sec = be64_to_cpu(str->di_atime);
atime.tv_nsec = be32_to_cpu(str->di_atime_nsec); atime.tv_nsec = be32_to_cpu(str->di_atime_nsec);
if (timespec64_compare(&inode->i_atime, &atime) < 0) iatime = inode_get_atime(inode);
inode->i_atime = atime; if (timespec64_compare(&iatime, &atime) < 0)
inode->i_mtime.tv_sec = be64_to_cpu(str->di_mtime); inode_set_atime_to_ts(inode, atime);
inode->i_mtime.tv_nsec = be32_to_cpu(str->di_mtime_nsec); inode_set_mtime(inode, be64_to_cpu(str->di_mtime),
be32_to_cpu(str->di_mtime_nsec));
inode_set_ctime(inode, be64_to_cpu(str->di_ctime), inode_set_ctime(inode, be64_to_cpu(str->di_ctime),
be32_to_cpu(str->di_ctime_nsec)); be32_to_cpu(str->di_ctime_nsec));

7
fs/gfs2/inode.c
View File

@ -185,8 +185,9 @@ struct inode *gfs2_inode_lookup(struct super_block *sb, unsigned int type,
set_bit(GLF_INSTANTIATE_NEEDED, &ip->i_gl->gl_flags); set_bit(GLF_INSTANTIATE_NEEDED, &ip->i_gl->gl_flags);
/* Lowest possible timestamp; will be overwritten in gfs2_dinode_in. */ /* Lowest possible timestamp; will be overwritten in gfs2_dinode_in. */
inode->i_atime.tv_sec = 1LL << (8 * sizeof(inode->i_atime.tv_sec) - 1); inode_set_atime(inode,
inode->i_atime.tv_nsec = 0; 1LL << (8 * sizeof(inode_get_atime_sec(inode)) - 1),
0);
glock_set_object(ip->i_gl, ip); glock_set_object(ip->i_gl, ip);
@ -696,7 +697,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_set_ctime_current(inode); simple_inode_init_ts(inode);
munge_mode_uid_gid(dip, inode); munge_mode_uid_gid(dip, inode);
check_and_update_goal(dip); check_and_update_goal(dip);
ip->i_goal = dip->i_goal; ip->i_goal = dip->i_goal;

2
fs/gfs2/quota.c
View File

@ -886,7 +886,7 @@ static int gfs2_adjust_quota(struct gfs2_sbd *sdp, 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_set_ctime_current(inode); inode_set_mtime_to_ts(inode, inode_set_ctime_current(inode));
mark_inode_dirty(inode); mark_inode_dirty(inode);
set_bit(QDF_REFRESH, &qd->qd_flags); set_bit(QDF_REFRESH, &qd->qd_flags);
} }

12
fs/gfs2/super.c
View File

@ -410,9 +410,9 @@ void gfs2_dinode_out(const struct gfs2_inode *ip, void *buf)
str->di_nlink = cpu_to_be32(inode->i_nlink); str->di_nlink = cpu_to_be32(inode->i_nlink);
str->di_size = cpu_to_be64(i_size_read(inode)); str->di_size = cpu_to_be64(i_size_read(inode));
str->di_blocks = cpu_to_be64(gfs2_get_inode_blocks(inode)); str->di_blocks = cpu_to_be64(gfs2_get_inode_blocks(inode));
str->di_atime = cpu_to_be64(inode->i_atime.tv_sec); str->di_atime = cpu_to_be64(inode_get_atime_sec(inode));
str->di_mtime = cpu_to_be64(inode->i_mtime.tv_sec); str->di_mtime = cpu_to_be64(inode_get_mtime_sec(inode));
str->di_ctime = cpu_to_be64(inode_get_ctime(inode).tv_sec); str->di_ctime = cpu_to_be64(inode_get_ctime_sec(inode));
str->di_goal_meta = cpu_to_be64(ip->i_goal); str->di_goal_meta = cpu_to_be64(ip->i_goal);
str->di_goal_data = cpu_to_be64(ip->i_goal); str->di_goal_data = cpu_to_be64(ip->i_goal);
@ -427,9 +427,9 @@ void gfs2_dinode_out(const struct gfs2_inode *ip, void *buf)
str->di_entries = cpu_to_be32(ip->i_entries); str->di_entries = cpu_to_be32(ip->i_entries);
str->di_eattr = cpu_to_be64(ip->i_eattr); str->di_eattr = cpu_to_be64(ip->i_eattr);
str->di_atime_nsec = cpu_to_be32(inode->i_atime.tv_nsec); str->di_atime_nsec = cpu_to_be32(inode_get_atime_nsec(inode));
str->di_mtime_nsec = cpu_to_be32(inode->i_mtime.tv_nsec); str->di_mtime_nsec = cpu_to_be32(inode_get_mtime_nsec(inode));
str->di_ctime_nsec = cpu_to_be32(inode_get_ctime(inode).tv_nsec); str->di_ctime_nsec = cpu_to_be32(inode_get_ctime_nsec(inode));
} }
/** /**

8
fs/hfs/catalog.c
View File

@ -133,7 +133,7 @@ int hfs_cat_create(u32 cnid, struct inode *dir, const struct qstr *str, struct i
goto err1; goto err1;
dir->i_size++; dir->i_size++;
dir->i_mtime = inode_set_ctime_current(dir); inode_set_mtime_to_ts(dir, inode_set_ctime_current(dir));
mark_inode_dirty(dir); mark_inode_dirty(dir);
hfs_find_exit(&fd); hfs_find_exit(&fd);
return 0; return 0;
@ -269,7 +269,7 @@ int hfs_cat_delete(u32 cnid, struct inode *dir, const struct qstr *str)
} }
dir->i_size--; dir->i_size--;
dir->i_mtime = inode_set_ctime_current(dir); inode_set_mtime_to_ts(dir, inode_set_ctime_current(dir));
mark_inode_dirty(dir); mark_inode_dirty(dir);
res = 0; res = 0;
out: out:
@ -337,7 +337,7 @@ int hfs_cat_move(u32 cnid, struct inode *src_dir, const struct qstr *src_name,
if (err) if (err)
goto out; goto out;
dst_dir->i_size++; dst_dir->i_size++;
dst_dir->i_mtime = inode_set_ctime_current(dst_dir); inode_set_mtime_to_ts(dst_dir, inode_set_ctime_current(dst_dir));
mark_inode_dirty(dst_dir); mark_inode_dirty(dst_dir);
/* finally remove the old entry */ /* finally remove the old entry */
@ -349,7 +349,7 @@ int hfs_cat_move(u32 cnid, struct inode *src_dir, const struct qstr *src_name,
if (err) if (err)
goto out; goto out;
src_dir->i_size--; src_dir->i_size--;
src_dir->i_mtime = inode_set_ctime_current(src_dir); inode_set_mtime_to_ts(src_dir, inode_set_ctime_current(src_dir));
mark_inode_dirty(src_dir); mark_inode_dirty(src_dir);
type = entry.type; type = entry.type;

16
fs/hfs/inode.c
View File

@ -200,7 +200,7 @@ struct inode *hfs_new_inode(struct inode *dir, const struct qstr *name, umode_t
inode->i_uid = current_fsuid(); inode->i_uid = current_fsuid();
inode->i_gid = current_fsgid(); inode->i_gid = current_fsgid();
set_nlink(inode, 1); set_nlink(inode, 1);
inode->i_mtime = inode->i_atime = inode_set_ctime_current(inode); simple_inode_init_ts(inode);
HFS_I(inode)->flags = 0; HFS_I(inode)->flags = 0;
HFS_I(inode)->rsrc_inode = NULL; HFS_I(inode)->rsrc_inode = NULL;
HFS_I(inode)->fs_blocks = 0; HFS_I(inode)->fs_blocks = 0;
@ -355,8 +355,8 @@ static int hfs_read_inode(struct inode *inode, void *data)
inode->i_mode |= S_IWUGO; inode->i_mode |= S_IWUGO;
inode->i_mode &= ~hsb->s_file_umask; inode->i_mode &= ~hsb->s_file_umask;
inode->i_mode |= S_IFREG; inode->i_mode |= S_IFREG;
inode->i_atime = inode->i_mtime = inode_set_ctime_to_ts(inode, inode_set_mtime_to_ts(inode,
hfs_m_to_utime(rec->file.MdDat)); inode_set_atime_to_ts(inode, inode_set_ctime_to_ts(inode, hfs_m_to_utime(rec->file.MdDat))));
inode->i_op = &hfs_file_inode_operations; inode->i_op = &hfs_file_inode_operations;
inode->i_fop = &hfs_file_operations; inode->i_fop = &hfs_file_operations;
inode->i_mapping->a_ops = &hfs_aops; inode->i_mapping->a_ops = &hfs_aops;
@ -366,8 +366,8 @@ static int hfs_read_inode(struct inode *inode, void *data)
inode->i_size = be16_to_cpu(rec->dir.Val) + 2; inode->i_size = be16_to_cpu(rec->dir.Val) + 2;
HFS_I(inode)->fs_blocks = 0; HFS_I(inode)->fs_blocks = 0;
inode->i_mode = S_IFDIR | (S_IRWXUGO & ~hsb->s_dir_umask); inode->i_mode = S_IFDIR | (S_IRWXUGO & ~hsb->s_dir_umask);
inode->i_atime = inode->i_mtime = inode_set_ctime_to_ts(inode, inode_set_mtime_to_ts(inode,
hfs_m_to_utime(rec->dir.MdDat)); inode_set_atime_to_ts(inode, inode_set_ctime_to_ts(inode, hfs_m_to_utime(rec->dir.MdDat))));
inode->i_op = &hfs_dir_inode_operations; inode->i_op = &hfs_dir_inode_operations;
inode->i_fop = &hfs_dir_operations; inode->i_fop = &hfs_dir_operations;
break; break;
@ -474,7 +474,7 @@ int hfs_write_inode(struct inode *inode, struct writeback_control *wbc)
be32_to_cpu(rec.dir.DirID) != inode->i_ino) { be32_to_cpu(rec.dir.DirID) != inode->i_ino) {
} }
rec.dir.MdDat = hfs_u_to_mtime(inode->i_mtime); rec.dir.MdDat = hfs_u_to_mtime(inode_get_mtime(inode));
rec.dir.Val = cpu_to_be16(inode->i_size - 2); rec.dir.Val = cpu_to_be16(inode->i_size - 2);
hfs_bnode_write(fd.bnode, &rec, fd.entryoffset, hfs_bnode_write(fd.bnode, &rec, fd.entryoffset,
@ -502,7 +502,7 @@ int hfs_write_inode(struct inode *inode, struct writeback_control *wbc)
else else
rec.file.Flags |= HFS_FIL_LOCK; rec.file.Flags |= HFS_FIL_LOCK;
hfs_inode_write_fork(inode, rec.file.ExtRec, &rec.file.LgLen, &rec.file.PyLen); hfs_inode_write_fork(inode, rec.file.ExtRec, &rec.file.LgLen, &rec.file.PyLen);
rec.file.MdDat = hfs_u_to_mtime(inode->i_mtime); rec.file.MdDat = hfs_u_to_mtime(inode_get_mtime(inode));
hfs_bnode_write(fd.bnode, &rec, fd.entryoffset, hfs_bnode_write(fd.bnode, &rec, fd.entryoffset,
sizeof(struct hfs_cat_file)); sizeof(struct hfs_cat_file));
@ -654,7 +654,7 @@ int hfs_inode_setattr(struct mnt_idmap *idmap, struct dentry *dentry,
truncate_setsize(inode, attr->ia_size); truncate_setsize(inode, attr->ia_size);
hfs_file_truncate(inode); hfs_file_truncate(inode);
inode->i_atime = inode->i_mtime = inode_set_ctime_current(inode); simple_inode_init_ts(inode);
} }
setattr_copy(&nop_mnt_idmap, inode, attr); setattr_copy(&nop_mnt_idmap, inode, attr);

10
fs/hfs/sysdep.c
View File

@ -28,11 +28,13 @@ static int hfs_revalidate_dentry(struct dentry *dentry, unsigned int flags)
/* fix up inode on a timezone change */ /* fix up inode on a timezone change */
diff = sys_tz.tz_minuteswest * 60 - HFS_I(inode)->tz_secondswest; diff = sys_tz.tz_minuteswest * 60 - HFS_I(inode)->tz_secondswest;
if (diff) { if (diff) {
struct timespec64 ctime = inode_get_ctime(inode); struct timespec64 ts = inode_get_ctime(inode);
inode_set_ctime(inode, ctime.tv_sec + diff, ctime.tv_nsec); inode_set_ctime(inode, ts.tv_sec + diff, ts.tv_nsec);
inode->i_atime.tv_sec += diff; ts = inode_get_atime(inode);
inode->i_mtime.tv_sec += diff; inode_set_atime(inode, ts.tv_sec + diff, ts.tv_nsec);
ts = inode_get_mtime(inode);
inode_set_mtime(inode, ts.tv_sec + diff, ts.tv_nsec);
HFS_I(inode)->tz_secondswest += diff; HFS_I(inode)->tz_secondswest += diff;
} }
return 1; return 1;

8
fs/hfsplus/catalog.c
View File

@ -312,7 +312,7 @@ int hfsplus_create_cat(u32 cnid, struct inode *dir,
dir->i_size++; dir->i_size++;
if (S_ISDIR(inode->i_mode)) if (S_ISDIR(inode->i_mode))
hfsplus_subfolders_inc(dir); hfsplus_subfolders_inc(dir);
dir->i_mtime = inode_set_ctime_current(dir); inode_set_mtime_to_ts(dir, inode_set_ctime_current(dir));
hfsplus_mark_inode_dirty(dir, HFSPLUS_I_CAT_DIRTY); hfsplus_mark_inode_dirty(dir, HFSPLUS_I_CAT_DIRTY);
hfs_find_exit(&fd); hfs_find_exit(&fd);
@ -417,7 +417,7 @@ int hfsplus_delete_cat(u32 cnid, struct inode *dir, const struct qstr *str)
dir->i_size--; dir->i_size--;
if (type == HFSPLUS_FOLDER) if (type == HFSPLUS_FOLDER)
hfsplus_subfolders_dec(dir); hfsplus_subfolders_dec(dir);
dir->i_mtime = inode_set_ctime_current(dir); inode_set_mtime_to_ts(dir, inode_set_ctime_current(dir));
hfsplus_mark_inode_dirty(dir, HFSPLUS_I_CAT_DIRTY); hfsplus_mark_inode_dirty(dir, HFSPLUS_I_CAT_DIRTY);
if (type == HFSPLUS_FILE || type == HFSPLUS_FOLDER) { if (type == HFSPLUS_FILE || type == HFSPLUS_FOLDER) {
@ -494,7 +494,7 @@ int hfsplus_rename_cat(u32 cnid,
dst_dir->i_size++; dst_dir->i_size++;
if (type == HFSPLUS_FOLDER) if (type == HFSPLUS_FOLDER)
hfsplus_subfolders_inc(dst_dir); hfsplus_subfolders_inc(dst_dir);
dst_dir->i_mtime = inode_set_ctime_current(dst_dir); inode_set_mtime_to_ts(dst_dir, inode_set_ctime_current(dst_dir));
/* finally remove the old entry */ /* finally remove the old entry */
err = hfsplus_cat_build_key(sb, src_fd.search_key, err = hfsplus_cat_build_key(sb, src_fd.search_key,
@ -511,7 +511,7 @@ int hfsplus_rename_cat(u32 cnid,
src_dir->i_size--; src_dir->i_size--;
if (type == HFSPLUS_FOLDER) if (type == HFSPLUS_FOLDER)
hfsplus_subfolders_dec(src_dir); hfsplus_subfolders_dec(src_dir);
src_dir->i_mtime = inode_set_ctime_current(src_dir); inode_set_mtime_to_ts(src_dir, inode_set_ctime_current(src_dir));
/* remove old thread entry */ /* remove old thread entry */
hfsplus_cat_build_key_with_cnid(sb, src_fd.search_key, cnid); hfsplus_cat_build_key_with_cnid(sb, src_fd.search_key, cnid);

22
fs/hfsplus/inode.c
View File

@ -267,7 +267,7 @@ static int hfsplus_setattr(struct mnt_idmap *idmap,
} }
truncate_setsize(inode, attr->ia_size); truncate_setsize(inode, attr->ia_size);
hfsplus_file_truncate(inode); hfsplus_file_truncate(inode);
inode->i_mtime = inode_set_ctime_current(inode); inode_set_mtime_to_ts(inode, inode_set_ctime_current(inode));
} }
setattr_copy(&nop_mnt_idmap, inode, attr); setattr_copy(&nop_mnt_idmap, inode, attr);
@ -392,7 +392,7 @@ struct inode *hfsplus_new_inode(struct super_block *sb, struct inode *dir,
inode->i_ino = sbi->next_cnid++; inode->i_ino = sbi->next_cnid++;
inode_init_owner(&nop_mnt_idmap, inode, dir, mode); inode_init_owner(&nop_mnt_idmap, inode, dir, mode);
set_nlink(inode, 1); set_nlink(inode, 1);
inode->i_mtime = inode->i_atime = inode_set_ctime_current(inode); simple_inode_init_ts(inode);
hip = HFSPLUS_I(inode); hip = HFSPLUS_I(inode);
INIT_LIST_HEAD(&hip->open_dir_list); INIT_LIST_HEAD(&hip->open_dir_list);
@ -521,8 +521,9 @@ int hfsplus_cat_read_inode(struct inode *inode, struct hfs_find_data *fd)
hfsplus_get_perms(inode, &folder->permissions, 1); hfsplus_get_perms(inode, &folder->permissions, 1);
set_nlink(inode, 1); set_nlink(inode, 1);
inode->i_size = 2 + be32_to_cpu(folder->valence); inode->i_size = 2 + be32_to_cpu(folder->valence);
inode->i_atime = hfsp_mt2ut(folder->access_date); inode_set_atime_to_ts(inode, hfsp_mt2ut(folder->access_date));
inode->i_mtime = hfsp_mt2ut(folder->content_mod_date); inode_set_mtime_to_ts(inode,
hfsp_mt2ut(folder->content_mod_date));
inode_set_ctime_to_ts(inode, inode_set_ctime_to_ts(inode,
hfsp_mt2ut(folder->attribute_mod_date)); hfsp_mt2ut(folder->attribute_mod_date));
HFSPLUS_I(inode)->create_date = folder->create_date; HFSPLUS_I(inode)->create_date = folder->create_date;
@ -563,8 +564,9 @@ int hfsplus_cat_read_inode(struct inode *inode, struct hfs_find_data *fd)
init_special_inode(inode, inode->i_mode, init_special_inode(inode, inode->i_mode,
be32_to_cpu(file->permissions.dev)); be32_to_cpu(file->permissions.dev));
} }
inode->i_atime = hfsp_mt2ut(file->access_date); inode_set_atime_to_ts(inode, hfsp_mt2ut(file->access_date));
inode->i_mtime = hfsp_mt2ut(file->content_mod_date); inode_set_mtime_to_ts(inode,
hfsp_mt2ut(file->content_mod_date));
inode_set_ctime_to_ts(inode, inode_set_ctime_to_ts(inode,
hfsp_mt2ut(file->attribute_mod_date)); hfsp_mt2ut(file->attribute_mod_date));
HFSPLUS_I(inode)->create_date = file->create_date; HFSPLUS_I(inode)->create_date = file->create_date;
@ -609,8 +611,8 @@ int hfsplus_cat_write_inode(struct inode *inode)
sizeof(struct hfsplus_cat_folder)); sizeof(struct hfsplus_cat_folder));
/* simple node checks? */ /* simple node checks? */
hfsplus_cat_set_perms(inode, &folder->permissions); hfsplus_cat_set_perms(inode, &folder->permissions);
folder->access_date = hfsp_ut2mt(inode->i_atime); folder->access_date = hfsp_ut2mt(inode_get_atime(inode));
folder->content_mod_date = hfsp_ut2mt(inode->i_mtime); folder->content_mod_date = hfsp_ut2mt(inode_get_mtime(inode));
folder->attribute_mod_date = hfsp_ut2mt(inode_get_ctime(inode)); folder->attribute_mod_date = hfsp_ut2mt(inode_get_ctime(inode));
folder->valence = cpu_to_be32(inode->i_size - 2); folder->valence = cpu_to_be32(inode->i_size - 2);
if (folder->flags & cpu_to_be16(HFSPLUS_HAS_FOLDER_COUNT)) { if (folder->flags & cpu_to_be16(HFSPLUS_HAS_FOLDER_COUNT)) {
@ -644,8 +646,8 @@ int hfsplus_cat_write_inode(struct inode *inode)
file->flags |= cpu_to_be16(HFSPLUS_FILE_LOCKED); file->flags |= cpu_to_be16(HFSPLUS_FILE_LOCKED);
else else
file->flags &= cpu_to_be16(~HFSPLUS_FILE_LOCKED); file->flags &= cpu_to_be16(~HFSPLUS_FILE_LOCKED);
file->access_date = hfsp_ut2mt(inode->i_atime); file->access_date = hfsp_ut2mt(inode_get_atime(inode));
file->content_mod_date = hfsp_ut2mt(inode->i_mtime); file->content_mod_date = hfsp_ut2mt(inode_get_mtime(inode));
file->attribute_mod_date = hfsp_ut2mt(inode_get_ctime(inode)); file->attribute_mod_date = hfsp_ut2mt(inode_get_ctime(inode));
hfs_bnode_write(fd.bnode, &entry, fd.entryoffset, hfs_bnode_write(fd.bnode, &entry, fd.entryoffset,
sizeof(struct hfsplus_cat_file)); sizeof(struct hfsplus_cat_file));

12
fs/hostfs/hostfs_kern.c
View File

@ -513,10 +513,14 @@ static int hostfs_inode_update(struct inode *ino, const struct hostfs_stat *st)
set_nlink(ino, st->nlink); set_nlink(ino, st->nlink);
i_uid_write(ino, st->uid); i_uid_write(ino, st->uid);
i_gid_write(ino, st->gid); i_gid_write(ino, st->gid);
ino->i_atime = inode_set_atime_to_ts(ino, (struct timespec64){
(struct timespec64){ st->atime.tv_sec, st->atime.tv_nsec }; st->atime.tv_sec,
ino->i_mtime = st->atime.tv_nsec,
(struct timespec64){ st->mtime.tv_sec, st->mtime.tv_nsec }; });
inode_set_mtime_to_ts(ino, (struct timespec64){
st->mtime.tv_sec,
st->mtime.tv_nsec,
});
inode_set_ctime(ino, st->ctime.tv_sec, st->ctime.tv_nsec); inode_set_ctime(ino, st->ctime.tv_sec, st->ctime.tv_nsec);
ino->i_size = st->size; ino->i_size = st->size;
ino->i_blocks = st->blocks; ino->i_blocks = st->blocks;

12
fs/hpfs/dir.c
View File

@ -277,14 +277,16 @@ struct dentry *hpfs_lookup(struct inode *dir, struct dentry *dentry, unsigned in
* inode. * inode.
*/ */
if (!inode_get_ctime(result).tv_sec) { if (!inode_get_ctime_sec(result)) {
time64_t csec = local_to_gmt(dir->i_sb, le32_to_cpu(de->creation_date)); time64_t csec = local_to_gmt(dir->i_sb, le32_to_cpu(de->creation_date));
inode_set_ctime(result, csec ? csec : 1, 0); inode_set_ctime(result, csec ? csec : 1, 0);
result->i_mtime.tv_sec = local_to_gmt(dir->i_sb, le32_to_cpu(de->write_date)); inode_set_mtime(result,
result->i_mtime.tv_nsec = 0; local_to_gmt(dir->i_sb, le32_to_cpu(de->write_date)),
result->i_atime.tv_sec = local_to_gmt(dir->i_sb, le32_to_cpu(de->read_date)); 0);
result->i_atime.tv_nsec = 0; inode_set_atime(result,
local_to_gmt(dir->i_sb, le32_to_cpu(de->read_date)),
0);
hpfs_result->i_ea_size = le32_to_cpu(de->ea_size); hpfs_result->i_ea_size = le32_to_cpu(de->ea_size);
if (!hpfs_result->i_ea_mode && de->read_only) if (!hpfs_result->i_ea_mode && de->read_only)
result->i_mode &= ~0222; result->i_mode &= ~0222;

16
fs/hpfs/inode.c
View File

@ -37,8 +37,8 @@ void hpfs_init_inode(struct inode *i)
hpfs_inode->i_dirty = 0; hpfs_inode->i_dirty = 0;
inode_set_ctime(i, 0, 0); inode_set_ctime(i, 0, 0);
i->i_mtime.tv_sec = i->i_mtime.tv_nsec = 0; inode_set_mtime(i, 0, 0);
i->i_atime.tv_sec = i->i_atime.tv_nsec = 0; inode_set_atime(i, 0, 0);
} }
void hpfs_read_inode(struct inode *i) void hpfs_read_inode(struct inode *i)
@ -230,9 +230,9 @@ void hpfs_write_inode_nolock(struct inode *i)
} }
hpfs_write_inode_ea(i, fnode); hpfs_write_inode_ea(i, fnode);
if (de) { if (de) {
de->write_date = cpu_to_le32(gmt_to_local(i->i_sb, i->i_mtime.tv_sec)); de->write_date = cpu_to_le32(gmt_to_local(i->i_sb, inode_get_mtime_sec(i)));
de->read_date = cpu_to_le32(gmt_to_local(i->i_sb, i->i_atime.tv_sec)); de->read_date = cpu_to_le32(gmt_to_local(i->i_sb, inode_get_atime_sec(i)));
de->creation_date = cpu_to_le32(gmt_to_local(i->i_sb, inode_get_ctime(i).tv_sec)); de->creation_date = cpu_to_le32(gmt_to_local(i->i_sb, inode_get_ctime_sec(i)));
de->read_only = !(i->i_mode & 0222); de->read_only = !(i->i_mode & 0222);
de->ea_size = cpu_to_le32(hpfs_inode->i_ea_size); de->ea_size = cpu_to_le32(hpfs_inode->i_ea_size);
hpfs_mark_4buffers_dirty(&qbh); hpfs_mark_4buffers_dirty(&qbh);
@ -240,9 +240,9 @@ void hpfs_write_inode_nolock(struct inode *i)
} }
if (S_ISDIR(i->i_mode)) { if (S_ISDIR(i->i_mode)) {
if ((de = map_dirent(i, hpfs_inode->i_dno, "\001\001", 2, NULL, &qbh))) { if ((de = map_dirent(i, hpfs_inode->i_dno, "\001\001", 2, NULL, &qbh))) {
de->write_date = cpu_to_le32(gmt_to_local(i->i_sb, i->i_mtime.tv_sec)); de->write_date = cpu_to_le32(gmt_to_local(i->i_sb, inode_get_mtime_sec(i)));
de->read_date = cpu_to_le32(gmt_to_local(i->i_sb, i->i_atime.tv_sec)); de->read_date = cpu_to_le32(gmt_to_local(i->i_sb, inode_get_atime_sec(i)));
de->creation_date = cpu_to_le32(gmt_to_local(i->i_sb, inode_get_ctime(i).tv_sec)); de->creation_date = cpu_to_le32(gmt_to_local(i->i_sb, inode_get_ctime_sec(i)));
de->read_only = !(i->i_mode & 0222); de->read_only = !(i->i_mode & 0222);
de->ea_size = cpu_to_le32(/*hpfs_inode->i_ea_size*/0); de->ea_size = cpu_to_le32(/*hpfs_inode->i_ea_size*/0);
de->file_size = cpu_to_le32(0); de->file_size = cpu_to_le32(0);

22
fs/hpfs/namei.c
View File

@ -12,10 +12,10 @@
static void hpfs_update_directory_times(struct inode *dir) static void hpfs_update_directory_times(struct inode *dir)
{ {
time64_t t = local_to_gmt(dir->i_sb, local_get_seconds(dir->i_sb)); time64_t t = local_to_gmt(dir->i_sb, local_get_seconds(dir->i_sb));
if (t == dir->i_mtime.tv_sec && if (t == inode_get_mtime_sec(dir) &&
t == inode_get_ctime(dir).tv_sec) t == inode_get_ctime_sec(dir))
return; return;
dir->i_mtime = inode_set_ctime(dir, t, 0); inode_set_mtime_to_ts(dir, inode_set_ctime(dir, t, 0));
hpfs_write_inode_nolock(dir); hpfs_write_inode_nolock(dir);
} }
@ -58,8 +58,8 @@ static int hpfs_mkdir(struct mnt_idmap *idmap, struct inode *dir,
result->i_ino = fno; result->i_ino = fno;
hpfs_i(result)->i_parent_dir = dir->i_ino; hpfs_i(result)->i_parent_dir = dir->i_ino;
hpfs_i(result)->i_dno = dno; hpfs_i(result)->i_dno = dno;
result->i_mtime = result->i_atime = inode_set_mtime_to_ts(result,
inode_set_ctime(result, local_to_gmt(dir->i_sb, le32_to_cpu(dee.creation_date)), 0); inode_set_atime_to_ts(result, inode_set_ctime(result, local_to_gmt(dir->i_sb, le32_to_cpu(dee.creation_date)), 0)));
hpfs_i(result)->i_ea_size = 0; hpfs_i(result)->i_ea_size = 0;
result->i_mode |= S_IFDIR; result->i_mode |= S_IFDIR;
result->i_op = &hpfs_dir_iops; result->i_op = &hpfs_dir_iops;
@ -164,8 +164,8 @@ static int hpfs_create(struct mnt_idmap *idmap, struct inode *dir,
result->i_fop = &hpfs_file_ops; result->i_fop = &hpfs_file_ops;
set_nlink(result, 1); set_nlink(result, 1);
hpfs_i(result)->i_parent_dir = dir->i_ino; hpfs_i(result)->i_parent_dir = dir->i_ino;
result->i_mtime = result->i_atime = inode_set_mtime_to_ts(result,
inode_set_ctime(result, local_to_gmt(dir->i_sb, le32_to_cpu(dee.creation_date)), 0); inode_set_atime_to_ts(result, inode_set_ctime(result, local_to_gmt(dir->i_sb, le32_to_cpu(dee.creation_date)), 0)));
hpfs_i(result)->i_ea_size = 0; hpfs_i(result)->i_ea_size = 0;
if (dee.read_only) if (dee.read_only)
result->i_mode &= ~0222; result->i_mode &= ~0222;
@ -245,8 +245,8 @@ static int hpfs_mknod(struct mnt_idmap *idmap, struct inode *dir,
hpfs_init_inode(result); hpfs_init_inode(result);
result->i_ino = fno; result->i_ino = fno;
hpfs_i(result)->i_parent_dir = dir->i_ino; hpfs_i(result)->i_parent_dir = dir->i_ino;
result->i_mtime = result->i_atime = inode_set_mtime_to_ts(result,
inode_set_ctime(result, local_to_gmt(dir->i_sb, le32_to_cpu(dee.creation_date)), 0); inode_set_atime_to_ts(result, inode_set_ctime(result, local_to_gmt(dir->i_sb, le32_to_cpu(dee.creation_date)), 0)));
hpfs_i(result)->i_ea_size = 0; hpfs_i(result)->i_ea_size = 0;
result->i_uid = current_fsuid(); result->i_uid = current_fsuid();
result->i_gid = current_fsgid(); result->i_gid = current_fsgid();
@ -319,8 +319,8 @@ static int hpfs_symlink(struct mnt_idmap *idmap, struct inode *dir,
result->i_ino = fno; result->i_ino = fno;
hpfs_init_inode(result); hpfs_init_inode(result);
hpfs_i(result)->i_parent_dir = dir->i_ino; hpfs_i(result)->i_parent_dir = dir->i_ino;
result->i_mtime = result->i_atime = inode_set_mtime_to_ts(result,
inode_set_ctime(result, local_to_gmt(dir->i_sb, le32_to_cpu(dee.creation_date)), 0); inode_set_atime_to_ts(result, inode_set_ctime(result, local_to_gmt(dir->i_sb, le32_to_cpu(dee.creation_date)), 0)));
hpfs_i(result)->i_ea_size = 0; hpfs_i(result)->i_ea_size = 0;
result->i_mode = S_IFLNK | 0777; result->i_mode = S_IFLNK | 0777;
result->i_uid = current_fsuid(); result->i_uid = current_fsuid();

Some files were not shown because too many files have changed in this diff Show More