* [RFC PATCH v4 01/10] vfs: add provenance time (ptime)
2026-11-15 18:03 [RFC PATCH v4 00/10] add provenance time (ptime) koraynilay
@ 2026-11-15 18:03 ` koraynilay
2026-11-15 18:03 ` [RFC PATCH v4 02/10] vfs: add fileattr_has_fsx_mask() koraynilay
` (8 subsequent siblings)
9 siblings, 0 replies; 11+ messages in thread
From: koraynilay @ 2026-11-15 18:03 UTC (permalink / raw)
To: David Sterba, Namjae Jeon, Sungjong Seo, Alexander Viro,
Christian Brauner, Trond Myklebust, Anna Schumaker, Chuck Lever,
Jeff Layton, Konstantin Komarov, Paulo Alcantara
Cc: Chris Mason, Yuezhang Mo, Jan Kara, NeilBrown, Olga Kornievskaia,
Dai Ngo, Tom Talpey, Ronnie Sahlberg, Shyam Prasad N, Bharath SM,
Sergey Senozhatsky, ChenXiaoSong, Darrick J . Wong, Sean Smith,
Andrey Albershteyn, Pedro Falcato, Amir Goldstein,
Pali Rohár, linux-btrfs, linux-kernel, linux-fsdevel, exfat,
ntfs3, linux-cifs, linux-nfs, linux-api, koraynilay
Add provenance time (ptime), indicating the time when a file or
directory was created. This is user-settable via file_setattr() and
retrievable via statx(2) (using STATX_PTIME) or file_getattr().
The semantics of when to preserve this new timestamp are the same as
mtime, the idea being that there is a correspondence like this:
ctime <-> btime
mtime <-> ptime
so every operation (copying, moving, ...) that currently preserves mtime
should also preserve ptime.
Also add fa_xflags_mask to struct file_attr (and equivalent
fsx_xflags_mask to struct file_kattr) to let the filesystems advertise
their support for specific xflags and users advertise what they want to
change, behaving like statx.stx_attributes_mask:
- on GET (file_getattr): each filesystem fills the mask according to
their supported xflags, e.g. FS_XFLAG_PTIME or FS_XFLAG_COWEXTSIZE,
and provides the values in the corresponding struct fields;
- on SET (file_setattr): userspace fills the mask according to which
xflags it wants to change, VFS validates this and preserves xflags
that were not specified in the mask;
- if xflags_mask == 0, use legacy full-struct replacement to keep
compatibility with older programs.
Furthermore, in order to avoid the legacy FS_IOC_FSSETXATTR accepting
FS_XFLAG_PTIME, add an FS_FILE_ATTR_XFLAGS_MASK mask to support new
xflags and use it in fileattr_to_file_attr()/file_attr_to_fileattr() to
validate that the xflags passed in xflags and xflags_mask fields are
valid.
Finally, add the missing FS_XFLAG_PROJID flag, to allow userspace to set
the projid using file_[sg]etattr().
[ This is a re-implementation of the initial patch[1] by Sean Smith
<defendthedisabled@gmail.com>, following the advice[2] from Darrick J.
Wong <djwong@kernel.org> of using file_setattr() instead of updating
utimensat() ]
[1]: https://lore.kernel.org/20260405195007.1306-2-DefendTheDisabled@gmail.com
[2]: https://lore.kernel.org/20260407014129.GC6192@frogsfrogsfrogs
Assisted-by: Gemini:3.8-flash-high antigravity-cli-1.4.7
Signed-off-by: koraynilay <koray.fra@gmail.com>
---
fs/file_attr.c | 75 +++++++++++++++++++++++++++++++++++++--
fs/stat.c | 2 ++
include/linux/fileattr.h | 6 ++++
include/linux/stat.h | 1 +
include/uapi/linux/fs.h | 9 ++++-
include/uapi/linux/stat.h | 7 +++-
6 files changed, 95 insertions(+), 5 deletions(-)
diff --git a/fs/file_attr.c b/fs/file_attr.c
index 833e03810b24..12610fb6a751 100644
--- a/fs/file_attr.c
+++ b/fs/file_attr.c
@@ -102,14 +102,23 @@ EXPORT_SYMBOL(vfs_fileattr_get);
static void fileattr_to_file_attr(const struct file_kattr *fa,
struct file_attr *fattr)
{
- __u32 mask = FS_XFLAGS_MASK;
+ /*
+ * fsx_xflags_mask contains only flags added after the
+ * file_[gs]etattr() API, so we need to tell userspace the filesystem
+ * actually supports all legacy and new advertised flags
+ */
+ __u32 mask = (FS_XFLAGS_MASK | fa->fsx_xflags_mask) &
+ FS_FILE_ATTR_XFLAGS_MASK;
memset(fattr, 0, sizeof(struct file_attr));
fattr->fa_xflags = fa->fsx_xflags & mask;
+ fattr->fa_xflags_mask = mask;
fattr->fa_extsize = fa->fsx_extsize;
fattr->fa_nextents = fa->fsx_nextents;
fattr->fa_projid = fa->fsx_projid;
fattr->fa_cowextsize = fa->fsx_cowextsize;
+ fattr->fa_ptime_sec = fa->fsx_ptime.tv_sec;
+ fattr->fa_ptime_nsec = fa->fsx_ptime.tv_nsec;
}
/**
@@ -141,15 +150,23 @@ EXPORT_SYMBOL(copy_fsxattr_to_user);
static int file_attr_to_fileattr(const struct file_attr *fattr,
struct file_kattr *fa)
{
- __u64 mask = FS_XFLAGS_MASK;
+ __u64 mask = fattr->fa_xflags_mask ?: FS_XFLAGS_MASK;
+
+ if (fattr->fa_xflags_mask & ~FS_FILE_ATTR_XFLAGS_MASK)
+ return -EINVAL;
if (fattr->fa_xflags & ~mask)
return -EINVAL;
fileattr_fill_xflags(fa, fattr->fa_xflags & ~FS_XFLAG_RDONLY_MASK);
+ fa->fsx_xflags_mask = fattr->fa_xflags_mask;
fa->fsx_extsize = fattr->fa_extsize;
fa->fsx_projid = fattr->fa_projid;
fa->fsx_cowextsize = fattr->fa_cowextsize;
+ if (fattr->fa_xflags_mask & FS_XFLAG_PTIME) {
+ fa->fsx_ptime.tv_sec = fattr->fa_ptime_sec;
+ fa->fsx_ptime.tv_nsec = fattr->fa_ptime_nsec;
+ }
return 0;
}
@@ -232,6 +249,23 @@ static int fileattr_set_prepare(struct inode *inode,
!S_ISREG(inode->i_mode) && !S_ISDIR(inode->i_mode))
return -EINVAL;
+ if (fa->fsx_xflags_mask & FS_XFLAG_PTIME) {
+ if (!(old_ma->fsx_xflags_mask & FS_XFLAG_PTIME))
+ return -EOPNOTSUPP;
+
+ if (!(fa->fsx_xflags & FS_XFLAG_PTIME))
+ return -EINVAL;
+
+ if ((unsigned long)fa->fsx_ptime.tv_nsec >= NSEC_PER_SEC)
+ return -EINVAL;
+
+ fa->fsx_ptime = timestamp_truncate(fa->fsx_ptime, inode);
+
+ if (!timespec64_equal(&old_ma->fsx_ptime, &fa->fsx_ptime) &&
+ (fa->flags & old_ma->flags) & (FS_APPEND_FL | FS_IMMUTABLE_FL))
+ return -EPERM;
+ }
+
/*
* It is only valid to set the DAX flag on regular files and
* directories on filesystems.
@@ -288,13 +322,41 @@ int vfs_fileattr_set(const struct mnt_idmap *idmap, struct dentry *dentry,
if (!err) {
/* initialize missing bits from old_ma */
if (fa->flags_valid) {
- fa->fsx_xflags |= old_ma.fsx_xflags & ~FS_XFLAG_COMMON;
+ /* FS_IOC_SETFLAGS */
+ fa->fsx_xflags |= (old_ma.fsx_xflags & FS_XFLAGS_MASK) &
+ ~FS_XFLAG_COMMON;
fa->fsx_extsize = old_ma.fsx_extsize;
fa->fsx_nextents = old_ma.fsx_nextents;
fa->fsx_projid = old_ma.fsx_projid;
fa->fsx_cowextsize = old_ma.fsx_cowextsize;
+ fa->fsx_ptime = old_ma.fsx_ptime;
} else {
+ /*
+ * Preserve unmasked xflags when running file_setattr()
+ * with a mask, which doesn't need a read-modify-write
+ * so these attributes would be set to 0.
+ *
+ * With FS_IOC_FSSETXATTR or mask == 0 (legacy mode)
+ * this is not needed as userspace does
+ * read-modify-write already.
+ */
+ if (fa->fsx_xflags_mask) {
+ fa->fsx_xflags |= old_ma.fsx_xflags &
+ ~fa->fsx_xflags_mask;
+ fileattr_fill_xflags(fa, fa->fsx_xflags &
+ ~FS_XFLAG_RDONLY_MASK);
+ if (!(fa->fsx_xflags_mask & FS_XFLAG_EXTSIZE))
+ fa->fsx_extsize = old_ma.fsx_extsize;
+ if (!(fa->fsx_xflags_mask & FS_XFLAG_PROJID))
+ fa->fsx_projid = old_ma.fsx_projid;
+ if (!(fa->fsx_xflags_mask & FS_XFLAG_COWEXTSIZE))
+ fa->fsx_cowextsize = old_ma.fsx_cowextsize;
+ }
fa->flags |= old_ma.flags & ~FS_COMMON_FL;
+
+ /* xflags not present in fsxattr */
+ if (!(fa->fsx_xflags_mask & FS_XFLAG_PTIME))
+ fa->fsx_ptime = old_ma.fsx_ptime;
}
err = fileattr_set_prepare(inode, &old_ma, fa);
@@ -423,6 +485,10 @@ SYSCALL_DEFINE5(file_getattr, int, dfd, const char __user *, filename,
return error;
fileattr_to_file_attr(&fa, &fattr);
+
+ if (usize < FILE_ATTR_SIZE_VER1)
+ fattr.fa_xflags &= ~FS_XFLAG_PTIME;
+
error = copy_struct_to_user(ufattr, usize, &fattr,
sizeof(struct file_attr), NULL);
@@ -459,6 +525,9 @@ SYSCALL_DEFINE5(file_setattr, int, dfd, const char __user *, filename,
if (error)
return error;
+ if ((fattr.fa_xflags & FS_XFLAG_PTIME) && usize < FILE_ATTR_SIZE_VER1)
+ return -EINVAL;
+
error = file_attr_to_fileattr(&fattr, &fa);
if (error)
return error;
diff --git a/fs/stat.c b/fs/stat.c
index 34d786c1de3e..1e4260f55f01 100644
--- a/fs/stat.c
+++ b/fs/stat.c
@@ -728,6 +728,8 @@ cp_statx(const struct kstat *stat, struct statx __user *buffer)
tmp.stx_ctime.tv_nsec = stat->ctime.tv_nsec;
tmp.stx_mtime.tv_sec = stat->mtime.tv_sec;
tmp.stx_mtime.tv_nsec = stat->mtime.tv_nsec;
+ tmp.stx_ptime.tv_sec = stat->ptime.tv_sec;
+ tmp.stx_ptime.tv_nsec = stat->ptime.tv_nsec;
tmp.stx_rdev_major = MAJOR(stat->rdev);
tmp.stx_rdev_minor = MINOR(stat->rdev);
tmp.stx_dev_major = MAJOR(stat->dev);
diff --git a/include/linux/fileattr.h b/include/linux/fileattr.h
index 09e32b84e02a..42b92ccdc583 100644
--- a/include/linux/fileattr.h
+++ b/include/linux/fileattr.h
@@ -35,6 +35,10 @@
(FS_XFLAG_COMMON | FS_XFLAG_RDONLY_MASK | FS_XFLAG_VALUES_MASK | \
FS_XFLAG_DIRONLY_MASK | FS_XFLAG_MISC_MASK)
+/* Flags only for fa_ fields */
+#define FS_FILE_ATTR_XFLAGS_MASK \
+ (FS_XFLAGS_MASK | FS_XFLAG_PTIME | FS_XFLAG_PROJID)
+
/*
* Merged interface for miscellaneous file attributes. 'flags' originates from
* ext* and 'fsx_flags' from xfs. There's some overlap between the two, which
@@ -45,10 +49,12 @@ struct file_kattr {
u32 flags; /* flags (FS_IOC_GETFLAGS/FS_IOC_SETFLAGS) */
/* struct fsxattr: */
u32 fsx_xflags; /* xflags field value (get/set) */
+ u32 fsx_xflags_mask; /* supported xflags (get) / flags to set (set) */
u32 fsx_extsize; /* extsize field value (get/set)*/
u32 fsx_nextents; /* nextents field value (get) */
u32 fsx_projid; /* project identifier (get/set) */
u32 fsx_cowextsize; /* CoW extsize field value (get/set)*/
+ struct timespec64 fsx_ptime; /* provenance (settable birth) time */
/* selectors: */
bool flags_valid:1;
bool fsx_valid:1;
diff --git a/include/linux/stat.h b/include/linux/stat.h
index 4f0a4af7a067..5384a77676f1 100644
--- a/include/linux/stat.h
+++ b/include/linux/stat.h
@@ -48,6 +48,7 @@ struct kstat {
struct timespec64 mtime;
struct timespec64 ctime;
struct timespec64 btime; /* File creation time */
+ struct timespec64 ptime; /* File provenance (user-settable creation) time */
u64 blocks;
u64 mnt_id;
u64 change_cookie;
diff --git a/include/uapi/linux/fs.h b/include/uapi/linux/fs.h
index a46c33692aa2..655e448cdd23 100644
--- a/include/uapi/linux/fs.h
+++ b/include/uapi/linux/fs.h
@@ -229,10 +229,14 @@ struct file_attr {
__u32 fa_nextents; /* nextents field value (get) */
__u32 fa_projid; /* project identifier (get/set) */
__u32 fa_cowextsize; /* CoW extsize field value (get/set) */
+ __s64 fa_ptime_sec; /* provenance (settable birth) time (seconds) */
+ __u32 fa_ptime_nsec; /* provenance (settable birth) time (nanoseconds) */
+ __u32 fa_xflags_mask; /* supported xflags (get) / flags to set (set) */
};
#define FILE_ATTR_SIZE_VER0 24
-#define FILE_ATTR_SIZE_LATEST FILE_ATTR_SIZE_VER0
+#define FILE_ATTR_SIZE_VER1 40
+#define FILE_ATTR_SIZE_LATEST FILE_ATTR_SIZE_VER1
/*
* Flags for the fsx_xflags field
@@ -261,6 +265,9 @@ struct file_attr {
*/
#define FS_XFLAG_CASEFOLD 0x00040000 /* case-insensitive lookups */
#define FS_XFLAG_CASENONPRESERVING 0x00080000 /* case not preserved */
+
+#define FS_XFLAG_PTIME 0x00100000 /* provenance time */
+#define FS_XFLAG_PROJID 0x00200000 /* project ID */
#define FS_XFLAG_HASATTR 0x80000000 /* no DIFLAG for this */
/* the read-only stuff doesn't really belong here, but any other place is
diff --git a/include/uapi/linux/stat.h b/include/uapi/linux/stat.h
index 1686861aae20..f3a1013ba022 100644
--- a/include/uapi/linux/stat.h
+++ b/include/uapi/linux/stat.h
@@ -187,7 +187,11 @@ struct statx {
__u32 __spare2[1];
/* 0xc0 */
- __u64 __spare3[8]; /* Spare space for future expansion */
+ /* Data provenance (creation) time */
+ struct statx_timestamp stx_ptime;
+
+ /* 0xd0 */
+ __u64 __spare3[6]; /* Spare space for future expansion */
/* 0x100 */
};
@@ -219,6 +223,7 @@ struct statx {
#define STATX_SUBVOL 0x00008000U /* Want/got stx_subvol */
#define STATX_WRITE_ATOMIC 0x00010000U /* Want/got atomic_write_* fields */
#define STATX_DIO_READ_ALIGN 0x00020000U /* Want/got dio read alignment info */
+#define STATX_PTIME 0x00040000U /* Want/got stx_ptime */
#define STATX__RESERVED 0x80000000U /* Reserved for future struct statx expansion */
--
2.56.0
^ permalink raw reply related [flat|nested] 11+ messages in thread* [RFC PATCH v4 02/10] vfs: add fileattr_has_fsx_mask()
2026-11-15 18:03 [RFC PATCH v4 00/10] add provenance time (ptime) koraynilay
2026-11-15 18:03 ` [RFC PATCH v4 01/10] vfs: " koraynilay
@ 2026-11-15 18:03 ` koraynilay
2026-11-15 18:03 ` [RFC PATCH v4 03/10] ntfs3: make crtime user-settable using ptime koraynilay
` (7 subsequent siblings)
9 siblings, 0 replies; 11+ messages in thread
From: koraynilay @ 2026-11-15 18:03 UTC (permalink / raw)
To: David Sterba, Namjae Jeon, Sungjong Seo, Alexander Viro,
Christian Brauner, Trond Myklebust, Anna Schumaker, Chuck Lever,
Jeff Layton, Konstantin Komarov, Paulo Alcantara
Cc: Chris Mason, Yuezhang Mo, Jan Kara, NeilBrown, Olga Kornievskaia,
Dai Ngo, Tom Talpey, Ronnie Sahlberg, Shyam Prasad N, Bharath SM,
Sergey Senozhatsky, ChenXiaoSong, Darrick J . Wong, Sean Smith,
Andrey Albershteyn, Pedro Falcato, Amir Goldstein,
Pali Rohár, linux-btrfs, linux-kernel, linux-fsdevel, exfat,
ntfs3, linux-cifs, linux-nfs, linux-api, koraynilay
Add fileattr_has_fsx_mask() as a helper to let filesystems check for
unsupported xflags while allowing supported ones. Can be used in the
same way as fileattr_has_fsx().
Also make fileattr_has_fsx() a wrapper around fileattr_has_fsx_mask().
Assisted-by: Gemini:3.8-flash-high antigravity-cli-1.4.7
Signed-off-by: koraynilay <koray.fra@gmail.com>
---
include/linux/fileattr.h | 21 ++++++++++++++++++---
1 file changed, 18 insertions(+), 3 deletions(-)
diff --git a/include/linux/fileattr.h b/include/linux/fileattr.h
index 42b92ccdc583..ba7ed3b387d8 100644
--- a/include/linux/fileattr.h
+++ b/include/linux/fileattr.h
@@ -65,6 +65,23 @@ int copy_fsxattr_to_user(const struct file_kattr *fa, struct fsxattr __user *ufa
void fileattr_fill_xflags(struct file_kattr *fa, u32 xflags);
void fileattr_fill_flags(struct file_kattr *fa, u32 flags);
+/**
+ * fileattr_has_fsx_mask - check for extended flags/attributes
+ * @fa: fileattr pointer
+ * @allowed_xflags_mask: additional xflags permitted
+ *
+ * Return: true if any attributes are present that are not represented in
+ * ->flags or @allowed_xflags_mask.
+ */
+static inline bool fileattr_has_fsx_mask(const struct file_kattr *fa,
+ u32 allowed_xflags_mask)
+{
+ return fa->fsx_valid &&
+ ((fa->fsx_xflags & ~(FS_XFLAG_COMMON | allowed_xflags_mask)) ||
+ fa->fsx_extsize != 0 || fa->fsx_projid != 0 ||
+ fa->fsx_cowextsize != 0);
+}
+
/**
* fileattr_has_fsx - check for extended flags/attributes
* @fa: fileattr pointer
@@ -74,9 +91,7 @@ void fileattr_fill_flags(struct file_kattr *fa, u32 flags);
*/
static inline bool fileattr_has_fsx(const struct file_kattr *fa)
{
- return fa->fsx_valid &&
- ((fa->fsx_xflags & ~FS_XFLAG_COMMON) || fa->fsx_extsize != 0 ||
- fa->fsx_projid != 0 || fa->fsx_cowextsize != 0);
+ return fileattr_has_fsx_mask(fa, 0);
}
int vfs_fileattr_get(struct dentry *dentry, struct file_kattr *fa);
--
2.56.0
^ permalink raw reply related [flat|nested] 11+ messages in thread* [RFC PATCH v4 03/10] ntfs3: make crtime user-settable using ptime
2026-11-15 18:03 [RFC PATCH v4 00/10] add provenance time (ptime) koraynilay
2026-11-15 18:03 ` [RFC PATCH v4 01/10] vfs: " koraynilay
2026-11-15 18:03 ` [RFC PATCH v4 02/10] vfs: add fileattr_has_fsx_mask() koraynilay
@ 2026-11-15 18:03 ` koraynilay
2026-11-15 18:03 ` [RFC PATCH v4 04/10] exfat: " koraynilay
` (6 subsequent siblings)
9 siblings, 0 replies; 11+ messages in thread
From: koraynilay @ 2026-11-15 18:03 UTC (permalink / raw)
To: David Sterba, Namjae Jeon, Sungjong Seo, Alexander Viro,
Christian Brauner, Trond Myklebust, Anna Schumaker, Chuck Lever,
Jeff Layton, Konstantin Komarov, Paulo Alcantara
Cc: Chris Mason, Yuezhang Mo, Jan Kara, NeilBrown, Olga Kornievskaia,
Dai Ngo, Tom Talpey, Ronnie Sahlberg, Shyam Prasad N, Bharath SM,
Sergey Senozhatsky, ChenXiaoSong, Darrick J . Wong, Sean Smith,
Andrey Albershteyn, Pedro Falcato, Amir Goldstein,
Pali Rohár, linux-btrfs, linux-kernel, linux-fsdevel, exfat,
ntfs3, linux-cifs, linux-nfs, linux-api, koraynilay
Since NTFS supports user-settable file creation timestamps, map
provenance time (ptime) to NTFS file creation time (crtime) by using the
newly introduced ptime API (in commit "vfs: add provenance time
(ptime)").
To do this, update ntfs_fileattr_[gs]et(), ntfs_getattr() and make it
persist to disk in ni_write_inode().
The timestamp is now retrievable by using file_getattr() or statx(), and
is settable by using file_setattr() with the FS_XFLAG_PTIME flag.
Assisted-by: Gemini:3.8-flash-high antigravity-cli-1.4.7
Signed-off-by: koraynilay <koray.fra@gmail.com>
---
fs/ntfs3/file.c | 20 ++++++++++++++++++--
fs/ntfs3/frecord.c | 8 +++++++-
2 files changed, 25 insertions(+), 3 deletions(-)
diff --git a/fs/ntfs3/file.c b/fs/ntfs3/file.c
index 6c84a3e1c7fe..1a9301006154 100644
--- a/fs/ntfs3/file.c
+++ b/fs/ntfs3/file.c
@@ -90,6 +90,8 @@ static int ntfs_ioctl_fitrim(struct ntfs_sb_info *sbi, unsigned long arg)
return 0;
}
+#define NTFS_SUPPORTED_XFLAGS (FS_XFLAG_PTIME)
+
/*
* ntfs_fileattr_get - inode_operations::fileattr_get
*/
@@ -124,6 +126,11 @@ int ntfs_fileattr_get(struct dentry *dentry, struct file_kattr *fa)
fileattr_fill_flags(fa, flags);
+ fa->fsx_ptime.tv_sec = ni->i_crtime.tv_sec;
+ fa->fsx_ptime.tv_nsec = ni->i_crtime.tv_nsec;
+ fa->fsx_xflags |= FS_XFLAG_PTIME;
+ fa->fsx_xflags_mask |= FS_XFLAG_PTIME;
+
return 0;
}
@@ -142,7 +149,10 @@ int ntfs_fileattr_set(const struct mnt_idmap *idmap, struct dentry *dentry,
if (unlikely(is_bad_ni(ni)))
return -EINVAL;
- if (fileattr_has_fsx(fa))
+ if (fileattr_has_fsx_mask(fa, NTFS_SUPPORTED_XFLAGS))
+ return -EOPNOTSUPP;
+
+ if (fa->fsx_xflags_mask & ~NTFS_SUPPORTED_XFLAGS)
return -EOPNOTSUPP;
if (flags & ~(FS_IMMUTABLE_FL | FS_APPEND_FL | FS_NODUMP_FL))
@@ -154,6 +164,11 @@ int ntfs_fileattr_set(const struct mnt_idmap *idmap, struct dentry *dentry,
if (flags & FS_APPEND_FL)
new_fl |= S_APPEND;
+ if (fa->fsx_xflags_mask & FS_XFLAG_PTIME) {
+ ni->i_crtime.tv_sec = fa->fsx_ptime.tv_sec;
+ ni->i_crtime.tv_nsec = fa->fsx_ptime.tv_nsec;
+ }
+
inode_set_flags(inode, new_fl, S_IMMUTABLE | S_APPEND);
/* Save nodump flag to return in ntfs_getattr. */
@@ -275,8 +290,9 @@ int ntfs_getattr(const struct mnt_idmap *idmap, const struct path *path,
if (unlikely(is_bad_ni(ni)))
return -EINVAL;
- stat->result_mask |= STATX_BTIME;
+ stat->result_mask |= (STATX_BTIME | STATX_PTIME);
stat->btime = ni->i_crtime;
+ stat->ptime = ni->i_crtime;
stat->blksize = ni->mi.sbi->cluster_size; /* 512, 1K, ..., 2M */
if (inode->i_flags & S_IMMUTABLE)
diff --git a/fs/ntfs3/frecord.c b/fs/ntfs3/frecord.c
index 16ac847de48d..5e4f743a5930 100644
--- a/fs/ntfs3/frecord.c
+++ b/fs/ntfs3/frecord.c
@@ -3215,6 +3215,13 @@ int ni_write_inode(struct inode *inode, int sync, const char *hint)
}
/* Update the access times if they have changed. */
+ ts = ni->i_crtime;
+ dup.cr_time = kernel2nt(&ts);
+ if (std->cr_time != dup.cr_time) {
+ std->cr_time = dup.cr_time;
+ modified = true;
+ }
+
ts = inode_get_mtime(inode);
dup.m_time = kernel2nt(&ts);
if (std->m_time != dup.m_time) {
@@ -3250,7 +3257,6 @@ int ni_write_inode(struct inode *inode, int sync, const char *hint)
(modified || (ni->ni_flags & NI_FLAG_UPDATE_PARENT))
/* Avoid __wait_on_freeing_inode(inode). */
&& (sb->s_flags & SB_ACTIVE)) {
- dup.cr_time = std->cr_time;
/* Not critical if this function fail. */
re_dirty = ni_update_parent(ni, &dup, sync);
--
2.56.0
^ permalink raw reply related [flat|nested] 11+ messages in thread* [RFC PATCH v4 04/10] exfat: make crtime user-settable using ptime
2026-11-15 18:03 [RFC PATCH v4 00/10] add provenance time (ptime) koraynilay
` (2 preceding siblings ...)
2026-11-15 18:03 ` [RFC PATCH v4 03/10] ntfs3: make crtime user-settable using ptime koraynilay
@ 2026-11-15 18:03 ` koraynilay
2026-11-15 18:03 ` [RFC PATCH v4 05/10] btrfs: add provenance time (ptime) koraynilay
` (5 subsequent siblings)
9 siblings, 0 replies; 11+ messages in thread
From: koraynilay @ 2026-11-15 18:03 UTC (permalink / raw)
To: David Sterba, Namjae Jeon, Sungjong Seo, Alexander Viro,
Christian Brauner, Trond Myklebust, Anna Schumaker, Chuck Lever,
Jeff Layton, Konstantin Komarov, Paulo Alcantara
Cc: Chris Mason, Yuezhang Mo, Jan Kara, NeilBrown, Olga Kornievskaia,
Dai Ngo, Tom Talpey, Ronnie Sahlberg, Shyam Prasad N, Bharath SM,
Sergey Senozhatsky, ChenXiaoSong, Darrick J . Wong, Sean Smith,
Andrey Albershteyn, Pedro Falcato, Amir Goldstein,
Pali Rohár, linux-btrfs, linux-kernel, linux-fsdevel, exfat,
ntfs3, linux-cifs, linux-nfs, linux-api, koraynilay
Since exFAT supports user-settable file creation timestamps, map
provenance time (ptime) to exFAT file creation time (crtime) using the
newly introduced ptime API (in commit "vfs: add provenance time
(ptime)").
To do this, implement exfat_fileattr_set(), set .fileattr_set to it for
both file_inode and dir_inode operations and update exfat_fileattr_get()
and exfat_getattr().
The timestamp is now retrievable by using file_getattr() or statx(), and
is settable by using file_setattr() with the FS_XFLAG_PTIME flag.
Assisted-by: Gemini:3.8-flash-high antigravity-cli-1.4.7
Signed-off-by: koraynilay <koray.fra@gmail.com>
---
fs/exfat/exfat_fs.h | 2 ++
fs/exfat/file.c | 42 +++++++++++++++++++++++++++++++++++++++++-
fs/exfat/namei.c | 1 +
3 files changed, 44 insertions(+), 1 deletion(-)
diff --git a/fs/exfat/exfat_fs.h b/fs/exfat/exfat_fs.h
index eee573d1697c..aff96afa258a 100644
--- a/fs/exfat/exfat_fs.h
+++ b/fs/exfat/exfat_fs.h
@@ -619,6 +619,8 @@ int exfat_getattr(const struct mnt_idmap *idmap, const struct path *path,
unsigned int query_flags);
struct file_kattr;
int exfat_fileattr_get(struct dentry *dentry, struct file_kattr *fa);
+int exfat_fileattr_set(const struct mnt_idmap *idmap, struct dentry *dentry,
+ struct file_kattr *fa);
int exfat_file_fsync(struct file *file, loff_t start, loff_t end, int datasync);
long exfat_ioctl(struct file *filp, unsigned int cmd, unsigned long arg);
long exfat_compat_ioctl(struct file *filp, unsigned int cmd,
diff --git a/fs/exfat/file.c b/fs/exfat/file.c
index 435bbef288b8..02390b03eecd 100644
--- a/fs/exfat/file.c
+++ b/fs/exfat/file.c
@@ -384,15 +384,22 @@ int exfat_getattr(const struct mnt_idmap *idmap, const struct path *path,
generic_fillattr(idmap, request_mask, inode, stat);
exfat_truncate_atime(&stat->atime);
- stat->result_mask |= STATX_BTIME;
+ stat->result_mask |= (STATX_BTIME | STATX_PTIME);
stat->btime.tv_sec = ei->i_crtime.tv_sec;
stat->btime.tv_nsec = ei->i_crtime.tv_nsec;
+ stat->ptime.tv_sec = ei->i_crtime.tv_sec;
+ stat->ptime.tv_nsec = ei->i_crtime.tv_nsec;
stat->blksize = EXFAT_SB(inode->i_sb)->cluster_size;
return 0;
}
+#define EXFAT_SUPPORTED_XFLAGS (FS_XFLAG_PTIME)
+
int exfat_fileattr_get(struct dentry *dentry, struct file_kattr *fa)
{
+ struct inode *inode = d_backing_inode(dentry);
+ struct exfat_inode_info *ei = EXFAT_I(inode);
+
/*
* exFAT compares filenames through an upcase table, so lookup
* is always case-insensitive. Long names are stored in UTF-16
@@ -400,6 +407,12 @@ int exfat_fileattr_get(struct dentry *dentry, struct file_kattr *fa)
*/
fa->fsx_xflags |= FS_XFLAG_CASEFOLD;
fa->flags |= FS_CASEFOLD_FL;
+
+ fa->fsx_ptime.tv_sec = ei->i_crtime.tv_sec;
+ fa->fsx_ptime.tv_nsec = ei->i_crtime.tv_nsec;
+ fa->fsx_xflags |= FS_XFLAG_PTIME;
+ fa->fsx_xflags_mask |= FS_XFLAG_PTIME;
+
return 0;
}
@@ -485,6 +498,32 @@ int exfat_setattr(const struct mnt_idmap *idmap, struct dentry *dentry,
return error;
}
+int exfat_fileattr_set(const struct mnt_idmap *idmap, struct dentry *dentry,
+ struct file_kattr *fa)
+{
+ struct inode *inode = d_backing_inode(dentry);
+ struct exfat_inode_info *ei = EXFAT_I(inode);
+
+ if (fileattr_has_fsx_mask(fa, EXFAT_SUPPORTED_XFLAGS))
+ return -EOPNOTSUPP;
+
+ if (fa->fsx_xflags_mask & ~EXFAT_SUPPORTED_XFLAGS)
+ return -EOPNOTSUPP;
+
+ if (fa->flags & ~FS_CASEFOLD_FL)
+ return -EOPNOTSUPP;
+
+ if (fa->fsx_xflags_mask & FS_XFLAG_PTIME) {
+ ei->i_crtime.tv_sec = fa->fsx_ptime.tv_sec;
+ ei->i_crtime.tv_nsec = fa->fsx_ptime.tv_nsec;
+ }
+
+ inode_set_ctime_current(inode);
+ mark_inode_dirty(inode);
+
+ return 0;
+}
+
/*
* modified ioctls from fat/file.c by Welmer Almesberger
*/
@@ -1110,4 +1149,5 @@ const struct inode_operations exfat_file_inode_operations = {
.setattr = exfat_setattr,
.getattr = exfat_getattr,
.fileattr_get = exfat_fileattr_get,
+ .fileattr_set = exfat_fileattr_set,
};
diff --git a/fs/exfat/namei.c b/fs/exfat/namei.c
index 68ddb9c5504f..15ec7f1942c8 100644
--- a/fs/exfat/namei.c
+++ b/fs/exfat/namei.c
@@ -1349,4 +1349,5 @@ const struct inode_operations exfat_dir_inode_operations = {
.setattr = exfat_setattr,
.getattr = exfat_getattr,
.fileattr_get = exfat_fileattr_get,
+ .fileattr_set = exfat_fileattr_set,
};
--
2.56.0
^ permalink raw reply related [flat|nested] 11+ messages in thread* [RFC PATCH v4 05/10] btrfs: add provenance time (ptime)
2026-11-15 18:03 [RFC PATCH v4 00/10] add provenance time (ptime) koraynilay
` (3 preceding siblings ...)
2026-11-15 18:03 ` [RFC PATCH v4 04/10] exfat: " koraynilay
@ 2026-11-15 18:03 ` koraynilay
2026-11-15 18:03 ` [RFC PATCH v4 06/10] vfs: add __vfs_fileattr_set_locked() for inode_lock()'d callers koraynilay
` (4 subsequent siblings)
9 siblings, 0 replies; 11+ messages in thread
From: koraynilay @ 2026-11-15 18:03 UTC (permalink / raw)
To: David Sterba, Namjae Jeon, Sungjong Seo, Alexander Viro,
Christian Brauner, Trond Myklebust, Anna Schumaker, Chuck Lever,
Jeff Layton, Konstantin Komarov, Paulo Alcantara
Cc: Chris Mason, Yuezhang Mo, Jan Kara, NeilBrown, Olga Kornievskaia,
Dai Ngo, Tom Talpey, Ronnie Sahlberg, Shyam Prasad N, Bharath SM,
Sergey Senozhatsky, ChenXiaoSong, Darrick J . Wong, Sean Smith,
Andrey Albershteyn, Pedro Falcato, Amir Goldstein,
Pali Rohár, linux-btrfs, linux-kernel, linux-fsdevel, exfat,
ntfs3, linux-cifs, linux-nfs, linux-api, koraynilay
Implement provenance time (ptime) in Btrfs, as introduced in a
previous commit ("vfs: add provenance time (ptime)").
Update the on-disk format by claiming 12 bytes from the reserved[] space
in btrfs_inode_item, putting ptime before other timestamps. When loading
stale garbage data from disk for ptime, warn (rate-limited) to dmesg.
Advertise support for FS_XFLAG_PTIME using fa_xflags_mask in
btrfs_fileattr_get(), and validate that only supported xflags are
requested in btrfs_fileattr_set() using a newly introduced
BTRFS_SUPPORTED_XFLAGS (containing only FS_XFLAG_PTIME for now).
Also, set .fileattr_[gs]et to btrfs_fileattr_[gs]et() for both symlinks
and special files and reject any other flag update on them with
-EOPNOTSUPP.
Assisted-by: Gemini:3.8-flash-high antigravity-cli-1.4.7
Signed-off-by: koraynilay <koray.fra@gmail.com>
---
fs/btrfs/btrfs_inode.h | 4 ++++
fs/btrfs/delayed-inode.c | 6 ++++++
fs/btrfs/inode.c | 29 ++++++++++++++++++++++++++++-
fs/btrfs/ioctl.c | 24 +++++++++++++++++++++++-
fs/btrfs/print-tree.c | 1 +
fs/btrfs/tree-log.c | 3 +++
include/uapi/linux/btrfs_tree.h | 3 ++-
7 files changed, 67 insertions(+), 3 deletions(-)
diff --git a/fs/btrfs/btrfs_inode.h b/fs/btrfs/btrfs_inode.h
index 0782f917fccc..c9822340567a 100644
--- a/fs/btrfs/btrfs_inode.h
+++ b/fs/btrfs/btrfs_inode.h
@@ -332,6 +332,10 @@ struct btrfs_inode {
u64 i_otime_sec;
u32 i_otime_nsec;
+ /* File *data* creation (provenance) time. */
+ s64 i_ptime_sec;
+ u32 i_ptime_nsec;
+
/* Hook into fs_info->delayed_iputs */
struct list_head delayed_iput;
diff --git a/fs/btrfs/delayed-inode.c b/fs/btrfs/delayed-inode.c
index 333ce8b52489..eef73ebb4a52 100644
--- a/fs/btrfs/delayed-inode.c
+++ b/fs/btrfs/delayed-inode.c
@@ -1932,6 +1932,9 @@ static void fill_stack_inode_item(struct btrfs_trans_handle *trans,
btrfs_set_stack_timespec_sec(&inode_item->otime, inode->i_otime_sec);
btrfs_set_stack_timespec_nsec(&inode_item->otime, inode->i_otime_nsec);
+
+ btrfs_set_stack_timespec_sec(&inode_item->ptime, inode->i_ptime_sec);
+ btrfs_set_stack_timespec_nsec(&inode_item->ptime, inode->i_ptime_nsec);
}
int btrfs_fill_inode(struct btrfs_inode *inode, u32 *rdev)
@@ -1981,6 +1984,9 @@ int btrfs_fill_inode(struct btrfs_inode *inode, u32 *rdev)
inode->i_otime_sec = btrfs_stack_timespec_sec(&inode_item->otime);
inode->i_otime_nsec = btrfs_stack_timespec_nsec(&inode_item->otime);
+ inode->i_ptime_sec = btrfs_stack_timespec_sec(&inode_item->ptime);
+ inode->i_ptime_nsec = btrfs_stack_timespec_nsec(&inode_item->ptime);
+
vfs_inode->i_generation = inode->generation;
if (S_ISDIR(vfs_inode->i_mode))
inode->index_cnt = (u64)-1;
diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index abaa33471456..ff8f7a0caad3 100644
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -4057,6 +4057,17 @@ static int btrfs_read_locked_inode(struct btrfs_inode *inode, struct btrfs_path
inode->i_otime_sec = btrfs_timespec_sec(leaf, &inode_item->otime);
inode->i_otime_nsec = btrfs_timespec_nsec(leaf, &inode_item->otime);
+ inode->i_ptime_sec = btrfs_timespec_sec(leaf, &inode_item->ptime);
+ inode->i_ptime_nsec = btrfs_timespec_nsec(leaf, &inode_item->ptime);
+ /* Avoid old garbage on-disk data making btrfs load a bad value */
+ if (unlikely(inode->i_ptime_nsec >= NSEC_PER_SEC)) {
+ btrfs_warn_rl(fs_info,
+ "invalid ptime.nsec %u on ino %llu from disk, setting ptime to otime",
+ inode->i_ptime_nsec, btrfs_ino(inode));
+ inode->i_ptime_sec = inode->i_otime_sec;
+ inode->i_ptime_nsec = inode->i_otime_nsec;
+ }
+
inode_set_bytes(vfs_inode, btrfs_inode_nbytes(leaf, inode_item));
inode->generation = btrfs_inode_generation(leaf, inode_item);
inode->last_trans = btrfs_inode_transid(leaf, inode_item);
@@ -4249,6 +4260,9 @@ static void fill_inode_item(struct btrfs_trans_handle *trans,
btrfs_set_timespec_sec(leaf, &item->otime, BTRFS_I(inode)->i_otime_sec);
btrfs_set_timespec_nsec(leaf, &item->otime, BTRFS_I(inode)->i_otime_nsec);
+ btrfs_set_timespec_sec(leaf, &item->ptime, BTRFS_I(inode)->i_ptime_sec);
+ btrfs_set_timespec_nsec(leaf, &item->ptime, BTRFS_I(inode)->i_ptime_nsec);
+
btrfs_set_inode_nbytes(leaf, item, inode_get_bytes(inode));
btrfs_set_inode_generation(leaf, item, BTRFS_I(inode)->generation);
btrfs_set_inode_sequence(leaf, item, inode_peek_iversion(inode));
@@ -5988,6 +6002,8 @@ static struct btrfs_inode *new_simple_dir(struct inode *dir,
inode_set_atime_to_ts(vfs_inode, inode_get_atime(dir));
inode->i_otime_sec = ts.tv_sec;
inode->i_otime_nsec = ts.tv_nsec;
+ inode->i_ptime_sec = ts.tv_sec;
+ inode->i_ptime_nsec = ts.tv_nsec;
vfs_inode->i_uid = dir->i_uid;
vfs_inode->i_gid = dir->i_gid;
@@ -6714,6 +6730,8 @@ int btrfs_create_new_inode(struct btrfs_trans_handle *trans,
ts = simple_inode_init_ts(inode);
BTRFS_I(inode)->i_otime_sec = ts.tv_sec;
BTRFS_I(inode)->i_otime_nsec = ts.tv_nsec;
+ BTRFS_I(inode)->i_ptime_sec = ts.tv_sec;
+ BTRFS_I(inode)->i_ptime_nsec = ts.tv_nsec;
/*
* We're going to fill the inode item now, so at this point the inode
@@ -8048,6 +8066,9 @@ struct inode *btrfs_alloc_inode(struct super_block *sb)
ei->i_otime_sec = 0;
ei->i_otime_nsec = 0;
+ ei->i_ptime_sec = 0;
+ ei->i_ptime_nsec = 0;
+
inode = &ei->vfs_inode;
btrfs_extent_map_tree_init(&ei->extent_tree);
@@ -8186,9 +8207,11 @@ static int btrfs_getattr(const struct mnt_idmap *idmap,
u32 blocksize = btrfs_sb(inode->i_sb)->sectorsize;
u32 bi_flags = BTRFS_I(inode)->flags;
- stat->result_mask |= STATX_BTIME;
+ stat->result_mask |= (STATX_BTIME | STATX_PTIME);
stat->btime.tv_sec = BTRFS_I(inode)->i_otime_sec;
stat->btime.tv_nsec = BTRFS_I(inode)->i_otime_nsec;
+ stat->ptime.tv_sec = BTRFS_I(inode)->i_ptime_sec;
+ stat->ptime.tv_nsec = BTRFS_I(inode)->i_ptime_nsec;
if (bi_flags & BTRFS_INODE_APPEND)
stat->attributes |= STATX_ATTR_APPEND;
if (bi_flags & BTRFS_INODE_COMPRESS)
@@ -10779,6 +10802,8 @@ static const struct inode_operations btrfs_special_inode_operations = {
.get_inode_acl = btrfs_get_acl,
.set_acl = btrfs_set_acl,
.update_time = btrfs_update_time,
+ .fileattr_get = btrfs_fileattr_get,
+ .fileattr_set = btrfs_fileattr_set,
};
static const struct inode_operations btrfs_symlink_inode_operations = {
.get_link = page_get_link,
@@ -10787,6 +10812,8 @@ static const struct inode_operations btrfs_symlink_inode_operations = {
.permission = btrfs_permission,
.listxattr = btrfs_listxattr,
.update_time = btrfs_update_time,
+ .fileattr_get = btrfs_fileattr_get,
+ .fileattr_set = btrfs_fileattr_set,
};
const struct dentry_operations btrfs_dentry_operations = {
diff --git a/fs/btrfs/ioctl.c b/fs/btrfs/ioctl.c
index 6ba883db107b..f6c5bf9bf217 100644
--- a/fs/btrfs/ioctl.c
+++ b/fs/btrfs/ioctl.c
@@ -270,11 +270,17 @@ static int btrfs_check_ioctl_vol_args2_subvol_name(const struct btrfs_ioctl_vol_
* Set flags/xflags from the internal inode flags. The remaining items of
* fsxattr are zeroed.
*/
+#define BTRFS_SUPPORTED_XFLAGS (FS_XFLAG_PTIME)
+
int btrfs_fileattr_get(struct dentry *dentry, struct file_kattr *fa)
{
const struct btrfs_inode *inode = BTRFS_I(d_inode(dentry));
fileattr_fill_flags(fa, btrfs_inode_flags_to_fsflags(inode));
+ fa->fsx_ptime.tv_sec = inode->i_ptime_sec;
+ fa->fsx_ptime.tv_nsec = inode->i_ptime_nsec;
+ fa->fsx_xflags |= FS_XFLAG_PTIME;
+ fa->fsx_xflags_mask |= FS_XFLAG_PTIME;
return 0;
}
@@ -294,9 +300,21 @@ int btrfs_fileattr_set(const struct mnt_idmap *idmap,
if (btrfs_root_readonly(root))
return -EROFS;
- if (fileattr_has_fsx(fa))
+ /*
+ * We now support FS_XFLAG_PTIME, so exclude it from the unsupported
+ * check
+ */
+ if (fileattr_has_fsx_mask(fa, BTRFS_SUPPORTED_XFLAGS))
+ return -EOPNOTSUPP;
+
+ if (fa->fsx_xflags_mask & ~BTRFS_SUPPORTED_XFLAGS)
return -EOPNOTSUPP;
+ if (!S_ISREG(inode->vfs_inode.i_mode) && !S_ISDIR(inode->vfs_inode.i_mode)) {
+ if (fa->flags)
+ return -EOPNOTSUPP;
+ }
+
fsflags = btrfs_mask_fsflags_for_type(&inode->vfs_inode, fa->flags);
old_fsflags = btrfs_inode_flags_to_fsflags(inode);
ret = check_fsflags(old_fsflags, fsflags);
@@ -449,6 +467,10 @@ int btrfs_fileattr_set(const struct mnt_idmap *idmap,
}
update_flags:
+ if (!fa->flags_valid && (fa->fsx_xflags_mask & FS_XFLAG_PTIME)) {
+ inode->i_ptime_sec = fa->fsx_ptime.tv_sec;
+ inode->i_ptime_nsec = fa->fsx_ptime.tv_nsec;
+ }
inode->flags = inode_flags;
btrfs_update_inode_mapping_flags(inode);
btrfs_sync_inode_flags_to_i_flags(inode);
diff --git a/fs/btrfs/print-tree.c b/fs/btrfs/print-tree.c
index 53e726119ca7..ba385d0ed9ed 100644
--- a/fs/btrfs/print-tree.c
+++ b/fs/btrfs/print-tree.c
@@ -263,6 +263,7 @@ static void print_inode_item(const struct extent_buffer *eb, int i)
print_timespec(eb, &ii->ctime, "\t\tctime ", "\n");
print_timespec(eb, &ii->mtime, "\t\tmtime ", "\n");
print_timespec(eb, &ii->otime, "\t\totime ", "\n");
+ print_timespec(eb, &ii->ptime, "\t\tptime ", "\n");
}
static void print_dir_item(const struct extent_buffer *eb, int i)
diff --git a/fs/btrfs/tree-log.c b/fs/btrfs/tree-log.c
index 1d9dfb63fc5a..72a4a92b40b9 100644
--- a/fs/btrfs/tree-log.c
+++ b/fs/btrfs/tree-log.c
@@ -4631,6 +4631,9 @@ static void fill_inode_item(struct btrfs_trans_handle *trans,
btrfs_set_timespec_sec(leaf, &item->otime, inode->i_otime_sec);
btrfs_set_timespec_nsec(leaf, &item->otime, inode->i_otime_nsec);
+ btrfs_set_timespec_sec(leaf, &item->ptime, inode->i_ptime_sec);
+ btrfs_set_timespec_nsec(leaf, &item->ptime, inode->i_ptime_nsec);
+
/*
* We do not need to set the nbytes field, in fact during a fast fsync
* its value may not even be correct, since a fast fsync does not wait
diff --git a/include/uapi/linux/btrfs_tree.h b/include/uapi/linux/btrfs_tree.h
index 47ee52859b45..c360b3e95f45 100644
--- a/include/uapi/linux/btrfs_tree.h
+++ b/include/uapi/linux/btrfs_tree.h
@@ -900,7 +900,8 @@ struct btrfs_inode_item {
* a little future expansion, for more than this we can
* just grow the inode item and version it
*/
- __le64 reserved[4];
+ __le32 reserved[5];
+ struct btrfs_timespec ptime;
struct btrfs_timespec atime;
struct btrfs_timespec ctime;
struct btrfs_timespec mtime;
--
2.56.0
^ permalink raw reply related [flat|nested] 11+ messages in thread* [RFC PATCH v4 06/10] vfs: add __vfs_fileattr_set_locked() for inode_lock()'d callers
2026-11-15 18:03 [RFC PATCH v4 00/10] add provenance time (ptime) koraynilay
` (4 preceding siblings ...)
2026-11-15 18:03 ` [RFC PATCH v4 05/10] btrfs: add provenance time (ptime) koraynilay
@ 2026-11-15 18:03 ` koraynilay
2026-11-15 18:03 ` [RFC PATCH v4 07/10] nfsd: add provenance time (ptime) via FATTR4_TIME_CREATE koraynilay
` (3 subsequent siblings)
9 siblings, 0 replies; 11+ messages in thread
From: koraynilay @ 2026-11-15 18:03 UTC (permalink / raw)
To: David Sterba, Namjae Jeon, Sungjong Seo, Alexander Viro,
Christian Brauner, Trond Myklebust, Anna Schumaker, Chuck Lever,
Jeff Layton, Konstantin Komarov, Paulo Alcantara
Cc: Chris Mason, Yuezhang Mo, Jan Kara, NeilBrown, Olga Kornievskaia,
Dai Ngo, Tom Talpey, Ronnie Sahlberg, Shyam Prasad N, Bharath SM,
Sergey Senozhatsky, ChenXiaoSong, Darrick J . Wong, Sean Smith,
Andrey Albershteyn, Pedro Falcato, Amir Goldstein,
Pali Rohár, linux-btrfs, linux-kernel, linux-fsdevel, exfat,
ntfs3, linux-cifs, linux-nfs, linux-api, koraynilay
Currently there is no way for a caller to invoke vfs_fileattr_set()
while holding an inode lock without having the kernel go into deadlock.
Fix this by moving the vfs_fileattr_set() logic into
__vfs_fileattr_set_locked() and making vfs_fileattr_set() a simple
wrapper that only handles the inode lock.
Assisted-by: Gemini:3.8-flash-high antigravity-cli-1.5.7
Signed-off-by: koraynilay <koray.fra@gmail.com>
---
fs/file_attr.c | 139 +++++++++++++++++++++++----------------
include/linux/fileattr.h | 2 +
2 files changed, 86 insertions(+), 55 deletions(-)
diff --git a/fs/file_attr.c b/fs/file_attr.c
index 12610fb6a751..063c81fbfa6a 100644
--- a/fs/file_attr.c
+++ b/fs/file_attr.c
@@ -288,6 +288,89 @@ static int fileattr_set_prepare(struct inode *inode,
return 0;
}
+/**
+ * __vfs_fileattr_set_locked - change miscellaneous file attributes while
+ * holding the inode lock
+ *
+ * @idmap: idmap of the mount
+ * @dentry: the object to change
+ * @fa: fileattr pointer
+ *
+ * Same as vfs_fileattr_set(), but caller must hold the inode lock.
+ *
+ * Return: 0 on success, or a negative error on failure.
+ */
+int __vfs_fileattr_set_locked(const struct mnt_idmap *idmap, struct dentry *dentry,
+ struct file_kattr *fa)
+{
+ struct inode *inode = d_inode(dentry);
+ struct file_kattr old_ma = {};
+ int err;
+
+ if (!inode->i_op->fileattr_set)
+ return -ENOIOCTLCMD;
+
+ if (!inode_owner_or_capable(idmap, inode))
+ return -EPERM;
+
+ err = vfs_fileattr_get(dentry, &old_ma);
+ if (err)
+ return err;
+
+ /* initialize missing bits from old_ma */
+ if (fa->flags_valid) {
+ /* FS_IOC_SETFLAGS */
+ fa->fsx_xflags |= (old_ma.fsx_xflags & FS_XFLAGS_MASK) &
+ ~FS_XFLAG_COMMON;
+ fa->fsx_extsize = old_ma.fsx_extsize;
+ fa->fsx_nextents = old_ma.fsx_nextents;
+ fa->fsx_projid = old_ma.fsx_projid;
+ fa->fsx_cowextsize = old_ma.fsx_cowextsize;
+ fa->fsx_ptime = old_ma.fsx_ptime;
+ } else {
+ /*
+ * Preserve unmasked xflags when running file_setattr()
+ * with a mask, which doesn't need a read-modify-write
+ * so these attributes would be set to 0.
+ *
+ * With FS_IOC_FSSETXATTR or mask == 0 (legacy mode)
+ * this is not needed as userspace does
+ * read-modify-write already.
+ */
+ if (fa->fsx_xflags_mask) {
+ fa->fsx_xflags |= old_ma.fsx_xflags &
+ ~fa->fsx_xflags_mask;
+ fileattr_fill_xflags(fa, fa->fsx_xflags &
+ ~FS_XFLAG_RDONLY_MASK);
+ if (!(fa->fsx_xflags_mask & FS_XFLAG_EXTSIZE))
+ fa->fsx_extsize = old_ma.fsx_extsize;
+ if (!(fa->fsx_xflags_mask & FS_XFLAG_PROJID))
+ fa->fsx_projid = old_ma.fsx_projid;
+ if (!(fa->fsx_xflags_mask & FS_XFLAG_COWEXTSIZE))
+ fa->fsx_cowextsize = old_ma.fsx_cowextsize;
+ }
+ fa->flags |= old_ma.flags & ~FS_COMMON_FL;
+
+ /* xflags not present in fsxattr */
+ if (!(fa->fsx_xflags_mask & FS_XFLAG_PTIME))
+ fa->fsx_ptime = old_ma.fsx_ptime;
+ }
+
+ err = fileattr_set_prepare(inode, &old_ma, fa);
+ if (err)
+ return err;
+ err = security_inode_file_setattr(dentry, fa);
+ if (err)
+ return err;
+ err = inode->i_op->fileattr_set(idmap, dentry, fa);
+ if (err)
+ return err;
+ fsnotify_xattr(dentry);
+
+ return 0;
+}
+EXPORT_SYMBOL(__vfs_fileattr_set_locked);
+
/**
* vfs_fileattr_set - change miscellaneous file attributes
* @idmap: idmap of the mount
@@ -308,7 +391,6 @@ int vfs_fileattr_set(const struct mnt_idmap *idmap, struct dentry *dentry,
struct file_kattr *fa)
{
struct inode *inode = d_inode(dentry);
- struct file_kattr old_ma = {};
int err;
if (!inode->i_op->fileattr_set)
@@ -318,60 +400,7 @@ int vfs_fileattr_set(const struct mnt_idmap *idmap, struct dentry *dentry,
return -EPERM;
inode_lock(inode);
- err = vfs_fileattr_get(dentry, &old_ma);
- if (!err) {
- /* initialize missing bits from old_ma */
- if (fa->flags_valid) {
- /* FS_IOC_SETFLAGS */
- fa->fsx_xflags |= (old_ma.fsx_xflags & FS_XFLAGS_MASK) &
- ~FS_XFLAG_COMMON;
- fa->fsx_extsize = old_ma.fsx_extsize;
- fa->fsx_nextents = old_ma.fsx_nextents;
- fa->fsx_projid = old_ma.fsx_projid;
- fa->fsx_cowextsize = old_ma.fsx_cowextsize;
- fa->fsx_ptime = old_ma.fsx_ptime;
- } else {
- /*
- * Preserve unmasked xflags when running file_setattr()
- * with a mask, which doesn't need a read-modify-write
- * so these attributes would be set to 0.
- *
- * With FS_IOC_FSSETXATTR or mask == 0 (legacy mode)
- * this is not needed as userspace does
- * read-modify-write already.
- */
- if (fa->fsx_xflags_mask) {
- fa->fsx_xflags |= old_ma.fsx_xflags &
- ~fa->fsx_xflags_mask;
- fileattr_fill_xflags(fa, fa->fsx_xflags &
- ~FS_XFLAG_RDONLY_MASK);
- if (!(fa->fsx_xflags_mask & FS_XFLAG_EXTSIZE))
- fa->fsx_extsize = old_ma.fsx_extsize;
- if (!(fa->fsx_xflags_mask & FS_XFLAG_PROJID))
- fa->fsx_projid = old_ma.fsx_projid;
- if (!(fa->fsx_xflags_mask & FS_XFLAG_COWEXTSIZE))
- fa->fsx_cowextsize = old_ma.fsx_cowextsize;
- }
- fa->flags |= old_ma.flags & ~FS_COMMON_FL;
-
- /* xflags not present in fsxattr */
- if (!(fa->fsx_xflags_mask & FS_XFLAG_PTIME))
- fa->fsx_ptime = old_ma.fsx_ptime;
- }
-
- err = fileattr_set_prepare(inode, &old_ma, fa);
- if (err)
- goto out;
- err = security_inode_file_setattr(dentry, fa);
- if (err)
- goto out;
- err = inode->i_op->fileattr_set(idmap, dentry, fa);
- if (err)
- goto out;
- fsnotify_xattr(dentry);
- }
-
-out:
+ err = __vfs_fileattr_set_locked(idmap, dentry, fa);
inode_unlock(inode);
return err;
}
diff --git a/include/linux/fileattr.h b/include/linux/fileattr.h
index ba7ed3b387d8..7ff62ee27e58 100644
--- a/include/linux/fileattr.h
+++ b/include/linux/fileattr.h
@@ -97,6 +97,8 @@ static inline bool fileattr_has_fsx(const struct file_kattr *fa)
int vfs_fileattr_get(struct dentry *dentry, struct file_kattr *fa);
int vfs_fileattr_set(const struct mnt_idmap *idmap, struct dentry *dentry,
struct file_kattr *fa);
+int __vfs_fileattr_set_locked(const struct mnt_idmap *idmap, struct dentry *dentry,
+ struct file_kattr *fa);
int ioctl_getflags(struct file *file, unsigned int __user *argp);
int ioctl_setflags(struct file *file, unsigned int __user *argp);
int ioctl_fsgetxattr(struct file *file, void __user *argp);
--
2.56.0
^ permalink raw reply related [flat|nested] 11+ messages in thread* [RFC PATCH v4 07/10] nfsd: add provenance time (ptime) via FATTR4_TIME_CREATE
2026-11-15 18:03 [RFC PATCH v4 00/10] add provenance time (ptime) koraynilay
` (5 preceding siblings ...)
2026-11-15 18:03 ` [RFC PATCH v4 06/10] vfs: add __vfs_fileattr_set_locked() for inode_lock()'d callers koraynilay
@ 2026-11-15 18:03 ` koraynilay
2026-11-15 18:03 ` [RFC PATCH v4 08/10] nfs: " koraynilay
` (2 subsequent siblings)
9 siblings, 0 replies; 11+ messages in thread
From: koraynilay @ 2026-11-15 18:03 UTC (permalink / raw)
To: David Sterba, Namjae Jeon, Sungjong Seo, Alexander Viro,
Christian Brauner, Trond Myklebust, Anna Schumaker, Chuck Lever,
Jeff Layton, Konstantin Komarov, Paulo Alcantara
Cc: Chris Mason, Yuezhang Mo, Jan Kara, NeilBrown, Olga Kornievskaia,
Dai Ngo, Tom Talpey, Ronnie Sahlberg, Shyam Prasad N, Bharath SM,
Sergey Senozhatsky, ChenXiaoSong, Darrick J . Wong, Sean Smith,
Andrey Albershteyn, Pedro Falcato, Amir Goldstein,
Pali Rohár, linux-btrfs, linux-kernel, linux-fsdevel, exfat,
ntfs3, linux-cifs, linux-nfs, linux-api, koraynilay
Implement provenance time (ptime) in NFSD, as introduced in a
previous commit ("vfs: add provenance time (ptime)").
Map ptime to FATTR4_TIME_CREATE, allowing clients to set it across
CREATE, OPEN and SETATTR compounds.
If the underlying filesystem supports it, use __vfs_fileattr_set_locked()
to set it, returning -EOPNOTSUPP in case it's not supported (i.e. when
__vfs_fileattr_set_locked() returns -ENOIOCTLCMD).
When querying FATTR4_TIME_CREATE, request both STATX_PTIME and
STATX_BTIME, preferring ptime over btime if available, and advertise
FATTR4_TIME_CREATE support if either ptime or btime is available.
Assisted-by: Gemini:3.8-flash-high antigravity-cli-1.5.7
Signed-off-by: koraynilay <koray.fra@gmail.com>
---
fs/nfsd/nfs4proc.c | 9 +++++++++
fs/nfsd/nfs4xdr.c | 40 +++++++++++++++++++++++++---------------
fs/nfsd/vfs.c | 17 +++++++++++++++++
fs/nfsd/vfs.h | 4 +++-
fs/nfsd/xdr4.h | 3 +++
5 files changed, 57 insertions(+), 16 deletions(-)
diff --git a/fs/nfsd/nfs4proc.c b/fs/nfsd/nfs4proc.c
index 3a82af381a8d..06074a7f213e 100644
--- a/fs/nfsd/nfs4proc.c
+++ b/fs/nfsd/nfs4proc.c
@@ -322,6 +322,9 @@ nfsd4_create_file(struct svc_rqst *rqstp, struct svc_fh *fhp,
__be32 status, create_status;
int want_write_err;
+ if (open->op_bmval[1] & FATTR4_WORD1_TIME_CREATE)
+ attrs.na_time_create = &open->op_time_create;
+
if (name_is_dot_dotdot(open->op_fname, open->op_fnamelen))
return nfserr_exist;
if (!(iap->ia_valid & ATTR_MODE))
@@ -929,6 +932,9 @@ nfsd4_create(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
__be32 status;
dev_t rdev;
+ if (create->cr_bmval[1] & FATTR4_WORD1_TIME_CREATE)
+ attrs.na_time_create = &create->cr_time_create;
+
fh_init(&resfh, NFS4_FHSIZE);
status = fh_verify(rqstp, &cstate->current_fh, S_IFDIR, NFSD_MAY_NOP);
@@ -1347,6 +1353,9 @@ nfsd4_setattr(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
__be32 status = nfs_ok;
int err;
+ if (setattr->sa_bmval[1] & FATTR4_WORD1_TIME_CREATE)
+ attrs.na_time_create = &setattr->sa_time_create;
+
deleg_attrs = setattr->sa_bmval[2] & (FATTR4_WORD2_TIME_DELEG_ACCESS |
FATTR4_WORD2_TIME_DELEG_MODIFY);
diff --git a/fs/nfsd/nfs4xdr.c b/fs/nfsd/nfs4xdr.c
index 84161dbecd1c..faca3b9b58b8 100644
--- a/fs/nfsd/nfs4xdr.c
+++ b/fs/nfsd/nfs4xdr.c
@@ -509,7 +509,8 @@ static __be32
nfsd4_decode_fattr4(struct nfsd4_compoundargs *argp, u32 *bmval, u32 bmlen,
struct iattr *iattr, struct nfs4_acl **acl,
struct xdr_netobj *label, int *umask,
- struct posix_acl **dpaclp, struct posix_acl **paclp)
+ struct posix_acl **dpaclp, struct posix_acl **paclp,
+ struct timespec64 *time_create)
{
unsigned int starting_pos;
u32 attrlist4_count;
@@ -603,11 +604,10 @@ nfsd4_decode_fattr4(struct nfsd4_compoundargs *argp, u32 *bmval, u32 bmlen,
}
}
if (bmval[1] & FATTR4_WORD1_TIME_CREATE) {
- struct timespec64 ts;
+ if (!time_create)
+ return nfserr_bad_xdr;
- /* No Linux filesystem supports setting this attribute. */
- bmval[1] &= ~FATTR4_WORD1_TIME_CREATE;
- status = nfsd4_decode_nfstime4(argp, &ts);
+ status = nfsd4_decode_nfstime4(argp, time_create);
if (status)
return status;
}
@@ -1013,7 +1013,8 @@ nfsd4_decode_create(struct nfsd4_compoundargs *argp, union nfsd4_op_u *u)
ARRAY_SIZE(create->cr_bmval),
&create->cr_iattr, &create->cr_acl,
&create->cr_label, &create->cr_umask,
- &create->cr_dpacl, &create->cr_pacl);
+ &create->cr_dpacl, &create->cr_pacl,
+ &create->cr_time_create);
if (status)
return status;
@@ -1165,7 +1166,8 @@ nfsd4_decode_createhow4(struct nfsd4_compoundargs *argp, struct nfsd4_open *open
ARRAY_SIZE(open->op_bmval),
&open->op_iattr, &open->op_acl,
&open->op_label, &open->op_umask,
- &open->op_dpacl, &open->op_pacl);
+ &open->op_dpacl, &open->op_pacl,
+ &open->op_time_create);
if (status)
return status;
break;
@@ -1184,7 +1186,8 @@ nfsd4_decode_createhow4(struct nfsd4_compoundargs *argp, struct nfsd4_open *open
ARRAY_SIZE(open->op_bmval),
&open->op_iattr, &open->op_acl,
&open->op_label, &open->op_umask,
- &open->op_dpacl, &open->op_pacl);
+ &open->op_dpacl, &open->op_pacl,
+ &open->op_time_create);
if (status)
return status;
break;
@@ -1512,7 +1515,7 @@ nfsd4_decode_setattr(struct nfsd4_compoundargs *argp, union nfsd4_op_u *u)
ARRAY_SIZE(setattr->sa_bmval),
&setattr->sa_iattr, &setattr->sa_acl,
&setattr->sa_label, NULL, &setattr->sa_dpacl,
- &setattr->sa_pacl);
+ &setattr->sa_pacl, &setattr->sa_time_create);
}
static __be32
@@ -3646,7 +3649,14 @@ static __be32 nfsd4_encode_fattr4_time_access(struct xdr_stream *xdr,
static __be32 nfsd4_encode_fattr4_time_create(struct xdr_stream *xdr,
const struct nfsd4_fattr_args *args)
{
- return nfsd4_encode_nfstime4(xdr, &args->stat.btime);
+ const struct timespec64 *ts;
+
+ if (args->stat.result_mask & STATX_PTIME)
+ ts = &args->stat.ptime;
+ else
+ ts = &args->stat.btime;
+
+ return nfsd4_encode_nfstime4(xdr, ts);
}
/*
@@ -4089,8 +4099,8 @@ nfsd4_encode_fattr4(struct svc_rqst *rqstp, struct xdr_stream *xdr,
}
err = vfs_getattr(&path, &args.stat,
- STATX_BASIC_STATS | STATX_BTIME | STATX_CHANGE_COOKIE,
- AT_STATX_SYNC_AS_STAT);
+ STATX_BASIC_STATS | STATX_BTIME | STATX_PTIME |
+ STATX_CHANGE_COOKIE, AT_STATX_SYNC_AS_STAT);
if (dp) {
struct nfs4_cb_fattr *ncf = &dp->dl_cb_fattr;
@@ -4113,8 +4123,8 @@ nfsd4_encode_fattr4(struct svc_rqst *rqstp, struct xdr_stream *xdr,
if (err)
goto out_nfserr;
- if (!(args.stat.result_mask & STATX_BTIME))
- /* underlying FS does not offer btime so we can't share it */
+ if (!(args.stat.result_mask & (STATX_BTIME | STATX_PTIME)))
+ /* underlying FS does not offer ptime or btime so we can't share it */
attrmask[1] &= ~FATTR4_WORD1_TIME_CREATE;
if ((attrmask[0] & (FATTR4_WORD0_FILES_AVAIL | FATTR4_WORD0_FILES_FREE |
FATTR4_WORD0_FILES_TOTAL | FATTR4_WORD0_MAXNAME)) ||
@@ -4434,7 +4444,7 @@ nfsd4_setup_notify_entry4(struct notify_entry4 *ne, struct xdr_stream *xdr,
if (!setup_notify_fhandle(dentry, dp, nf, &args))
attrmask[0] &= ~FATTR4_WORD0_FILEHANDLE;
- if (!(args.stat.result_mask & STATX_BTIME))
+ if (!(args.stat.result_mask & (STATX_PTIME | STATX_BTIME)))
attrmask[1] &= ~FATTR4_WORD1_TIME_CREATE;
}
attrmask[2] = 0;
diff --git a/fs/nfsd/vfs.c b/fs/nfsd/vfs.c
index 56c49b5bc5bb..286ed7c98d91 100644
--- a/fs/nfsd/vfs.c
+++ b/fs/nfsd/vfs.c
@@ -621,6 +621,23 @@ nfsd_setattr(struct svc_rqst *rqstp, struct svc_fh *fhp,
if (attr->na_seclabel && attr->na_seclabel->len)
attr->na_labelerr = security_inode_setsecctx(dentry,
attr->na_seclabel->data, attr->na_seclabel->len);
+
+ if (attr->na_time_create) {
+ struct file_kattr fa = {
+ .fsx_valid = true,
+ .fsx_xflags = FS_XFLAG_PTIME,
+ .fsx_xflags_mask = FS_XFLAG_PTIME,
+ .fsx_ptime = *attr->na_time_create,
+ };
+
+ host_err = __vfs_fileattr_set_locked(&nop_mnt_idmap, dentry, &fa);
+ if (host_err) {
+ if (host_err == -ENOIOCTLCMD)
+ host_err = -EOPNOTSUPP;
+ goto out_fill_attrs;
+ }
+ }
+
if (IS_ENABLED(CONFIG_FS_POSIX_ACL) && attr->na_dpacl) {
if (!S_ISDIR(inode->i_mode))
attr->na_dpaclerr = -EINVAL;
diff --git a/fs/nfsd/vfs.h b/fs/nfsd/vfs.h
index 38f7d36bd4da..24c2c22b3e72 100644
--- a/fs/nfsd/vfs.h
+++ b/fs/nfsd/vfs.h
@@ -100,6 +100,7 @@ struct nfsd_attrs {
struct xdr_netobj *na_seclabel; /* input */
struct posix_acl *na_pacl; /* input */
struct posix_acl *na_dpacl; /* input */
+ struct timespec64 *na_time_create; /* input */
int na_labelerr; /* output */
int na_dpaclerr; /* output */
@@ -118,7 +119,8 @@ static inline bool nfsd_attrs_valid(struct nfsd_attrs *attrs)
return (iap->ia_valid || (attrs->na_seclabel &&
attrs->na_seclabel->len) ||
- attrs->na_pacl || attrs->na_dpacl);
+ attrs->na_pacl || attrs->na_dpacl ||
+ attrs->na_time_create);
}
struct nfsd_net;
diff --git a/fs/nfsd/xdr4.h b/fs/nfsd/xdr4.h
index ec198993429e..a495a20e5889 100644
--- a/fs/nfsd/xdr4.h
+++ b/fs/nfsd/xdr4.h
@@ -123,6 +123,7 @@ struct nfsd4_create {
struct posix_acl *cr_dpacl;
struct posix_acl *cr_pacl;
struct xdr_netobj cr_label;
+ struct timespec64 cr_time_create;
};
#define cr_datalen u.link.datalen
#define cr_data u.link.data
@@ -277,6 +278,7 @@ struct nfsd4_open {
struct posix_acl *op_dpacl;
struct posix_acl *op_pacl;
struct xdr_netobj op_label;
+ struct timespec64 op_time_create;
struct svc_rqst *op_rqstp;
};
@@ -378,6 +380,7 @@ struct nfsd4_setattr {
struct xdr_netobj sa_label;
struct posix_acl *sa_dpacl;
struct posix_acl *sa_pacl;
+ struct timespec64 sa_time_create;
};
struct nfsd4_setclientid {
--
2.56.0
^ permalink raw reply related [flat|nested] 11+ messages in thread* [RFC PATCH v4 08/10] nfs: add provenance time (ptime) via FATTR4_TIME_CREATE
2026-11-15 18:03 [RFC PATCH v4 00/10] add provenance time (ptime) koraynilay
` (6 preceding siblings ...)
2026-11-15 18:03 ` [RFC PATCH v4 07/10] nfsd: add provenance time (ptime) via FATTR4_TIME_CREATE koraynilay
@ 2026-11-15 18:03 ` koraynilay
2026-11-15 18:03 ` [RFC PATCH v4 09/10] ksmbd: add provenance time (ptime) and map it to CreationTime koraynilay
2026-11-15 18:03 ` [RFC PATCH v4 10/10] cifs: add provenance time (ptime) and map it to SMB's CreationTime koraynilay
9 siblings, 0 replies; 11+ messages in thread
From: koraynilay @ 2026-11-15 18:03 UTC (permalink / raw)
To: David Sterba, Namjae Jeon, Sungjong Seo, Alexander Viro,
Christian Brauner, Trond Myklebust, Anna Schumaker, Chuck Lever,
Jeff Layton, Konstantin Komarov, Paulo Alcantara
Cc: Chris Mason, Yuezhang Mo, Jan Kara, NeilBrown, Olga Kornievskaia,
Dai Ngo, Tom Talpey, Ronnie Sahlberg, Shyam Prasad N, Bharath SM,
Sergey Senozhatsky, ChenXiaoSong, Darrick J . Wong, Sean Smith,
Andrey Albershteyn, Pedro Falcato, Amir Goldstein,
Pali Rohár, linux-btrfs, linux-kernel, linux-fsdevel, exfat,
ntfs3, linux-cifs, linux-nfs, linux-api, koraynilay
Implement provenance time (ptime) in the NFS client, as introduced in a
previous commit ("vfs: add provenance time (ptime)").
Support reading ptime via statx(2) and file_getattr(), returning the
cached creation time when the server advertises NFS_ATTR_FATTR_BTIME.
Implement sending FATTR4_TIME_CREATE, asking the server to persist the
file creation time using ptime on the underlying filesystem.
Also add .fileattr_set to struct nfs_rpc_ops and set it to
nfs4_fileattr_set() in nfs_v4_clientops. Provide a generic
nfs_fileattr_set() dispatcher so even symlinks can update ptime under
NFSv4 while cleanly returning -EOPNOTSUPP on NFSv2/v3.
Assisted-by: Gemini:3.8-flash-high antigravity-cli-1.5.7
Signed-off-by: koraynilay <koray.fra@gmail.com>
---
fs/nfs/inode.c | 27 ++++++++++++++++----
fs/nfs/internal.h | 2 ++
fs/nfs/nfs4proc.c | 56 ++++++++++++++++++++++++++++++++++++++---
fs/nfs/nfs4xdr.c | 19 +++++++++-----
fs/nfs/symlink.c | 1 +
include/linux/nfs_xdr.h | 3 +++
6 files changed, 93 insertions(+), 15 deletions(-)
diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c
index e0a2e92952af..2ddcfd872616 100644
--- a/fs/nfs/inode.c
+++ b/fs/nfs/inode.c
@@ -955,7 +955,7 @@ static u32 nfs_get_valid_attrmask(struct inode *inode)
reply_mask |= STATX_BLOCKS;
if (!(cache_validity & NFS_INO_INVALID_BTIME) &&
(fattr_valid & NFS_ATTR_FATTR_BTIME))
- reply_mask |= STATX_BTIME;
+ reply_mask |= STATX_BTIME | STATX_PTIME;
if (!(cache_validity & NFS_INO_INVALID_CHANGE))
reply_mask |= STATX_CHANGE_COOKIE;
return reply_mask;
@@ -978,10 +978,10 @@ int nfs_getattr(const struct mnt_idmap *idmap, const struct path *path,
request_mask &= STATX_TYPE | STATX_MODE | STATX_NLINK | STATX_UID |
STATX_GID | STATX_ATIME | STATX_MTIME | STATX_CTIME |
STATX_INO | STATX_SIZE | STATX_BLOCKS | STATX_BTIME |
- STATX_CHANGE_COOKIE;
+ STATX_PTIME | STATX_CHANGE_COOKIE;
if (!(fattr_valid & NFS_ATTR_FATTR_BTIME))
- request_mask &= ~STATX_BTIME;
+ request_mask &= ~(STATX_BTIME | STATX_PTIME);
if ((query_flags & AT_STATX_DONT_SYNC) && !force_sync) {
if (readdirplus_enabled)
@@ -1015,7 +1015,7 @@ int nfs_getattr(const struct mnt_idmap *idmap, const struct path *path,
if (!(request_mask & (STATX_MODE|STATX_NLINK|STATX_ATIME|STATX_CTIME|
STATX_MTIME|STATX_UID|STATX_GID|
STATX_SIZE|STATX_BLOCKS|STATX_BTIME|
- STATX_CHANGE_COOKIE)))
+ STATX_PTIME|STATX_CHANGE_COOKIE)))
goto out_no_revalidate;
/* Check whether the cached attributes are stale */
@@ -1038,7 +1038,7 @@ int nfs_getattr(const struct mnt_idmap *idmap, const struct path *path,
do_update |= cache_validity & NFS_INO_INVALID_OTHER;
if (request_mask & STATX_BLOCKS)
do_update |= cache_validity & NFS_INO_INVALID_BLOCKS;
- if (request_mask & STATX_BTIME)
+ if (request_mask & (STATX_BTIME | STATX_PTIME))
do_update |= cache_validity & NFS_INO_INVALID_BTIME;
if (do_update) {
@@ -1061,6 +1061,7 @@ int nfs_getattr(const struct mnt_idmap *idmap, const struct path *path,
if (S_ISDIR(inode->i_mode))
stat->blksize = NFS_SERVER(inode)->dtsize;
stat->btime = NFS_I(inode)->btime;
+ stat->ptime = NFS_I(inode)->btime;
/* Special handling for STATX_DIOALIGN and STATX_DIO_READ_ALIGN
* - NFS doesn't have DIO alignment constraints, avoid getting
@@ -1092,10 +1093,26 @@ int nfs_fileattr_get(struct dentry *dentry, struct file_kattr *fa)
}
if (nfs_server_capable(inode, NFS_CAP_CASE_NONPRESERVING))
fa->fsx_xflags |= FS_XFLAG_CASENONPRESERVING;
+ if (NFS_SERVER(inode)->fattr_valid & NFS_ATTR_FATTR_BTIME) {
+ fa->fsx_xflags |= FS_XFLAG_PTIME;
+ fa->fsx_xflags_mask |= FS_XFLAG_PTIME;
+ fa->fsx_ptime = NFS_I(inode)->btime;
+ }
return 0;
}
EXPORT_SYMBOL_GPL(nfs_fileattr_get);
+int nfs_fileattr_set(const struct mnt_idmap *idmap, struct dentry *dentry,
+ struct file_kattr *fa)
+{
+ const struct nfs_rpc_ops *ops = NFS_PROTO(d_inode(dentry));
+
+ if (ops->fileattr_set)
+ return ops->fileattr_set(idmap, dentry, fa);
+ return -EOPNOTSUPP;
+}
+EXPORT_SYMBOL_GPL(nfs_fileattr_set);
+
static void nfs_init_lock_context(struct nfs_lock_context *l_ctx)
{
refcount_set(&l_ctx->count, 1);
diff --git a/fs/nfs/internal.h b/fs/nfs/internal.h
index 5af6a032f145..0e47fad944de 100644
--- a/fs/nfs/internal.h
+++ b/fs/nfs/internal.h
@@ -458,6 +458,8 @@ extern int nfs_wait_bit_killable(struct wait_bit_key *key, int mode);
struct file_kattr;
int nfs_fileattr_get(struct dentry *dentry, struct file_kattr *fa);
+int nfs_fileattr_set(const struct mnt_idmap *idmap, struct dentry *dentry,
+ struct file_kattr *fa);
#if IS_ENABLED(CONFIG_NFS_LOCALIO)
/* localio.c */
diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
index e1018b03c1cb..31d58ceb4dc0 100644
--- a/fs/nfs/nfs4proc.c
+++ b/fs/nfs/nfs4proc.c
@@ -55,6 +55,7 @@
#include <linux/utsname.h>
#include <linux/freezer.h>
#include <linux/iversion.h>
+#include <linux/fileattr.h>
#include "nfs4_fs.h"
#include "delegation.h"
@@ -98,7 +99,8 @@ static int _nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle,
struct nfs_fattr *fattr, struct inode *inode);
static int nfs4_do_setattr(struct inode *inode, const struct cred *cred,
struct nfs_fattr *fattr, struct iattr *sattr,
- struct nfs_open_context *ctx, struct nfs4_label *ilabel);
+ struct nfs_open_context *ctx, struct nfs4_label *ilabel,
+ const struct timespec64 *time_create);
static struct rpc_task *_nfs41_proc_sequence(struct nfs_client *clp,
const struct cred *cred,
struct nfs4_slot *slot,
@@ -3216,7 +3218,7 @@ static int _nfs4_do_open(struct inode *dir,
nfs_fattr_init(opendata->o_res.f_attr);
status = nfs4_do_setattr(state->inode, cred,
opendata->o_res.f_attr, sattr,
- ctx, label);
+ ctx, label, NULL);
if (status == 0) {
nfs_setattr_update_inode(state->inode, sattr,
opendata->o_res.f_attr);
@@ -3380,7 +3382,8 @@ static int _nfs4_do_setattr(struct inode *inode,
static int nfs4_do_setattr(struct inode *inode, const struct cred *cred,
struct nfs_fattr *fattr, struct iattr *sattr,
- struct nfs_open_context *ctx, struct nfs4_label *ilabel)
+ struct nfs_open_context *ctx, struct nfs4_label *ilabel,
+ const struct timespec64 *time_create)
{
struct nfs_server *server = NFS_SERVER(inode);
__u32 bitmask[NFS4_BITMASK_SZ];
@@ -3391,6 +3394,7 @@ static int nfs4_do_setattr(struct inode *inode, const struct cred *cred,
.server = server,
.bitmask = bitmask,
.label = ilabel,
+ .time_create = time_create,
};
struct nfs_setattrres res = {
.fattr = fattr,
@@ -3414,6 +3418,9 @@ static int nfs4_do_setattr(struct inode *inode, const struct cred *cred,
if (sattr->ia_valid & ATTR_MTIME)
adjust_flags |= NFS_INO_INVALID_MTIME;
+ if (time_create)
+ adjust_flags |= NFS_INO_INVALID_BTIME;
+
do {
nfs4_bitmap_copy_adjust(bitmask, nfs4_bitmask(server, fattr->label),
inode, adjust_flags);
@@ -4587,7 +4594,7 @@ nfs4_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr,
if ((sattr->ia_valid & (ATTR_MODE|ATTR_UID|ATTR_GID)) != 0)
nfs4_inode_make_writeable(inode);
- status = nfs4_do_setattr(inode, cred, fattr, sattr, ctx, NULL);
+ status = nfs4_do_setattr(inode, cred, fattr, sattr, ctx, NULL, NULL);
if (status == 0) {
nfs_setattr_update_inode(inode, sattr, fattr);
nfs_setsecurity(inode, fattr);
@@ -10845,6 +10852,44 @@ static void nfs4_disable_swap(struct inode *inode)
wake_up_var(&clp->cl_state);
}
+#define NFS4_SUPPORTED_XFLAGS (FS_XFLAG_PTIME)
+static int nfs4_fileattr_set(const struct mnt_idmap *idmap, struct dentry *dentry,
+ struct file_kattr *fa)
+{
+ struct inode *inode = d_inode(dentry);
+ struct nfs_server *server = NFS_SERVER(inode);
+ struct nfs_fattr *fattr;
+ struct iattr sattr = { .ia_valid = 0 };
+ const struct timespec64 *time_create = NULL;
+ int error;
+
+ if (!(server->fattr_valid & NFS_ATTR_FATTR_BTIME))
+ return -EOPNOTSUPP;
+
+ if (fa->flags_valid)
+ return -EOPNOTSUPP;
+
+ if (fileattr_has_fsx_mask(fa, NFS4_SUPPORTED_XFLAGS))
+ return -EOPNOTSUPP;
+
+ if (fa->fsx_xflags_mask & ~NFS4_SUPPORTED_XFLAGS)
+ return -EOPNOTSUPP;
+
+ if (fa->fsx_xflags_mask & FS_XFLAG_PTIME)
+ time_create = &fa->fsx_ptime;
+
+ fattr = nfs_alloc_fattr_with_label(server);
+ if (!fattr)
+ return -ENOMEM;
+
+ error = nfs4_do_setattr(inode, NULL, fattr, &sattr, NULL, NULL, time_create);
+ if (error == 0)
+ nfs_refresh_inode(inode, fattr);
+
+ nfs_free_fattr(fattr);
+ return error;
+}
+
static const struct inode_operations nfs4_dir_inode_operations = {
.create = nfs_create,
.lookup = nfs_lookup,
@@ -10861,6 +10906,7 @@ static const struct inode_operations nfs4_dir_inode_operations = {
.setattr = nfs_setattr,
.listxattr = nfs4_listxattr,
.fileattr_get = nfs_fileattr_get,
+ .fileattr_set = nfs4_fileattr_set,
};
static const struct inode_operations nfs4_file_inode_operations = {
@@ -10869,6 +10915,7 @@ static const struct inode_operations nfs4_file_inode_operations = {
.setattr = nfs_setattr,
.listxattr = nfs4_listxattr,
.fileattr_get = nfs_fileattr_get,
+ .fileattr_set = nfs4_fileattr_set,
};
static struct nfs_server *nfs4_clone_server(struct nfs_server *source,
@@ -10905,6 +10952,7 @@ const struct nfs_rpc_ops nfs_v4_clientops = {
.try_get_tree = nfs4_try_get_tree,
.getattr = nfs4_proc_getattr,
.setattr = nfs4_proc_setattr,
+ .fileattr_set = nfs4_fileattr_set,
.lookup = nfs4_proc_lookup,
.lookupp = nfs4_proc_lookupp,
.access = nfs4_proc_access,
diff --git a/fs/nfs/nfs4xdr.c b/fs/nfs/nfs4xdr.c
index 740f3bc4a19d..dc1dff06c5da 100644
--- a/fs/nfs/nfs4xdr.c
+++ b/fs/nfs/nfs4xdr.c
@@ -1086,7 +1086,8 @@ static void encode_attrs(struct xdr_stream *xdr, const struct iattr *iap,
const struct nfs4_label *label,
const umode_t *umask,
const struct nfs_server *server,
- const uint32_t attrmask[])
+ const uint32_t attrmask[],
+ const struct timespec64 *time_create)
{
char owner_name[IDMAP_NAMESZ];
char owner_group[IDMAP_NAMESZ];
@@ -1147,6 +1148,10 @@ static void encode_attrs(struct xdr_stream *xdr, const struct iattr *iap,
len += 4;
}
}
+ if (time_create && (attrmask[1] & FATTR4_WORD1_TIME_CREATE)) {
+ bmval[1] |= FATTR4_WORD1_TIME_CREATE;
+ len += (nfstime4_maxsz << 2);
+ }
if (attrmask[1] & FATTR4_WORD1_TIME_MODIFY_SET) {
if (iap->ia_valid & ATTR_MTIME_SET) {
bmval[1] |= FATTR4_WORD1_TIME_MODIFY_SET;
@@ -1180,6 +1185,8 @@ static void encode_attrs(struct xdr_stream *xdr, const struct iattr *iap,
} else
*p++ = cpu_to_be32(NFS4_SET_TO_SERVER_TIME);
}
+ if (bmval[1] & FATTR4_WORD1_TIME_CREATE)
+ p = xdr_encode_nfstime4(p, time_create);
if (bmval[1] & FATTR4_WORD1_TIME_MODIFY_SET) {
if (iap->ia_valid & ATTR_MTIME_SET) {
*p++ = cpu_to_be32(NFS4_SET_TO_CLIENT_TIME);
@@ -1252,7 +1259,7 @@ static void encode_create(struct xdr_stream *xdr, const struct nfs4_create_arg *
encode_string(xdr, create->name->len, create->name->name);
encode_attrs(xdr, create->attrs, create->label, &create->umask,
- create->server, create->server->attr_bitmask);
+ create->server, create->server->attr_bitmask, NULL);
}
static void encode_getattr(struct xdr_stream *xdr,
@@ -1440,12 +1447,12 @@ static inline void encode_createmode(struct xdr_stream *xdr, const struct nfs_op
case NFS4_CREATE_UNCHECKED:
*p = cpu_to_be32(NFS4_CREATE_UNCHECKED);
encode_attrs(xdr, arg->u.attrs, arg->label, &arg->umask,
- arg->server, arg->server->attr_bitmask);
+ arg->server, arg->server->attr_bitmask, NULL);
break;
case NFS4_CREATE_GUARDED:
*p = cpu_to_be32(NFS4_CREATE_GUARDED);
encode_attrs(xdr, arg->u.attrs, arg->label, &arg->umask,
- arg->server, arg->server->attr_bitmask);
+ arg->server, arg->server->attr_bitmask, NULL);
break;
case NFS4_CREATE_EXCLUSIVE:
*p = cpu_to_be32(NFS4_CREATE_EXCLUSIVE);
@@ -1455,7 +1462,7 @@ static inline void encode_createmode(struct xdr_stream *xdr, const struct nfs_op
*p = cpu_to_be32(NFS4_CREATE_EXCLUSIVE4_1);
encode_nfs4_verifier(xdr, &arg->u.verifier);
encode_attrs(xdr, arg->u.attrs, arg->label, &arg->umask,
- arg->server, arg->server->exclcreat_bitmask);
+ arg->server, arg->server->exclcreat_bitmask, NULL);
}
}
@@ -1737,7 +1744,7 @@ static void encode_setattr(struct xdr_stream *xdr, const struct nfs_setattrargs
encode_op_hdr(xdr, OP_SETATTR, decode_setattr_maxsz, hdr);
encode_nfs4_stateid(xdr, &arg->stateid);
encode_attrs(xdr, arg->iap, arg->label, NULL, server,
- server->attr_bitmask);
+ server->attr_bitmask, arg->time_create);
}
static void encode_delegattr(struct xdr_stream *xdr,
diff --git a/fs/nfs/symlink.c b/fs/nfs/symlink.c
index 74a072896f8d..8f50e56fbda0 100644
--- a/fs/nfs/symlink.c
+++ b/fs/nfs/symlink.c
@@ -77,4 +77,5 @@ const struct inode_operations nfs_symlink_inode_operations = {
.getattr = nfs_getattr,
.setattr = nfs_setattr,
.fileattr_get = nfs_fileattr_get,
+ .fileattr_set = nfs_fileattr_set,
};
diff --git a/include/linux/nfs_xdr.h b/include/linux/nfs_xdr.h
index c0e29b4dfa62..8576c8d8e840 100644
--- a/include/linux/nfs_xdr.h
+++ b/include/linux/nfs_xdr.h
@@ -833,6 +833,7 @@ struct nfs_setattrargs {
const struct nfs_server * server; /* Needed for name mapping */
const u32 * bitmask;
const struct nfs4_label *label;
+ const struct timespec64 *time_create;
};
enum nfs4_acl_type {
@@ -1801,6 +1802,8 @@ struct nfs_rpc_ops {
struct nfs_fattr *, struct inode *);
int (*setattr) (struct dentry *, struct nfs_fattr *,
struct iattr *);
+ int (*fileattr_set)(const struct mnt_idmap *, struct dentry *,
+ struct file_kattr *);
int (*lookup) (struct inode *, struct dentry *, const struct qstr *,
struct nfs_fh *, struct nfs_fattr *);
int (*lookupp) (struct inode *, struct nfs_fh *,
--
2.56.0
^ permalink raw reply related [flat|nested] 11+ messages in thread* [RFC PATCH v4 09/10] ksmbd: add provenance time (ptime) and map it to CreationTime
2026-11-15 18:03 [RFC PATCH v4 00/10] add provenance time (ptime) koraynilay
` (7 preceding siblings ...)
2026-11-15 18:03 ` [RFC PATCH v4 08/10] nfs: " koraynilay
@ 2026-11-15 18:03 ` koraynilay
2026-11-15 18:03 ` [RFC PATCH v4 10/10] cifs: add provenance time (ptime) and map it to SMB's CreationTime koraynilay
9 siblings, 0 replies; 11+ messages in thread
From: koraynilay @ 2026-11-15 18:03 UTC (permalink / raw)
To: David Sterba, Namjae Jeon, Sungjong Seo, Alexander Viro,
Christian Brauner, Trond Myklebust, Anna Schumaker, Chuck Lever,
Jeff Layton, Konstantin Komarov, Paulo Alcantara
Cc: Chris Mason, Yuezhang Mo, Jan Kara, NeilBrown, Olga Kornievskaia,
Dai Ngo, Tom Talpey, Ronnie Sahlberg, Shyam Prasad N, Bharath SM,
Sergey Senozhatsky, ChenXiaoSong, Darrick J . Wong, Sean Smith,
Andrey Albershteyn, Pedro Falcato, Amir Goldstein,
Pali Rohár, linux-btrfs, linux-kernel, linux-fsdevel, exfat,
ntfs3, linux-cifs, linux-nfs, linux-api, koraynilay
Implement provenance time (ptime) in ksmbd, as introduced in a
previous commit ("vfs: add provenance time (ptime)").
Map it to SMB's CreationTime, making it settable by SMB clients. When
reporting CreationTime to clients, prioritize ptime over da.create_time
memorized in the user.DOSATTRIB xattr.
Update smb2_new_xattrs() and smb2_update_xattrs() to accept a stat
argument so they can check whether ptime is supported or already set and
behave accordingly. When ptime is natively supported and saved to the
filesystem, skip storing da.create_time in user.DOSATTRIB to avoid
redundant and desynchronized metadata, while falling back to the xattr
for filesystems without ptime.
Finally, add the ksmbd_vfs_set_ptime() helper to persist ptime to the
underlying filesystem, if supported.
Assisted-by: Gemini:3.8-flash-high antigravity-cli-1.5.7
Signed-off-by: koraynilay <koray.fra@gmail.com>
---
fs/smb/server/smb2pdu.c | 37 ++++++++++++++++++++++-------------
fs/smb/server/vfs.c | 43 +++++++++++++++++++++++++++++++++++++----
fs/smb/server/vfs.h | 1 +
3 files changed, 64 insertions(+), 17 deletions(-)
diff --git a/fs/smb/server/smb2pdu.c b/fs/smb/server/smb2pdu.c
index 63dfbffbb575..f389025dc518 100644
--- a/fs/smb/server/smb2pdu.c
+++ b/fs/smb/server/smb2pdu.c
@@ -3814,7 +3814,7 @@ static int smb2_create_truncate(const struct path *path)
}
static void smb2_new_xattrs(struct ksmbd_tree_connect *tcon, const struct path *path,
- struct ksmbd_file *fp)
+ struct ksmbd_file *fp, struct kstat *stat)
{
struct xattr_dos_attrib da = {0};
int rc;
@@ -3825,9 +3825,12 @@ static void smb2_new_xattrs(struct ksmbd_tree_connect *tcon, const struct path *
da.version = 4;
da.attr = le32_to_cpu(fp->f_ci->m_fattr);
- da.itime = da.create_time = fp->create_time;
- da.flags = XATTR_DOSINFO_ATTRIB | XATTR_DOSINFO_CREATE_TIME |
- XATTR_DOSINFO_ITIME;
+ da.itime = fp->create_time;
+ da.flags = XATTR_DOSINFO_ATTRIB | XATTR_DOSINFO_ITIME;
+ if (!(stat->result_mask & STATX_PTIME)) {
+ da.create_time = fp->create_time;
+ da.flags |= XATTR_DOSINFO_CREATE_TIME;
+ }
rc = ksmbd_vfs_set_dos_attrib_xattr(mnt_idmap(path->mnt), path, &da, true);
if (rc)
@@ -3859,7 +3862,8 @@ static bool smb2_parent_compressed(struct ksmbd_tree_connect *tcon,
}
static void smb2_update_xattrs(struct ksmbd_tree_connect *tcon,
- const struct path *path, struct ksmbd_file *fp)
+ const struct path *path, struct ksmbd_file *fp,
+ struct kstat *stat)
{
struct xattr_dos_attrib da = {};
bool store_dos_attrs = test_share_config_flag(tcon->share_conf,
@@ -3879,7 +3883,8 @@ static void smb2_update_xattrs(struct ksmbd_tree_connect *tcon,
* or compression updates. Fall back to using a non-zero stored time
* for backwards compatibility.
*/
- if ((da.flags & XATTR_DOSINFO_CREATE_TIME) || da.create_time > 0)
+ if (!(stat->result_mask & STATX_PTIME) &&
+ ((da.flags & XATTR_DOSINFO_CREATE_TIME) || da.create_time > 0))
fp->create_time = da.create_time;
fp->itime = da.itime;
} else {
@@ -5505,7 +5510,9 @@ int smb2_open(struct ksmbd_work *work)
if (rc)
goto err_out1;
- if (stat.result_mask & STATX_BTIME)
+ if (stat.result_mask & STATX_PTIME)
+ fp->create_time = ksmbd_UnixTimeToNT(stat.ptime);
+ else if (stat.result_mask & STATX_BTIME)
fp->create_time = ksmbd_UnixTimeToNT(stat.btime);
else
fp->create_time = ksmbd_UnixTimeToNT(stat.ctime);
@@ -5517,12 +5524,12 @@ int smb2_open(struct ksmbd_work *work)
cpu_to_le32(smb2_get_dos_mode(&stat, le32_to_cpu(req->FileAttributes)));
if (!created)
- smb2_update_xattrs(tcon, &path, fp);
+ smb2_update_xattrs(tcon, &path, fp, &stat);
if (need_truncate && req->FileAttributes) {
dos_attr = le32_to_cpu(req->FileAttributes);
fp->f_ci->m_fattr =
cpu_to_le32(smb2_get_dos_mode(&stat, dos_attr));
- smb2_new_xattrs(tcon, &path, fp);
+ smb2_new_xattrs(tcon, &path, fp, &stat);
}
ksmbd_vfs_update_compressed_fattr(path.dentry, &fp->f_ci->m_fattr);
@@ -5544,7 +5551,7 @@ int smb2_open(struct ksmbd_work *work)
}
if (created)
- smb2_new_xattrs(tcon, &path, fp);
+ smb2_new_xattrs(tcon, &path, fp, &stat);
fp->create_action = cpu_to_le32(file_info);
@@ -8995,6 +9002,7 @@ static int set_file_basic_info(struct ksmbd_file *fp,
const struct mnt_idmap *idmap;
__le32 attrs_mask = FILE_ATTRIBUTE_DIRECTORY_LE |
FILE_ATTRIBUTE_COMPRESSED_LE;
+ bool ptime_saved = false;
s64 crtime, time;
int rc = 0;
@@ -9016,8 +9024,11 @@ static int set_file_basic_info(struct ksmbd_file *fp,
return rc;
crtime = (s64)le64_to_cpu(file_info->CreationTime);
- if (crtime > 0)
+ if (crtime > 0) {
fp->create_time = crtime;
+ if (ksmbd_vfs_set_ptime(idmap, filp, crtime) == 0)
+ ptime_saved = true;
+ }
time = (s64)le64_to_cpu(file_info->LastAccessTime);
if (time > 0) {
@@ -9053,7 +9064,7 @@ static int set_file_basic_info(struct ksmbd_file *fp,
}
if (test_share_config_flag(share, KSMBD_SHARE_FLAG_STORE_DOS_ATTRS) &&
- (crtime > 0 || file_info->Attributes)) {
+ ((!ptime_saved && crtime > 0) || file_info->Attributes)) {
struct xattr_dos_attrib da = {0};
rc = ksmbd_vfs_get_dos_attrib_xattr(idmap, fp->filp->f_path.dentry, &da);
@@ -9066,7 +9077,7 @@ static int set_file_basic_info(struct ksmbd_file *fp,
* itime gets preserved when reading the xattr if already present
* otherwise don't write it as it wasn't asked for by the client
*/
- if (crtime > 0) {
+ if (!ptime_saved && crtime > 0) {
da.create_time = fp->create_time;
da.flags |= XATTR_DOSINFO_CREATE_TIME;
} else if (da.create_time > 0) {
diff --git a/fs/smb/server/vfs.c b/fs/smb/server/vfs.c
index da13f13f8980..63453f5d02b9 100644
--- a/fs/smb/server/vfs.c
+++ b/fs/smb/server/vfs.c
@@ -602,7 +602,8 @@ int ksmbd_vfs_getattr(const struct path *path, struct kstat *stat)
{
int err;
- err = vfs_getattr(path, stat, STATX_BASIC_STATS | STATX_BTIME,
+ err = vfs_getattr(path, stat,
+ STATX_BASIC_STATS | STATX_BTIME | STATX_PTIME,
AT_STATX_SYNC_AS_STAT);
if (err)
pr_err("getattr failed, err %d\n", err);
@@ -1909,12 +1910,14 @@ int ksmbd_vfs_fill_dentry_attrs(struct ksmbd_work *work,
};
rc = vfs_getattr(&path, ksmbd_kstat->kstat,
- STATX_BASIC_STATS | STATX_BTIME,
+ STATX_BASIC_STATS | STATX_BTIME | STATX_PTIME,
AT_STATX_SYNC_AS_STAT);
if (rc)
return rc;
- if (ksmbd_kstat->kstat->result_mask & STATX_BTIME)
+ if (ksmbd_kstat->kstat->result_mask & STATX_PTIME)
+ time = ksmbd_UnixTimeToNT(ksmbd_kstat->kstat->ptime);
+ else if (ksmbd_kstat->kstat->result_mask & STATX_BTIME)
time = ksmbd_UnixTimeToNT(ksmbd_kstat->kstat->btime);
else
time = ksmbd_UnixTimeToNT(ksmbd_kstat->kstat->ctime);
@@ -1941,7 +1944,8 @@ int ksmbd_vfs_fill_dentry_attrs(struct ksmbd_work *work,
* or compression updates. Fall back to using a non-zero stored time
* for backwards compatibility.
*/
- if ((da.flags & XATTR_DOSINFO_CREATE_TIME) || da.create_time > 0)
+ if (!(ksmbd_kstat->kstat->result_mask & STATX_PTIME) &&
+ ((da.flags & XATTR_DOSINFO_CREATE_TIME) || da.create_time > 0))
ksmbd_kstat->create_time = da.create_time;
} else {
ksmbd_debug(VFS, "fail to load dos attribute.\n");
@@ -2524,3 +2528,34 @@ int ksmbd_vfs_set_compression_create(struct ksmbd_work *work,
{
return __ksmbd_vfs_set_compression(work, fp, fmt, false);
}
+
+/**
+ * ksmbd_vfs_set_ptime() - set provenance time on filesystem
+ * @idmap: mount idmap
+ * @filp: open file pointer
+ * @crtime: creation time in NT time
+ *
+ * Return: 0 on success, otherwise error
+ */
+int ksmbd_vfs_set_ptime(const struct mnt_idmap *idmap, struct file *filp, u64 crtime)
+{
+ struct file_kattr fa = {
+ .fsx_valid = true,
+ .fsx_xflags = FS_XFLAG_PTIME,
+ .fsx_xflags_mask = FS_XFLAG_PTIME,
+ .fsx_ptime = ksmbd_NTtimeToUnix(cpu_to_le64(crtime)),
+ };
+ const struct cred *saved_cred;
+ int rc;
+
+ saved_cred = override_creds(filp->f_cred);
+ rc = mnt_want_write_file(filp);
+ if (rc)
+ goto out;
+
+ rc = vfs_fileattr_set(idmap, filp->f_path.dentry, &fa);
+ mnt_drop_write_file(filp);
+out:
+ revert_creds(saved_cred);
+ return rc;
+}
diff --git a/fs/smb/server/vfs.h b/fs/smb/server/vfs.h
index 21b0d29a3db0..5925d63841f2 100644
--- a/fs/smb/server/vfs.h
+++ b/fs/smb/server/vfs.h
@@ -187,4 +187,5 @@ int ksmbd_vfs_get_compression(struct ksmbd_file *fp, u16 *fmt);
int ksmbd_vfs_set_compression(struct ksmbd_work *work, struct ksmbd_file *fp, u16 fmt);
int ksmbd_vfs_set_compression_create(struct ksmbd_work *work,
struct ksmbd_file *fp, u16 fmt);
+int ksmbd_vfs_set_ptime(const struct mnt_idmap *idmap, struct file *filp, u64 crtime);
#endif /* __KSMBD_VFS_H__ */
--
2.56.0
^ permalink raw reply related [flat|nested] 11+ messages in thread* [RFC PATCH v4 10/10] cifs: add provenance time (ptime) and map it to SMB's CreationTime
2026-11-15 18:03 [RFC PATCH v4 00/10] add provenance time (ptime) koraynilay
` (8 preceding siblings ...)
2026-11-15 18:03 ` [RFC PATCH v4 09/10] ksmbd: add provenance time (ptime) and map it to CreationTime koraynilay
@ 2026-11-15 18:03 ` koraynilay
9 siblings, 0 replies; 11+ messages in thread
From: koraynilay @ 2026-11-15 18:03 UTC (permalink / raw)
To: David Sterba, Namjae Jeon, Sungjong Seo, Alexander Viro,
Christian Brauner, Trond Myklebust, Anna Schumaker, Chuck Lever,
Jeff Layton, Konstantin Komarov, Paulo Alcantara
Cc: Chris Mason, Yuezhang Mo, Jan Kara, NeilBrown, Olga Kornievskaia,
Dai Ngo, Tom Talpey, Ronnie Sahlberg, Shyam Prasad N, Bharath SM,
Sergey Senozhatsky, ChenXiaoSong, Darrick J . Wong, Sean Smith,
Andrey Albershteyn, Pedro Falcato, Amir Goldstein,
Pali Rohár, linux-btrfs, linux-kernel, linux-fsdevel, exfat,
ntfs3, linux-cifs, linux-nfs, linux-api, koraynilay
Implement provenance time (ptime) in cifs, as introduced in a
previous commit ("vfs: add provenance time (ptime)").
Map it to SMB's CreationTime, making it settable from userspace and
propagating it to the SMB server via FILE_BASIC_INFO.
Support reading ptime via statx(2) and fileattr_get() from the cached
CreationTime.
Update cifs_fileattr_set() to check xflags instead of only legacy flags
and add the cifs_set_file_crtime() helper to wrap the RPC call to the
SMB server.
Assisted-by: Gemini:3.8-flash-high antigravity-cli-1.5.7
Signed-off-by: koraynilay <koray.fra@gmail.com>
---
fs/smb/client/cifsfs.c | 8 +++
fs/smb/client/inode.c | 7 ++-
fs/smb/client/ioctl.c | 109 ++++++++++++++++++++++++++++++-----------
3 files changed, 94 insertions(+), 30 deletions(-)
diff --git a/fs/smb/client/cifsfs.c b/fs/smb/client/cifsfs.c
index 8cff7857b450..c2f557e406d3 100644
--- a/fs/smb/client/cifsfs.c
+++ b/fs/smb/client/cifsfs.c
@@ -1307,6 +1307,14 @@ int cifs_fileattr_get(struct dentry *dentry, struct file_kattr *fa)
if (READ_ONCE(CIFS_I(inode)->cifsAttrs) & ATTR_COMPRESSED)
fa->flags |= FS_COMPR_FL;
+ /* Report provenance time (ptime) to userspace */
+ if (CIFS_I(inode)->createtime) {
+ fa->fsx_xflags |= FS_XFLAG_PTIME;
+ fa->fsx_xflags_mask |= FS_XFLAG_PTIME;
+ fa->fsx_ptime =
+ cifs_NTtimeToUnix(cpu_to_le64(CIFS_I(inode)->createtime));
+ }
+
/*
* FS_CASEFOLD_FL is defined by UAPI as a folder attribute,
* and userspace tools (e.g., lsattr) display it only on
diff --git a/fs/smb/client/inode.c b/fs/smb/client/inode.c
index 2647785ec1e4..f0b20a72b9c2 100644
--- a/fs/smb/client/inode.c
+++ b/fs/smb/client/inode.c
@@ -222,6 +222,7 @@ cifs_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr,
cifs_i->cifsAttrs = fattr->cf_cifsattrs;
cifs_i->reparse_tag = fattr->cf_cifstag;
+ cifs_i->createtime = fattr->cf_createtime;
if (fattr->cf_flags & CIFS_FATTR_NEED_REVAL)
cifs_i->time = 0;
@@ -2958,7 +2959,8 @@ int cifs_getattr(const struct mnt_idmap *idmap, const struct path *path,
* We need to be sure that all dirty pages are written and the server
* has actual ctime, mtime and file length.
*/
- if ((request_mask & (STATX_CTIME | STATX_MTIME | STATX_SIZE | STATX_BLOCKS)) &&
+ if ((request_mask & (STATX_CTIME | STATX_MTIME | STATX_PTIME
+ | STATX_SIZE | STATX_BLOCKS)) &&
!CIFS_CACHE_READ(CIFS_I(inode)) &&
inode->i_mapping && inode->i_mapping->nrpages != 0) {
rc = filemap_fdatawait(inode->i_mapping);
@@ -2992,6 +2994,9 @@ int cifs_getattr(const struct mnt_idmap *idmap, const struct path *path,
stat->result_mask |= STATX_BTIME;
stat->btime =
cifs_NTtimeToUnix(cpu_to_le64(CIFS_I(inode)->createtime));
+ stat->result_mask |= STATX_PTIME;
+ stat->ptime =
+ cifs_NTtimeToUnix(cpu_to_le64(CIFS_I(inode)->createtime));
}
stat->attributes_mask |= (STATX_ATTR_COMPRESSED | STATX_ATTR_ENCRYPTED);
diff --git a/fs/smb/client/ioctl.c b/fs/smb/client/ioctl.c
index bb8808289a46..19a9556d39b4 100644
--- a/fs/smb/client/ioctl.c
+++ b/fs/smb/client/ioctl.c
@@ -181,6 +181,41 @@ static int cifs_set_compression(unsigned int xid, struct dentry *dentry,
compression_state);
}
+static int cifs_set_file_crtime(unsigned int xid, struct dentry *dentry,
+ struct cifs_tcon *tcon, u64 crtime)
+{
+ struct inode *inode = d_inode(dentry);
+ struct TCP_Server_Info *server = tcon->ses->server;
+ FILE_BASIC_INFO info_buf = {};
+ const char *full_path;
+ void *page;
+ int rc;
+
+ if (!server->ops->set_file_info)
+ return -EOPNOTSUPP;
+
+ info_buf.CreationTime = cpu_to_le64(crtime);
+
+ page = alloc_dentry_path();
+ full_path = build_path_from_dentry(dentry, page);
+ if (IS_ERR(full_path)) {
+ rc = PTR_ERR(full_path);
+ goto out;
+ }
+
+ rc = server->ops->set_file_info(inode, full_path, &info_buf, xid);
+ if (rc == 0) {
+ CIFS_I(inode)->createtime = crtime;
+ CIFS_I(inode)->time = 0;
+ inode_set_ctime_current(inode);
+ }
+
+out:
+ free_dentry_path(page);
+ return rc;
+}
+
+#define CIFS_SUPPORTED_XFLAGS (FS_XFLAG_PTIME)
int cifs_fileattr_set(const struct mnt_idmap *idmap, struct dentry *dentry,
struct file_kattr *fa)
{
@@ -193,49 +228,65 @@ int cifs_fileattr_set(const struct mnt_idmap *idmap, struct dentry *dentry,
bool enable_compression;
struct cifs_tcon *tcon;
unsigned int xid;
- int rc;
+ int rc = 0;
- if (!fa->flags_valid)
+ if (fileattr_has_fsx_mask(fa, CIFS_SUPPORTED_XFLAGS))
return -EOPNOTSUPP;
- /*
- * chattr writes back all flags returned by fileattr_get(). Accept
- * FS_CASEFOLD_FL only when it reflects the share's casefold state.
- */
- if (fa->flags & FS_CASEFOLD_FL) {
- rc = cifs_fileattr_get(dentry, ¤t_fa);
- if (rc)
- return rc;
- if (current_fa.flags & FS_CASEFOLD_FL)
- allowed |= FS_CASEFOLD_FL;
- }
- if (fa->flags & ~allowed)
+ if (fa->fsx_xflags_mask & ~CIFS_SUPPORTED_XFLAGS)
return -EOPNOTSUPP;
- enable_compression = fa->flags & FS_COMPR_FL;
- compression_state = enable_compression ? COMPRESSION_FORMAT_DEFAULT :
- COMPRESSION_FORMAT_NONE;
+ if (fa->flags_valid) {
+ /*
+ * chattr writes back all flags returned by fileattr_get(). Accept
+ * FS_CASEFOLD_FL only when it reflects the share's casefold state.
+ */
+ if (fa->flags & FS_CASEFOLD_FL) {
+ rc = cifs_fileattr_get(dentry, ¤t_fa);
+ if (rc)
+ return rc;
+ if (current_fa.flags & FS_CASEFOLD_FL)
+ allowed |= FS_CASEFOLD_FL;
+ }
+ if (fa->flags & ~allowed)
+ return -EOPNOTSUPP;
+ }
tlink = cifs_sb_tlink(cifs_sb);
if (IS_ERR(tlink))
return PTR_ERR(tlink);
tcon = tlink_tcon(tlink);
-
xid = get_xid();
- rc = cifs_set_compression(xid, dentry, tcon, NULL, compression_state);
- free_xid(xid);
- cifs_put_tlink(tlink);
- if (!rc) {
- spin_lock(&inode->i_lock);
- if (enable_compression)
- CIFS_I(inode)->cifsAttrs |= FILE_ATTRIBUTE_COMPRESSED;
- else
- CIFS_I(inode)->cifsAttrs &= ~FILE_ATTRIBUTE_COMPRESSED;
- spin_unlock(&inode->i_lock);
+ /* modern xflags */
+ if (fa->fsx_valid) {
+ if (fa->fsx_xflags_mask & FS_XFLAG_PTIME) {
+ rc = cifs_set_file_crtime(xid, dentry, tcon,
+ cifs_UnixTimeToNT(fa->fsx_ptime));
+ if (rc)
+ goto out;
+ }
+ } else if (fa->flags_valid) { /* legacy flags */
+ enable_compression = fa->flags & FS_COMPR_FL;
+ compression_state = enable_compression ? COMPRESSION_FORMAT_DEFAULT :
+ COMPRESSION_FORMAT_NONE;
+
+ rc = cifs_set_compression(xid, dentry, tcon, NULL, compression_state);
+
+ if (!rc) {
+ spin_lock(&inode->i_lock);
+ if (enable_compression)
+ CIFS_I(inode)->cifsAttrs |= FILE_ATTRIBUTE_COMPRESSED;
+ else
+ CIFS_I(inode)->cifsAttrs &= ~FILE_ATTRIBUTE_COMPRESSED;
+ spin_unlock(&inode->i_lock);
+ }
+ cifs_dbg(FYI, "set compress flag rc %d\n", rc);
}
- cifs_dbg(FYI, "set compress flag rc %d\n", rc);
+out:
+ free_xid(xid);
+ cifs_put_tlink(tlink);
return rc;
}
--
2.56.0
^ permalink raw reply related [flat|nested] 11+ messages in thread