Skip to content

Commit

Permalink
Revert "fs: add infrastructure for multigrain timestamps"
Browse files Browse the repository at this point in the history 
This reverts commit ffb6cf1.

Users reported regressions due to enabling multi-grained timestamps
unconditionally. As no clear consensus on a solution has come up and the
discussion has gone back to the drawing board revert the infrastructure
changes for. If it isn't code that's here to stay, make it go away.

Message-ID: <20230920-keine-eile-c9755b5825db@brauner>
Acked-by: Jan Kara <jack@suse.cz>
Acked-by: Jeff Layton <jlayton@kernel.org>
Signed-off-by: Christian Brauner <brauner@kernel.org>
  • Loading branch information
Christian Brauner committed Sep 20, 2023
1 parent efd34f0 commit 647aa76
Show file tree
Hide file tree
Showing 3 changed files with 7 additions and 162 deletions.
82 changes: 3 additions & 79 deletions fs/inode.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -2102,52 +2102,10 @@ int file_remove_privs(struct file *file)
}
EXPORT_SYMBOL(file_remove_privs);

/**
* current_mgtime - Return FS time (possibly fine-grained)
* @inode: inode.
*
* Return the current time truncated to the time granularity supported by
* the fs, as suitable for a ctime/mtime change. If the ctime is flagged
* as having been QUERIED, get a fine-grained timestamp.
*/
struct timespec64 current_mgtime(struct inode *inode)
{
struct timespec64 now, ctime;
atomic_long_t *pnsec = (atomic_long_t *)&inode->__i_ctime.tv_nsec;
long nsec = atomic_long_read(pnsec);

if (nsec & I_CTIME_QUERIED) {
ktime_get_real_ts64(&now);
return timestamp_truncate(now, inode);
}

ktime_get_coarse_real_ts64(&now);
now = timestamp_truncate(now, inode);

/*
* If we've recently fetched a fine-grained timestamp
* then the coarse-grained one may still be earlier than the
* existing ctime. Just keep the existing value if so.
*/
ctime = inode_get_ctime(inode);
if (timespec64_compare(&ctime, &now) > 0)
now = ctime;

return now;
}
EXPORT_SYMBOL(current_mgtime);

static struct timespec64 current_ctime(struct inode *inode)
{
if (is_mgtime(inode))
return current_mgtime(inode);
return current_time(inode);
}

static int inode_needs_update_time(struct inode *inode)
{
int sync_it = 0;
struct timespec64 now = current_ctime(inode);
struct timespec64 now = current_time(inode);
struct timespec64 ctime;

/* First try to exhaust all avenues to not sync */
Expand Down Expand Up @@ -2578,43 +2536,9 @@ EXPORT_SYMBOL(current_time);
*/
struct timespec64 inode_set_ctime_current(struct inode *inode)
{
struct timespec64 now;
struct timespec64 ctime;

ctime.tv_nsec = READ_ONCE(inode->__i_ctime.tv_nsec);
if (!(ctime.tv_nsec & I_CTIME_QUERIED)) {
now = current_time(inode);
struct timespec64 now = current_time(inode);

/* Just copy it into place if it's not multigrain */
if (!is_mgtime(inode)) {
inode_set_ctime_to_ts(inode, now);
return now;
}

/*
* If we've recently updated with a fine-grained timestamp,
* then the coarse-grained one may still be earlier than the
* existing ctime. Just keep the existing value if so.
*/
ctime.tv_sec = inode->__i_ctime.tv_sec;
if (timespec64_compare(&ctime, &now) > 0)
return ctime;

/*
* Ctime updates are usually protected by the inode_lock, but
* we can still race with someone setting the QUERIED flag.
* Try to swap the new nsec value into place. If it's changed
* in the interim, then just go with a fine-grained timestamp.
*/
if (cmpxchg(&inode->__i_ctime.tv_nsec, ctime.tv_nsec,
now.tv_nsec) != ctime.tv_nsec)
goto fine_grained;
inode->__i_ctime.tv_sec = now.tv_sec;
return now;
}
fine_grained:
ktime_get_real_ts64(&now);
inode_set_ctime_to_ts(inode, timestamp_truncate(now, inode));
inode_set_ctime(inode, now.tv_sec, now.tv_nsec);
return now;
}
EXPORT_SYMBOL(inode_set_ctime_current);
Expand Down
41 changes: 2 additions & 39 deletions fs/stat.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -26,37 +26,6 @@
#include "internal.h"
#include "mount.h"

/**
* fill_mg_cmtime - Fill in the mtime and ctime and flag ctime as QUERIED
* @stat: where to store the resulting values
* @request_mask: STATX_* values requested
* @inode: inode from which to grab the c/mtime
*
* Given @inode, grab the ctime and mtime out if it and store the result
* in @stat. When fetching the value, flag it as queried so the next write
* will use a fine-grained timestamp.
*/
void fill_mg_cmtime(struct kstat *stat, u32 request_mask, struct inode *inode)
{
atomic_long_t *pnsec = (atomic_long_t *)&inode->__i_ctime.tv_nsec;

/* If neither time was requested, then don't report them */
if (!(request_mask & (STATX_CTIME|STATX_MTIME))) {
stat->result_mask &= ~(STATX_CTIME|STATX_MTIME);
return;
}

stat->mtime = inode->i_mtime;
stat->ctime.tv_sec = inode->__i_ctime.tv_sec;
/*
* Atomically set the QUERIED flag and fetch the new value with
* the flag masked off.
*/
stat->ctime.tv_nsec = atomic_long_fetch_or(I_CTIME_QUERIED, pnsec) &
~I_CTIME_QUERIED;
}
EXPORT_SYMBOL(fill_mg_cmtime);

/**
* generic_fillattr - Fill in the basic attributes from the inode struct
* @idmap: idmap of the mount the inode was found from
Expand Down Expand Up @@ -89,14 +58,8 @@ void generic_fillattr(struct mnt_idmap *idmap, u32 request_mask,
stat->rdev = inode->i_rdev;
stat->size = i_size_read(inode);
stat->atime = inode->i_atime;

if (is_mgtime(inode)) {
fill_mg_cmtime(stat, request_mask, inode);
} else {
stat->mtime = inode->i_mtime;
stat->ctime = inode_get_ctime(inode);
}

stat->mtime = inode->i_mtime;
stat->ctime = inode_get_ctime(inode);
stat->blksize = i_blocksize(inode);
stat->blocks = inode->i_blocks;

Expand Down
46 changes: 2 additions & 44 deletions include/linux/fs.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -1508,47 +1508,18 @@ static inline bool fsuidgid_has_mapping(struct super_block *sb,
kgid_has_mapping(fs_userns, kgid);
}

struct timespec64 current_mgtime(struct inode *inode);
struct timespec64 current_time(struct inode *inode);
struct timespec64 inode_set_ctime_current(struct inode *inode);

/*
* Multigrain timestamps
*
* Conditionally use fine-grained ctime and mtime timestamps when there
* are users actively observing them via getattr. The primary use-case
* for this is NFS clients that use the ctime to distinguish between
* different states of the file, and that are often fooled by multiple
* operations that occur in the same coarse-grained timer tick.
*
* The kernel always keeps normalized struct timespec64 values in the ctime,
* which means that only the first 30 bits of the value are used. Use the
* 31st bit of the ctime's tv_nsec field as a flag to indicate that the value
* has been queried since it was last updated.
*/
#define I_CTIME_QUERIED (1L<<30)

/**
* inode_get_ctime - fetch the current ctime from the inode
* @inode: inode from which to fetch ctime
*
* Grab the current ctime tv_nsec field from the inode, mask off the
* I_CTIME_QUERIED flag and return it. This is mostly intended for use by
* internal consumers of the ctime that aren't concerned with ensuring a
* fine-grained update on the next change (e.g. when preparing to store
* the value in the backing store for later retrieval).
*
* This is safe to call regardless of whether the underlying filesystem
* is using multigrain timestamps.
* Grab the current ctime from the inode and return it.
*/
static inline struct timespec64 inode_get_ctime(const struct inode *inode)
{
struct timespec64 ctime;

ctime.tv_sec = inode->__i_ctime.tv_sec;
ctime.tv_nsec = inode->__i_ctime.tv_nsec & ~I_CTIME_QUERIED;

return ctime;
return inode->__i_ctime;
}

/**
Expand Down Expand Up @@ -2334,7 +2305,6 @@ struct file_system_type {
#define FS_USERNS_MOUNT 8 /* Can be mounted by userns root */
#define FS_DISALLOW_NOTIFY_PERM 16 /* Disable fanotify permission events */
#define FS_ALLOW_IDMAP 32 /* FS has been updated to handle vfs idmappings. */
#define FS_MGTIME 64 /* FS uses multigrain timestamps */
#define FS_RENAME_DOES_D_MOVE 32768 /* FS will handle d_move() during rename() internally. */
int (*init_fs_context)(struct fs_context *);
const struct fs_parameter_spec *parameters;
Expand All @@ -2358,17 +2328,6 @@ struct file_system_type {

#define MODULE_ALIAS_FS(NAME) MODULE_ALIAS("fs-" NAME)

/**
* is_mgtime: is this inode using multigrain timestamps
* @inode: inode to test for multigrain timestamps
*
* Return true if the inode uses multigrain timestamps, false otherwise.
*/
static inline bool is_mgtime(const struct inode *inode)
{
return inode->i_sb->s_type->fs_flags & FS_MGTIME;
}

extern struct dentry *mount_bdev(struct file_system_type *fs_type,
int flags, const char *dev_name, void *data,
int (*fill_super)(struct super_block *, void *, int));
Expand Down Expand Up @@ -3054,7 +3013,6 @@ extern void page_put_link(void *);
extern int page_symlink(struct inode *inode, const char *symname, int len);
extern const struct inode_operations page_symlink_inode_operations;
extern void kfree_link(void *);
void fill_mg_cmtime(struct kstat *stat, u32 request_mask, struct inode *inode);
void generic_fillattr(struct mnt_idmap *, u32, struct inode *, struct kstat *);
void generic_fill_statx_attr(struct inode *inode, struct kstat *stat);
extern int vfs_getattr_nosec(const struct path *, struct kstat *, u32, unsigned int);
Expand Down

0 comments on commit 647aa76

Please sign in to comment.