[RFC][PATCH 00/12] Enhanced file stat system call

[RFC][PATCH 00/12] Enhanced file stat system call

[David Howells]

Implement new system calls to provide enhanced file stats and enhanced
filesystem stats.  The patches can be found here:

	http://git.kernel.org/cgit/linux/kernel/git/dhowells/linux-fs.git/log/?h=xstat


===========
DESCRIPTION
===========

The third patch provides this new system call:

	long ret = statx(int dfd,
			 const char *filename,
			 unsigned atflag,
			 unsigned mask,
			 struct statx *buffer);

This is an enhanced file stat function that provides a number of useful
features, in summary:

 (1) More information: creation time, data version number,
     flags/attributes.  A subset of these is available through a number of
     filesystems (such as CIFS, NFS, AFS, Ext4 and BTRFS).

 (2) Lightweight stat (AT_NO_ATTR_SYNC): Ask for just those details of
     interest, and allow a network fs to approximate anything not of
     interest, without going to the server.

 (3) Heavyweight stat (AT_FORCE_ATTR_SYNC): Force a network fs to flush
     buffers and go to the server, even if it thinks its cached attributes
     are up to date.

 (4) Allow the filesystem to indicate what it can/cannot provide: A
     filesystem can now say it doesn't support a standard stat feature if
     that isn't available.

 (5) Make the fields a consistent size on all arches, and make them large.

 (6) Can be extended by using more request flags and using up the padding
     space in the statx struct.

Note that no lstat() equivalent is required as that can be implemented
through statx() with atflag == 0.  There is also no fstat() equivalent as
that can be implemented through statx() with filename == NULL and the
relevant fd passed as dfd.


The seventh patch provides another new system call:

	long ret = fsinfo(int dfd,
			  const char *filename,
			  unsigned atflag,
			  unsigned request,
			  void *buffer);

This is an enhanced filesystem stat and information retrieval function that
provides more information, in summary:

 (1) All the information provided by statfs() and more.  The fields are
     made large.

 (2) Provides information about timestamp range and resolution to
     complement statx().

 (3) Provides information about IOC flags supported in statx()'s return.

 (4) Provides volume binary IDs and UUIDs.

 (5) Provides the filesystem name according to the kernel as a string
     (eg. "ext4" or "nfs3") in addition to the magic number.

 (6) Provides information obtained from network filesystems, such as volume
     and domain names.

 (7) Has lots of spare space that can be used for future extenstions and a
     bit mask indicating what was provided.

Note that I've added a 'request' identifier.  This is to select the set of
data to be returned.  The idea is that 'buffer' points to a fixed-size
struct selected by request.  Currently only 0 is available and this refers
to 'struct fsinfo'.  However, I could split up the buffer into say 3:

 (0) statfs-type information

 (1) Timestamp and IOC flags info.

 (2) Network fs strings.

However, some of this might be better retrieved through getxattr().


=======
TESTING
=======

Test programs are added into samples/statx/ by the appropriate patches.

David
---
David Howells (12):
      Ext4: Fix extended timestamp encoding and decoding
      statx: Provide IOC flags for Windows fs attributes
      statx: Add a system call to make enhanced file info available
      statx: AFS: Return enhanced file attributes
      statx: Ext4: Return enhanced file attributes
      statx: NFS: Return enhanced file attributes
      statx: CIFS: Return enhanced attributes
      fsinfo: Add a system call to make enhanced filesystem info available
      fsinfo: Ext4: Return information through the filesystem info syscall
      fsinfo: AFS: Return information through the filesystem info syscall
      fsinfo: NFS: Return information through the filesystem info syscall
      fsinfo: CIFS: Return information through the filesystem info syscall


 arch/x86/entry/syscalls/syscall_32.tbl |    2 
 arch/x86/entry/syscalls/syscall_64.tbl |    2 
 fs/afs/inode.c                         |   23 ++
 fs/afs/super.c                         |   39 ++++
 fs/cifs/cifsfs.c                       |   25 +++
 fs/cifs/cifsfs.h                       |    4 
 fs/cifs/cifsglob.h                     |    8 +
 fs/cifs/dir.c                          |    2 
 fs/cifs/inode.c                        |  124 ++++++++++---
 fs/cifs/netmisc.c                      |    4 
 fs/exportfs/expfs.c                    |    4 
 fs/ext4/ext4.h                         |   24 ++-
 fs/ext4/file.c                         |    2 
 fs/ext4/inode.c                        |   31 +++
 fs/ext4/namei.c                        |    2 
 fs/ext4/super.c                        |   39 ++++
 fs/ext4/symlink.c                      |    2 
 fs/nfs/inode.c                         |   45 ++++-
 fs/nfs/internal.h                      |    1 
 fs/nfs/nfs4super.c                     |    1 
 fs/nfs/super.c                         |   58 ++++++
 fs/ntfs/time.h                         |    2 
 fs/stat.c                              |  305 +++++++++++++++++++++++++++++---
 fs/statfs.c                            |  218 +++++++++++++++++++++++
 include/linux/fs.h                     |    7 +
 include/linux/stat.h                   |   14 +
 include/linux/syscalls.h               |    6 +
 include/linux/time64.h                 |    2 
 include/uapi/linux/fcntl.h             |    2 
 include/uapi/linux/fs.h                |    7 +
 include/uapi/linux/stat.h              |  185 +++++++++++++++++++
 samples/Makefile                       |    3 
 samples/statx/Makefile                 |   13 +
 samples/statx/test-fsinfo.c            |  179 +++++++++++++++++++
 samples/statx/test-statx.c             |  273 +++++++++++++++++++++++++++++
 35 files changed, 1558 insertions(+), 100 deletions(-)
 create mode 100644 samples/statx/Makefile
 create mode 100644 samples/statx/test-fsinfo.c
 create mode 100644 samples/statx/test-statx.c

[PATCH 01/12] Ext4: Fix extended timestamp encoding and decoding

[David Howells]

The handling of extended timestamps in Ext4 is broken as can be seen in the
output of the test program attached below:

time     extra   bad decode        good decode         bad encode  good encode
======== =====   ================= =================   =========== ===========
ffffffff     0 >  ffffffffffffffff  ffffffffffffffff > *ffffffff 3  ffffffff 0
80000000     0 >  ffffffff80000000  ffffffff80000000 > *80000000 3  80000000 0
00000000     0 >                 0                 0 >  00000000 0  00000000 0
7fffffff     0 >          7fffffff          7fffffff >  7fffffff 0  7fffffff 0
80000000     1 > *ffffffff80000000          80000000 > *80000000 0  80000000 1
ffffffff     1 > *ffffffffffffffff          ffffffff > *ffffffff 0  ffffffff 1
00000000     1 >         100000000         100000000 >  00000000 1  00000000 1
7fffffff     1 >         17fffffff         17fffffff >  7fffffff 1  7fffffff 1
80000000     2 > *ffffffff80000000         180000000 > *80000000 1  80000000 2
ffffffff     2 > *ffffffffffffffff         1ffffffff > *ffffffff 1  ffffffff 2
00000000     2 >         200000000         200000000 >  00000000 2  00000000 2
7fffffff     2 >         27fffffff         27fffffff >  7fffffff 2  7fffffff 2
80000000     3 > *ffffffff80000000         280000000 > *80000000 2  80000000 3
ffffffff     3 > *ffffffffffffffff         2ffffffff > *ffffffff 2  ffffffff 3
00000000     3 >         300000000         300000000 >  00000000 3  00000000 3
7fffffff     3 >         37fffffff         37fffffff >  7fffffff 3  7fffffff 3

The values marked with asterisks are wrong.

The problem is that with a 64-bit time, in ext4_decode_extra_time() the
epoch value is just OR'd with the sign-extended time - which, if negative,
has all of the upper 32 bits set anyway.  We need to add the epoch instead
of OR'ing it.  In ext4_encode_extra_time(), the reverse operation needs to
take place as the 32-bit part of the number of seconds needs to be
subtracted from the 64-bit value before the epoch is shifted down.

Since the epoch is presumably unsigned, this has the slightly strange
effect of, for epochs > 0, putting the 0x80000000-0xffffffff range before
the 0x00000000-0x7fffffff range.

This affects all kernels from v2.6.23-rc1 onwards.

The test program:

	#include <stdio.h>

	#define EXT4_FITS_IN_INODE(x, y, z) 1
	#define EXT4_EPOCH_BITS 2
	#define EXT4_EPOCH_MASK ((1 << EXT4_EPOCH_BITS) - 1)
	#define EXT4_NSEC_MASK  (~0UL << EXT4_EPOCH_BITS)

	#define le32_to_cpu(x) (x)
	#define cpu_to_le32(x) (x)
	typedef unsigned int __le32;
	typedef unsigned int u32;
	typedef signed int s32;
	typedef unsigned long long __u64;
	typedef signed long long s64;

	struct timespec {
		long long	tv_sec;			/* seconds */
		long		tv_nsec;		/* nanoseconds */
	};

	struct ext4_inode_info {
		struct timespec i_crtime;
	};

	struct ext4_inode {
		__le32  i_crtime;       /* File Creation time */
		__le32  i_crtime_extra; /* extra FileCreationtime (nsec << 2 | epoch) */
	};

	/* Incorrect implementation */
	static inline void ext4_decode_extra_time_bad(struct timespec *time, __le32 extra)
	{
	       if (sizeof(time->tv_sec) > 4)
		       time->tv_sec |= (__u64)(le32_to_cpu(extra) & EXT4_EPOCH_MASK)
				       << 32;
	       time->tv_nsec = (le32_to_cpu(extra) & EXT4_NSEC_MASK) >> EXT4_EPOCH_BITS;
	}

	static inline __le32 ext4_encode_extra_time_bad(struct timespec *time)
	{
	       return cpu_to_le32((sizeof(time->tv_sec) > 4 ?
				   (time->tv_sec >> 32) & EXT4_EPOCH_MASK : 0) |
				  ((time->tv_nsec << EXT4_EPOCH_BITS) & EXT4_NSEC_MASK));
	}

	/* Fixed implementation */
	static inline void ext4_decode_extra_time_good(struct timespec *time, __le32 _extra)
	{
		u32 extra = le32_to_cpu(_extra);
		u32 epoch = extra & EXT4_EPOCH_MASK;

		time->tv_sec = (s32)time->tv_sec + ((s64)epoch  << 32);
		time->tv_nsec = (extra & EXT4_NSEC_MASK) >> EXT4_EPOCH_BITS;
	}

	static inline __le32 ext4_encode_extra_time_good(struct timespec *time)
	{
		u32 extra;
		s64 epoch = time->tv_sec - (s32)time->tv_sec;

		extra = (epoch >> 32) & EXT4_EPOCH_MASK;
		extra |= (time->tv_nsec << EXT4_EPOCH_BITS) & EXT4_NSEC_MASK;
		return cpu_to_le32(extra);
	}

	#define EXT4_INODE_GET_XTIME_BAD(xtime, inode, raw_inode)		\
	do {									       \
		(inode)->xtime.tv_sec = (signed)le32_to_cpu((raw_inode)->xtime);       \
		if (EXT4_FITS_IN_INODE(raw_inode, EXT4_I(inode), xtime ## _extra))     \
			ext4_decode_extra_time_bad(&(inode)->xtime,		\
						   raw_inode->xtime ## _extra);	\
		else								       \
			(inode)->xtime.tv_nsec = 0;				       \
	} while (0)

	#define EXT4_INODE_SET_XTIME_BAD(xtime, inode, raw_inode)		\
	do {									       \
		(raw_inode)->xtime = cpu_to_le32((inode)->xtime.tv_sec);	       \
		if (EXT4_FITS_IN_INODE(raw_inode, EXT4_I(inode), xtime ## _extra))     \
			(raw_inode)->xtime ## _extra =				       \
				ext4_encode_extra_time_bad(&(inode)->xtime);	\
	} while (0)

	#define EXT4_INODE_GET_XTIME_GOOD(xtime, inode, raw_inode)		\
	do {									       \
		(inode)->xtime.tv_sec = (signed)le32_to_cpu((raw_inode)->xtime);       \
		if (EXT4_FITS_IN_INODE(raw_inode, EXT4_I(inode), xtime ## _extra))     \
			ext4_decode_extra_time_good(&(inode)->xtime,			       \
					       raw_inode->xtime ## _extra);	\
		else								       \
			(inode)->xtime.tv_nsec = 0;				       \
	} while (0)

	#define EXT4_INODE_SET_XTIME_GOOD(xtime, inode, raw_inode)		\
	do {									       \
		(raw_inode)->xtime = cpu_to_le32((inode)->xtime.tv_sec);	       \
		if (EXT4_FITS_IN_INODE(raw_inode, EXT4_I(inode), xtime ## _extra))     \
			(raw_inode)->xtime ## _extra =				       \
				ext4_encode_extra_time_good(&(inode)->xtime);	\
	} while (0)

	static const struct test {
		unsigned crtime;
		unsigned extra;
		long long sec;
		int nsec;
	} tests[] = {
		// crtime	extra		tv_sec			tv_nsec
		0xffffffff,	0x00000000,	0xffffffffffffffff,	0,
		0x80000000,	0x00000000,	0xffffffff80000000,	0,
		0x00000000,	0x00000000,	0x0000000000000000,	0,
		0x7fffffff,	0x00000000,	0x000000007fffffff,	0,
		0x80000000,	0x00000001,	0x0000000080000000,	0,
		0xffffffff,	0x00000001,	0x00000000ffffffff,	0,
		0x00000000,	0x00000001,	0x0000000100000000,	0,
		0x7fffffff,	0x00000001,	0x000000017fffffff,	0,
		0x80000000,	0x00000002,	0x0000000180000000,	0,
		0xffffffff,	0x00000002,	0x00000001ffffffff,	0,
		0x00000000,	0x00000002,	0x0000000200000000,	0,
		0x7fffffff,	0x00000002,	0x000000027fffffff,	0,
		0x80000000,	0x00000003,	0x0000000280000000,	0,
		0xffffffff,	0x00000003,	0x00000002ffffffff,	0,
		0x00000000,	0x00000003,	0x0000000300000000,	0,
		0x7fffffff,	0x00000003,	0x000000037fffffff,	0,
	};

	int main()
	{
		struct ext4_inode_info ii_bad, ii_good;
		struct ext4_inode raw, *praw = &raw;
		struct ext4_inode raw_bad, *praw_bad = &raw_bad;
		struct ext4_inode raw_good, *praw_good = &raw_good;
		const struct test *t;
		int i, ret = 0;

		printf("time     extra   bad decode        good decode         bad encode  good encode\n");
		printf("======== =====   ================= =================   =========== ===========\n");
		for (i = 0; i < sizeof(tests) / sizeof(t[0]); i++) {
			t = &tests[i];
			raw.i_crtime = t->crtime;
			raw.i_crtime_extra = t->extra;
			printf("%08x %5d > ", t->crtime, t->extra);

			EXT4_INODE_GET_XTIME_BAD(i_crtime, &ii_bad, praw);
			EXT4_INODE_GET_XTIME_GOOD(i_crtime, &ii_good, praw);
			if (ii_bad.i_crtime.tv_sec != t->sec ||
			    ii_bad.i_crtime.tv_nsec != t->nsec)
				printf("*");
			else
				printf(" ");
			printf("%16llx", ii_bad.i_crtime.tv_sec);
			printf(" ");
			if (ii_good.i_crtime.tv_sec != t->sec ||
			    ii_good.i_crtime.tv_nsec != t->nsec) {
				printf("*");
				ret = 1;
			} else {
				printf(" ");
			}
			printf("%16llx", ii_good.i_crtime.tv_sec);

			EXT4_INODE_SET_XTIME_BAD(i_crtime, &ii_good, praw_bad);
			EXT4_INODE_SET_XTIME_GOOD(i_crtime, &ii_good, praw_good);

			printf(" > ");
			if (raw_bad.i_crtime != raw.i_crtime ||
			    raw_bad.i_crtime_extra != raw.i_crtime_extra)
				printf("*");
			else
				printf(" ");
			printf("%08llx %d", raw_bad.i_crtime, raw_bad.i_crtime_extra);
			printf(" ");

			if (raw_good.i_crtime != raw.i_crtime ||
			    raw_good.i_crtime_extra != raw.i_crtime_extra) {
				printf("*");
				ret = 1;
			} else {
				printf(" ");
			}
			printf("%08llx %d", raw_good.i_crtime, raw_good.i_crtime_extra);
			printf("\n");
		}

		return ret;
	}

Signed-off-by: David Howells <dhowells@redhat.com>
---

 fs/ext4/ext4.h |   22 +++++++++++++---------
 1 file changed, 13 insertions(+), 9 deletions(-)

diff --git a/fs/ext4/ext4.h b/fs/ext4/ext4.h
index fd1f28be5296..31efcd78bf51 100644
--- a/fs/ext4/ext4.h
+++ b/fs/ext4/ext4.h
@@ -723,19 +723,23 @@ struct move_extent {
 	<= (EXT4_GOOD_OLD_INODE_SIZE +			\
 	    (einode)->i_extra_isize))			\
 
-static inline __le32 ext4_encode_extra_time(struct timespec *time)
+static inline void ext4_decode_extra_time(struct timespec *time, __le32 _extra)
 {
-       return cpu_to_le32((sizeof(time->tv_sec) > 4 ?
-			   (time->tv_sec >> 32) & EXT4_EPOCH_MASK : 0) |
-                          ((time->tv_nsec << EXT4_EPOCH_BITS) & EXT4_NSEC_MASK));
+	u32 extra = le32_to_cpu(_extra);
+	u32 epoch = extra & EXT4_EPOCH_MASK;
+
+	time->tv_sec = (s32)time->tv_sec + ((s64)epoch  << 32);
+	time->tv_nsec = (extra & EXT4_NSEC_MASK) >> EXT4_EPOCH_BITS;
 }
 
-static inline void ext4_decode_extra_time(struct timespec *time, __le32 extra)
+static inline __le32 ext4_encode_extra_time(struct timespec *time)
 {
-       if (sizeof(time->tv_sec) > 4)
-	       time->tv_sec |= (__u64)(le32_to_cpu(extra) & EXT4_EPOCH_MASK)
-			       << 32;
-       time->tv_nsec = (le32_to_cpu(extra) & EXT4_NSEC_MASK) >> EXT4_EPOCH_BITS;
+	u32 extra;
+	s64 epoch = time->tv_sec - (s32)time->tv_sec;
+
+	extra = (epoch >> 32) & EXT4_EPOCH_MASK;
+	extra |= (time->tv_nsec << EXT4_EPOCH_BITS) & EXT4_NSEC_MASK;
+	return cpu_to_le32(extra);
 }
 
 #define EXT4_INODE_SET_XTIME(xtime, inode, raw_inode)			       \

[PATCH 02/12] statx: Provide IOC flags for Windows fs attributes

[David Howells]

Provide IOC flags for Windows fs attributes so that they can be retrieved (or
even altered) using the FS_IOC_[GS]ETFLAGS ioctl and read using statx().

Signed-off-by: David Howells <dhowells@redhat.com>
---

 include/uapi/linux/fs.h |    7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/include/uapi/linux/fs.h b/include/uapi/linux/fs.h
index 9b964a5920af..a195287b8744 100644
--- a/include/uapi/linux/fs.h
+++ b/include/uapi/linux/fs.h
@@ -197,10 +197,13 @@ struct inodes_stat_t {
 #define FS_EXTENT_FL			0x00080000 /* Extents */
 #define FS_DIRECTIO_FL			0x00100000 /* Use direct i/o */
 #define FS_NOCOW_FL			0x00800000 /* Do not cow file */
+#define FS_HIDDEN_FL			0x10000000 /* Windows hidden file attribute */
+#define FS_SYSTEM_FL			0x20000000 /* Windows system file attribute */
+#define FS_ARCHIVE_FL			0x40000000 /* Windows archive file attribute */
 #define FS_RESERVED_FL			0x80000000 /* reserved for ext2 lib */
 
-#define FS_FL_USER_VISIBLE		0x0003DFFF /* User visible flags */
-#define FS_FL_USER_MODIFIABLE		0x000380FF /* User modifiable flags */
+#define FS_FL_USER_VISIBLE		0x7003DFFF /* User visible flags */
+#define FS_FL_USER_MODIFIABLE		0x700380FF /* User modifiable flags */
 
 
 #define SYNC_FILE_RANGE_WAIT_BEFORE	1

[PATCH 03/12] statx: Add a system call to make enhanced file info available

[David Howells]

Add a system call to make extended file information available, including
file creation time, inode version and data version where available through
the underlying filesystem.


========
OVERVIEW
========

The idea was initially proposed as a set of xattrs that could be retrieved
with getxattr(), but the general preferance proved to be for a new syscall
with an extended stat structure.

This has a number of uses:

 (1) Better support for the y2038 problem [Arnd Bergmann].

 (2) Creation time: The SMB protocol carries the creation time, which could
     be exported by Samba, which will in turn help CIFS make use of
     FS-Cache as that can be used for coherency data.

     This is also specified in NFSv4 as a recommended attribute and could
     be exported by NFSD [Steve French].

 (3) Lightweight stat: Ask for just those details of interest, and allow a
     netfs (such as NFS) to approximate anything not of interest, possibly
     without going to the server [Trond Myklebust, Ulrich Drepper, Andreas
     Dilger].

 (4) Heavyweight stat: Force a netfs to go to the server, even if it thinks
     its cached attributes are up to date [Trond Myklebust].

 (5) Data version number: Could be used by userspace NFS servers [Aneesh
     Kumar].

     Can also be used to modify fill_post_wcc() in NFSD which retrieves
     i_version directly, but has just called vfs_getattr().  It could get
     it from the kstat struct if it used vfs_xgetattr() instead.

 (6) BSD stat compatibility: Including more fields from the BSD stat such
     as creation time (st_btime) and inode generation number (st_gen)
     [Jeremy Allison, Bernd Schubert].

 (7) Inode generation number: Useful for FUSE and userspace NFS servers
     [Bernd Schubert].  This was asked for but later deemed unnecessary
     with the open-by-handle capability available

 (8) Extra coherency data may be useful in making backups [Andreas Dilger].

 (9) Allow the filesystem to indicate what it can/cannot provide: A
     filesystem can now say it doesn't support a standard stat feature if
     that isn't available, so if, for instance, inode numbers or UIDs don't
     exist or are fabricated locally...

(10) Make the fields a consistent size on all arches and make them large.

(11) Store a 16-byte volume ID in the superblock that can be returned in
     struct xstat [Steve French].

(12) Include granularity fields in the time data to indicate the
     granularity of each of the times (NFSv4 time_delta) [Steve French].

(13) FS_IOC_GETFLAGS value.  These could be translated to BSD's st_flags.
     Note that the Linux IOC flags are a mess and filesystems such as Ext4
     define flags that aren't in linux/fs.h, so translation in the kernel
     may be a necessity (or, possibly, we provide the filesystem type too).

(14) Mask of features available on file (eg: ACLs, seclabel) [Brad Boyer,
     Michael Kerrisk].

(15) Spare space, request flags and information flags are provided for
     future expansion.


===============
NEW SYSTEM CALL
===============

The new system call is:

	int ret = statx(int dfd,
			const char *filename,
			unsigned int flags,
			unsigned int mask,
			struct statx *buffer);

The dfd, filename and flags parameters indicate the file to query.  There
is no equivalent of lstat() as that can be emulated with statx() by passing
AT_SYMLINK_NOFOLLOW in flags.  There is also no equivalent of fstat() as
that can be emulated by passing a NULL filename to statx() with the fd of
interest in dfd.

AT_FORCE_ATTR_SYNC can be set in flags.  This will require a network
filesystem to synchronise its attributes with the server.

AT_NO_ATTR_SYNC can be set in flags.  This will suppress synchronisation
with the server in a network filesystem.  The resulting values should be
considered approximate.

mask is a bitmask indicating the fields in struct statx that are of
interest to the caller.  The user should set this to STATX_BASIC_STATS to
get the basic set returned by stat().

buffer points to the destination for the main data.  This must be 256 bytes
in size.


======================
MAIN ATTRIBUTES RECORD
======================

The following structures are defined in which to return the main attribute
set:

	struct statx {
		__u32	st_mask;
		__u32	st_information;
		__u16	st_mode;
		__u16	__spare0[1];
		__u32	st_nlink;
		__u32	st_uid;
		__u32	st_gid;
		__u32	st_blksize;
		__u32	__spare1[3];
		__u32	st_rdev_major;
		__u32	st_rdev_minor;
		__u32	st_dev_major;
		__u32	st_dev_minor;
		__s32	st_atime_ns;
		__s32	st_btime_ns;
		__s32	st_ctime_ns;
		__s32	st_mtime_ns;
		__s64	st_atime;
		__s64	st_btime;
		__s64	st_ctime;
		__s64	st_mtime;
		__u64	st_ino;
		__u64	st_size;
		__u64	st_blocks;
		__u64	st_version;
		__u64	st_ioc_flags;
		__u64	__spare1[14];
	};

where st_information is local system information about the file, st_btime
is the file creation time, st_version is the data version number
(i_version), st_ioc_flags holds the flags from FS_IOC_GETFLAGS, st_mask is
a bitmask indicating the data provided and __spares*[] are where as-yet
undefined fields can be placed.

Time fields are split into separate seconds and nanoseconds fields to make
packing easier and the granularities can be queried with the filesystem
info system call.  Note that times will be negative if before 1970; in such
a case, the nanosecond fields should also be negative if not zero.

The defined bits in request_mask and st_mask are:

	STATX_MODE		Want/got st_mode
	STATX_NLINK		Want/got st_nlink
	STATX_UID		Want/got st_uid
	STATX_GID		Want/got st_gid
	STATX_RDEV		Want/got st_rdev_*
	STATX_ATIME		Want/got st_atime
	STATX_MTIME		Want/got st_mtime
	STATX_CTIME		Want/got st_ctime
	STATX_INO		Want/got st_ino
	STATX_SIZE		Want/got st_size
	STATX_BLOCKS		Want/got st_blocks
	STATX_BASIC_STATS	[The stuff in the normal stat struct]
	STATX_BTIME		Want/got st_btime
	STATX_VERSION		Want/got st_data_version
	STATX_IOC_FLAGS		Want/got FS_IOC_GETFLAGS
	STATX_ALL_STATS		[All currently available stuff]

The defined bits in st_ioc_flags are the usual FS_xxx_FL, plus some extra
flags that might be supplied by the filesystem.  Note that Ext4 returns
flags outside of {EXT4,FS}_FL_USER_VISIBLE in response to FS_IOC_GETFLAGS.
Should {EXT4,FS}_FL_USER_VISIBLE be extended to cover them?  Or should the
extra flags be suppressed?

The defined bits in the st_information field give local system data on a
file, how it is accessed, where it is and what it does:

	STATX_INFO_ENCRYPTED		File is encrypted
	STATX_INFO_TEMPORARY		File is temporary (NTFS/CIFS/deleted)
	STATX_INFO_FABRICATED		File was made up by filesystem
	STATX_INFO_KERNEL_API		File is kernel API (eg: procfs/sysfs)
	STATX_INFO_REMOTE		File is remote
	STATX_INFO_OFFLINE		File is offline (CIFS)
	STATX_INFO_AUTOMOUNT		Dir is automount trigger
	STATX_INFO_AUTODIR		Dir provides unlisted automounts
	STATX_INFO_NONSYSTEM_OWNERSHIP	File has non-system ownership details
	STATX_INFO_REPARSE_POINT	File is reparse point (NTFS/CIFS)

These are for the use of GUI tools that might want to mark files specially,
depending on what they are.  I've tried not to provide overlap with
st_ioc_flags where something usable exists there.

The fields in struct statx come in a number of classes:

 (0) st_dev_*, st_information.

     These are local data and are always available.

 (1) st_nlinks, st_uid, st_gid, st_[amc]time*, st_ino, st_size, st_blocks,
     st_blksize.

     These will be returned whether the caller asks for them or not.  The
     corresponding bits in st_mask will be set to indicate their presence.

     If the caller didn't ask for them, then they may be approximated.  For
     example, NFS won't waste any time updating them from the server, unless as
     a byproduct of updating something requested.

     If the values don't actually exist for the underlying object (such as
     UID or GID on a DOS file), then the bit won't be set in the st_mask,
     even if the caller asked for the value.  In such a case, the returned
     value will be a fabrication.

 (2) st_mode.

     The part of this that identifies the file type will always be
     available, irrespective of the setting of STATX_MODE.  The access
     flags and sticky bit are as for class (1).

 (3) st_rdev_*.

     As for class (1), but these won't be returned if the file is not a
     blockdev or chardev.  The bit will be cleared if the value is not
     returned.

 (4) File creation time (st_btime*), data version (st_version), inode flags
     (st_ioc_flags).

     These will be returned if available whether the caller asked for them or
     not.  The corresponding bits in st_mask will be set or cleared as
     appropriate to indicate their presence.

     If the caller didn't ask for them, then they may be approximated.  For
     example, NFS won't waste any time updating them from the server, unless
     as a byproduct of updating something requested.


=======
TESTING
=======

The following test program can be used to test the statx system call:

	samples/statx/test-statx.c

Just compile and run, passing it paths to the files you want to examine.
The file is built automatically if CONFIG_SAMPLES is enabled.

Here's some example output.  Firstly, an NFS directory that crosses to
another FSID.  Note that the FABRICATED and AUTOMOUNT info flags are set.
The former because the directory is invented locally as we don't see the
underlying dir on the server, the latter because transiting this directory
will cause d_automount to be invoked by the VFS.

	[root@andromeda tmp]# ./samples/statx/test-statx -A /warthog/data
	statx(/warthog/data) = 0
	results=4fef
	  Size: 4096            Blocks: 8          IO Block: 1048576  directory
	Device: 00:1d           Inode: 2           Links: 110
	Access: (3777/drwxrwxrwx)  Uid: -2
	Gid: 4294967294
	Access: 2012-04-30 09:01:55.283819565+0100
	Modify: 2012-03-28 19:01:19.405465361+0100
	Change: 2012-03-28 19:01:19.405465361+0100
	Data version: ef51734f11e92a18h
	Information: 00000254 (-------- -------- ------a- -m-r-f--)

Secondly, the result of automounting on that directory.

	[root@andromeda tmp]# ./samples/statx/test-statx /warthog/data
	statx(/warthog/data) = 0
	results=14fef
	  Size: 4096            Blocks: 8          IO Block: 1048576  directory
	Device: 00:1e           Inode: 2           Links: 110
	Access: (3777/drwxrwxrwx)  Uid: -2
	Gid: 4294967294
	Access: 2012-04-30 09:01:55.283819565+0100
	Modify: 2012-03-28 19:01:19.405465361+0100
	Change: 2012-03-28 19:01:19.405465361+0100
	Data version: ef51734f11e92a18h
	Information: 00000210 (-------- -------- ------a- ---r----)

Signed-off-by: David Howells <dhowells@redhat.com>
---

 arch/x86/entry/syscalls/syscall_32.tbl |    1 
 arch/x86/entry/syscalls/syscall_64.tbl |    1 
 fs/exportfs/expfs.c                    |    4 
 fs/stat.c                              |  305 +++++++++++++++++++++++++++++---
 include/linux/fs.h                     |    5 -
 include/linux/stat.h                   |   14 +
 include/linux/syscalls.h               |    3 
 include/uapi/linux/fcntl.h             |    2 
 include/uapi/linux/stat.h              |  116 ++++++++++++
 samples/Makefile                       |    3 
 samples/statx/Makefile                 |   10 +
 samples/statx/test-statx.c             |  273 +++++++++++++++++++++++++++++
 12 files changed, 700 insertions(+), 37 deletions(-)
 create mode 100644 samples/statx/Makefile
 create mode 100644 samples/statx/test-statx.c

diff --git a/arch/x86/entry/syscalls/syscall_32.tbl b/arch/x86/entry/syscalls/syscall_32.tbl
index 7663c455b9f6..6e570ee4241d 100644
--- a/arch/x86/entry/syscalls/syscall_32.tbl
+++ b/arch/x86/entry/syscalls/syscall_32.tbl
@@ -382,3 +382,4 @@
 373	i386	shutdown		sys_shutdown
 374	i386	userfaultfd		sys_userfaultfd
 375	i386	membarrier		sys_membarrier
+376	i386	statx			sys_statx
diff --git a/arch/x86/entry/syscalls/syscall_64.tbl b/arch/x86/entry/syscalls/syscall_64.tbl
index 278842fdf1f6..cbfef23f8067 100644
--- a/arch/x86/entry/syscalls/syscall_64.tbl
+++ b/arch/x86/entry/syscalls/syscall_64.tbl
@@ -331,6 +331,7 @@
 322	64	execveat		stub_execveat
 323	common	userfaultfd		sys_userfaultfd
 324	common	membarrier		sys_membarrier
+325	common	statx			sys_statx
 
 #
 # x32-specific system call numbers start at 512 to avoid cache impact
diff --git a/fs/exportfs/expfs.c b/fs/exportfs/expfs.c
index 714cd37a6ba3..ef32ea41925e 100644
--- a/fs/exportfs/expfs.c
+++ b/fs/exportfs/expfs.c
@@ -295,7 +295,9 @@ static int get_name(const struct path *path, char *name, struct dentry *child)
 	 * filesystem supports 64-bit inode numbers.  So we need to
 	 * actually call ->getattr, not just read i_ino:
 	 */
-	error = vfs_getattr_nosec(&child_path, &stat);
+	stat.query_flags = 0;
+	stat.request_mask = STATX_BASIC_STATS;
+	error = vfs_xgetattr_nosec(&child_path, &stat);
 	if (error)
 		return error;
 	buffer.ino = stat.ino;
diff --git a/fs/stat.c b/fs/stat.c
index cccc1aab9a8b..573772cbe6f0 100644
--- a/fs/stat.c
+++ b/fs/stat.c
@@ -18,6 +18,15 @@
 #include <asm/uaccess.h>
 #include <asm/unistd.h>
 
+/**
+ * generic_fillattr - Fill in the basic attributes from the inode struct
+ * @inode: Inode to use as the source
+ * @stat: Where to fill in the attributes
+ *
+ * Fill in the basic attributes in the kstat structure from data that's to be
+ * found on the VFS inode structure.  This is the default if no getattr inode
+ * operation is supplied.
+ */
 void generic_fillattr(struct inode *inode, struct kstat *stat)
 {
 	stat->dev = inode->i_sb->s_dev;
@@ -27,87 +36,198 @@ void generic_fillattr(struct inode *inode, struct kstat *stat)
 	stat->uid = inode->i_uid;
 	stat->gid = inode->i_gid;
 	stat->rdev = inode->i_rdev;
-	stat->size = i_size_read(inode);
-	stat->atime = inode->i_atime;
 	stat->mtime = inode->i_mtime;
 	stat->ctime = inode->i_ctime;
-	stat->blksize = (1 << inode->i_blkbits);
+	stat->size = i_size_read(inode);
 	stat->blocks = inode->i_blocks;
-}
+	stat->blksize = 1 << inode->i_blkbits;
 
+	stat->result_mask |= STATX_BASIC_STATS & ~STATX_RDEV;
+	if (IS_NOATIME(inode))
+		stat->result_mask &= ~STATX_ATIME;
+	else
+		stat->atime = inode->i_atime;
+
+	if (S_ISREG(stat->mode) && stat->nlink == 0)
+		stat->information |= STATX_INFO_TEMPORARY;
+	if (IS_AUTOMOUNT(inode))
+		stat->information |= STATX_INFO_AUTOMOUNT;
+
+	if (unlikely(S_ISBLK(stat->mode) || S_ISCHR(stat->mode)))
+		stat->result_mask |= STATX_RDEV;
+}
 EXPORT_SYMBOL(generic_fillattr);
 
 /**
- * vfs_getattr_nosec - getattr without security checks
+ * vfs_xgetattr_nosec - getattr without security checks
  * @path: file to get attributes from
  * @stat: structure to return attributes in
  *
  * Get attributes without calling security_inode_getattr.
  *
- * Currently the only caller other than vfs_getattr is internal to the
- * filehandle lookup code, which uses only the inode number and returns
- * no attributes to any user.  Any other code probably wants
- * vfs_getattr.
+ * Currently the only caller other than vfs_xgetattr is internal to the
+ * filehandle lookup code, which uses only the inode number and returns no
+ * attributes to any user.  Any other code probably wants vfs_xgetattr.
+ *
+ * The caller must set stat->request_mask to indicate what they want and
+ * stat->query_flags to indicate whether the server should be queried.
  */
-int vfs_getattr_nosec(struct path *path, struct kstat *stat)
+int vfs_xgetattr_nosec(struct path *path, struct kstat *stat)
 {
 	struct inode *inode = d_backing_inode(path->dentry);
 
+	stat->query_flags &= ~KSTAT_QUERY_FLAGS;
+	if ((stat->query_flags & AT_FORCE_ATTR_SYNC) &&
+	    (stat->query_flags & AT_NO_ATTR_SYNC))
+		return -EINVAL;
+
+	stat->result_mask = 0;
+	stat->information = 0;
+	stat->ioc_flags = 0;
 	if (inode->i_op->getattr)
 		return inode->i_op->getattr(path->mnt, path->dentry, stat);
 
 	generic_fillattr(inode, stat);
 	return 0;
 }
+EXPORT_SYMBOL(vfs_xgetattr_nosec);
 
-EXPORT_SYMBOL(vfs_getattr_nosec);
-
-int vfs_getattr(struct path *path, struct kstat *stat)
+/*
+ * vfs_xgetattr - Get the enhanced basic attributes of a file
+ * @path: The file of interest
+ * @stat: Where to return the statistics
+ *
+ * Ask the filesystem for a file's attributes.  The caller must have preset
+ * stat->request_mask and stat->query_flags to indicate what they want.
+ *
+ * If the file is remote, the filesystem can be forced to update the attributes
+ * from the backing store by passing AT_FORCE_ATTR_SYNC in query_flags or can
+ * suppress the update by passing AT_NO_ATTR_SYNC.
+ *
+ * Bits must have been set in stat->request_mask to indicate which attributes
+ * the caller wants retrieving.  Any such attribute not requested may be
+ * returned anyway, but the value may be approximate, and, if remote, may not
+ * have been synchronised with the server.
+ *
+ * 0 will be returned on success, and a -ve error code if unsuccessful.
+ */
+int vfs_xgetattr(struct path *path, struct kstat *stat)
 {
 	int retval;
 
 	retval = security_inode_getattr(path);
 	if (retval)
 		return retval;
-	return vfs_getattr_nosec(path, stat);
+	return vfs_xgetattr_nosec(path, stat);
 }
+EXPORT_SYMBOL(vfs_xgetattr);
 
+/**
+ * vfs_getattr - Get the basic attributes of a file
+ * @path: The file of interest
+ * @stat: Where to return the statistics
+ *
+ * Ask the filesystem for a file's attributes.  If remote, the filesystem isn't
+ * forced to update its files from the backing store.  Only the basic set of
+ * attributes will be retrieved; anyone wanting more must use vfs_xgetattr(),
+ * as must anyone who wants to force attributes to be sync'd with the server.
+ *
+ * 0 will be returned on success, and a -ve error code if unsuccessful.
+ */
+int vfs_getattr(struct path *path, struct kstat *stat)
+{
+	stat->query_flags = 0;
+	stat->request_mask = STATX_BASIC_STATS;
+	return vfs_xgetattr(path, stat);
+}
 EXPORT_SYMBOL(vfs_getattr);
 
-int vfs_fstat(unsigned int fd, struct kstat *stat)
+/**
+ * vfs_fstatx - Get the enhanced basic attributes by file descriptor
+ * @fd: The file descriptor referring to the file of interest
+ * @stat: The result structure to fill in.
+ *
+ * This function is a wrapper around vfs_xgetattr().  The main difference is
+ * that it uses a file descriptor to determine the file location.
+ *
+ * The caller must have preset stat->query_flags, stat->request_mask and
+ * stat->auxinfo as for vfs_xgetattr().
+ *
+ * 0 will be returned on success, and a -ve error code if unsuccessful.
+ */
+int vfs_fstatx(unsigned int fd, struct kstat *stat)
 {
 	struct fd f = fdget_raw(fd);
 	int error = -EBADF;
 
 	if (f.file) {
-		error = vfs_getattr(&f.file->f_path, stat);
+		error = vfs_xgetattr(&f.file->f_path, stat);
 		fdput(f);
 	}
 	return error;
 }
+EXPORT_SYMBOL(vfs_fstatx);
+
+/**
+ * vfs_fstat - Get basic attributes by file descriptor
+ * @fd: The file descriptor referring to the file of interest
+ * @stat: The result structure to fill in.
+ *
+ * This function is a wrapper around vfs_getattr().  The main difference is
+ * that it uses a file descriptor to determine the file location.
+ *
+ * 0 will be returned on success, and a -ve error code if unsuccessful.
+ */
+int vfs_fstat(unsigned int fd, struct kstat *stat)
+{
+	stat->query_flags = 0;
+	stat->request_mask = STATX_BASIC_STATS;
+	return vfs_fstatx(fd, stat);
+}
 EXPORT_SYMBOL(vfs_fstat);
 
-int vfs_fstatat(int dfd, const char __user *filename, struct kstat *stat,
-		int flag)
+/**
+ * vfs_statx - Get basic and extra attributes by filename
+ * @dfd: A file descriptor representing the base dir for a relative filename
+ * @filename: The name of the file of interest
+ * @flags: Flags to control the query
+ * @stat: The result structure to fill in.
+ *
+ * This function is a wrapper around vfs_xgetattr().  The main difference is
+ * that it uses a filename and base directory to determine the file location.
+ * Additionally, the addition of AT_SYMLINK_NOFOLLOW to flags will prevent a
+ * symlink at the given name from being referenced.
+ *
+ * The caller must have preset stat->request_mask and stat->auxinfo as for
+ * vfs_xgetattr().  The flags are also used to load up stat->query_flags.
+ *
+ * 0 will be returned on success, and a -ve error code if unsuccessful.
+ */
+int vfs_statx(int dfd, const char __user *filename, int flags,
+	      struct kstat *stat)
 {
 	struct path path;
 	int error = -EINVAL;
-	unsigned int lookup_flags = 0;
+	unsigned int lookup_flags = LOOKUP_FOLLOW | LOOKUP_AUTOMOUNT;
 
-	if ((flag & ~(AT_SYMLINK_NOFOLLOW | AT_NO_AUTOMOUNT |
-		      AT_EMPTY_PATH)) != 0)
-		goto out;
+	if ((flags & ~(AT_SYMLINK_NOFOLLOW | AT_NO_AUTOMOUNT |
+		       AT_EMPTY_PATH | KSTAT_QUERY_FLAGS)) != 0)
+		return -EINVAL;
 
-	if (!(flag & AT_SYMLINK_NOFOLLOW))
-		lookup_flags |= LOOKUP_FOLLOW;
-	if (flag & AT_EMPTY_PATH)
+	if (flags & AT_SYMLINK_NOFOLLOW)
+		lookup_flags &= ~LOOKUP_FOLLOW;
+	if (flags & AT_NO_AUTOMOUNT)
+		lookup_flags &= ~LOOKUP_AUTOMOUNT;
+	if (flags & AT_EMPTY_PATH)
 		lookup_flags |= LOOKUP_EMPTY;
+	stat->query_flags = flags;
+
 retry:
 	error = user_path_at(dfd, filename, lookup_flags, &path);
 	if (error)
 		goto out;
 
-	error = vfs_getattr(&path, stat);
+	error = vfs_xgetattr(&path, stat);
 	path_put(&path);
 	if (retry_estale(error, lookup_flags)) {
 		lookup_flags |= LOOKUP_REVAL;
@@ -116,17 +236,65 @@ retry:
 out:
 	return error;
 }
+EXPORT_SYMBOL(vfs_statx);
+
+/**
+ * vfs_fstatat - Get basic attributes by filename
+ * @dfd: A file descriptor representing the base dir for a relative filename
+ * @filename: The name of the file of interest
+ * @flags: Flags to control the query
+ * @stat: The result structure to fill in.
+ *
+ * This function is a wrapper around vfs_statx().  The difference is that it
+ * preselects basic stats only.  The flags are used to load up
+ * stat->query_flags in addition to indicating symlink handling during path
+ * resolution.
+ *
+ * 0 will be returned on success, and a -ve error code if unsuccessful.
+ */
+int vfs_fstatat(int dfd, const char __user *filename, struct kstat *stat,
+		int flags)
+{
+	stat->request_mask = STATX_BASIC_STATS;
+	return vfs_statx(dfd, filename, flags, stat);
+}
 EXPORT_SYMBOL(vfs_fstatat);
 
-int vfs_stat(const char __user *name, struct kstat *stat)
+/**
+ * vfs_stat - Get basic attributes by filename
+ * @filename: The name of the file of interest
+ * @stat: The result structure to fill in.
+ *
+ * This function is a wrapper around vfs_statx().  The difference is that it
+ * preselects basic stats only, terminal symlinks are followed regardless and a
+ * remote filesystem can't be forced to query the server.  If such is desired,
+ * vfs_statx() should be used instead.
+ *
+ * 0 will be returned on success, and a -ve error code if unsuccessful.
+ */
+int vfs_stat(const char __user *filename, struct kstat *stat)
 {
-	return vfs_fstatat(AT_FDCWD, name, stat, 0);
+	stat->request_mask = STATX_BASIC_STATS;
+	return vfs_statx(AT_FDCWD, filename, 0, stat);
 }
 EXPORT_SYMBOL(vfs_stat);
 
+/**
+ * vfs_lstat - Get basic attrs by filename, without following terminal symlink
+ * @filename: The name of the file of interest
+ * @stat: The result structure to fill in.
+ *
+ * This function is a wrapper around vfs_statx().  The difference is that it
+ * preselects basic stats only, terminal symlinks are note followed regardless
+ * and a remote filesystem can't be forced to query the server.  If such is
+ * desired, vfs_statx() should be used instead.
+ *
+ * 0 will be returned on success, and a -ve error code if unsuccessful.
+ */
 int vfs_lstat(const char __user *name, struct kstat *stat)
 {
-	return vfs_fstatat(AT_FDCWD, name, stat, AT_SYMLINK_NOFOLLOW);
+	stat->request_mask = STATX_BASIC_STATS;
+	return vfs_statx(AT_FDCWD, name, AT_SYMLINK_NOFOLLOW, stat);
 }
 EXPORT_SYMBOL(vfs_lstat);
 
@@ -141,7 +309,7 @@ static int cp_old_stat(struct kstat *stat, struct __old_kernel_stat __user * sta
 {
 	static int warncount = 5;
 	struct __old_kernel_stat tmp;
-	
+
 	if (warncount > 0) {
 		warncount--;
 		printk(KERN_WARNING "VFS: Warning: %s using old stat() call. Recompile your binary.\n",
@@ -166,7 +334,7 @@ static int cp_old_stat(struct kstat *stat, struct __old_kernel_stat __user * sta
 #if BITS_PER_LONG == 32
 	if (stat->size > MAX_NON_LFS)
 		return -EOVERFLOW;
-#endif	
+#endif
 	tmp.st_size = stat->size;
 	tmp.st_atime = stat->atime.tv_sec;
 	tmp.st_mtime = stat->mtime.tv_sec;
@@ -445,6 +613,81 @@ SYSCALL_DEFINE4(fstatat64, int, dfd, const char __user *, filename,
 }
 #endif /* __ARCH_WANT_STAT64 || __ARCH_WANT_COMPAT_STAT64 */
 
+/*
+ * Set the statx results.
+ */
+static long statx_set_result(struct kstat *stat, struct statx __user *buffer)
+{
+	uid_t uid = from_kuid_munged(current_user_ns(), stat->uid);
+	gid_t gid = from_kgid_munged(current_user_ns(), stat->gid);
+
+#define __put_timestamp(kts, uts) (				\
+		__put_user(kts.tv_sec,	uts##_s		) ||	\
+		__put_user(kts.tv_nsec,	uts##_ns	))
+
+	if (__put_user(stat->result_mask,	&buffer->st_mask	) ||
+	    __put_user(stat->mode,		&buffer->st_mode	) ||
+	    __clear_user(&buffer->__spare0, sizeof(buffer->__spare0))	  ||
+	    __put_user(stat->nlink,		&buffer->st_nlink	) ||
+	    __put_user(uid,			&buffer->st_uid		) ||
+	    __put_user(gid,			&buffer->st_gid		) ||
+	    __put_user(stat->information,	&buffer->st_information	) ||
+	    __put_user(stat->blksize,		&buffer->st_blksize	) ||
+	    __put_user(MAJOR(stat->rdev),	&buffer->st_rdev_major	) ||
+	    __put_user(MINOR(stat->rdev),	&buffer->st_rdev_minor	) ||
+	    __put_user(MAJOR(stat->dev),	&buffer->st_dev_major	) ||
+	    __put_user(MINOR(stat->dev),	&buffer->st_dev_minor	) ||
+	    __put_timestamp(stat->atime,	&buffer->st_atime	) ||
+	    __put_timestamp(stat->btime,	&buffer->st_btime	) ||
+	    __put_timestamp(stat->ctime,	&buffer->st_ctime	) ||
+	    __put_timestamp(stat->mtime,	&buffer->st_mtime	) ||
+	    __put_user(stat->ino,		&buffer->st_ino		) ||
+	    __put_user(stat->size,		&buffer->st_size	) ||
+	    __put_user(stat->blocks,		&buffer->st_blocks	) ||
+	    __put_user(stat->version,		&buffer->st_version	) ||
+	    __put_user(stat->ioc_flags,		&buffer->st_ioc_flags	) ||
+	    __clear_user(&buffer->__spare1, sizeof(buffer->__spare1))	  ||
+	    __clear_user(&buffer->__spare2, sizeof(buffer->__spare2)))
+		return -EFAULT;
+
+	return 0;
+}
+
+/**
+ * sys_statx - System call to get enhanced stats
+ * @dfd: Base directory to pathwalk from *or* fd to stat.
+ * @filename: File to stat *or* NULL.
+ * @flags: AT_* flags to control pathwalk.
+ * @mask: Parts of statx struct actually required.
+ * @buffer: Result buffer.
+ *
+ * Note that if filename is NULL, then it does the equivalent of fstat() using
+ * dfd to indicate the file of interest.
+ */
+SYSCALL_DEFINE5(statx,
+		int, dfd, const char __user *, filename, unsigned, flags,
+		unsigned int, mask,
+		struct statx __user *, buffer)
+{
+	struct kstat stat;
+	int error;
+
+	if (!access_ok(VERIFY_WRITE, buffer, sizeof(*buffer)))
+		return -EFAULT;
+
+	memset(&stat, 0, sizeof(stat));
+	stat.query_flags = flags;
+	stat.request_mask = mask & STATX_ALL_STATS;
+
+	if (filename)
+		error = vfs_statx(dfd, filename, flags, &stat);
+	else
+		error = vfs_fstatx(dfd, &stat);
+	if (error)
+		return error;
+	return statx_set_result(&stat, buffer);
+}
+
 /* Caller is here responsible for sufficient locking (ie. inode->i_lock) */
 void __inode_add_bytes(struct inode *inode, loff_t bytes)
 {
diff --git a/include/linux/fs.h b/include/linux/fs.h
index 72d8a844c692..8fb641ac1027 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -2760,8 +2760,9 @@ extern void kfree_put_link(struct inode *, void *);
 extern void free_page_put_link(struct inode *, void *);
 extern int generic_readlink(struct dentry *, char __user *, int);
 extern void generic_fillattr(struct inode *, struct kstat *);
-int vfs_getattr_nosec(struct path *path, struct kstat *stat);
+extern int vfs_xgetattr_nosec(struct path *path, struct kstat *stat);
 extern int vfs_getattr(struct path *, struct kstat *);
+extern int vfs_xgetattr(struct path *, struct kstat *);
 void __inode_add_bytes(struct inode *inode, loff_t bytes);
 void inode_add_bytes(struct inode *inode, loff_t bytes);
 void __inode_sub_bytes(struct inode *inode, loff_t bytes);
@@ -2777,6 +2778,8 @@ extern int vfs_stat(const char __user *, struct kstat *);
 extern int vfs_lstat(const char __user *, struct kstat *);
 extern int vfs_fstat(unsigned int, struct kstat *);
 extern int vfs_fstatat(int , const char __user *, struct kstat *, int);
+extern int vfs_xstat(int, const char __user *, int, struct kstat *);
+extern int vfs_xfstat(unsigned int, struct kstat *);
 
 extern int do_vfs_ioctl(struct file *filp, unsigned int fd, unsigned int cmd,
 		    unsigned long arg);
diff --git a/include/linux/stat.h b/include/linux/stat.h
index 075cb0c7eb2a..b6bcbe17bfc2 100644
--- a/include/linux/stat.h
+++ b/include/linux/stat.h
@@ -19,6 +19,12 @@
 #include <linux/uidgid.h>
 
 struct kstat {
+	u32		query_flags;		/* Operational flags */
+#define KSTAT_QUERY_FLAGS (AT_FORCE_ATTR_SYNC | AT_NO_ATTR_SYNC)
+	u32		request_mask;		/* What fields the user asked for */
+	u32		result_mask;		/* What fields the user got */
+	u32		information;
+	u64		ioc_flags;		/* Inode flags (FS_IOC_GETFLAGS) */
 	u64		ino;
 	dev_t		dev;
 	umode_t		mode;
@@ -27,11 +33,13 @@ struct kstat {
 	kgid_t		gid;
 	dev_t		rdev;
 	loff_t		size;
-	struct timespec  atime;
+	struct timespec	atime;
 	struct timespec	mtime;
 	struct timespec	ctime;
-	unsigned long	blksize;
-	unsigned long long	blocks;
+	struct timespec	btime;			/* File creation time */
+	uint32_t	blksize;		/* Preferred I/O size */
+	u64		blocks;
+	u64		version;		/* Data version */
 };
 
 #endif
diff --git a/include/linux/syscalls.h b/include/linux/syscalls.h
index a460e2ef2843..09eb280f6bf6 100644
--- a/include/linux/syscalls.h
+++ b/include/linux/syscalls.h
@@ -48,6 +48,7 @@ struct stat;
 struct stat64;
 struct statfs;
 struct statfs64;
+struct statx;
 struct __sysctl_args;
 struct sysinfo;
 struct timespec;
@@ -886,5 +887,7 @@ asmlinkage long sys_execveat(int dfd, const char __user *filename,
 			const char __user *const __user *envp, int flags);
 
 asmlinkage long sys_membarrier(int cmd, int flags);
+asmlinkage long sys_statx(int dfd, const char __user *path, unsigned flags,
+			  unsigned mask, struct statx __user *buffer);
 
 #endif
diff --git a/include/uapi/linux/fcntl.h b/include/uapi/linux/fcntl.h
index beed138bd359..5c8143b04ff7 100644
--- a/include/uapi/linux/fcntl.h
+++ b/include/uapi/linux/fcntl.h
@@ -62,6 +62,8 @@
 #define AT_SYMLINK_FOLLOW	0x400   /* Follow symbolic links.  */
 #define AT_NO_AUTOMOUNT		0x800	/* Suppress terminal automount traversal */
 #define AT_EMPTY_PATH		0x1000	/* Allow empty relative pathname */
+#define AT_FORCE_ATTR_SYNC	0x2000	/* Force the attributes to be sync'd with the server */
+#define AT_NO_ATTR_SYNC		0x4000	/* Don't sync attributes with the server */
 
 
 #endif /* _UAPI_LINUX_FCNTL_H */
diff --git a/include/uapi/linux/stat.h b/include/uapi/linux/stat.h
index 7fec7e36d921..41a5412e7ad5 100644
--- a/include/uapi/linux/stat.h
+++ b/include/uapi/linux/stat.h
@@ -1,6 +1,7 @@
 #ifndef _UAPI_LINUX_STAT_H
 #define _UAPI_LINUX_STAT_H
 
+#include <linux/types.h>
 
 #if defined(__KERNEL__) || !defined(__GLIBC__) || (__GLIBC__ < 2)
 
@@ -41,5 +42,120 @@
 
 #endif
 
+/*
+ * Structures for the extended file attribute retrieval system call
+ * (statx()).
+ *
+ * The caller passes a mask of what they're specifically interested in as a
+ * parameter to statx().  What statx() actually got will be indicated in
+ * st_mask upon return.
+ *
+ * For each bit in the mask argument:
+ *
+ * - if the datum is not available at all, the field and the bit will both be
+ *   cleared;
+ *
+ * - otherwise, if explicitly requested:
+ *
+ *   - the datum will be synchronised to the server if AT_FORCE_ATTR_SYNC is
+ *     set or if the datum is considered out of date, and
+ *
+ *   - the field will be filled in and the bit will be set;
+ *
+ * - otherwise, if not requested, but available in approximate form without any
+ *   effort, it will be filled in anyway, and the bit will be set upon return
+ *   (it might not be up to date, however, and no attempt will be made to
+ *   synchronise the internal state first);
+ *
+ * - otherwise the field and the bit will be cleared before returning.
+ *
+ * Items in STATX_BASIC_STATS may be marked unavailable on return, but they
+ * will have values installed for compatibility purposes so that stat() and
+ * co. can be emulated in userspace.
+ */
+struct statx {
+	/* 0x00 */
+	__u32	st_mask;	/* What results were written [uncond] */
+	__u32	st_information;	/* Information about the file [uncond] */
+	__u16	st_mode;	/* File mode */
+	__u16	__spare0[1];
+	/* 0xc */
+	__u32	st_nlink;	/* Number of hard links */
+	__u32	st_uid;		/* User ID of owner */
+	__u32	st_gid;		/* Group ID of owner */
+	/* 0x18 - I/O parameters */
+	__u32	st_blksize;	/* Preferred general I/O size [uncond] */
+	__u32	__spare1[3];
+	/* 0x28 */
+	__u32	st_rdev_major;	/* Device ID of special file */
+	__u32	st_rdev_minor;
+	__u32	st_dev_major;	/* ID of device containing file [uncond] */
+	__u32	st_dev_minor;
+	/* 0x38 */
+	__s32	st_atime_ns;	/* Last access time (ns part) */
+	__s32	st_btime_ns;	/* File creation time (ns part) */
+	__s32	st_ctime_ns;	/* Last attribute change time (ns part) */
+	__s32	st_mtime_ns;	/* Last data modification time (ns part) */
+	/* 0x48 */
+	__s64	st_atime_s;	/* Last access time */
+	__s64	st_btime_s;	/* File creation time */
+	__s64	st_ctime_s;	/* Last attribute change time */
+	__s64	st_mtime_s;	/* Last data modification time */
+	/* 0x68 */
+	__u64	st_ino;		/* Inode number */
+	__u64	st_size;	/* File size */
+	__u64	st_blocks;	/* Number of 512-byte blocks allocated */
+	__u64	st_version;	/* Data version number */
+	__u64	st_ioc_flags;	/* As FS_IOC_GETFLAGS */
+	/* 0x90 */
+	__u64	__spare2[14];	/* Spare space for future expansion */
+	/* 0x100 */
+};
+
+/*
+ * Flags to be st_mask
+ *
+ * Query request/result mask for statx() and struct statx::st_mask.
+ *
+ * These bits should be set in the mask argument of statx() to request
+ * particular items when calling statx().
+ */
+#define STATX_MODE		0x00000001U	/* Want/got st_mode */
+#define STATX_NLINK		0x00000002U	/* Want/got st_nlink */
+#define STATX_UID		0x00000004U	/* Want/got st_uid */
+#define STATX_GID		0x00000008U	/* Want/got st_gid */
+#define STATX_RDEV		0x00000010U	/* Want/got st_rdev */
+#define STATX_ATIME		0x00000020U	/* Want/got st_atime */
+#define STATX_MTIME		0x00000040U	/* Want/got st_mtime */
+#define STATX_CTIME		0x00000080U	/* Want/got st_ctime */
+#define STATX_INO		0x00000100U	/* Want/got st_ino */
+#define STATX_SIZE		0x00000200U	/* Want/got st_size */
+#define STATX_BLOCKS		0x00000400U	/* Want/got st_blocks */
+#define STATX_BASIC_STATS	0x000007ffU	/* The stuff in the normal stat struct */
+#define STATX_BTIME		0x00000800U	/* Want/got st_btime */
+#define STATX_VERSION		0x00001000U	/* Want/got st_version */
+#define STATX_IOC_FLAGS		0x00002000U	/* Want/got FS_IOC_GETFLAGS */
+#define STATX_ALL_STATS		0x00003fffU	/* All supported stats */
+
+/*
+ * Flags to be found in st_information
+ *
+ * These give information about the features or the state of a file that might
+ * be of use to ordinary userspace programs such as GUIs or ls rather than
+ * specialised tools.
+ *
+ * Additional information may be found in st_ioc_flags and we try not to
+ * overlap with it.
+ */
+#define STATX_INFO_ENCRYPTED		0x00000001U /* File is encrypted */
+#define STATX_INFO_TEMPORARY		0x00000002U /* File is temporary (NTFS/CIFS) */
+#define STATX_INFO_FABRICATED		0x00000004U /* File was made up by filesystem */
+#define STATX_INFO_KERNEL_API		0x00000008U /* File is kernel API (eg: procfs/sysfs) */
+#define STATX_INFO_REMOTE		0x00000010U /* File is remote */
+#define STATX_INFO_OFFLINE		0x00000020U /* File is offline (CIFS) */
+#define STATX_INFO_AUTOMOUNT		0x00000040U /* Dir is automount trigger */
+#define STATX_INFO_AUTODIR		0x00000080U /* Dir provides unlisted automounts */
+#define STATX_INFO_NONSYSTEM_OWNERSHIP	0x00000100U /* File has non-system ownership details */
+#define STATX_INFO_REPARSE_POINT	0x00000200U /* File is reparse point (NTFS/CIFS) */
 
 #endif /* _UAPI_LINUX_STAT_H */
diff --git a/samples/Makefile b/samples/Makefile
index f00257bcc5a7..e2db7f5672a0 100644
--- a/samples/Makefile
+++ b/samples/Makefile
@@ -1,4 +1,5 @@
 # Makefile for Linux samples code
 
 obj-$(CONFIG_SAMPLES)	+= kobject/ kprobes/ trace_events/ livepatch/ \
-			   hw_breakpoint/ kfifo/ kdb/ hidraw/ rpmsg/ seccomp/
+			   hw_breakpoint/ kfifo/ kdb/ hidraw/ rpmsg/ seccomp/ \
+			   statx/
diff --git a/samples/statx/Makefile b/samples/statx/Makefile
new file mode 100644
index 000000000000..6765dabc4c8d
--- /dev/null
+++ b/samples/statx/Makefile
@@ -0,0 +1,10 @@
+# kbuild trick to avoid linker error. Can be omitted if a module is built.
+obj- := dummy.o
+
+# List of programs to build
+hostprogs-y := test-statx
+
+# Tell kbuild to always build the programs
+always := $(hostprogs-y)
+
+HOSTCFLAGS_test-statx.o += -I$(objtree)/usr/include
diff --git a/samples/statx/test-statx.c b/samples/statx/test-statx.c
new file mode 100644
index 000000000000..86bbf4e945f4
--- /dev/null
+++ b/samples/statx/test-statx.c
@@ -0,0 +1,273 @@
+/* Test the statx() system call
+ *
+ * Copyright (C) 2015 Red Hat, Inc. All Rights Reserved.
+ * Written by David Howells (dhowells@redhat.com)
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public Licence
+ * as published by the Free Software Foundation; either version
+ * 2 of the Licence, or (at your option) any later version.
+ */
+
+#define _GNU_SOURCE
+#define _ATFILE_SOURCE
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <ctype.h>
+#include <errno.h>
+#include <time.h>
+#include <sys/syscall.h>
+#include <sys/types.h>
+#include <linux/stat.h>
+#include <linux/fcntl.h>
+#include <sys/stat.h>
+
+#define AT_FORCE_ATTR_SYNC	0x2000
+#define AT_NO_ATTR_SYNC		0x4000
+
+#define __NR_statx 325
+
+static __attribute__((unused))
+ssize_t statx(int dfd, const char *filename, unsigned flags,
+	      unsigned int mask, struct statx *buffer)
+{
+	return syscall(__NR_statx, dfd, filename, flags, mask, buffer);
+}
+
+static void print_time(const char *field, __s64 tv_sec, __s32 tv_nsec)
+{
+	struct tm tm;
+	time_t tim;
+	char buffer[100];
+	int len;
+
+	tim = tv_sec;
+	if (!localtime_r(&tim, &tm)) {
+		perror("localtime_r");
+		exit(1);
+	}
+	len = strftime(buffer, 100, "%F %T", &tm);
+	if (len == 0) {
+		perror("strftime");
+		exit(1);
+	}
+	printf("%s", field);
+	fwrite(buffer, 1, len, stdout);
+	printf(".%09u", tv_nsec);
+	len = strftime(buffer, 100, "%z", &tm);
+	if (len == 0) {
+		perror("strftime2");
+		exit(1);
+	}
+	fwrite(buffer, 1, len, stdout);
+	printf("\n");
+}
+
+static void dump_statx(struct statx *stx)
+{
+	char buffer[256], ft = '?';
+
+	printf("results=%x\n", stx->st_mask);
+
+	printf(" ");
+	if (stx->st_mask & STATX_SIZE)
+		printf(" Size: %-15llu", (unsigned long long)stx->st_size);
+	if (stx->st_mask & STATX_BLOCKS)
+		printf(" Blocks: %-10llu", (unsigned long long)stx->st_blocks);
+	printf(" IO Block: %-6llu ", (unsigned long long)stx->st_blksize);
+	if (stx->st_mask & STATX_MODE) {
+		switch (stx->st_mode & S_IFMT) {
+		case S_IFIFO:	printf(" FIFO\n");			ft = 'p'; break;
+		case S_IFCHR:	printf(" character special file\n");	ft = 'c'; break;
+		case S_IFDIR:	printf(" directory\n");			ft = 'd'; break;
+		case S_IFBLK:	printf(" block special file\n");	ft = 'b'; break;
+		case S_IFREG:	printf(" regular file\n");		ft = '-'; break;
+		case S_IFLNK:	printf(" symbolic link\n");		ft = 'l'; break;
+		case S_IFSOCK:	printf(" socket\n");			ft = 's'; break;
+		default:
+			printf("unknown type (%o)\n", stx->st_mode & S_IFMT);
+			break;
+		}
+	}
+
+	sprintf(buffer, "%02x:%02x", stx->st_dev_major, stx->st_dev_minor);
+	printf("Device: %-15s", buffer);
+	if (stx->st_mask & STATX_INO)
+		printf(" Inode: %-11llu", (unsigned long long) stx->st_ino);
+	if (stx->st_mask & STATX_SIZE)
+		printf(" Links: %-5u", stx->st_nlink);
+	if (stx->st_mask & STATX_RDEV)
+		printf(" Device type: %u,%u", stx->st_rdev_major, stx->st_rdev_minor);
+	printf("\n");
+
+	if (stx->st_mask & STATX_MODE)
+		printf("Access: (%04o/%c%c%c%c%c%c%c%c%c%c)  ",
+		       stx->st_mode & 07777,
+		       ft,
+		       stx->st_mode & S_IRUSR ? 'r' : '-',
+		       stx->st_mode & S_IWUSR ? 'w' : '-',
+		       stx->st_mode & S_IXUSR ? 'x' : '-',
+		       stx->st_mode & S_IRGRP ? 'r' : '-',
+		       stx->st_mode & S_IWGRP ? 'w' : '-',
+		       stx->st_mode & S_IXGRP ? 'x' : '-',
+		       stx->st_mode & S_IROTH ? 'r' : '-',
+		       stx->st_mode & S_IWOTH ? 'w' : '-',
+		       stx->st_mode & S_IXOTH ? 'x' : '-');
+	if (stx->st_mask & STATX_UID)
+		printf("Uid: %5d   ", stx->st_uid);
+	if (stx->st_mask & STATX_GID)
+		printf("Gid: %5d\n", stx->st_gid);
+
+	if (stx->st_mask & STATX_ATIME)
+		print_time("Access: ", stx->st_atime_s, stx->st_atime_ns);
+	if (stx->st_mask & STATX_MTIME)
+		print_time("Modify: ", stx->st_mtime_s, stx->st_mtime_ns);
+	if (stx->st_mask & STATX_CTIME)
+		print_time("Change: ", stx->st_ctime_s, stx->st_ctime_ns);
+	if (stx->st_mask & STATX_BTIME)
+		print_time(" Birth: ", stx->st_btime_s, stx->st_btime_ns);
+
+	if (stx->st_mask & STATX_VERSION)
+		printf("Data version: %llxh\n",
+		       (unsigned long long)stx->st_version);
+
+	if (stx->st_mask & STATX_IOC_FLAGS) {
+		unsigned char bits;
+		int loop, byte;
+
+		static char flag_representation[32 + 1] =
+			/* FS_IOC_GETFLAGS flags: */
+			"?????ASH"	/* 31-24	0x00000000-ff000000 */
+			"????ehTD"	/* 23-16	0x00000000-00ff0000 */
+			"tj?IE?XZ"	/* 15- 8	0x00000000-0000ff00 */
+			"AdaiScus"	/*  7- 0	0x00000000-000000ff */
+			;
+
+		printf("Inode flags: %08llx (",
+		       (unsigned long long)stx->st_ioc_flags);
+		for (byte = 32 - 8; byte >= 0; byte -= 8) {
+			bits = stx->st_ioc_flags >> byte;
+			for (loop = 7; loop >= 0; loop--) {
+				int bit = byte + loop;
+
+				if (bits & 0x80)
+					putchar(flag_representation[31 - bit]);
+				else
+					putchar('-');
+				bits <<= 1;
+			}
+			if (byte)
+				putchar(' ');
+		}
+		printf(")\n");
+	}
+
+	if (stx->st_information) {
+		unsigned char bits;
+		int loop, byte;
+
+		static char info_representation[32 + 1] =
+			/* STATX_INFO_ flags: */
+			"????????"	/* 31-24	0x00000000-ff000000 */
+			"????????"	/* 23-16	0x00000000-00ff0000 */
+			"??????Rn"	/* 15- 8	0x00000000-0000ff00 */
+			"dmorkfte"	/*  7- 0	0x00000000-000000ff */
+			;
+
+		printf("Information: %08x (", stx->st_information);
+		for (byte = 32 - 8; byte >= 0; byte -= 8) {
+			bits = stx->st_information >> byte;
+			for (loop = 7; loop >= 0; loop--) {
+				int bit = byte + loop;
+
+				if (bits & 0x80)
+					putchar(info_representation[31 - bit]);
+				else
+					putchar('-');
+				bits <<= 1;
+			}
+			if (byte)
+				putchar(' ');
+		}
+		printf(")\n");
+	}
+
+	printf("IO-blocksize: blksize=%u\n", stx->st_blksize);
+}
+
+static void dump_hex(unsigned long long *data, int from, int to)
+{
+	unsigned offset, print_offset = 1, col = 0;
+
+	from /= 8;
+	to = (to + 7) / 8;
+
+	for (offset = from; offset < to; offset++) {
+		if (print_offset) {
+			printf("%04x: ", offset * 8);
+			print_offset = 0;
+		}
+		printf("%016llx", data[offset]);
+		col++;
+		if ((col & 3) == 0) {
+			printf("\n");
+			print_offset = 1;
+		} else {
+			printf(" ");
+		}
+	}
+
+	if (!print_offset)
+		printf("\n");
+}
+
+int main(int argc, char **argv)
+{
+	struct statx stx;
+	int ret, raw = 0, atflag = AT_SYMLINK_NOFOLLOW;
+
+	unsigned int mask = STATX_ALL_STATS;
+
+	for (argv++; *argv; argv++) {
+		if (strcmp(*argv, "-F") == 0) {
+			atflag |= AT_FORCE_ATTR_SYNC;
+			continue;
+		}
+		if (strcmp(*argv, "-N") == 0) {
+			atflag |= AT_NO_ATTR_SYNC;
+			continue;
+		}
+		if (strcmp(*argv, "-L") == 0) {
+			atflag &= ~AT_SYMLINK_NOFOLLOW;
+			continue;
+		}
+		if (strcmp(*argv, "-O") == 0) {
+			mask &= ~STATX_BASIC_STATS;
+			continue;
+		}
+		if (strcmp(*argv, "-A") == 0) {
+			atflag |= AT_NO_AUTOMOUNT;
+			continue;
+		}
+		if (strcmp(*argv, "-R") == 0) {
+			raw = 1;
+			continue;
+		}
+
+		memset(&stx, 0xbf, sizeof(stx));
+		ret = statx(AT_FDCWD, *argv, atflag, mask, &stx);
+		printf("statx(%s) = %d\n", *argv, ret);
+		if (ret < 0) {
+			perror(*argv);
+			exit(1);
+		}
+
+		if (raw)
+			dump_hex((unsigned long long *)&stx, 0, sizeof(stx));
+
+		dump_statx(&stx);
+	}
+	return 0;
+}

[PATCH 04/12] statx: AFS: Return enhanced file attributes

[David Howells]

Return enhanced file attributes from the AFS filesystem.  This includes the
following:

 (1) The data version number as st_version, setting STATX_VERSION.

 (2) STATX_INFO_AUTOMOUNT will be set on automount directories by virtue of
     S_AUTOMOUNT being set on the inode.  These are referrals to other
     volumes or other cells.

 (3) STATX_INFO_AUTODIR on a directory that does cell lookup for
     non-existent names and mounts them (typically mounted on /afs with -o
     autocell).  The resulting directories are marked STATX_INFO_FABRICATED
     as they do not actually exist in the mounted AFS directory.

 (4) Files, directories and symlinks accessed over AFS are marked
     STATX_INFO_REMOTE.  Local fake directories are marked
     STATX_INFO_FABRICATED.

 (5) STATX_INFO_NONSYSTEM_OWNERSHIP is set as the UID and GID retrieved
     from an AFS share may not be applicable on the system.

STATX_ATIME, STATX_CTIME and STATX_BLOCKS are cleared as AFS does not
support them.

Example output:

	[root@andromeda ~]# ./samples/statx/test-statx /afs
	statx(/afs) = 0
	results=7ef
	  Size: 2048            Blocks: 0          IO Block: 4096    directory
	Device: 00:25           Inode: 1           Links: 2
	Access: (0777/drwxrwxrwx)  Uid:     0   Gid:     0
	Access: 2006-05-07 00:21:15.000000000+0100
	Modify: 2006-05-07 00:21:15.000000000+0100
	Change: 2006-05-07 00:21:15.000000000+0100
	IO-blocksize: blksize=4096

Signed-off-by: David Howells <dhowells@redhat.com>
---

 fs/afs/inode.c |   23 ++++++++++++++++++-----
 1 file changed, 18 insertions(+), 5 deletions(-)

diff --git a/fs/afs/inode.c b/fs/afs/inode.c
index e06f5a23352a..dcf0338ea5cc 100644
--- a/fs/afs/inode.c
+++ b/fs/afs/inode.c
@@ -71,9 +71,9 @@ static int afs_inode_map_status(struct afs_vnode *vnode, struct key *key)
 	inode->i_uid		= vnode->status.owner;
 	inode->i_gid		= GLOBAL_ROOT_GID;
 	inode->i_size		= vnode->status.size;
-	inode->i_ctime.tv_sec	= vnode->status.mtime_server;
-	inode->i_ctime.tv_nsec	= 0;
-	inode->i_atime		= inode->i_mtime = inode->i_ctime;
+	inode->i_mtime.tv_sec	= vnode->status.mtime_server;
+	inode->i_mtime.tv_nsec	= 0;
+	inode->i_atime		= inode->i_ctime = inode->i_mtime;
 	inode->i_blocks		= 0;
 	inode->i_generation	= vnode->fid.unique;
 	inode->i_version	= vnode->status.data_version;
@@ -374,8 +374,7 @@ error_unlock:
 /*
  * read the attributes of an inode
  */
-int afs_getattr(struct vfsmount *mnt, struct dentry *dentry,
-		      struct kstat *stat)
+int afs_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
 {
 	struct inode *inode;
 
@@ -384,6 +383,20 @@ int afs_getattr(struct vfsmount *mnt, struct dentry *dentry,
 	_enter("{ ino=%lu v=%u }", inode->i_ino, inode->i_generation);
 
 	generic_fillattr(inode, stat);
+
+	stat->result_mask &= ~(STATX_ATIME | STATX_CTIME | STATX_BLOCKS);
+	stat->result_mask |= STATX_VERSION;
+	stat->version = inode->i_version;
+
+	if (test_bit(AFS_VNODE_AUTOCELL, &AFS_FS_I(inode)->flags))
+		stat->information |= STATX_INFO_AUTODIR;
+
+	if (test_bit(AFS_VNODE_PSEUDODIR, &AFS_FS_I(inode)->flags))
+		stat->information |= STATX_INFO_FABRICATED;
+	else
+		stat->information |= STATX_INFO_REMOTE;
+
+	stat->information |= STATX_INFO_NONSYSTEM_OWNERSHIP;
 	return 0;
 }
 

[PATCH 05/12] statx: Ext4: Return enhanced file attributes

[David Howells]

Return enhanced file attributes from the Ext4 filesystem.  This includes
the following:

 (1) The inode creation time (i_crtime) as i_btime, setting STATX_BTIME.

 (2) The inode i_version as st_version if a file with I_VERSION set or a
     directory, setting STATX_VERSION.

 (3) FS_xxx_FL flags are returned as for ioctl(FS_IOC_GETFLAGS), setting
     STATX_IOC_FLAGS.

This requires that all ext4 inodes have a getattr call, not just some of
them, so to this end, split the ext4_getattr() function and only call part
of it where appropriate.

Example output:

	[root@andromeda ~]# ./samples/statx/test-statx /usr
	statx(/usr) = 0
	results=37ef
	  Size: 4096            Blocks: 16         IO Block: 4096    directory
	Device: 08:02           Inode: 1572865     Links: 14
	Access: (0755/drwxr-xr-x)  Uid:     0   Gid:     0
	Access: 2015-11-03 16:12:30.000000000+0000
	Modify: 2013-10-18 15:29:18.000000000+0100
	Change: 2013-10-18 15:29:18.000000000+0100
	Data version: 2fh
	Inode flags: 00000000 (-------- -------- -------- --------)
	IO-blocksize: blksize=4096

Signed-off-by: David Howells <dhowells@redhat.com>
---

 fs/ext4/ext4.h    |    2 ++
 fs/ext4/file.c    |    2 +-
 fs/ext4/inode.c   |   31 ++++++++++++++++++++++++++++---
 fs/ext4/namei.c   |    2 ++
 fs/ext4/symlink.c |    2 ++
 5 files changed, 35 insertions(+), 4 deletions(-)

diff --git a/fs/ext4/ext4.h b/fs/ext4/ext4.h
index 31efcd78bf51..606f94ba455c 100644
--- a/fs/ext4/ext4.h
+++ b/fs/ext4/ext4.h
@@ -2302,6 +2302,8 @@ extern int  ext4_getattr(struct vfsmount *mnt, struct dentry *dentry,
 				struct kstat *stat);
 extern void ext4_evict_inode(struct inode *);
 extern void ext4_clear_inode(struct inode *);
+extern int  ext4_file_getattr(struct vfsmount *mnt, struct dentry *dentry,
+			      struct kstat *stat);
 extern int  ext4_sync_inode(handle_t *, struct inode *);
 extern void ext4_dirty_inode(struct inode *, int);
 extern int ext4_change_inode_journal_flag(struct inode *, int);
diff --git a/fs/ext4/file.c b/fs/ext4/file.c
index 113837e7ba98..3b6fe04b199e 100644
--- a/fs/ext4/file.c
+++ b/fs/ext4/file.c
@@ -712,7 +712,7 @@ const struct file_operations ext4_file_operations = {
 
 const struct inode_operations ext4_file_inode_operations = {
 	.setattr	= ext4_setattr,
-	.getattr	= ext4_getattr,
+	.getattr	= ext4_file_getattr,
 	.setxattr	= generic_setxattr,
 	.getxattr	= generic_getxattr,
 	.listxattr	= ext4_listxattr,
diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
index 612fbcf76b5c..c86ff971d8bc 100644
--- a/fs/ext4/inode.c
+++ b/fs/ext4/inode.c
@@ -4818,11 +4818,36 @@ err_out:
 int ext4_getattr(struct vfsmount *mnt, struct dentry *dentry,
 		 struct kstat *stat)
 {
-	struct inode *inode;
-	unsigned long long delalloc_blocks;
+	struct inode *inode = d_inode(dentry);
+	struct ext4_inode *raw_inode;
+	struct ext4_inode_info *ei = EXT4_I(inode);
+
+	if (EXT4_FITS_IN_INODE(raw_inode, ei, i_crtime)) {
+		stat->result_mask |= STATX_BTIME;
+		stat->btime.tv_sec = ei->i_crtime.tv_sec;
+		stat->btime.tv_nsec = ei->i_crtime.tv_nsec;
+	}
+
+	if (S_ISDIR(inode->i_mode) || IS_I_VERSION(inode)) {
+		stat->result_mask |= STATX_VERSION;
+		stat->version = inode->i_version;
+	}
+
+	ext4_get_inode_flags(ei);
+	stat->ioc_flags |= ei->i_flags & EXT4_FL_USER_VISIBLE;
+	stat->result_mask |= STATX_IOC_FLAGS;
 
-	inode = d_inode(dentry);
 	generic_fillattr(inode, stat);
+	return 0;
+}
+
+int ext4_file_getattr(struct vfsmount *mnt, struct dentry *dentry,
+		      struct kstat *stat)
+{
+	struct inode *inode = dentry->d_inode;
+	u64 delalloc_blocks;
+
+	ext4_getattr(mnt, dentry, stat);
 
 	/*
 	 * If there is inline data in the inode, the inode will normally not
diff --git a/fs/ext4/namei.c b/fs/ext4/namei.c
index 9f61e7679a6d..1f18e61c4f8a 100644
--- a/fs/ext4/namei.c
+++ b/fs/ext4/namei.c
@@ -3848,6 +3848,7 @@ const struct inode_operations ext4_dir_inode_operations = {
 	.tmpfile	= ext4_tmpfile,
 	.rename2	= ext4_rename2,
 	.setattr	= ext4_setattr,
+	.getattr	= ext4_getattr,
 	.setxattr	= generic_setxattr,
 	.getxattr	= generic_getxattr,
 	.listxattr	= ext4_listxattr,
@@ -3859,6 +3860,7 @@ const struct inode_operations ext4_dir_inode_operations = {
 
 const struct inode_operations ext4_special_inode_operations = {
 	.setattr	= ext4_setattr,
+	.getattr	= ext4_getattr,
 	.setxattr	= generic_setxattr,
 	.getxattr	= generic_getxattr,
 	.listxattr	= ext4_listxattr,
diff --git a/fs/ext4/symlink.c b/fs/ext4/symlink.c
index c677f2c1044b..89c9d27c6319 100644
--- a/fs/ext4/symlink.c
+++ b/fs/ext4/symlink.c
@@ -106,6 +106,7 @@ const struct inode_operations ext4_symlink_inode_operations = {
 	.follow_link	= page_follow_link_light,
 	.put_link	= page_put_link,
 	.setattr	= ext4_setattr,
+	.getattr	= ext4_getattr,
 	.setxattr	= generic_setxattr,
 	.getxattr	= generic_getxattr,
 	.listxattr	= ext4_listxattr,
@@ -116,6 +117,7 @@ const struct inode_operations ext4_fast_symlink_inode_operations = {
 	.readlink	= generic_readlink,
 	.follow_link    = simple_follow_link,
 	.setattr	= ext4_setattr,
+	.getattr	= ext4_getattr,
 	.setxattr	= generic_setxattr,
 	.getxattr	= generic_getxattr,
 	.listxattr	= ext4_listxattr,

[PATCH 06/12] statx: NFS: Return enhanced file attributes

[David Howells]

Return enhanced file atrributes from the NFS filesystem.  This includes the
following:

 (1) The change attribute as st_version if NFSv4.

 (2) STATX_INFO_AUTOMOUNT and STATX_INFO_FABRICATED are set on referral or
     submount directories that are automounted upon.  NFS shows one
     directory with a different FSID, but the local filesystem has two: the
     mountpoint directory and the root of the filesystem mounted upon it.

 (3) STATX_INFO_REMOTE is set on files acquired over NFS.

 (4) STATX_IOC_FLAGS is set and if the atime is unavailable on a file,
     st_ioc_flags will have FL_NOATIME_FL set in it.

Furthermore, what nfs_getattr() does can be controlled as follows:

 (1) If AT_NO_ATTR_SYNC is indicated then this will suppress the flushing
     of outstanding writes and the rereading of the inode's attributes with
     the server as detailed below.

 (2) Otherwise:

     (a) If AT_FORCE_ATTR_SYNC is indicated, or mtime, ctime or
     	 data_version (NFSv4 only) are requested then the outstanding
     	 writes will be written to the server first.

     (b) The inode's attributes will be reread from the server:

     	 (i) if AT_FORCE_ATTR_SYNC is indicated;

        (ii) if atime is requested (and atime updating is not suppressed by
     	     a mount flag); or

       (iii) if the cached attributes have expired;

If the inode isn't synchronised, then the cached attributes will be used -
even if expired - without reference to the server.

Example output:

	[root@andromeda ~]# ./samples/statx/test-statx /warthog/
	statx(/warthog/) = 0
	results=37ef
	  Size: 4096            Blocks: 8          IO Block: 1048576  directory
	Device: 00:26           Inode: 2           Links: 122
	Access: (3777/drwxrwxrwx)  Uid:     0   Gid:  4041
	Access: 2015-10-30 16:15:41.730925545+0000
	Modify: 2015-10-07 10:33:19.896108112+0100
	Change: 2015-10-07 10:33:19.896108112+0100
	Data version: 5614e6df35698650h
	Inode flags: 00000000 (-------- -------- -------- --------)
	Information: 00000010 (-------- -------- -------- ---r----)
	IO-blocksize: blksize=1048576

Note that the NFS4 protocol potentially provides a creation time that could
be passed through this interface and system, hidden and archive values that
could be passed as IOC flags.  There is also a backup time that could be
added.

Signed-off-by: David Howells <dhowells@redhat.com>
---

 fs/nfs/inode.c |   45 ++++++++++++++++++++++++++++++++++++++-------
 1 file changed, 38 insertions(+), 7 deletions(-)

diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c
index 326d9e10d833..4d86663e37b2 100644
--- a/fs/nfs/inode.c
+++ b/fs/nfs/inode.c
@@ -645,12 +645,23 @@ static bool nfs_need_revalidate_inode(struct inode *inode)
 int nfs_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
 {
 	struct inode *inode = d_inode(dentry);
-	int need_atime = NFS_I(inode)->cache_validity & NFS_INO_INVALID_ATIME;
+	bool force_sync = stat->query_flags & AT_FORCE_ATTR_SYNC;
+	bool suppress_sync = stat->query_flags & AT_NO_ATTR_SYNC;
+	bool need_atime = NFS_I(inode)->cache_validity & NFS_INO_INVALID_ATIME;
 	int err = 0;
 
 	trace_nfs_getattr_enter(inode);
-	/* Flush out writes to the server in order to update c/mtime.  */
-	if (S_ISREG(inode->i_mode)) {
+
+	if (NFS_SERVER(inode)->nfs_client->rpc_ops->version < 4)
+		stat->request_mask &= ~STATX_VERSION;
+
+	/* Flush out writes to the server in order to update c/mtime or data
+	 * version if the user wants them.
+	 */
+	if (S_ISREG(inode->i_mode) && !suppress_sync &&
+	    (force_sync || (stat->request_mask &
+			    (STATX_MTIME | STATX_CTIME | STATX_VERSION)))
+	    ) {
 		mutex_lock(&inode->i_mutex);
 		err = nfs_sync_inode(inode);
 		mutex_unlock(&inode->i_mutex);
@@ -667,11 +678,16 @@ int nfs_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
 	 *  - NFS never sets MS_NOATIME or MS_NODIRATIME so there is
 	 *    no point in checking those.
 	 */
- 	if ((mnt->mnt_flags & MNT_NOATIME) ||
- 	    ((mnt->mnt_flags & MNT_NODIRATIME) && S_ISDIR(inode->i_mode)))
-		need_atime = 0;
+	if ((mnt->mnt_flags & MNT_NOATIME) ||
+	    ((mnt->mnt_flags & MNT_NODIRATIME) && S_ISDIR(inode->i_mode))) {
+		stat->ioc_flags |= FS_NOATIME_FL;
+		need_atime = false;
+	} else if (!(stat->request_mask & STATX_ATIME)) {
+		need_atime = false;
+	}
 
-	if (need_atime || nfs_need_revalidate_inode(inode)) {
+	if (!suppress_sync &&
+	    (force_sync || need_atime || nfs_need_revalidate_inode(inode))) {
 		struct nfs_server *server = NFS_SERVER(inode);
 
 		if (server->caps & NFS_CAP_READDIRPLUS)
@@ -684,6 +700,21 @@ int nfs_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
 		if (S_ISDIR(inode->i_mode))
 			stat->blksize = NFS_SERVER(inode)->dtsize;
 	}
+
+	generic_fillattr(inode, stat);
+	stat->ino = nfs_compat_user_ino64(NFS_FILEID(inode));
+
+	if (stat->request_mask & STATX_VERSION) {
+		stat->version = inode->i_version;
+		stat->result_mask |= STATX_VERSION;
+	}
+
+	if (IS_AUTOMOUNT(inode))
+		stat->information |= STATX_INFO_FABRICATED;
+
+	stat->information |= STATX_INFO_REMOTE;
+	stat->result_mask |= STATX_IOC_FLAGS;
+
 out:
 	trace_nfs_getattr_exit(inode, err);
 	return err;

[PATCH 07/12] statx: CIFS: Return enhanced attributes

[David Howells]

Return enhanced attributes from the CIFS filesystem.  This includes the
following:

 (1) Return the file creation time as btime.  We assume that the creation
     time won't change over the life of the inode.

 (2) Set STATX_INFO_AUTOMOUNT on referral/submount directories.

 (3) Unset STATX_INO if we made up the inode number and didn't get it from
     the server.

 (4) Unset STATX_[UG]ID if we are either returning values passed to mount
     and/or the server doesn't return them.

 (5) Set STATX_IOC_FLAGS and map various Windows file attributes to
     FS_xxx_FL flags in st_ioc_flags, fetching them from the server if we
     don't have them yet or don't have a current copy.  This includes the
     following:

	ATTR_READONLY	-> FS_IMMUTABLE_FL
	ATTR_COMPRESSED	-> FS_COMPR_FL
	ATTR_HIDDEN	-> FS_HIDDEN_FL
	ATTR_SYSTEM	-> FS_SYSTEM_FL
	ATTR_ARCHIVE	-> FS_ARCHIVE_FL

 (6) Set certain STATX_INFO_xxx to reflect other Windows file attributes:

	ATTR_TEMPORARY	-> STATX_INFO_TEMPORARY;
	ATTR_REPARSE	-> STATX_INFO_REPARSE_POINT;
	ATTR_OFFLINE	-> STATX_INFO_OFFLINE;
	ATTR_ENCRYPTED	-> STATX_INFO_ENCRYPTED;

 (7) Set STATX_INFO_REMOTE on all files fetched by CIFS.

 (8) Set STATX_INFO_NONSYSTEM_OWNERSHIP on all files as they all have
     Windows ownership details too.

Furthermore, what cifs_getattr() does can be controlled as follows:

 (1) If AT_NO_ATTR_SYNC is indicated then this will suppress the flushing
     of outstanding writes and the rereading of the inode's attributes with
     the server as detailed below.

 (2) Otherwise:

     (a) If AT_FORCE_ATTR_SYNC is indicated, or mtime, ctime or size are
     	 requested then the outstanding writes will be written to the
     	 server first.

     (b) The inode's attributes will be reread from the server:

     	 (i) if AT_FORCE_ATTR_SYNC is indicated;

        (ii) if the cached attributes have expired;

       (iii) extra attributes are requested that aren't normally stored.

If the inode isn't synchronised, then the cached attributes will be used -
even if expired - without reference to the server.  Some attributes may be
unavailable that would otherwise be provided.

Note that cifs_revalidate_dentry() will issue an extra operation to get the
FILE_ALL_INFO in addition to the FILE_UNIX_BASIC_INFO if it needs to
collect creation time and attributes on behalf of cifs_getattr().

[NOTE: THIS PATCH IS UNTESTED!]

Signed-off-by: David Howells <dhowells@redhat.com>
---

 fs/cifs/cifsfs.h   |    4 +-
 fs/cifs/cifsglob.h |    8 +++
 fs/cifs/dir.c      |    2 -
 fs/cifs/inode.c    |  124 +++++++++++++++++++++++++++++++++++++++++-----------
 4 files changed, 108 insertions(+), 30 deletions(-)

diff --git a/fs/cifs/cifsfs.h b/fs/cifs/cifsfs.h
index c3cc1609025f..fb38d47d84de 100644
--- a/fs/cifs/cifsfs.h
+++ b/fs/cifs/cifsfs.h
@@ -71,9 +71,9 @@ extern int cifs_rmdir(struct inode *, struct dentry *);
 extern int cifs_rename2(struct inode *, struct dentry *, struct inode *,
 			struct dentry *, unsigned int);
 extern int cifs_revalidate_file_attr(struct file *filp);
-extern int cifs_revalidate_dentry_attr(struct dentry *);
+extern int cifs_revalidate_dentry_attr(struct dentry *, bool, bool);
 extern int cifs_revalidate_file(struct file *filp);
-extern int cifs_revalidate_dentry(struct dentry *);
+extern int cifs_revalidate_dentry(struct dentry *, bool, bool);
 extern int cifs_invalidate_mapping(struct inode *inode);
 extern int cifs_revalidate_mapping(struct inode *inode);
 extern int cifs_zap_mapping(struct inode *inode);
diff --git a/fs/cifs/cifsglob.h b/fs/cifs/cifsglob.h
index b406a32deb1f..493e40a15b86 100644
--- a/fs/cifs/cifsglob.h
+++ b/fs/cifs/cifsglob.h
@@ -1152,7 +1152,11 @@ struct cifsInodeInfo {
 	unsigned long flags;
 	spinlock_t writers_lock;
 	unsigned int writers;		/* Number of writers on this inode */
+	bool btime_valid:1;		/* stored creation time is valid */
+	bool uid_faked:1;		/* true if i_uid is faked */
+	bool gid_faked:1;		/* true if i_gid is faked */
 	unsigned long time;		/* jiffies of last update of inode */
+	struct timespec btime;		/* creation time */
 	u64  server_eof;		/* current file size on server -- protected by i_lock */
 	u64  uniqueid;			/* server inode number */
 	u64  createtime;		/* creation time on server */
@@ -1365,6 +1369,9 @@ struct dfs_info3_param {
 #define CIFS_FATTR_NEED_REVAL		0x4
 #define CIFS_FATTR_INO_COLLISION	0x8
 #define CIFS_FATTR_UNKNOWN_NLINK	0x10
+#define CIFS_FATTR_WINATTRS_VALID	0x20	/* T if cf_btime and cf_cifsattrs valid */
+#define CIFS_FATTR_UID_FAKED		0x40	/* T if cf_uid is faked */
+#define CIFS_FATTR_GID_FAKED		0x80	/* T if cf_gid is faked */
 
 struct cifs_fattr {
 	u32		cf_flags;
@@ -1382,6 +1389,7 @@ struct cifs_fattr {
 	struct timespec	cf_atime;
 	struct timespec	cf_mtime;
 	struct timespec	cf_ctime;
+	struct timespec	cf_btime;
 };
 
 static inline void free_dfs_info_param(struct dfs_info3_param *param)
diff --git a/fs/cifs/dir.c b/fs/cifs/dir.c
index c3eb998a99bd..4984f04b0677 100644
--- a/fs/cifs/dir.c
+++ b/fs/cifs/dir.c
@@ -792,7 +792,7 @@ cifs_d_revalidate(struct dentry *direntry, unsigned int flags)
 		return -ECHILD;
 
 	if (d_really_is_positive(direntry)) {
-		if (cifs_revalidate_dentry(direntry))
+		if (cifs_revalidate_dentry(direntry, false, false))
 			return 0;
 		else {
 			/*
diff --git a/fs/cifs/inode.c b/fs/cifs/inode.c
index 6b66dd5d1540..fcb024efbd4b 100644
--- a/fs/cifs/inode.c
+++ b/fs/cifs/inode.c
@@ -166,13 +166,21 @@ cifs_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr)
 	cifs_nlink_fattr_to_inode(inode, fattr);
 	inode->i_uid = fattr->cf_uid;
 	inode->i_gid = fattr->cf_gid;
+	if (fattr->cf_flags & CIFS_FATTR_UID_FAKED)
+		cifs_i->uid_faked = true;
+	if (fattr->cf_flags & CIFS_FATTR_GID_FAKED)
+		cifs_i->gid_faked = true;
 
 	/* if dynperm is set, don't clobber existing mode */
 	if (inode->i_state & I_NEW ||
 	    !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM))
 		inode->i_mode = fattr->cf_mode;
 
-	cifs_i->cifsAttrs = fattr->cf_cifsattrs;
+	if (fattr->cf_flags & CIFS_FATTR_WINATTRS_VALID) {
+		cifs_i->cifsAttrs = fattr->cf_cifsattrs;
+		cifs_i->btime = fattr->cf_btime;
+		cifs_i->btime_valid = true;
+	}
 
 	if (fattr->cf_flags & CIFS_FATTR_NEED_REVAL)
 		cifs_i->time = 0;
@@ -284,18 +292,22 @@ cifs_unix_basic_to_fattr(struct cifs_fattr *fattr, FILE_UNIX_BASIC_INFO *info,
 		u64 id = le64_to_cpu(info->Uid);
 		if (id < ((uid_t)-1)) {
 			kuid_t uid = make_kuid(&init_user_ns, id);
-			if (uid_valid(uid))
+			if (uid_valid(uid)) {
 				fattr->cf_uid = uid;
+				fattr->cf_flags |= CIFS_FATTR_UID_FAKED;
+			}
 		}
 	}
-	
+
 	fattr->cf_gid = cifs_sb->mnt_gid;
 	if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)) {
 		u64 id = le64_to_cpu(info->Gid);
 		if (id < ((gid_t)-1)) {
 			kgid_t gid = make_kgid(&init_user_ns, id);
-			if (gid_valid(gid))
+			if (gid_valid(gid)) {
 				fattr->cf_gid = gid;
+				fattr->cf_flags |= CIFS_FATTR_GID_FAKED;
+			}
 		}
 	}
 
@@ -324,7 +336,8 @@ cifs_create_dfs_fattr(struct cifs_fattr *fattr, struct super_block *sb)
 	fattr->cf_ctime = CURRENT_TIME;
 	fattr->cf_mtime = CURRENT_TIME;
 	fattr->cf_nlink = 2;
-	fattr->cf_flags |= CIFS_FATTR_DFS_REFERRAL;
+	fattr->cf_flags |= CIFS_FATTR_DFS_REFERRAL |
+		CIFS_FATTR_UID_FAKED | CIFS_FATTR_GID_FAKED;
 }
 
 static int
@@ -590,6 +603,7 @@ cifs_all_info_to_fattr(struct cifs_fattr *fattr, FILE_ALL_INFO *info,
 	struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
 
 	memset(fattr, 0, sizeof(*fattr));
+	fattr->cf_flags = CIFS_FATTR_WINATTRS_VALID;
 	fattr->cf_cifsattrs = le32_to_cpu(info->Attributes);
 	if (info->DeletePending)
 		fattr->cf_flags |= CIFS_FATTR_DELETE_PENDING;
@@ -601,6 +615,7 @@ cifs_all_info_to_fattr(struct cifs_fattr *fattr, FILE_ALL_INFO *info,
 
 	fattr->cf_ctime = cifs_NTtimeToUnix(info->ChangeTime);
 	fattr->cf_mtime = cifs_NTtimeToUnix(info->LastWriteTime);
+	fattr->cf_btime = cifs_NTtimeToUnix(info->CreationTime);
 
 	if (adjust_tz) {
 		fattr->cf_ctime.tv_sec += tcon->ses->server->timeAdj;
@@ -1887,7 +1902,8 @@ int cifs_revalidate_file_attr(struct file *filp)
 	return rc;
 }
 
-int cifs_revalidate_dentry_attr(struct dentry *dentry)
+int cifs_revalidate_dentry_attr(struct dentry *dentry,
+				bool want_extra_bits, bool force)
 {
 	unsigned int xid;
 	int rc = 0;
@@ -1898,7 +1914,7 @@ int cifs_revalidate_dentry_attr(struct dentry *dentry)
 	if (inode == NULL)
 		return -ENOENT;
 
-	if (!cifs_inode_needs_reval(inode))
+	if (!force && !cifs_inode_needs_reval(inode))
 		return rc;
 
 	xid = get_xid();
@@ -1915,9 +1931,12 @@ int cifs_revalidate_dentry_attr(struct dentry *dentry)
 		 full_path, inode, inode->i_count.counter,
 		 dentry, dentry->d_time, jiffies);
 
-	if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext)
+	if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext) {
 		rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
-	else
+		if (rc != 0)
+			goto out;
+	}
+	if (!cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext || want_extra_bits)
 		rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
 					 xid, NULL);
 
@@ -1940,12 +1959,13 @@ int cifs_revalidate_file(struct file *filp)
 }
 
 /* revalidate a dentry's inode attributes */
-int cifs_revalidate_dentry(struct dentry *dentry)
+int cifs_revalidate_dentry(struct dentry *dentry,
+			   bool want_extra_bits, bool force)
 {
 	int rc;
 	struct inode *inode = d_inode(dentry);
 
-	rc = cifs_revalidate_dentry_attr(dentry);
+	rc = cifs_revalidate_dentry_attr(dentry, want_extra_bits, force);
 	if (rc)
 		return rc;
 
@@ -1958,28 +1978,62 @@ int cifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
 	struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb);
 	struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
 	struct inode *inode = d_inode(dentry);
+	struct cifsInodeInfo *cifs_i = CIFS_I(inode);
+	bool force = stat->query_flags & AT_FORCE_ATTR_SYNC;
+	bool want_extra_bits = false;
+	u32 info, ioc = 0;
+	u32 attrs;
 	int rc;
 
-	/*
-	 * We need to be sure that all dirty pages are written and the server
-	 * has actual ctime, mtime and file length.
-	 */
-	if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
-	    inode->i_mapping->nrpages != 0) {
-		rc = filemap_fdatawait(inode->i_mapping);
-		if (rc) {
-			mapping_set_error(inode->i_mapping, rc);
-			return rc;
+	if (cifs_i->uid_faked)
+		stat->request_mask &= ~STATX_UID;
+	if (cifs_i->gid_faked)
+		stat->request_mask &= ~STATX_GID;
+
+	if ((stat->request_mask & STATX_BTIME && !cifs_i->btime_valid) ||
+	    stat->request_mask & STATX_IOC_FLAGS)
+		want_extra_bits = force = true;
+
+	if (!(stat->query_flags & AT_NO_ATTR_SYNC)) {
+		/* Unless we're explicitly told not to sync, we need to be sure
+		 * that all dirty pages are written and the server has actual
+		 * ctime, mtime and file length.
+		 */
+		bool flush = force;
+
+		if (stat->request_mask &
+		    (STATX_CTIME | STATX_MTIME | STATX_SIZE))
+			flush = true;
+
+		if (flush &&
+		    !CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
+		    inode->i_mapping->nrpages != 0) {
+			rc = filemap_fdatawait(inode->i_mapping);
+			if (rc) {
+				mapping_set_error(inode->i_mapping, rc);
+				return rc;
+			}
 		}
-	}
 
-	rc = cifs_revalidate_dentry_attr(dentry);
-	if (rc)
-		return rc;
+		rc = cifs_revalidate_dentry(dentry, want_extra_bits, force);
+		if (rc)
+			return rc;
+	}
 
 	generic_fillattr(inode, stat);
 	stat->blksize = CIFS_MAX_MSGSIZE;
-	stat->ino = CIFS_I(inode)->uniqueid;
+
+	info = STATX_INFO_REMOTE | STATX_INFO_NONSYSTEM_OWNERSHIP;
+
+	if (cifs_i->btime_valid) {
+		stat->btime = cifs_i->btime;
+		stat->result_mask |= STATX_BTIME;
+	}
+
+	/* We don't promise an inode number if we made one up */
+	stat->ino = cifs_i->uniqueid;
+	if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM))
+		stat->result_mask &= ~STATX_INO;
 
 	/*
 	 * If on a multiuser mount without unix extensions or cifsacl being
@@ -1993,8 +2047,24 @@ int cifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
 			stat->uid = current_fsuid();
 		if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID))
 			stat->gid = current_fsgid();
+		stat->result_mask &= ~(STATX_UID | STATX_GID);
 	}
-	return rc;
+
+	attrs = cifs_i->cifsAttrs;
+	if (attrs & ATTR_TEMPORARY)	info |= STATX_INFO_TEMPORARY;
+	if (attrs & ATTR_REPARSE)	info |= STATX_INFO_REPARSE_POINT;
+	if (attrs & ATTR_OFFLINE)	info |= STATX_INFO_OFFLINE;
+	if (attrs & ATTR_ENCRYPTED)	info |= STATX_INFO_ENCRYPTED;
+	stat->information |= info;
+
+	if (attrs & ATTR_READONLY)	ioc |= FS_IMMUTABLE_FL;
+	if (attrs & ATTR_COMPRESSED)	ioc |= FS_COMPR_FL;
+	if (attrs & ATTR_HIDDEN)	ioc |= FS_HIDDEN_FL;
+	if (attrs & ATTR_SYSTEM)	ioc |= FS_SYSTEM_FL;
+	if (attrs & ATTR_ARCHIVE)	ioc |= FS_ARCHIVE_FL;
+	stat->ioc_flags |= ioc;
+
+	return 0;
 }
 
 static int cifs_truncate_page(struct address_space *mapping, loff_t from)

[PATCH 08/12] fsinfo: Add a system call to make enhanced filesystem info available

[David Howells]

Add a system call to make enhanced filesystem information available - this
is the counterpart to the addition of the enhanced stat syscall.  The extra
data includes information about the timestamps, available IOC flags, volume
identifiers and the domain or server name of a network filesystem.


===============
NEW SYSTEM CALL
===============

The new system call is:

	int ret = fsinfo(int dfd,
			 const char *filename,
			 unsigned int flags,
			 unsigned int request,
			 void *buffer);

The dfd, filename and flags parameters indicate the file to query.  There
is no equivalent of lstat() as that can be emulated with fsinfo() by
passing AT_SYMLINK_NOFOLLOW in flags.  There is also no equivalent of
fstat() as that can be emulated by passing a NULL filename to fsinfo() with
the fd of interest in dfd.  AT_NO_AUTOMOUNT can also be used to allow
automount points to be queried without triggering it.

AT_FORCE_ATTR_SYNC can be set in flags.  This will require a network
filesystem to synchronise its attributes with the server.

AT_NO_ATTR_SYNC can be set in flags.  This will suppress synchronisation
with the server in a network filesystem.  The resulting values should be
considered approximate.

request indicates what is desired.  Currently this only available request
value is 0.

buffer points to the destination for the main data.

At the moment, this will only work on x86_64 and i386 as it requires the system
call to be wired up.


========================================
REQUEST 0: FILESYSTEM INFORMATION RECORD
========================================

The following structures are defined in which to return the filesystem
information set:

	struct fsinfo {
		__u32	f_mask;
		__u32	f_fstype;
		__u64	f_dev;
		__u64	f_blocks;
		__u64	f_bfree;
		__u64	f_bavail;
		__u64	f_files;
		__u64	f_ffree;
		__u64	f_favail;
		__u32	f_bsize;
		__u16	f_frsize;
		__u16	f_namelen;
		__u64	f_flags;
		__u64	f_fsid;
		__u64	f_supported_ioc_flags;
		__s64	f_min_time;
		__s64	f_max_time;
		__u16	f_atime_gran_mantissa;
		__u16	f_btime_gran_mantissa;
		__u16	f_ctime_gran_mantissa;
		__u16	f_mtime_gran_mantissa;
		__s8	f_atime_gran_exponent;
		__s8	f_btime_gran_exponent;
		__s8	f_ctime_gran_exponent;
		__s8	f_mtime_gran_exponent;
		__u8	__spare6c[0x80 - 0x7c];
		__u8	__spare80[0xd0 - 0x80];
		char	f_fs_name[15 + 1];
		__u8	f_volume_id[16];
		__u8	f_volume_uuid[16];
		char	f_volume_name[255 + 1];
		char	f_domain_name[255 + 1];
		__u8	__spare300[0x400 - 0x300];
	};

where f_mask indicates the attributes that have been returned, f_fs_name is
the filesystem name as text, f_fstype is the filesystem type ID as per
linux/magic.h and f_supported_ioc_flags is the mask of flags in
st_ioc_flags that are supported.

f_?time_gran_* are time granularities in the form mant*10^exp (an exponent
of 0 would indicate seconds, -9 would indicate nanoseconds).  Note that
FAT, for example, has a different granularity for each time.

f_min_time and f_max_time give the range of the timestamps in seconds.  It
is assumed that all the timestamps in a filesystem have the same range, if
not the same resolution (ie. FAT).

f_blocks, f_bfree, f_bavail, f_files, f_ffree, f_favail, f_bsize, f_frsize,
f_namelen and f_flags are as for statfs.

There are five fields for volume identification:

 (1) f_fsid is the filesystem ID as per statfs::f_fsid.

 (2) f_volume_id is an arbitrary binary volume ID.

 (3) f_volume_uuid is the volume UUID

 (4) f_volume_name is a string holding the volume name

 (5) f_domain_name is a string holding the domain/cell/workgroup/server
     name.

All fields except f_mask are optional.  The fields are controlled by a
combination of the flags in st_mask (as returned by statx()) and the flags
in f_mask in the following manner:

	st_mask & STATX_ATIME		Got f_atime_gran_*
	st_mask & STATX_BTIME		Got f_btime_gran_*
	st_mask & STATX_CTIME		Got f_ctime_gran_*
	st_mask & STATX_MTIME		Got f_mtime_gran_*
	st_mask & STATX_?TIME		Got f_zero_time_offset
	st_mask & STATX_IOC_FLAGS	Got f_supported_ioc_flags
	f_mask & STATX_BLOCKS_INFO	Got f_blocks, f_bfree, f_bavail, f_bsize
	f_mask & STATX_FILES_INFO	Got f_files, f_ffree, f_favail
	f_mask & STATX_FSID		Got f_fsid
	f_mask & STATX_VOLUME_ID	Got f_volume_id
	f_mask & STATX_VOLUME_UUID	Got f_volume_uuid
	f_mask & STATX_VOLUME_NAME	Got f_volume_name
	f_mask & STATX_DOMAIN_NAME	Got f_domain_name

There is also spare expansion space in __spare*[].  The whole structure is
1024 bytes in size.


=======
TESTING
=======

A sample program is provided that can be used to test the fsinfo() system
call:

	./samples/statx/test-fsinfo.c

This will be built automatically with CONFIG_SAMPLES=y.  When run, it
should be passed the paths to the files you want to examine.

Here's some example output.

	[root@andromeda ~]# ./test-fsinfo /usr/
	fsinfo(/usr/) = 0
	mask  : 5f
	dev   : 08:02
	fs    : type=ef53 name=ext3
	ioc   : 0
	nameln: 255
	flags : 1020
	times : range=ffffffff80000000-7fffffff
	atime : gran=1s
	btime : gran=1s
	ctime : gran=1s
	mtime : gran=1s
	blocks: n=2505737 fr=308288 av=177258
	files : n=2621440 fr=2428582 av=2428582
	bsize : 4096
	frsize: 4096
	fsid  : 8bc3c470dfcc8abf
	uuid  : 2f07dbcf-6b6f-41fe-908d-17101bab8275

Signed-off-by: David Howells <dhowells@redhat.com>
---

 arch/x86/entry/syscalls/syscall_32.tbl |    1 
 arch/x86/entry/syscalls/syscall_64.tbl |    1 
 fs/statfs.c                            |  218 ++++++++++++++++++++++++++++++++
 include/linux/fs.h                     |    2 
 include/linux/syscalls.h               |    3 
 include/uapi/linux/stat.h              |   69 ++++++++++
 samples/statx/Makefile                 |    5 +
 samples/statx/test-fsinfo.c            |  179 ++++++++++++++++++++++++++
 8 files changed, 477 insertions(+), 1 deletion(-)
 create mode 100644 samples/statx/test-fsinfo.c

diff --git a/arch/x86/entry/syscalls/syscall_32.tbl b/arch/x86/entry/syscalls/syscall_32.tbl
index 6e570ee4241d..5faee9d28a21 100644
--- a/arch/x86/entry/syscalls/syscall_32.tbl
+++ b/arch/x86/entry/syscalls/syscall_32.tbl
@@ -383,3 +383,4 @@
 374	i386	userfaultfd		sys_userfaultfd
 375	i386	membarrier		sys_membarrier
 376	i386	statx			sys_statx
+377	i386	fsinfo			sys_fsinfo
diff --git a/arch/x86/entry/syscalls/syscall_64.tbl b/arch/x86/entry/syscalls/syscall_64.tbl
index cbfef23f8067..8b0958fdc86f 100644
--- a/arch/x86/entry/syscalls/syscall_64.tbl
+++ b/arch/x86/entry/syscalls/syscall_64.tbl
@@ -332,6 +332,7 @@
 323	common	userfaultfd		sys_userfaultfd
 324	common	membarrier		sys_membarrier
 325	common	statx			sys_statx
+326	common	fsinfo			sys_fsinfo
 
 #
 # x32-specific system call numbers start at 512 to avoid cache impact
diff --git a/fs/statfs.c b/fs/statfs.c
index 083dc0ac9140..99604cb42e8d 100644
--- a/fs/statfs.c
+++ b/fs/statfs.c
@@ -239,3 +239,221 @@ SYSCALL_DEFINE2(ustat, unsigned, dev, struct ustat __user *, ubuf)
 
 	return copy_to_user(ubuf, &tmp, sizeof(struct ustat)) ? -EFAULT : 0;
 }
+
+/**
+ * vfs_get_fsinfo_from_statfs - Fill in some of fsinfo from ->statfs()
+ * @dentry: The filesystem to query
+ * @fsinfo: The filesystem information record to fill in
+ * @flags: One of AT_{NO|FORCE}_SYNC_ATTR or 0
+ *
+ * Fill in some of the filesystem information record from data retrieved via
+ * the statfs superblock method.  This is called if there is no ->fsinfo() op
+ * and may also be called by a filesystem's ->fsinfo() op.
+ */
+int vfs_get_fsinfo_from_statfs(struct dentry *dentry,
+			       struct fsinfo *fsinfo, unsigned flags)
+{
+	struct kstatfs buf;
+	int ret;
+
+	ret = statfs_by_dentry(dentry, &buf);
+	if (ret < 0)
+		return ret;
+
+	if (buf.f_blocks) {
+		fsinfo->f_mask |= FSINFO_BLOCKS_INFO;
+		fsinfo->f_blocks = buf.f_blocks;
+		fsinfo->f_bfree  = buf.f_bfree;
+		fsinfo->f_bavail = buf.f_bavail;
+	}
+
+	if (buf.f_files) {
+		fsinfo->f_mask |= FSINFO_FILES_INFO;
+		fsinfo->f_files  = buf.f_files;
+		fsinfo->f_ffree  = buf.f_ffree;
+		fsinfo->f_favail = buf.f_ffree;
+	}
+
+	fsinfo->f_namelen = buf.f_namelen;
+	if (buf.f_bsize > 0) {
+		fsinfo->f_mask |= FSINFO_BSIZE;
+		fsinfo->f_bsize	= buf.f_bsize;
+	}
+	if (buf.f_frsize > 0) {
+		fsinfo->f_frsize = buf.f_frsize;
+		fsinfo->f_mask |= FSINFO_FRSIZE;
+	} else if (fsinfo->f_mask & FSINFO_BSIZE) {
+		fsinfo->f_frsize = fsinfo->f_bsize;
+	}
+
+	if (dentry->d_sb->s_op->statfs != simple_statfs) {
+		memcpy(&fsinfo->f_fsid, &buf.f_fsid, sizeof(fsinfo->f_fsid));
+		fsinfo->f_mask |= FSINFO_FSID;
+	}
+	return 0;
+}
+EXPORT_SYMBOL(vfs_get_fsinfo_from_statfs);
+
+/*
+ * Preset bits of the data to be returned with defaults.
+ */
+static void vfs_fsinfo_preset(struct dentry *dentry, struct fsinfo *fsinfo)
+{
+	struct super_block *sb = dentry->d_sb;
+	/* If unset, assume 1s granularity */
+	uint16_t mantissa = 1;
+	uint8_t exponent = 0;
+	u32 x;
+
+	fsinfo->f_fstype = sb->s_magic;
+	strcpy(fsinfo->f_fs_name, sb->s_type->name);
+
+	fsinfo->f_min_time = S64_MIN;
+	fsinfo->f_max_time = S64_MAX;
+	if (sb->s_time_gran < 1000000000) {
+		if (sb->s_time_gran < 1000)
+			exponent = -9;
+		else if (sb->s_time_gran < 1000000)
+			exponent = -6;
+		else
+			exponent = -3;
+	}
+#define set_gran(x)						\
+	do {							\
+		fsinfo->f_##x##_mantissa = mantissa;		\
+		fsinfo->f_##x##_exponent = exponent;		\
+	} while (0)
+	set_gran(atime_gran);
+	set_gran(btime_gran);
+	set_gran(ctime_gran);
+	set_gran(mtime_gran);
+
+	x  = ((u32 *)&fsinfo->f_volume_uuid)[0] = ((u32 *)&sb->s_uuid)[0];
+	x |= ((u32 *)&fsinfo->f_volume_uuid)[1] = ((u32 *)&sb->s_uuid)[1];
+	x |= ((u32 *)&fsinfo->f_volume_uuid)[2] = ((u32 *)&sb->s_uuid)[2];
+	x |= ((u32 *)&fsinfo->f_volume_uuid)[3] = ((u32 *)&sb->s_uuid)[3];
+	if (x)
+		fsinfo->f_mask |= FSINFO_VOLUME_UUID;
+}
+
+/*
+ * Retrieve the filesystem info.  We make some stuff up if the operation is not
+ * supported.
+ */
+static int vfs_fsinfo(struct path *path, struct fsinfo *fsinfo, unsigned flags)
+{
+	struct dentry *dentry = path->dentry;
+	int (*get_fsinfo)(struct dentry *, struct fsinfo *, unsigned) =
+		dentry->d_sb->s_op->get_fsinfo;
+	int ret;
+
+	if (!get_fsinfo) {
+		if (!dentry->d_sb->s_op->statfs)
+			return -ENOSYS;
+		get_fsinfo = vfs_get_fsinfo_from_statfs;
+	}
+
+	ret = security_sb_statfs(dentry);
+	if (ret)
+		return ret;
+
+	vfs_fsinfo_preset(dentry, fsinfo);
+	ret = get_fsinfo(dentry, fsinfo, flags);
+	if (ret < 0)
+		return ret;
+
+	fsinfo->f_dev_major = MAJOR(dentry->d_sb->s_dev);
+	fsinfo->f_dev_minor = MINOR(dentry->d_sb->s_dev);
+	fsinfo->f_flags = calculate_f_flags(path->mnt);
+	return 0;
+}
+
+static int vfs_fsinfo_path(int dfd, const char __user *filename, int flags,
+			   struct fsinfo *fsinfo)
+{
+	struct path path;
+	unsigned lookup_flags = LOOKUP_FOLLOW | LOOKUP_AUTOMOUNT;
+	int ret = -EINVAL;
+
+	if ((flags & ~(AT_SYMLINK_NOFOLLOW | AT_NO_AUTOMOUNT |
+		       AT_EMPTY_PATH | KSTAT_QUERY_FLAGS)) != 0)
+		return -EINVAL;
+
+	if (flags & AT_SYMLINK_NOFOLLOW)
+		lookup_flags &= ~LOOKUP_FOLLOW;
+	if (flags & AT_NO_AUTOMOUNT)
+		lookup_flags &= ~LOOKUP_AUTOMOUNT;
+	if (flags & AT_EMPTY_PATH)
+		lookup_flags |= LOOKUP_EMPTY;
+
+retry:
+	ret = user_path_at(dfd, filename, lookup_flags, &path);
+	if (ret)
+		goto out;
+
+	ret = vfs_fsinfo(&path, fsinfo, flags);
+	path_put(&path);
+	if (retry_estale(ret, lookup_flags)) {
+		lookup_flags |= LOOKUP_REVAL;
+		goto retry;
+	}
+out:
+	return ret;
+}
+
+static int vfs_fsinfo_fd(unsigned int fd, unsigned flags, struct fsinfo *fsinfo)
+{
+	struct fd f = fdget_raw(fd);
+	int ret = -EBADF;
+
+	if (f.file) {
+		ret = vfs_fsinfo(&f.file->f_path, fsinfo, flags);
+		fdput(f);
+	}
+	return ret;
+}
+
+/**
+ * sys_fsinfo - System call to get enhanced filesystem information
+ * @dfd: Base directory to pathwalk from *or* fd to stat.
+ * @filename: File to stat *or* NULL.
+ * @flags: AT_* flags to control pathwalk.
+ * @request: Request being made.
+ * @buffer: Result buffer.
+ *
+ * Note that if filename is NULL, then dfd is used to indicate the file of
+ * interest.
+ *
+ * Currently, the only permitted request value is 0.
+ */
+SYSCALL_DEFINE5(fsinfo,
+		int, dfd, const char __user *, filename, unsigned, flags,
+		unsigned, request, void __user *, buffer)
+{
+	struct fsinfo *fsinfo;
+	int ret;
+
+	if (request != 0)
+		return -EINVAL;
+	if ((flags & AT_FORCE_ATTR_SYNC) && (flags & AT_NO_ATTR_SYNC))
+		return -EINVAL;
+	if (!access_ok(VERIFY_WRITE, buffer, sizeof(*buffer)))
+		return -EFAULT;
+
+	fsinfo = kzalloc(sizeof(struct fsinfo), GFP_KERNEL);
+	if (!fsinfo)
+		return -ENOMEM;
+
+	if (filename)
+		ret = vfs_fsinfo_path(dfd, filename, flags, fsinfo);
+	else
+		ret = vfs_fsinfo_fd(dfd, flags, fsinfo);
+	if (ret)
+		goto error;
+
+	if (copy_to_user(buffer, fsinfo, sizeof(struct fsinfo)))
+		ret = -EFAULT;
+error:
+	kfree(fsinfo);
+	return ret;
+}
diff --git a/include/linux/fs.h b/include/linux/fs.h
index 8fb641ac1027..a7b629e99743 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -1711,6 +1711,7 @@ struct super_operations {
 	int (*thaw_super) (struct super_block *);
 	int (*unfreeze_fs) (struct super_block *);
 	int (*statfs) (struct dentry *, struct kstatfs *);
+	int (*get_fsinfo) (struct dentry *, struct fsinfo *, unsigned);
 	int (*remount_fs) (struct super_block *, int *, char *);
 	void (*umount_begin) (struct super_block *);
 
@@ -2027,6 +2028,7 @@ extern int vfs_statfs(struct path *, struct kstatfs *);
 extern int user_statfs(const char __user *, struct kstatfs *);
 extern int fd_statfs(int, struct kstatfs *);
 extern int vfs_ustat(dev_t, struct kstatfs *);
+extern int vfs_get_fsinfo_from_statfs(struct dentry *, struct fsinfo *, unsigned);
 extern int freeze_super(struct super_block *super);
 extern int thaw_super(struct super_block *super);
 extern bool our_mnt(struct vfsmount *mnt);
diff --git a/include/linux/syscalls.h b/include/linux/syscalls.h
index 09eb280f6bf6..d4fd7e4682f5 100644
--- a/include/linux/syscalls.h
+++ b/include/linux/syscalls.h
@@ -49,6 +49,7 @@ struct stat64;
 struct statfs;
 struct statfs64;
 struct statx;
+struct fsinfo;
 struct __sysctl_args;
 struct sysinfo;
 struct timespec;
@@ -889,5 +890,7 @@ asmlinkage long sys_execveat(int dfd, const char __user *filename,
 asmlinkage long sys_membarrier(int cmd, int flags);
 asmlinkage long sys_statx(int dfd, const char __user *path, unsigned flags,
 			  unsigned mask, struct statx __user *buffer);
+asmlinkage long sys_fsinfo(int dfd, const char __user *path, unsigned flags,
+			   unsigned request, void __user *buffer);
 
 #endif
diff --git a/include/uapi/linux/stat.h b/include/uapi/linux/stat.h
index 41a5412e7ad5..d0ce8fb7f848 100644
--- a/include/uapi/linux/stat.h
+++ b/include/uapi/linux/stat.h
@@ -158,4 +158,73 @@ struct statx {
 #define STATX_INFO_NONSYSTEM_OWNERSHIP	0x00000100U /* File has non-system ownership details */
 #define STATX_INFO_REPARSE_POINT	0x00000200U /* File is reparse point (NTFS/CIFS) */
 
+/*
+ * Information struct for fsinfo() request 0.
+ */
+struct fsinfo {
+	/* 0x00 - General info */
+	__u32	f_mask;		/* What optional fields are filled in */
+	__u32	f_fstype;	/* Filesystem type from linux/magic.h [uncond] */
+	__u32	f_dev_major;	/* As st_dev_* from struct statx [uncond] */
+	__u32	f_dev_minor;
+
+	/* 0x10 - statfs information */
+	__u64	f_blocks;	/* Total number of blocks in fs */
+	__u64	f_bfree;	/* Total number of free blocks */
+	__u64	f_bavail;	/* Number of free blocks available to ordinary user */
+	__u64	f_files;	/* Total number of file nodes in fs */
+	__u64	f_ffree;	/* Number of free file nodes */
+	__u64	f_favail;	/* Number of free file nodes available to ordinary user */
+	/* 0x40 */
+	__u32	f_bsize;	/* Optimal block size */
+	__u16	f_frsize;	/* Fragment size */
+	__u16	f_namelen;	/* Maximum name length [uncond] */
+	__u64	f_flags;	/* Filesystem mount flags */
+	/* 0x50 */
+	__u64	f_fsid;		/* Short 64-bit Filesystem ID (as statfs) */
+	__u64	f_supported_ioc_flags; /* supported FS_IOC_GETFLAGS flags  */
+
+	/* 0x60 - File timestamp info */
+	__s64	f_min_time;	/* Minimum timestamp value in seconds */
+	__s64	f_max_time;	/* Maximum timestamp value in seconds */
+	/* 0x70 */
+	__u16	f_atime_gran_mantissa;	/* granularity(secs) = mant * 10^exp */
+	__u16	f_btime_gran_mantissa;
+	__u16	f_ctime_gran_mantissa;
+	__u16	f_mtime_gran_mantissa;
+	__s8	f_atime_gran_exponent;
+	__s8	f_btime_gran_exponent;
+	__s8	f_ctime_gran_exponent;
+	__s8	f_mtime_gran_exponent;
+	__u8	__spare6c[0x80 - 0x7c];
+
+	/* 0x80 */
+	__u8	__spare80[0xd0 - 0x80];
+	/* 0xd0 */
+	char	f_fs_name[15 + 1]; /* Filesystem name [uncond] */
+	/* 0xe0 */
+	__u8	f_volume_id[16]; /* Volume/fs identifier */
+	__u8	f_volume_uuid[16]; /* Volume/fs UUID */
+	/* 0x100 */
+	char	f_volume_name[255 + 1]; /* Volume name */
+	/* 0x200 */
+	char	f_domain_name[255 + 1]; /* Domain/cell/workgroup name */
+	/* 0x300 */
+	__u8	__spare300[0x400 - 0x300];
+	/* 0x400 */
+};
+
+/*
+ * Flags to be found in f_mask.
+ */
+#define FSINFO_BLOCKS_INFO	0x00000001	/* Got f_blocks, f_bfree, f_bavail */
+#define FSINFO_FILES_INFO	0x00000002	/* Got f_files, f_ffree, f_favail */
+#define FSINFO_BSIZE		0x00000004	/* Got f_bsize */
+#define FSINFO_FRSIZE		0x00000008	/* Got f_frsize */
+#define FSINFO_FSID		0x00000010	/* Got f_fsid */
+#define FSINFO_VOLUME_ID	0x00000020	/* Got f_volume_id */
+#define FSINFO_VOLUME_UUID	0x00000040	/* Got f_volume_uuid */
+#define FSINFO_VOLUME_NAME	0x00000080	/* Got f_volume_name */
+#define FSINFO_DOMAIN_NAME	0x00000100	/* Got f_domain_name */
+
 #endif /* _UAPI_LINUX_STAT_H */
diff --git a/samples/statx/Makefile b/samples/statx/Makefile
index 6765dabc4c8d..bd8c3c34206d 100644
--- a/samples/statx/Makefile
+++ b/samples/statx/Makefile
@@ -2,9 +2,12 @@
 obj- := dummy.o
 
 # List of programs to build
-hostprogs-y := test-statx
+hostprogs-y := test-statx test-fsinfo
 
 # Tell kbuild to always build the programs
 always := $(hostprogs-y)
 
 HOSTCFLAGS_test-statx.o += -I$(objtree)/usr/include
+
+HOSTCFLAGS_test-fsinfo.o += -I$(objtree)/usr/include
+HOSTLOADLIBES_test-fsinfo += -lm
diff --git a/samples/statx/test-fsinfo.c b/samples/statx/test-fsinfo.c
new file mode 100644
index 000000000000..7724390b0aa4
--- /dev/null
+++ b/samples/statx/test-fsinfo.c
@@ -0,0 +1,179 @@
+/* Test the fsinfo() system call
+ *
+ * Copyright (C) 2015 Red Hat, Inc. All Rights Reserved.
+ * Written by David Howells (dhowells@redhat.com)
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public Licence
+ * as published by the Free Software Foundation; either version
+ * 2 of the Licence, or (at your option) any later version.
+ */
+
+#define _GNU_SOURCE
+#define _ATFILE_SOURCE
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <unistd.h>
+#include <ctype.h>
+#include <errno.h>
+#include <time.h>
+#include <math.h>
+#include <sys/syscall.h>
+#include <linux/stat.h>
+#include <linux/fcntl.h>
+#include <sys/stat.h>
+
+#define __NR_fsinfo 326
+
+static __attribute__((unused))
+ssize_t fsinfo(int dfd, const char *filename, unsigned flags,
+	       unsigned request, void *buffer)
+{
+	return syscall(__NR_fsinfo, dfd, filename, flags, request, buffer);
+}
+
+static void dump_fsinfo(struct fsinfo *f)
+{
+	printf("mask  : %x\n", f->f_mask);
+	printf("dev   : %02x:%02x\n", f->f_dev_major, f->f_dev_minor);
+	printf("fs    : type=%x name=%s\n", f->f_fstype, f->f_fs_name);
+	printf("ioc   : %llx\n", (unsigned long long)f->f_supported_ioc_flags);
+	printf("nameln: %u\n", f->f_namelen);
+	printf("flags : %llx\n", (unsigned long long)f->f_flags);
+	printf("times : range=%llx-%llx\n",
+	       (unsigned long long)f->f_min_time,
+	       (unsigned long long)f->f_max_time);
+
+#define print_time(G) \
+	printf(#G"time : gran=%gs\n",			\
+	       (f->f_##G##time_gran_mantissa *		\
+		pow(10., f->f_##G##time_gran_exponent)))
+	print_time(a);
+	print_time(b);
+	print_time(c);
+	print_time(m);
+
+
+	if (f->f_mask & FSINFO_BLOCKS_INFO)
+		printf("blocks: n=%llu fr=%llu av=%llu\n",
+		       (unsigned long long)f->f_blocks,
+		       (unsigned long long)f->f_bfree,
+		       (unsigned long long)f->f_bavail);
+
+	if (f->f_mask & FSINFO_FILES_INFO)
+		printf("files : n=%llu fr=%llu av=%llu\n",
+		       (unsigned long long)f->f_files,
+		       (unsigned long long)f->f_ffree,
+		       (unsigned long long)f->f_favail);
+
+	if (f->f_mask & FSINFO_BSIZE)
+		printf("bsize : %u\n", f->f_bsize);
+
+	if (f->f_mask & FSINFO_FRSIZE)
+		printf("frsize: %u\n", f->f_frsize);
+
+	if (f->f_mask & FSINFO_FSID)
+		printf("fsid  : %llx\n", (unsigned long long)f->f_fsid);
+
+	if (f->f_mask & FSINFO_VOLUME_ID) {
+		int printable = 1, loop;
+		printf("volid : ");
+		for (loop = 0; loop < sizeof(f->f_volume_id); loop++)
+			if (!isprint(f->f_volume_id[loop]))
+				printable = 0;
+		if (printable) {
+			printf("'%.*s'", 16, f->f_volume_id);
+		} else {
+			for (loop = 0; loop < sizeof(f->f_volume_id); loop++) {
+				if (loop % 4 == 0 && loop != 0)
+					printf(" ");
+				printf("%02x", f->f_volume_id[loop]);
+			}
+		}
+		printf("\n");
+	}
+
+	if (f->f_mask & FSINFO_VOLUME_UUID)
+		printf("uuid  : "
+		       "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x"
+		       "-%02x%02x%02x%02x%02x%02x\n",
+		       f->f_volume_uuid[ 0], f->f_volume_uuid[ 1],
+		       f->f_volume_uuid[ 2], f->f_volume_uuid[ 3],
+		       f->f_volume_uuid[ 4], f->f_volume_uuid[ 5],
+		       f->f_volume_uuid[ 6], f->f_volume_uuid[ 7],
+		       f->f_volume_uuid[ 8], f->f_volume_uuid[ 9],
+		       f->f_volume_uuid[10], f->f_volume_uuid[11],
+		       f->f_volume_uuid[12], f->f_volume_uuid[13],
+		       f->f_volume_uuid[14], f->f_volume_uuid[15]);
+	if (f->f_mask & FSINFO_VOLUME_NAME)
+		printf("volume: '%s'\n", f->f_volume_name);
+	if (f->f_mask & FSINFO_DOMAIN_NAME)
+		printf("domain: '%s'\n", f->f_domain_name);
+}
+
+static void dump_hex(unsigned long long *data, int from, int to)
+{
+	unsigned offset, print_offset = 1, col = 0;
+
+	from /= 8;
+	to = (to + 7) / 8;
+
+	for (offset = from; offset < to; offset++) {
+		if (print_offset) {
+			printf("%04x: ", offset * 8);
+			print_offset = 0;
+		}
+		printf("%016llx", data[offset]);
+		col++;
+		if ((col & 3) == 0) {
+			printf("\n");
+			print_offset = 1;
+		} else {
+			printf(" ");
+		}
+	}
+
+	if (!print_offset)
+		printf("\n");
+}
+
+int main(int argc, char **argv)
+{
+	struct fsinfo f;
+	int ret, raw = 0, atflag = AT_SYMLINK_NOFOLLOW;
+
+	for (argv++; *argv; argv++) {
+		if (strcmp(*argv, "-F") == 0) {
+			atflag |= AT_FORCE_ATTR_SYNC;
+			continue;
+		}
+		if (strcmp(*argv, "-L") == 0) {
+			atflag &= ~AT_SYMLINK_NOFOLLOW;
+			continue;
+		}
+		if (strcmp(*argv, "-A") == 0) {
+			atflag |= AT_NO_AUTOMOUNT;
+			continue;
+		}
+		if (strcmp(*argv, "-R") == 0) {
+			raw = 1;
+			continue;
+		}
+
+		memset(&f, 0xbd, sizeof(f));
+		ret = fsinfo(AT_FDCWD, *argv, atflag, 0, &f);
+		printf("fsinfo(%s) = %d\n", *argv, ret);
+		if (ret < 0) {
+			perror(*argv);
+			exit(1);
+		}
+
+		if (raw)
+			dump_hex((unsigned long long *)&f, 0, sizeof(f));
+
+		dump_fsinfo(&f);
+	}
+	return 0;
+}

[PATCH 09/12] fsinfo: Ext4: Return information through the filesystem info syscall

[David Howells]

Return Ext4 filesystem information through the filesystem info retrieval
system call.  This includes the following:

 (1) information about the capacity and resolution of the inode timestamps;

 (2) the volume label as the volume name, setting FSINFO_VOLUME_NAME;

 (3) the remote FSID as the volume ID, setting FSINFO_VOLUME_ID;

 (4) the statfs information;

 (5) a list of supported IOC flags.

Example output:

	[root@andromeda ~]# ./test-fsinfo /var/cache/fscache/
	fsinfo(/var/cache/fscache/) = 0
	mask  : 9f
	dev   : 08:06
	fs    : type=ef53 name=ext4
	ioc   : 4bdfff
	nameln: 255
	flags : 1020
	times : range=ffffffff80000000-37fffffff
	atime : gran=1e-09s
	btime : gran=1e-09s
	ctime : gran=1e-09s
	mtime : gran=1e-09s
	blocks: n=1123529 fr=208887 av=146054
	files : n=293760 fr=225334 av=225334
	bsize : 4096
	frsize: 4096
	fsid  : 48bc815f32464608
	volume: 'fred'

Signed-off-by: David Howells <dhowells@redhat.com>
---

 fs/ext4/super.c |   39 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 39 insertions(+)

diff --git a/fs/ext4/super.c b/fs/ext4/super.c
index a63c7b0a10cf..fbd1cad4ff3b 100644
--- a/fs/ext4/super.c
+++ b/fs/ext4/super.c
@@ -73,6 +73,8 @@ static void ext4_clear_journal_err(struct super_block *sb,
 static int ext4_sync_fs(struct super_block *sb, int wait);
 static int ext4_remount(struct super_block *sb, int *flags, char *data);
 static int ext4_statfs(struct dentry *dentry, struct kstatfs *buf);
+static int ext4_get_fsinfo(struct dentry *dentry, struct fsinfo *f,
+			   unsigned flags);
 static int ext4_unfreeze(struct super_block *sb);
 static int ext4_freeze(struct super_block *sb);
 static struct dentry *ext4_mount(struct file_system_type *fs_type, int flags,
@@ -1122,6 +1124,7 @@ static const struct super_operations ext4_sops = {
 	.freeze_fs	= ext4_freeze,
 	.unfreeze_fs	= ext4_unfreeze,
 	.statfs		= ext4_statfs,
+	.get_fsinfo	= ext4_get_fsinfo,
 	.remount_fs	= ext4_remount,
 	.show_options	= ext4_show_options,
 #ifdef CONFIG_QUOTA
@@ -3524,6 +3527,7 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
 	if (sb->s_magic != EXT4_SUPER_MAGIC)
 		goto cantfind_ext4;
 	sbi->s_kbytes_written = le64_to_cpu(es->s_kbytes_written);
+	memcpy(sb->s_uuid, es->s_uuid, sizeof(sb->s_uuid));
 
 	/* Warn if metadata_csum and gdt_csum are both set. */
 	if (EXT4_HAS_RO_COMPAT_FEATURE(sb,
@@ -5179,6 +5183,41 @@ static int ext4_statfs(struct dentry *dentry, struct kstatfs *buf)
 	return 0;
 }
 
+/*
+ * Read filesystem information.
+ */
+static int ext4_get_fsinfo(struct dentry *dentry, struct fsinfo *f,
+			   unsigned flags)
+{
+	struct super_block *sb = dentry->d_sb;
+	struct ext4_sb_info *sbi = EXT4_SB(sb);
+	struct ext4_super_block *es = sbi->s_es;
+	struct inode *inode = d_inode(dentry);
+	struct ext4_inode *raw_inode;
+	struct ext4_inode_info *ei = EXT4_I(inode);
+
+	strcpy(f->f_volume_name, es->s_volume_name);
+
+	f->f_mask = FSINFO_FSID | FSINFO_VOLUME_NAME;
+	f->f_supported_ioc_flags = EXT4_FL_USER_VISIBLE;
+
+	f->f_min_time = S32_MIN;
+	f->f_max_time = S32_MAX;
+
+	if (EXT4_FITS_IN_INODE(raw_inode, ei, i_ctime_extra))
+		f->f_ctime_gran_exponent = -9;
+	if (EXT4_FITS_IN_INODE(raw_inode, ei, i_mtime_extra))
+		f->f_mtime_gran_exponent = -9;
+	if (EXT4_FITS_IN_INODE(raw_inode, ei, i_atime_extra)) {
+		f->f_atime_gran_exponent = -9;
+		f->f_max_time += ((1 << EXT4_EPOCH_BITS) - 1) * 0x100000000LL;
+	}
+	if (EXT4_FITS_IN_INODE(raw_inode, ei, i_crtime_extra))
+		f->f_btime_gran_exponent = -9;
+
+	return vfs_get_fsinfo_from_statfs(dentry, f, flags);
+}
+
 /* Helper function for writing quotas on sync - we need to start transaction
  * before quota file is locked for write. Otherwise the are possible deadlocks:
  * Process 1                         Process 2

[PATCH 10/12] fsinfo: AFS: Return information through the filesystem info syscall

[David Howells]

Return AFS filesystem information through the filesystem info retrieval
system call.  This includes the following:

 (1) information about the capacity and resolution of the inode timestamps;

 (2) the cell name as the domain name, setting FSINFO_DOMAIN_NAME;

 (3) the volume name, setting FSINFO_VOLUME_NAME;

 (4) the volume ID plus the volume type75 as the volume ID, setting
     FSINFO_VOLUME_ID;

and unless AT_NO_ATTR_SYNC is specified:

 (5) the statfs information retrieved from the server.

Note that no FSID value is returned as the local FSID since the FSID value
is a local handle used by NFSD; see the volume ID field instead.

Example output:

	[root@andromeda ~]# ./test-fsinfo /afs
	fsinfo(/afs) = 0
	mask  : 1ad
	dev   : 00:24
	fs    : type=6b414653 name=afs
	ioc   : 0
	nameln: 255
	flags : 1020
	times : range=0-ffffffff
	atime : gran=1s
	btime : gran=1s
	ctime : gran=1s
	mtime : gran=1s
	blocks: n=5000 fr=4998 av=4998
	bsize : 1024
	frsize: 1024
	volid : 20000000 00000000 00000000 00000000
	volume: 'root.afs'
	domain: 'cambridge.redhat.com'

Possibly I should indicate the length of data stored in the volid field.

Signed-off-by: David Howells <dhowells@redhat.com>
---

 fs/afs/super.c |   39 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 39 insertions(+)

diff --git a/fs/afs/super.c b/fs/afs/super.c
index 1fb4a5129f7d..ca88bb43ee1a 100644
--- a/fs/afs/super.c
+++ b/fs/afs/super.c
@@ -37,6 +37,8 @@ static void afs_kill_super(struct super_block *sb);
 static struct inode *afs_alloc_inode(struct super_block *sb);
 static void afs_destroy_inode(struct inode *inode);
 static int afs_statfs(struct dentry *dentry, struct kstatfs *buf);
+static int afs_get_fsinfo(struct dentry *dentry, struct fsinfo *f,
+			  unsigned flags);
 
 struct file_system_type afs_fs_type = {
 	.owner		= THIS_MODULE,
@@ -49,6 +51,7 @@ MODULE_ALIAS_FS("afs");
 
 static const struct super_operations afs_super_ops = {
 	.statfs		= afs_statfs,
+	.get_fsinfo	= afs_get_fsinfo,
 	.alloc_inode	= afs_alloc_inode,
 	.drop_inode	= afs_drop_inode,
 	.destroy_inode	= afs_destroy_inode,
@@ -555,3 +558,39 @@ static int afs_statfs(struct dentry *dentry, struct kstatfs *buf)
 	buf->f_bavail = buf->f_bfree = buf->f_blocks - vs.blocks_in_use;
 	return 0;
 }
+
+/*
+ * Read filesystem information.
+ */
+static int afs_get_fsinfo(struct dentry *dentry, struct fsinfo *f,
+			  unsigned flags)
+{
+	struct afs_super_info *as = dentry->d_sb->s_fs_info;
+	int ret;
+
+	f->f_bsize	= AFS_BLOCK_SIZE;
+	f->f_namelen	= AFSNAMEMAX - 1;
+	f->f_min_time	= 0;
+	f->f_max_time	= U32_MAX;
+
+	/* Construct a volume ID from the AFS volume ID and type */
+	f->f_volume_id[0] = as->volume->vid >> 24;
+	f->f_volume_id[1] = as->volume->vid >> 16;
+	f->f_volume_id[2] = as->volume->vid >> 8;
+	f->f_volume_id[3] = as->volume->vid >> 0;
+	f->f_volume_id[4] = as->volume->type;
+
+	strcpy(f->f_volume_name, as->volume->vlocation->vldb.name);
+	strcpy(f->f_domain_name, as->volume->cell->name);
+
+	f->f_mask = FSINFO_VOLUME_ID | FSINFO_VOLUME_NAME | FSINFO_DOMAIN_NAME;
+
+	if (flags & AT_NO_ATTR_SYNC)
+		return 0;
+
+	ret = vfs_get_fsinfo_from_statfs(dentry, f, flags);
+
+	/* Don't pass the FSID to userspace since this isn't exportable */
+	f->f_mask &= ~FSINFO_FSID;
+	return 0;
+}

[PATCH 11/12] fsinfo: NFS: Return information through the filesystem info syscall

[David Howells]

Return NFS filesystem information through the filesystem info retrieval
system call.  This includes the following:

 (1) information about the capacity and resolution of the inode timestamps;

 (2) the client hostname as the domain name, setting FSINFO_DOMAIN_NAME;

 (3) the remote FSID as the volume ID, setting FSINFO_VOLUME_ID;

and unless AT_NO_ATTR_SYNC is specified:

 (4) the statfs information retrieved from the server.

Note that the NFS FSID value is *not* returned as the local FSID since the
FSID value is a local handle used by NFSD; see the volume ID field instead.

Example output:

	[root@andromeda ~]# ./test-fsinfo /warthog/
	fsinfo(/warthog/) = 0
	mask  : 12f
	dev   : 00:27
	fs    : type=6969 name=nfs4
	ioc   : 0
	nameln: 255
	flags : 1020
	times : range=8000000000000000-7fffffffffffffff
	atime : gran=1e-09s
	btime : gran=1e-09s
	ctime : gran=1e-09s
	mtime : gran=1e-09s
	blocks: n=503841 fr=48261 av=22645
	files : n=32776192 fr=18903243 av=18903243
	bsize : 1048576
	frsize: 0
	volid : 8c494c34 de5688ac 2e61e05d 5f144b8e
	domain: 'warthog'

Note that NFS4 potentially provides a separate value for f_favail that could
be provided through this interface.

Signed-off-by: David Howells <dhowells@redhat.com>
---

 fs/nfs/internal.h  |    1 +
 fs/nfs/nfs4super.c |    1 +
 fs/nfs/super.c     |   58 ++++++++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 60 insertions(+)

diff --git a/fs/nfs/internal.h b/fs/nfs/internal.h
index 56cfde26fb9c..6c7bb9c9e5c6 100644
--- a/fs/nfs/internal.h
+++ b/fs/nfs/internal.h
@@ -442,6 +442,7 @@ extern void nfs_pageio_reset_read_mds(struct nfs_pageio_descriptor *pgio);
 void nfs_clone_super(struct super_block *, struct nfs_mount_info *);
 void nfs_umount_begin(struct super_block *);
 int  nfs_statfs(struct dentry *, struct kstatfs *);
+int  nfs_get_fsinfo(struct dentry *, struct fsinfo *, unsigned);
 int  nfs_show_options(struct seq_file *, struct dentry *);
 int  nfs_show_devname(struct seq_file *, struct dentry *);
 int  nfs_show_path(struct seq_file *, struct dentry *);
diff --git a/fs/nfs/nfs4super.c b/fs/nfs/nfs4super.c
index 6fb7cb6b3f4b..1c15c5884ac4 100644
--- a/fs/nfs/nfs4super.c
+++ b/fs/nfs/nfs4super.c
@@ -54,6 +54,7 @@ static const struct super_operations nfs4_sops = {
 	.write_inode	= nfs4_write_inode,
 	.drop_inode	= nfs_drop_inode,
 	.statfs		= nfs_statfs,
+	.get_fsinfo	= nfs_get_fsinfo,
 	.evict_inode	= nfs4_evict_inode,
 	.umount_begin	= nfs_umount_begin,
 	.show_options	= nfs_show_options,
diff --git a/fs/nfs/super.c b/fs/nfs/super.c
index 383a027de452..bbd33b121b48 100644
--- a/fs/nfs/super.c
+++ b/fs/nfs/super.c
@@ -311,6 +311,7 @@ const struct super_operations nfs_sops = {
 	.write_inode	= nfs_write_inode,
 	.drop_inode	= nfs_drop_inode,
 	.statfs		= nfs_statfs,
+	.get_fsinfo	= nfs_get_fsinfo,
 	.evict_inode	= nfs_evict_inode,
 	.umount_begin	= nfs_umount_begin,
 	.show_options	= nfs_show_options,
@@ -494,6 +495,63 @@ int nfs_statfs(struct dentry *dentry, struct kstatfs *buf)
 EXPORT_SYMBOL_GPL(nfs_statfs);
 
 /*
+ * Read filesystem information.
+ */
+int nfs_get_fsinfo(struct dentry *dentry, struct fsinfo *f, unsigned flags)
+{
+	struct nfs_server *server = NFS_SB(dentry->d_sb);
+	struct nfs_client *client = server->nfs_client;
+	int ret;
+
+	f->f_bsize	= dentry->d_sb->s_blocksize;
+	f->f_namelen	= server->namelen;
+
+	if (client->rpc_ops->version < 4) {
+		f->f_min_time = 0;
+		f->f_max_time = U32_MAX;
+	} else {
+		f->f_min_time = S64_MIN;
+		f->f_max_time = S64_MAX;
+	}
+
+	f->f_atime_gran_exponent = -6;
+	f->f_ctime_gran_exponent = -6;
+	f->f_mtime_gran_exponent = -6;
+	if (client->rpc_ops->version >= 3) {
+		f->f_atime_gran_exponent = -9;
+		f->f_ctime_gran_exponent = -9;
+		f->f_mtime_gran_exponent = -9;
+	}
+
+	if (client->cl_hostname) {
+		strncpy(f->f_domain_name, client->cl_hostname,
+			sizeof(f->f_domain_name));
+		f->f_domain_name[sizeof(f->f_domain_name) - 1] = 0;
+		f->f_mask |= FSINFO_DOMAIN_NAME;
+	}
+
+	/* Treat the remote FSID as the volume ID since we don't support
+	 * reexportation through NFSD.
+	 */
+	memcpy(f->f_volume_id, &server->fsid,
+	       min(sizeof(f->f_volume_id), sizeof(server->fsid)));
+	f->f_mask |= FSINFO_VOLUME_ID;
+	
+	if (flags & AT_NO_ATTR_SYNC)
+		return 0;
+
+	ret = vfs_get_fsinfo_from_statfs(dentry, f, flags);
+	if (ret < 0)
+		return ret;
+
+	/* Don't pass the FSID to userspace since this isn't exportable */
+	memset(&f->f_fsid, 0, sizeof(f->f_fsid));
+	f->f_mask &= ~FSINFO_FSID;
+	return 0;
+}
+EXPORT_SYMBOL_GPL(nfs_get_fsinfo);
+
+/*
  * Map the security flavour number to a name
  */
 static const char *nfs_pseudoflavour_to_name(rpc_authflavor_t flavour)

[PATCH 12/12] fsinfo: CIFS: Return information through the filesystem info syscall

[David Howells]

Return CIFS filesystem information through the filesystem info retrieval
system call.  This includes the following:

 (1) information about the capacity and resolution of the inode timestamps;

 (2) information about the supported IOC flags;

and unless AT_NO_ATTR_SYNC is specified:

 (3) the statfs information retrieved from the server.

We could also return the server and/or domain name.

[NOTE: THIS PATCH IS UNTESTED!]

Signed-off-by: David Howells <dhowells-H+wXaHxf7aLQT0dZR+AlfA@public.gmane.org>
---

 fs/cifs/cifsfs.c       |   25 +++++++++++++++++++++++++
 fs/cifs/netmisc.c      |    4 ----
 fs/ntfs/time.h         |    2 --
 include/linux/time64.h |    2 ++
 4 files changed, 27 insertions(+), 6 deletions(-)

diff --git a/fs/cifs/cifsfs.c b/fs/cifs/cifsfs.c
index e739950ca084..213831972164 100644
--- a/fs/cifs/cifsfs.c
+++ b/fs/cifs/cifsfs.c
@@ -207,6 +207,30 @@ cifs_statfs(struct dentry *dentry, struct kstatfs *buf)
 	return 0;
 }
 
+/*
+ * Read filesystem information.
+ */
+static int cifs_get_fsinfo(struct dentry *dentry, struct fsinfo *f,
+			   unsigned flags)
+{
+	f->f_namelen = PATH_MAX;
+
+	/* Times are signed 64-bit values with a granularity of 100ns
+	 * with a zero point of 1st Jan 1601.
+	 */
+	f->f_min_time = S64_MIN / 10000000 - NTFS_TIME_OFFSET;
+	f->f_max_time = S64_MAX / 10000000 - NTFS_TIME_OFFSET;
+	f->f_atime_gran_exponent = -7;
+	f->f_btime_gran_exponent = -7;
+	f->f_ctime_gran_exponent = -7;
+	f->f_mtime_gran_exponent = -7;
+
+	f->f_supported_ioc_flags =
+		FS_IMMUTABLE_FL | FS_COMPR_FL | FS_HIDDEN_FL |
+		FS_SYSTEM_FL | FS_ARCHIVE_FL;
+	return 0;
+}
+
 static long cifs_fallocate(struct file *file, int mode, loff_t off, loff_t len)
 {
 	struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file);
@@ -571,6 +595,7 @@ static int cifs_drop_inode(struct inode *inode)
 
 static const struct super_operations cifs_super_ops = {
 	.statfs = cifs_statfs,
+	.get_fsinfo	= cifs_get_fsinfo,
 	.alloc_inode = cifs_alloc_inode,
 	.destroy_inode = cifs_destroy_inode,
 	.drop_inode	= cifs_drop_inode,
diff --git a/fs/cifs/netmisc.c b/fs/cifs/netmisc.c
index abae6dd2c6b9..74fdbd8d824d 100644
--- a/fs/cifs/netmisc.c
+++ b/fs/cifs/netmisc.c
@@ -910,10 +910,6 @@ smbCalcSize(void *buf)
 		2 /* size of the bcc field */ + get_bcc(ptr));
 }
 
-/* The following are taken from fs/ntfs/util.c */
-
-#define NTFS_TIME_OFFSET ((u64)(369*365 + 89) * 24 * 3600 * 10000000)
-
 /*
  * Convert the NT UTC (based 1601-01-01, in hundred nanosecond units)
  * into Unix UTC (based 1970-01-01, in seconds).
diff --git a/fs/ntfs/time.h b/fs/ntfs/time.h
index 01233989d5d1..7b546d0615ca 100644
--- a/fs/ntfs/time.h
+++ b/fs/ntfs/time.h
@@ -27,8 +27,6 @@
 
 #include "endian.h"
 
-#define NTFS_TIME_OFFSET ((s64)(369 * 365 + 89) * 24 * 3600 * 10000000)
-
 /**
  * utc2ntfs - convert Linux UTC time to NTFS time
  * @ts:		Linux UTC time to convert to NTFS time
diff --git a/include/linux/time64.h b/include/linux/time64.h
index 367d5af899e8..a12f6384febf 100644
--- a/include/linux/time64.h
+++ b/include/linux/time64.h
@@ -6,6 +6,8 @@
 
 typedef __s64 time64_t;
 
+#define NTFS_TIME_OFFSET ((u64)(369*365 + 89) * 24 * 3600 * 10000000)
+
 /*
  * This wants to go into uapi/linux/time.h once we agreed about the
  * userspace interfaces.

--
To unsubscribe from this list: send the line "unsubscribe linux-nfs" in
the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html

[PATCH 12/12] fsinfo: CIFS: Return information through the filesystem info syscall

[David Howells]

Return CIFS filesystem information through the filesystem info retrieval
system call.  This includes the following:

 (1) information about the capacity and resolution of the inode timestamps;

 (2) information about the supported IOC flags;

and unless AT_NO_ATTR_SYNC is specified:

 (3) the statfs information retrieved from the server.

We could also return the server and/or domain name.

[NOTE: THIS PATCH IS UNTESTED!]

Signed-off-by: David Howells <dhowells@redhat.com>
---

 fs/cifs/cifsfs.c       |   25 +++++++++++++++++++++++++
 fs/cifs/netmisc.c      |    4 ----
 fs/ntfs/time.h         |    2 --
 include/linux/time64.h |    2 ++
 4 files changed, 27 insertions(+), 6 deletions(-)

diff --git a/fs/cifs/cifsfs.c b/fs/cifs/cifsfs.c
index e739950ca084..213831972164 100644
--- a/fs/cifs/cifsfs.c
+++ b/fs/cifs/cifsfs.c
@@ -207,6 +207,30 @@ cifs_statfs(struct dentry *dentry, struct kstatfs *buf)
 	return 0;
 }
 
+/*
+ * Read filesystem information.
+ */
+static int cifs_get_fsinfo(struct dentry *dentry, struct fsinfo *f,
+			   unsigned flags)
+{
+	f->f_namelen = PATH_MAX;
+
+	/* Times are signed 64-bit values with a granularity of 100ns
+	 * with a zero point of 1st Jan 1601.
+	 */
+	f->f_min_time = S64_MIN / 10000000 - NTFS_TIME_OFFSET;
+	f->f_max_time = S64_MAX / 10000000 - NTFS_TIME_OFFSET;
+	f->f_atime_gran_exponent = -7;
+	f->f_btime_gran_exponent = -7;
+	f->f_ctime_gran_exponent = -7;
+	f->f_mtime_gran_exponent = -7;
+
+	f->f_supported_ioc_flags =
+		FS_IMMUTABLE_FL | FS_COMPR_FL | FS_HIDDEN_FL |
+		FS_SYSTEM_FL | FS_ARCHIVE_FL;
+	return 0;
+}
+
 static long cifs_fallocate(struct file *file, int mode, loff_t off, loff_t len)
 {
 	struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file);
@@ -571,6 +595,7 @@ static int cifs_drop_inode(struct inode *inode)
 
 static const struct super_operations cifs_super_ops = {
 	.statfs = cifs_statfs,
+	.get_fsinfo	= cifs_get_fsinfo,
 	.alloc_inode = cifs_alloc_inode,
 	.destroy_inode = cifs_destroy_inode,
 	.drop_inode	= cifs_drop_inode,
diff --git a/fs/cifs/netmisc.c b/fs/cifs/netmisc.c
index abae6dd2c6b9..74fdbd8d824d 100644
--- a/fs/cifs/netmisc.c
+++ b/fs/cifs/netmisc.c
@@ -910,10 +910,6 @@ smbCalcSize(void *buf)
 		2 /* size of the bcc field */ + get_bcc(ptr));
 }
 
-/* The following are taken from fs/ntfs/util.c */
-
-#define NTFS_TIME_OFFSET ((u64)(369*365 + 89) * 24 * 3600 * 10000000)
-
 /*
  * Convert the NT UTC (based 1601-01-01, in hundred nanosecond units)
  * into Unix UTC (based 1970-01-01, in seconds).
diff --git a/fs/ntfs/time.h b/fs/ntfs/time.h
index 01233989d5d1..7b546d0615ca 100644
--- a/fs/ntfs/time.h
+++ b/fs/ntfs/time.h
@@ -27,8 +27,6 @@
 
 #include "endian.h"
 
-#define NTFS_TIME_OFFSET ((s64)(369 * 365 + 89) * 24 * 3600 * 10000000)
-
 /**
  * utc2ntfs - convert Linux UTC time to NTFS time
  * @ts:		Linux UTC time to convert to NTFS time
diff --git a/include/linux/time64.h b/include/linux/time64.h
index 367d5af899e8..a12f6384febf 100644
--- a/include/linux/time64.h
+++ b/include/linux/time64.h
@@ -6,6 +6,8 @@
 
 typedef __s64 time64_t;
 
+#define NTFS_TIME_OFFSET ((u64)(369*365 + 89) * 24 * 3600 * 10000000)
+
 /*
  * This wants to go into uapi/linux/time.h once we agreed about the
  * userspace interfaces.

Re: [RFC][PATCH 00/12] Enhanced file stat system call

[Martin Steigerwald]

Am Freitag, 20. November 2015, 14:54:22 CET schrieb David Howells:
> The seventh patch provides another new system call:
> 
>         long ret = fsinfo(int dfd,
>                           const char *filename,
>                           unsigned atflag,
>                           unsigned request,
>                           void *buffer);
> 
> This is an enhanced filesystem stat and information retrieval function that
> provides more information, in summary:
> 
>  (1) All the information provided by statfs() and more.  The fields are
>      made large.
> 
>  (2) Provides information about timestamp range and resolution to
>      complement statx().
> 
>  (3) Provides information about IOC flags supported in statx()'s return.
> 
>  (4) Provides volume binary IDs and UUIDs.
> 
>  (5) Provides the filesystem name according to the kernel as a string
>      (eg. "ext4" or "nfs3") in addition to the magic number.
> 
>  (6) Provides information obtained from network filesystems, such as volume
>      and domain names.
> 
>  (7) Has lots of spare space that can be used for future extenstions and a
>      bit mask indicating what was provided.

Any plans to add limitations of filesystem to the call like maximum file size? 
I know its mostly relevant for just for FAT32, but on any account rather than 
trying to write 4 GiB and then file, it would be good to at some time get a 
dialog at the beginning of the copy.

Well, but okay, maybe its use case is too limited as FAT32 is not an in any 
kind modern filesystem anymore and limits of modern filesystems are much 
higher.

But other limits like maximum amount of extended attributes, maximum amount of 
acls or symlinks on one directory may be nice to query. Symlinks for BTRFS 
without extended symlink support and acls maybe for XFS, I remember there at 
least has been a limit at some time that was quite low.

Thanks,
-- 
Martin

Re: [RFC][PATCH 00/12] Enhanced file stat system call

[David Howells]

Martin Steigerwald <martin-3kZCPVa5dk2azgQtNeiOUg@public.gmane.org> wrote:

> Any plans to add limitations of filesystem to the call like maximum file
> size?  I know its mostly relevant for just for FAT32, but on any account
> rather than trying to write 4 GiB and then file, it would be good to at some
> time get a dialog at the beginning of the copy.

Adding filesystem limits can be done.  I got a shopping list of things people
wanted a while back and I've worked off of that list.  I can add other things
- that's on of the reasons I left room for expansion.

David

Re: [RFC][PATCH 00/12] Enhanced file stat system call

[David Howells]

Martin Steigerwald <martin@lichtvoll.de> wrote:

> Any plans to add limitations of filesystem to the call like maximum file
> size?  I know its mostly relevant for just for FAT32, but on any account
> rather than trying to write 4 GiB and then file, it would be good to at some
> time get a dialog at the beginning of the copy.

Adding filesystem limits can be done.  I got a shopping list of things people
wanted a while back and I've worked off of that list.  I can add other things
- that's on of the reasons I left room for expansion.

David

Re: [RFC][PATCH 00/12] Enhanced file stat system call

[Martin Steigerwald]

Cc linux-afs dropped due to bounce:

<linux-afs@vger.kernel.org>: host vger.kernel.org[209.132.180.67] said: 554
    5.0.0 Hi [194.150.191.11], unresolvable address:
    <linux-afs@vger.kernel.org>; nosuchuser; linux-afs@vger.kernel.org (in
    reply to RCPT TO command)

Am Freitag, 20. November 2015, 16:28:35 CET schrieb David Howells:
> Martin Steigerwald <martin@lichtvoll.de> wrote:
> > Any plans to add limitations of filesystem to the call like maximum file
> > size?  I know its mostly relevant for just for FAT32, but on any account
> > rather than trying to write 4 GiB and then file, it would be good to at
> > some time get a dialog at the beginning of the copy.
> 
> Adding filesystem limits can be done.  I got a shopping list of things
> people wanted a while back and I've worked off of that list.  I can add
> other things - that's on of the reasons I left room for expansion.

Cool, thank you for bringing this forward.

I am teaching in my Linux trainings since years that one day one will be able 
to see file creation time with stat shell command, actually mentioning ideas 
to make some xstat/statx system call. :)

Thanks,
-- 
Martin

Re: [RFC][PATCH 00/12] Enhanced file stat system call

[Casey Schaufler]

On 11/20/2015 6:54 AM, David Howells wrote:
> Implement new system calls to provide enhanced file stats and enhanced
> filesystem stats.  The patches can be found here:
>
> 	http://git.kernel.org/cgit/linux/kernel/git/dhowells/linux-fs.git/log/?h=xstat
>
>
> ===========
> DESCRIPTION
> ===========
>
> The third patch provides this new system call:
>
> 	long ret = statx(int dfd,
> 			 const char *filename,
> 			 unsigned atflag,
> 			 unsigned mask,
> 			 struct statx *buffer);
>
> This is an enhanced file stat function that provides a number of useful
> features, in summary:
>
>   (1) More information: creation time, data version number,
>       flags/attributes.  A subset of these is available through a number of
>       filesystems (such as CIFS, NFS, AFS, Ext4 and BTRFS).
>
>   (2) Lightweight stat (AT_NO_ATTR_SYNC): Ask for just those details of
>       interest, and allow a network fs to approximate anything not of
>       interest, without going to the server.
>
>   (3) Heavyweight stat (AT_FORCE_ATTR_SYNC): Force a network fs to flush
>       buffers and go to the server, even if it thinks its cached attributes
>       are up to date.
>
>   (4) Allow the filesystem to indicate what it can/cannot provide: A
>       filesystem can now say it doesn't support a standard stat feature if
>       that isn't available.
>
>   (5) Make the fields a consistent size on all arches, and make them large.
>
>   (6) Can be extended by using more request flags and using up the padding
>       space in the statx struct.

How about relevant xattrs? SELinux context, ACL, that sort of thing.
The fact that these are optional should be taken care of by (4).

>
> Note that no lstat() equivalent is required as that can be implemented
> through statx() with atflag == 0.  There is also no fstat() equivalent as
> that can be implemented through statx() with filename == NULL and the
> relevant fd passed as dfd.
>
>
> The seventh patch provides another new system call:
>
> 	long ret = fsinfo(int dfd,
> 			  const char *filename,
> 			  unsigned atflag,
> 			  unsigned request,
> 			  void *buffer);
>
> This is an enhanced filesystem stat and information retrieval function that
> provides more information, in summary:
>
>   (1) All the information provided by statfs() and more.  The fields are
>       made large.
>
>   (2) Provides information about timestamp range and resolution to
>       complement statx().
>
>   (3) Provides information about IOC flags supported in statx()'s return.
>
>   (4) Provides volume binary IDs and UUIDs.
>
>   (5) Provides the filesystem name according to the kernel as a string
>       (eg. "ext4" or "nfs3") in addition to the magic number.
>
>   (6) Provides information obtained from network filesystems, such as volume
>       and domain names.
>
>   (7) Has lots of spare space that can be used for future extenstions and a
>       bit mask indicating what was provided.
>
> Note that I've added a 'request' identifier.  This is to select the set of
> data to be returned.  The idea is that 'buffer' points to a fixed-size
> struct selected by request.  Currently only 0 is available and this refers
> to 'struct fsinfo'.  However, I could split up the buffer into say 3:
>
>   (0) statfs-type information
>
>   (1) Timestamp and IOC flags info.
>
>   (2) Network fs strings.
>
> However, some of this might be better retrieved through getxattr().
>
>
> =======
> TESTING
> =======
>
> Test programs are added into samples/statx/ by the appropriate patches.
>
> David
> ---
> David Howells (12):
>        Ext4: Fix extended timestamp encoding and decoding
>        statx: Provide IOC flags for Windows fs attributes
>        statx: Add a system call to make enhanced file info available
>        statx: AFS: Return enhanced file attributes
>        statx: Ext4: Return enhanced file attributes
>        statx: NFS: Return enhanced file attributes
>        statx: CIFS: Return enhanced attributes
>        fsinfo: Add a system call to make enhanced filesystem info available
>        fsinfo: Ext4: Return information through the filesystem info syscall
>        fsinfo: AFS: Return information through the filesystem info syscall
>        fsinfo: NFS: Return information through the filesystem info syscall
>        fsinfo: CIFS: Return information through the filesystem info syscall
>
>
>   arch/x86/entry/syscalls/syscall_32.tbl |    2
>   arch/x86/entry/syscalls/syscall_64.tbl |    2
>   fs/afs/inode.c                         |   23 ++
>   fs/afs/super.c                         |   39 ++++
>   fs/cifs/cifsfs.c                       |   25 +++
>   fs/cifs/cifsfs.h                       |    4
>   fs/cifs/cifsglob.h                     |    8 +
>   fs/cifs/dir.c                          |    2
>   fs/cifs/inode.c                        |  124 ++++++++++---
>   fs/cifs/netmisc.c                      |    4
>   fs/exportfs/expfs.c                    |    4
>   fs/ext4/ext4.h                         |   24 ++-
>   fs/ext4/file.c                         |    2
>   fs/ext4/inode.c                        |   31 +++
>   fs/ext4/namei.c                        |    2
>   fs/ext4/super.c                        |   39 ++++
>   fs/ext4/symlink.c                      |    2
>   fs/nfs/inode.c                         |   45 ++++-
>   fs/nfs/internal.h                      |    1
>   fs/nfs/nfs4super.c                     |    1
>   fs/nfs/super.c                         |   58 ++++++
>   fs/ntfs/time.h                         |    2
>   fs/stat.c                              |  305 +++++++++++++++++++++++++++++---
>   fs/statfs.c                            |  218 +++++++++++++++++++++++
>   include/linux/fs.h                     |    7 +
>   include/linux/stat.h                   |   14 +
>   include/linux/syscalls.h               |    6 +
>   include/linux/time64.h                 |    2
>   include/uapi/linux/fcntl.h             |    2
>   include/uapi/linux/fs.h                |    7 +
>   include/uapi/linux/stat.h              |  185 +++++++++++++++++++
>   samples/Makefile                       |    3
>   samples/statx/Makefile                 |   13 +
>   samples/statx/test-fsinfo.c            |  179 +++++++++++++++++++
>   samples/statx/test-statx.c             |  273 +++++++++++++++++++++++++++++
>   35 files changed, 1558 insertions(+), 100 deletions(-)
>   create mode 100644 samples/statx/Makefile
>   create mode 100644 samples/statx/test-fsinfo.c
>   create mode 100644 samples/statx/test-statx.c
>
> --
> To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at  http://vger.kernel.org/majordomo-info.html
> Please read the FAQ at  http://www.tux.org/lkml/
>

Re: [RFC][PATCH 00/12] Enhanced file stat system call

[Christoph Hellwig]

Hi David,

from a quick look the statx bits looks fine in general.  I think Ted
last time had a problem with the IOC flag allocation, so you might
want to ping him.

But fsinfo with the multiplexer and the void pointer is just horrible.
What were you thinking there?

Re: [RFC][PATCH 00/12] Enhanced file stat system call

[Christoph Hellwig]

Hi David,

from a quick look the statx bits looks fine in general.  I think Ted
last time had a problem with the IOC flag allocation, so you might
want to ping him.

But fsinfo with the multiplexer and the void pointer is just horrible.
What were you thinking there?

Re: [RFC][PATCH 00/12] Enhanced file stat system call

[Christoph Hellwig]

On Fri, Nov 20, 2015 at 05:19:31PM +0100, Martin Steigerwald wrote:
> I know its mostly relevant for just for FAT32, but on any account rather than 
> trying to write 4 GiB and then file, it would be good to at some time get a 
> dialog at the beginning of the copy.

pathconf/fpathconf is supposed to handle that.  It's not super pretty
but part of Posix.  Linus hates it, but it might be time to give it
another try.

Re: [RFC][PATCH 00/12] Enhanced file stat system call

[Christoph Hellwig]

On Fri, Nov 20, 2015 at 08:50:22AM -0800, Casey Schaufler wrote:
> How about relevant xattrs? SELinux context, ACL, that sort of thing.
> The fact that these are optional should be taken care of by (4).

Those are not simple, fixed size stat data and would make the system
call a giant mess.
--
To unsubscribe from this list: send the line "unsubscribe linux-nfs" in
the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html

Re: [RFC][PATCH 00/12] Enhanced file stat system call

[Christoph Hellwig]

On Fri, Nov 20, 2015 at 08:50:22AM -0800, Casey Schaufler wrote:
> How about relevant xattrs? SELinux context, ACL, that sort of thing.
> The fact that these are optional should be taken care of by (4).

Those are not simple, fixed size stat data and would make the system
call a giant mess.

Re: [RFC][PATCH 00/12] Enhanced file stat system call

[Martin Steigerwald]

Am Dienstag, 24. November 2015, 00:13:08 CET schrieb Christoph Hellwig:
> On Fri, Nov 20, 2015 at 05:19:31PM +0100, Martin Steigerwald wrote:
> > I know its mostly relevant for just for FAT32, but on any account rather
> > than trying to write 4 GiB and then file, it would be good to at some
> > time get a dialog at the beginning of the copy.
> 
> pathconf/fpathconf is supposed to handle that.  It's not super pretty
> but part of Posix.  Linus hates it, but it might be time to give it
> another try.

It might be interesting for BTRFS as well, to be able to ask what amount of 
free space there currently is *at* a given path. Cause with BTRFS and 
Subvolumes this may differ between different paths. Even tough its not 
implemented yet, it may be possible in the future to have one subvolume with 
RAID 1 profile and one with RAID 0 profile.

That said an application wanting to make sure it can write a certain amount of 
data can use fallocate. And thats thats the only reliable way to ensure it, I 
know of. Which can become tedious for several files, but there is no principal 
problem with preallocating all files if their sizes are known. Even rsync or 
desktop environments could work like that. First fallocate everything, then, 
only if that succeeds, start actually copying data. Disadvantage: On aborted 
copies you have all files with their correct sizes and no easy indicates on 
where the copy stopped.

Thanks,
-- 
Martin

Re: [RFC][PATCH 00/12] Enhanced file stat system call

[Christoph Hellwig]

On Tue, Nov 24, 2015 at 09:48:22AM +0100, Martin Steigerwald wrote:
> It might be interesting for BTRFS as well, to be able to ask what amount of 
> free space there currently is *at* a given path. Cause with BTRFS and 
> Subvolumes this may differ between different paths.

We can handle this trivial with the current statfs interface.  Take a
look at xfs_fs_statfs and xfs_qm_statvfs.

Re: [RFC][PATCH 00/12] Enhanced file stat system call

[Casey Schaufler]

On 11/24/2015 12:15 AM, Christoph Hellwig wrote:
> On Fri, Nov 20, 2015 at 08:50:22AM -0800, Casey Schaufler wrote:
>> How about relevant xattrs? SELinux context, ACL, that sort of thing.
>> The fact that these are optional should be taken care of by (4).
> Those are not simple, fixed size stat data and would make the system
> call a giant mess.
>
I didn't say it would be easy. I do think that adding a system call
that only deals with simple, fixed size data is going to fall short
of solving "the problem".

Actually, a Smack label is fixed size (256 bytes). I suspect there
is a maximum for SELinux contexts as well. ACLs I'll grant you are
infinite.

Re: [RFC][PATCH 00/12] Enhanced file stat system call

[Andreas Dilger]

[-- Attachment #1: Type: text/plain, Size: 7787 bytes --]

On Nov 20, 2015, at 9:50 AM, Casey Schaufler <casey@schaufler-ca.com> wrote:
> On 11/20/2015 6:54 AM, David Howells wrote:
>> Implement new system calls to provide enhanced file stats and enhanced
>> filesystem stats.  The patches can be found here:
>> 
>> 	http://git.kernel.org/cgit/linux/kernel/git/dhowells/linux-fs.git/log/?h=xstat
>> 
>> 
>> ===========
>> DESCRIPTION
>> ===========
>> 
>> The third patch provides this new system call:
>> 
>> 	long ret = statx(int dfd,
>> 			 const char *filename,
>> 			 unsigned atflag,
>> 			 unsigned mask,
>> 			 struct statx *buffer);
>> 
>> This is an enhanced file stat function that provides a number of useful
>> features, in summary:
>> 
>>  (1) More information: creation time, data version number,
>>      flags/attributes.  A subset of these is available through a number of
>>      filesystems (such as CIFS, NFS, AFS, Ext4 and BTRFS).
>> 
>>  (2) Lightweight stat (AT_NO_ATTR_SYNC): Ask for just those details of
>>      interest, and allow a network fs to approximate anything not of
>>      interest, without going to the server.
>> 
>>  (3) Heavyweight stat (AT_FORCE_ATTR_SYNC): Force a network fs to flush
>>      buffers and go to the server, even if it thinks its cached attributes
>>      are up to date.
>> 
>>  (4) Allow the filesystem to indicate what it can/cannot provide: A
>>      filesystem can now say it doesn't support a standard stat feature if
>>      that isn't available.
>> 
>>  (5) Make the fields a consistent size on all arches, and make them large.
>> 
>>  (6) Can be extended by using more request flags and using up the padding
>>      space in the statx struct.
> 
> How about relevant xattrs? SELinux context, ACL, that sort of thing.
> The fact that these are optional should be taken care of by (4).

Given that there are a wide variety of xattrs that different apps might be
interested in, this would probably be better served by an enhancement to
getxattr() or listxattr() to be able to retrieve a whole list of xattrs
at once, possibly with some wildcard support (e.g. "security.*") instead
of returning all or a specific subset of xattrs with statx() (which is
geared toward fixed-size attributes).

Cheers, Andreas


>> Note that no lstat() equivalent is required as that can be implemented
>> through statx() with atflag == 0.  There is also no fstat() equivalent as
>> that can be implemented through statx() with filename == NULL and the
>> relevant fd passed as dfd.
>> 
>> 
>> The seventh patch provides another new system call:
>> 
>> 	long ret = fsinfo(int dfd,
>> 			  const char *filename,
>> 			  unsigned atflag,
>> 			  unsigned request,
>> 			  void *buffer);
>> 
>> This is an enhanced filesystem stat and information retrieval function that
>> provides more information, in summary:
>> 
>>  (1) All the information provided by statfs() and more.  The fields are
>>      made large.
>> 
>>  (2) Provides information about timestamp range and resolution to
>>      complement statx().
>> 
>>  (3) Provides information about IOC flags supported in statx()'s return.
>> 
>>  (4) Provides volume binary IDs and UUIDs.
>> 
>>  (5) Provides the filesystem name according to the kernel as a string
>>      (eg. "ext4" or "nfs3") in addition to the magic number.
>> 
>>  (6) Provides information obtained from network filesystems, such as volume
>>      and domain names.
>> 
>>  (7) Has lots of spare space that can be used for future extenstions and a
>>      bit mask indicating what was provided.
>> 
>> Note that I've added a 'request' identifier.  This is to select the set of
>> data to be returned.  The idea is that 'buffer' points to a fixed-size
>> struct selected by request.  Currently only 0 is available and this refers
>> to 'struct fsinfo'.  However, I could split up the buffer into say 3:
>> 
>>  (0) statfs-type information
>> 
>>  (1) Timestamp and IOC flags info.
>> 
>>  (2) Network fs strings.
>> 
>> However, some of this might be better retrieved through getxattr().
>> 
>> 
>> =======
>> TESTING
>> =======
>> 
>> Test programs are added into samples/statx/ by the appropriate patches.
>> 
>> David
>> ---
>> David Howells (12):
>>       Ext4: Fix extended timestamp encoding and decoding
>>       statx: Provide IOC flags for Windows fs attributes
>>       statx: Add a system call to make enhanced file info available
>>       statx: AFS: Return enhanced file attributes
>>       statx: Ext4: Return enhanced file attributes
>>       statx: NFS: Return enhanced file attributes
>>       statx: CIFS: Return enhanced attributes
>>       fsinfo: Add a system call to make enhanced filesystem info available
>>       fsinfo: Ext4: Return information through the filesystem info syscall
>>       fsinfo: AFS: Return information through the filesystem info syscall
>>       fsinfo: NFS: Return information through the filesystem info syscall
>>       fsinfo: CIFS: Return information through the filesystem info syscall
>> 
>> 
>>  arch/x86/entry/syscalls/syscall_32.tbl |    2
>>  arch/x86/entry/syscalls/syscall_64.tbl |    2
>>  fs/afs/inode.c                         |   23 ++
>>  fs/afs/super.c                         |   39 ++++
>>  fs/cifs/cifsfs.c                       |   25 +++
>>  fs/cifs/cifsfs.h                       |    4
>>  fs/cifs/cifsglob.h                     |    8 +
>>  fs/cifs/dir.c                          |    2
>>  fs/cifs/inode.c                        |  124 ++++++++++---
>>  fs/cifs/netmisc.c                      |    4
>>  fs/exportfs/expfs.c                    |    4
>>  fs/ext4/ext4.h                         |   24 ++-
>>  fs/ext4/file.c                         |    2
>>  fs/ext4/inode.c                        |   31 +++
>>  fs/ext4/namei.c                        |    2
>>  fs/ext4/super.c                        |   39 ++++
>>  fs/ext4/symlink.c                      |    2
>>  fs/nfs/inode.c                         |   45 ++++-
>>  fs/nfs/internal.h                      |    1
>>  fs/nfs/nfs4super.c                     |    1
>>  fs/nfs/super.c                         |   58 ++++++
>>  fs/ntfs/time.h                         |    2
>>  fs/stat.c                              |  305 +++++++++++++++++++++++++++++---
>>  fs/statfs.c                            |  218 +++++++++++++++++++++++
>>  include/linux/fs.h                     |    7 +
>>  include/linux/stat.h                   |   14 +
>>  include/linux/syscalls.h               |    6 +
>>  include/linux/time64.h                 |    2
>>  include/uapi/linux/fcntl.h             |    2
>>  include/uapi/linux/fs.h                |    7 +
>>  include/uapi/linux/stat.h              |  185 +++++++++++++++++++
>>  samples/Makefile                       |    3
>>  samples/statx/Makefile                 |   13 +
>>  samples/statx/test-fsinfo.c            |  179 +++++++++++++++++++
>>  samples/statx/test-statx.c             |  273 +++++++++++++++++++++++++++++
>>  35 files changed, 1558 insertions(+), 100 deletions(-)
>>  create mode 100644 samples/statx/Makefile
>>  create mode 100644 samples/statx/test-fsinfo.c
>>  create mode 100644 samples/statx/test-statx.c
>> 
>> --
>> To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
>> the body of a message to majordomo@vger.kernel.org
>> More majordomo info at  http://vger.kernel.org/majordomo-info.html
>> Please read the FAQ at  http://www.tux.org/lkml/
>> 
> 
> --
> To unsubscribe from this list: send the line "unsubscribe linux-ext4" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at  http://vger.kernel.org/majordomo-info.html


Cheers, Andreas






[-- Attachment #2: Message signed with OpenPGP using GPGMail --]
[-- Type: application/pgp-signature, Size: 833 bytes --]

Re: [PATCH 07/12] statx: CIFS: Return enhanced attributes

[Steve French]

Is it worth storing the same creation time twice (in slightly different
formats, struct timespec and u64 DCE time) in cifsInodeInfo?

On Fri, Nov 20, 2015 at 8:55 AM, David Howells <dhowells@redhat.com> wrote:

> Return enhanced attributes from the CIFS filesystem.  This includes the
> following:
>
>  (1) Return the file creation time as btime.  We assume that the creation
>      time won't change over the life of the inode.
>
>  (2) Set STATX_INFO_AUTOMOUNT on referral/submount directories.
>
>  (3) Unset STATX_INO if we made up the inode number and didn't get it from
>      the server.
>
>  (4) Unset STATX_[UG]ID if we are either returning values passed to mount
>      and/or the server doesn't return them.
>
>  (5) Set STATX_IOC_FLAGS and map various Windows file attributes to
>      FS_xxx_FL flags in st_ioc_flags, fetching them from the server if we
>      don't have them yet or don't have a current copy.  This includes the
>      following:
>
>         ATTR_READONLY   -> FS_IMMUTABLE_FL
>         ATTR_COMPRESSED -> FS_COMPR_FL
>         ATTR_HIDDEN     -> FS_HIDDEN_FL
>         ATTR_SYSTEM     -> FS_SYSTEM_FL
>         ATTR_ARCHIVE    -> FS_ARCHIVE_FL
>
>  (6) Set certain STATX_INFO_xxx to reflect other Windows file attributes:
>
>         ATTR_TEMPORARY  -> STATX_INFO_TEMPORARY;
>         ATTR_REPARSE    -> STATX_INFO_REPARSE_POINT;
>         ATTR_OFFLINE    -> STATX_INFO_OFFLINE;
>         ATTR_ENCRYPTED  -> STATX_INFO_ENCRYPTED;
>
>  (7) Set STATX_INFO_REMOTE on all files fetched by CIFS.
>
>  (8) Set STATX_INFO_NONSYSTEM_OWNERSHIP on all files as they all have
>      Windows ownership details too.
>
> Furthermore, what cifs_getattr() does can be controlled as follows:
>
>  (1) If AT_NO_ATTR_SYNC is indicated then this will suppress the flushing
>      of outstanding writes and the rereading of the inode's attributes with
>      the server as detailed below.
>
>  (2) Otherwise:
>
>      (a) If AT_FORCE_ATTR_SYNC is indicated, or mtime, ctime or size are
>          requested then the outstanding writes will be written to the
>          server first.
>
>      (b) The inode's attributes will be reread from the server:
>
>          (i) if AT_FORCE_ATTR_SYNC is indicated;
>
>         (ii) if the cached attributes have expired;
>
>        (iii) extra attributes are requested that aren't normally stored.
>
> If the inode isn't synchronised, then the cached attributes will be used -
> even if expired - without reference to the server.  Some attributes may be
> unavailable that would otherwise be provided.
>
> Note that cifs_revalidate_dentry() will issue an extra operation to get the
> FILE_ALL_INFO in addition to the FILE_UNIX_BASIC_INFO if it needs to
> collect creation time and attributes on behalf of cifs_getattr().
>
> [NOTE: THIS PATCH IS UNTESTED!]
>
> Signed-off-by: David Howells <dhowells@redhat.com>
> ---
>
>  fs/cifs/cifsfs.h   |    4 +-
>  fs/cifs/cifsglob.h |    8 +++
>  fs/cifs/dir.c      |    2 -
>  fs/cifs/inode.c    |  124
> +++++++++++++++++++++++++++++++++++++++++-----------
>  4 files changed, 108 insertions(+), 30 deletions(-)
>
> diff --git a/fs/cifs/cifsfs.h b/fs/cifs/cifsfs.h
> index c3cc1609025f..fb38d47d84de 100644
> --- a/fs/cifs/cifsfs.h
> +++ b/fs/cifs/cifsfs.h
> @@ -71,9 +71,9 @@ extern int cifs_rmdir(struct inode *, struct dentry *);
>  extern int cifs_rename2(struct inode *, struct dentry *, struct inode *,
>                         struct dentry *, unsigned int);
>  extern int cifs_revalidate_file_attr(struct file *filp);
> -extern int cifs_revalidate_dentry_attr(struct dentry *);
> +extern int cifs_revalidate_dentry_attr(struct dentry *, bool, bool);
>  extern int cifs_revalidate_file(struct file *filp);
> -extern int cifs_revalidate_dentry(struct dentry *);
> +extern int cifs_revalidate_dentry(struct dentry *, bool, bool);
>  extern int cifs_invalidate_mapping(struct inode *inode);
>  extern int cifs_revalidate_mapping(struct inode *inode);
>  extern int cifs_zap_mapping(struct inode *inode);
> diff --git a/fs/cifs/cifsglob.h b/fs/cifs/cifsglob.h
> index b406a32deb1f..493e40a15b86 100644
> --- a/fs/cifs/cifsglob.h
> +++ b/fs/cifs/cifsglob.h
> @@ -1152,7 +1152,11 @@ struct cifsInodeInfo {
>         unsigned long flags;
>         spinlock_t writers_lock;
>         unsigned int writers;           /* Number of writers on this inode
> */
> +       bool btime_valid:1;             /* stored creation time is valid */
> +       bool uid_faked:1;               /* true if i_uid is faked */
> +       bool gid_faked:1;               /* true if i_gid is faked */
>         unsigned long time;             /* jiffies of last update of inode
> */
> +       struct timespec btime;          /* creation time */
>         u64  server_eof;                /* current file size on server --
> protected by i_lock */
>         u64  uniqueid;                  /* server inode number */
>         u64  createtime;                /* creation time on server */
> @@ -1365,6 +1369,9 @@ struct dfs_info3_param {
>  #define CIFS_FATTR_NEED_REVAL          0x4
>  #define CIFS_FATTR_INO_COLLISION       0x8
>  #define CIFS_FATTR_UNKNOWN_NLINK       0x10
> +#define CIFS_FATTR_WINATTRS_VALID      0x20    /* T if cf_btime and
> cf_cifsattrs valid */
> +#define CIFS_FATTR_UID_FAKED           0x40    /* T if cf_uid is faked */
> +#define CIFS_FATTR_GID_FAKED           0x80    /* T if cf_gid is faked */
>
>  struct cifs_fattr {
>         u32             cf_flags;
> @@ -1382,6 +1389,7 @@ struct cifs_fattr {
>         struct timespec cf_atime;
>         struct timespec cf_mtime;
>         struct timespec cf_ctime;
> +       struct timespec cf_btime;
>  };
>
>  static inline void free_dfs_info_param(struct dfs_info3_param *param)
> diff --git a/fs/cifs/dir.c b/fs/cifs/dir.c
> index c3eb998a99bd..4984f04b0677 100644
> --- a/fs/cifs/dir.c
> +++ b/fs/cifs/dir.c
> @@ -792,7 +792,7 @@ cifs_d_revalidate(struct dentry *direntry, unsigned
> int flags)
>                 return -ECHILD;
>
>         if (d_really_is_positive(direntry)) {
> -               if (cifs_revalidate_dentry(direntry))
> +               if (cifs_revalidate_dentry(direntry, false, false))
>                         return 0;
>                 else {
>                         /*
> diff --git a/fs/cifs/inode.c b/fs/cifs/inode.c
> index 6b66dd5d1540..fcb024efbd4b 100644
> --- a/fs/cifs/inode.c
> +++ b/fs/cifs/inode.c
> @@ -166,13 +166,21 @@ cifs_fattr_to_inode(struct inode *inode, struct
> cifs_fattr *fattr)
>         cifs_nlink_fattr_to_inode(inode, fattr);
>         inode->i_uid = fattr->cf_uid;
>         inode->i_gid = fattr->cf_gid;
> +       if (fattr->cf_flags & CIFS_FATTR_UID_FAKED)
> +               cifs_i->uid_faked = true;
> +       if (fattr->cf_flags & CIFS_FATTR_GID_FAKED)
> +               cifs_i->gid_faked = true;
>
>         /* if dynperm is set, don't clobber existing mode */
>         if (inode->i_state & I_NEW ||
>             !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM))
>                 inode->i_mode = fattr->cf_mode;
>
> -       cifs_i->cifsAttrs = fattr->cf_cifsattrs;
> +       if (fattr->cf_flags & CIFS_FATTR_WINATTRS_VALID) {
> +               cifs_i->cifsAttrs = fattr->cf_cifsattrs;
> +               cifs_i->btime = fattr->cf_btime;
> +               cifs_i->btime_valid = true;
> +       }
>
>         if (fattr->cf_flags & CIFS_FATTR_NEED_REVAL)
>                 cifs_i->time = 0;
> @@ -284,18 +292,22 @@ cifs_unix_basic_to_fattr(struct cifs_fattr *fattr,
> FILE_UNIX_BASIC_INFO *info,
>                 u64 id = le64_to_cpu(info->Uid);
>                 if (id < ((uid_t)-1)) {
>                         kuid_t uid = make_kuid(&init_user_ns, id);
> -                       if (uid_valid(uid))
> +                       if (uid_valid(uid)) {
>                                 fattr->cf_uid = uid;
> +                               fattr->cf_flags |= CIFS_FATTR_UID_FAKED;
> +                       }
>                 }
>         }
> -
> +
>         fattr->cf_gid = cifs_sb->mnt_gid;
>         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)) {
>                 u64 id = le64_to_cpu(info->Gid);
>                 if (id < ((gid_t)-1)) {
>                         kgid_t gid = make_kgid(&init_user_ns, id);
> -                       if (gid_valid(gid))
> +                       if (gid_valid(gid)) {
>                                 fattr->cf_gid = gid;
> +                               fattr->cf_flags |= CIFS_FATTR_GID_FAKED;
> +                       }
>                 }
>         }
>
> @@ -324,7 +336,8 @@ cifs_create_dfs_fattr(struct cifs_fattr *fattr, struct
> super_block *sb)
>         fattr->cf_ctime = CURRENT_TIME;
>         fattr->cf_mtime = CURRENT_TIME;
>         fattr->cf_nlink = 2;
> -       fattr->cf_flags |= CIFS_FATTR_DFS_REFERRAL;
> +       fattr->cf_flags |= CIFS_FATTR_DFS_REFERRAL |
> +               CIFS_FATTR_UID_FAKED | CIFS_FATTR_GID_FAKED;
>  }
>
>  static int
> @@ -590,6 +603,7 @@ cifs_all_info_to_fattr(struct cifs_fattr *fattr,
> FILE_ALL_INFO *info,
>         struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
>
>         memset(fattr, 0, sizeof(*fattr));
> +       fattr->cf_flags = CIFS_FATTR_WINATTRS_VALID;
>         fattr->cf_cifsattrs = le32_to_cpu(info->Attributes);
>         if (info->DeletePending)
>                 fattr->cf_flags |= CIFS_FATTR_DELETE_PENDING;
> @@ -601,6 +615,7 @@ cifs_all_info_to_fattr(struct cifs_fattr *fattr,
> FILE_ALL_INFO *info,
>
>         fattr->cf_ctime = cifs_NTtimeToUnix(info->ChangeTime);
>         fattr->cf_mtime = cifs_NTtimeToUnix(info->LastWriteTime);
> +       fattr->cf_btime = cifs_NTtimeToUnix(info->CreationTime);
>
>         if (adjust_tz) {
>                 fattr->cf_ctime.tv_sec += tcon->ses->server->timeAdj;
> @@ -1887,7 +1902,8 @@ int cifs_revalidate_file_attr(struct file *filp)
>         return rc;
>  }
>
> -int cifs_revalidate_dentry_attr(struct dentry *dentry)
> +int cifs_revalidate_dentry_attr(struct dentry *dentry,
> +                               bool want_extra_bits, bool force)
>  {
>         unsigned int xid;
>         int rc = 0;
> @@ -1898,7 +1914,7 @@ int cifs_revalidate_dentry_attr(struct dentry
> *dentry)
>         if (inode == NULL)
>                 return -ENOENT;
>
> -       if (!cifs_inode_needs_reval(inode))
> +       if (!force && !cifs_inode_needs_reval(inode))
>                 return rc;
>
>         xid = get_xid();
> @@ -1915,9 +1931,12 @@ int cifs_revalidate_dentry_attr(struct dentry
> *dentry)
>                  full_path, inode, inode->i_count.counter,
>                  dentry, dentry->d_time, jiffies);
>
> -       if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext)
> +       if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext) {
>                 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
> -       else
> +               if (rc != 0)
> +                       goto out;
> +       }
> +       if (!cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext || want_extra_bits)
>                 rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
>                                          xid, NULL);
>
> @@ -1940,12 +1959,13 @@ int cifs_revalidate_file(struct file *filp)
>  }
>
>  /* revalidate a dentry's inode attributes */
> -int cifs_revalidate_dentry(struct dentry *dentry)
> +int cifs_revalidate_dentry(struct dentry *dentry,
> +                          bool want_extra_bits, bool force)
>  {
>         int rc;
>         struct inode *inode = d_inode(dentry);
>
> -       rc = cifs_revalidate_dentry_attr(dentry);
> +       rc = cifs_revalidate_dentry_attr(dentry, want_extra_bits, force);
>         if (rc)
>                 return rc;
>
> @@ -1958,28 +1978,62 @@ int cifs_getattr(struct vfsmount *mnt, struct
> dentry *dentry,
>         struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb);
>         struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
>         struct inode *inode = d_inode(dentry);
> +       struct cifsInodeInfo *cifs_i = CIFS_I(inode);
> +       bool force = stat->query_flags & AT_FORCE_ATTR_SYNC;
> +       bool want_extra_bits = false;
> +       u32 info, ioc = 0;
> +       u32 attrs;
>         int rc;
>
> -       /*
> -        * We need to be sure that all dirty pages are written and the
> server
> -        * has actual ctime, mtime and file length.
> -        */
> -       if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
> -           inode->i_mapping->nrpages != 0) {
> -               rc = filemap_fdatawait(inode->i_mapping);
> -               if (rc) {
> -                       mapping_set_error(inode->i_mapping, rc);
> -                       return rc;
> +       if (cifs_i->uid_faked)
> +               stat->request_mask &= ~STATX_UID;
> +       if (cifs_i->gid_faked)
> +               stat->request_mask &= ~STATX_GID;
> +
> +       if ((stat->request_mask & STATX_BTIME && !cifs_i->btime_valid) ||
> +           stat->request_mask & STATX_IOC_FLAGS)
> +               want_extra_bits = force = true;
> +
> +       if (!(stat->query_flags & AT_NO_ATTR_SYNC)) {
> +               /* Unless we're explicitly told not to sync, we need to be
> sure
> +                * that all dirty pages are written and the server has
> actual
> +                * ctime, mtime and file length.
> +                */
> +               bool flush = force;
> +
> +               if (stat->request_mask &
> +                   (STATX_CTIME | STATX_MTIME | STATX_SIZE))
> +                       flush = true;
> +
> +               if (flush &&
> +                   !CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
> +                   inode->i_mapping->nrpages != 0) {
> +                       rc = filemap_fdatawait(inode->i_mapping);
> +                       if (rc) {
> +                               mapping_set_error(inode->i_mapping, rc);
> +                               return rc;
> +                       }
>                 }
> -       }
>
> -       rc = cifs_revalidate_dentry_attr(dentry);
> -       if (rc)
> -               return rc;
> +               rc = cifs_revalidate_dentry(dentry, want_extra_bits,
> force);
> +               if (rc)
> +                       return rc;
> +       }
>
>         generic_fillattr(inode, stat);
>         stat->blksize = CIFS_MAX_MSGSIZE;
> -       stat->ino = CIFS_I(inode)->uniqueid;
> +
> +       info = STATX_INFO_REMOTE | STATX_INFO_NONSYSTEM_OWNERSHIP;
> +
> +       if (cifs_i->btime_valid) {
> +               stat->btime = cifs_i->btime;
> +               stat->result_mask |= STATX_BTIME;
> +       }
> +
> +       /* We don't promise an inode number if we made one up */
> +       stat->ino = cifs_i->uniqueid;
> +       if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM))
> +               stat->result_mask &= ~STATX_INO;
>
>         /*
>          * If on a multiuser mount without unix extensions or cifsacl being
> @@ -1993,8 +2047,24 @@ int cifs_getattr(struct vfsmount *mnt, struct
> dentry *dentry,
>                         stat->uid = current_fsuid();
>                 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID))
>                         stat->gid = current_fsgid();
> +               stat->result_mask &= ~(STATX_UID | STATX_GID);
>         }
> -       return rc;
> +
> +       attrs = cifs_i->cifsAttrs;
> +       if (attrs & ATTR_TEMPORARY)     info |= STATX_INFO_TEMPORARY;
> +       if (attrs & ATTR_REPARSE)       info |= STATX_INFO_REPARSE_POINT;
> +       if (attrs & ATTR_OFFLINE)       info |= STATX_INFO_OFFLINE;
> +       if (attrs & ATTR_ENCRYPTED)     info |= STATX_INFO_ENCRYPTED;
> +       stat->information |= info;
> +
> +       if (attrs & ATTR_READONLY)      ioc |= FS_IMMUTABLE_FL;
> +       if (attrs & ATTR_COMPRESSED)    ioc |= FS_COMPR_FL;
> +       if (attrs & ATTR_HIDDEN)        ioc |= FS_HIDDEN_FL;
> +       if (attrs & ATTR_SYSTEM)        ioc |= FS_SYSTEM_FL;
> +       if (attrs & ATTR_ARCHIVE)       ioc |= FS_ARCHIVE_FL;
> +       stat->ioc_flags |= ioc;
> +
> +       return 0;
>  }
>
>  static int cifs_truncate_page(struct address_space *mapping, loff_t from)
>
> --
> To unsubscribe from this list: send the line "unsubscribe linux-nfs" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at  http://vger.kernel.org/majordomo-info.html
>



-- 
Thanks,

Steve

Re: [PATCH 07/12] statx: CIFS: Return enhanced attributes

[Steve French]

Is it worth storing the same creation time twice (in slightly
different formats, struct timespec and u64 DCE time) in cifsInodeInfo?

On Fri, Nov 20, 2015 at 8:55 AM, David Howells <dhowells@redhat.com> wrote:
> Return enhanced attributes from the CIFS filesystem.  This includes the
> following:
>
>  (1) Return the file creation time as btime.  We assume that the creation
>      time won't change over the life of the inode.
>
>  (2) Set STATX_INFO_AUTOMOUNT on referral/submount directories.
>
>  (3) Unset STATX_INO if we made up the inode number and didn't get it from
>      the server.
>
>  (4) Unset STATX_[UG]ID if we are either returning values passed to mount
>      and/or the server doesn't return them.
>
>  (5) Set STATX_IOC_FLAGS and map various Windows file attributes to
>      FS_xxx_FL flags in st_ioc_flags, fetching them from the server if we
>      don't have them yet or don't have a current copy.  This includes the
>      following:
>
>         ATTR_READONLY   -> FS_IMMUTABLE_FL
>         ATTR_COMPRESSED -> FS_COMPR_FL
>         ATTR_HIDDEN     -> FS_HIDDEN_FL
>         ATTR_SYSTEM     -> FS_SYSTEM_FL
>         ATTR_ARCHIVE    -> FS_ARCHIVE_FL
>
>  (6) Set certain STATX_INFO_xxx to reflect other Windows file attributes:
>
>         ATTR_TEMPORARY  -> STATX_INFO_TEMPORARY;
>         ATTR_REPARSE    -> STATX_INFO_REPARSE_POINT;
>         ATTR_OFFLINE    -> STATX_INFO_OFFLINE;
>         ATTR_ENCRYPTED  -> STATX_INFO_ENCRYPTED;
>
>  (7) Set STATX_INFO_REMOTE on all files fetched by CIFS.
>
>  (8) Set STATX_INFO_NONSYSTEM_OWNERSHIP on all files as they all have
>      Windows ownership details too.
>
> Furthermore, what cifs_getattr() does can be controlled as follows:
>
>  (1) If AT_NO_ATTR_SYNC is indicated then this will suppress the flushing
>      of outstanding writes and the rereading of the inode's attributes with
>      the server as detailed below.
>
>  (2) Otherwise:
>
>      (a) If AT_FORCE_ATTR_SYNC is indicated, or mtime, ctime or size are
>          requested then the outstanding writes will be written to the
>          server first.
>
>      (b) The inode's attributes will be reread from the server:
>
>          (i) if AT_FORCE_ATTR_SYNC is indicated;
>
>         (ii) if the cached attributes have expired;
>
>        (iii) extra attributes are requested that aren't normally stored.
>
> If the inode isn't synchronised, then the cached attributes will be used -
> even if expired - without reference to the server.  Some attributes may be
> unavailable that would otherwise be provided.
>
> Note that cifs_revalidate_dentry() will issue an extra operation to get the
> FILE_ALL_INFO in addition to the FILE_UNIX_BASIC_INFO if it needs to
> collect creation time and attributes on behalf of cifs_getattr().
>
> [NOTE: THIS PATCH IS UNTESTED!]
>
> Signed-off-by: David Howells <dhowells@redhat.com>
> ---
>
>  fs/cifs/cifsfs.h   |    4 +-
>  fs/cifs/cifsglob.h |    8 +++
>  fs/cifs/dir.c      |    2 -
>  fs/cifs/inode.c    |  124 +++++++++++++++++++++++++++++++++++++++++-----------
>  4 files changed, 108 insertions(+), 30 deletions(-)
>
> diff --git a/fs/cifs/cifsfs.h b/fs/cifs/cifsfs.h
> index c3cc1609025f..fb38d47d84de 100644
> --- a/fs/cifs/cifsfs.h
> +++ b/fs/cifs/cifsfs.h
> @@ -71,9 +71,9 @@ extern int cifs_rmdir(struct inode *, struct dentry *);
>  extern int cifs_rename2(struct inode *, struct dentry *, struct inode *,
>                         struct dentry *, unsigned int);
>  extern int cifs_revalidate_file_attr(struct file *filp);
> -extern int cifs_revalidate_dentry_attr(struct dentry *);
> +extern int cifs_revalidate_dentry_attr(struct dentry *, bool, bool);
>  extern int cifs_revalidate_file(struct file *filp);
> -extern int cifs_revalidate_dentry(struct dentry *);
> +extern int cifs_revalidate_dentry(struct dentry *, bool, bool);
>  extern int cifs_invalidate_mapping(struct inode *inode);
>  extern int cifs_revalidate_mapping(struct inode *inode);
>  extern int cifs_zap_mapping(struct inode *inode);
> diff --git a/fs/cifs/cifsglob.h b/fs/cifs/cifsglob.h
> index b406a32deb1f..493e40a15b86 100644
> --- a/fs/cifs/cifsglob.h
> +++ b/fs/cifs/cifsglob.h
> @@ -1152,7 +1152,11 @@ struct cifsInodeInfo {
>         unsigned long flags;
>         spinlock_t writers_lock;
>         unsigned int writers;           /* Number of writers on this inode */
> +       bool btime_valid:1;             /* stored creation time is valid */
> +       bool uid_faked:1;               /* true if i_uid is faked */
> +       bool gid_faked:1;               /* true if i_gid is faked */
>         unsigned long time;             /* jiffies of last update of inode */
> +       struct timespec btime;          /* creation time */
>         u64  server_eof;                /* current file size on server -- protected by i_lock */
>         u64  uniqueid;                  /* server inode number */
>         u64  createtime;                /* creation time on server */
> @@ -1365,6 +1369,9 @@ struct dfs_info3_param {
>  #define CIFS_FATTR_NEED_REVAL          0x4
>  #define CIFS_FATTR_INO_COLLISION       0x8
>  #define CIFS_FATTR_UNKNOWN_NLINK       0x10
> +#define CIFS_FATTR_WINATTRS_VALID      0x20    /* T if cf_btime and cf_cifsattrs valid */
> +#define CIFS_FATTR_UID_FAKED           0x40    /* T if cf_uid is faked */
> +#define CIFS_FATTR_GID_FAKED           0x80    /* T if cf_gid is faked */
>
>  struct cifs_fattr {
>         u32             cf_flags;
> @@ -1382,6 +1389,7 @@ struct cifs_fattr {
>         struct timespec cf_atime;
>         struct timespec cf_mtime;
>         struct timespec cf_ctime;
> +       struct timespec cf_btime;
>  };
>
>  static inline void free_dfs_info_param(struct dfs_info3_param *param)
> diff --git a/fs/cifs/dir.c b/fs/cifs/dir.c
> index c3eb998a99bd..4984f04b0677 100644
> --- a/fs/cifs/dir.c
> +++ b/fs/cifs/dir.c
> @@ -792,7 +792,7 @@ cifs_d_revalidate(struct dentry *direntry, unsigned int flags)
>                 return -ECHILD;
>
>         if (d_really_is_positive(direntry)) {
> -               if (cifs_revalidate_dentry(direntry))
> +               if (cifs_revalidate_dentry(direntry, false, false))
>                         return 0;
>                 else {
>                         /*
> diff --git a/fs/cifs/inode.c b/fs/cifs/inode.c
> index 6b66dd5d1540..fcb024efbd4b 100644
> --- a/fs/cifs/inode.c
> +++ b/fs/cifs/inode.c
> @@ -166,13 +166,21 @@ cifs_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr)
>         cifs_nlink_fattr_to_inode(inode, fattr);
>         inode->i_uid = fattr->cf_uid;
>         inode->i_gid = fattr->cf_gid;
> +       if (fattr->cf_flags & CIFS_FATTR_UID_FAKED)
> +               cifs_i->uid_faked = true;
> +       if (fattr->cf_flags & CIFS_FATTR_GID_FAKED)
> +               cifs_i->gid_faked = true;
>
>         /* if dynperm is set, don't clobber existing mode */
>         if (inode->i_state & I_NEW ||
>             !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM))
>                 inode->i_mode = fattr->cf_mode;
>
> -       cifs_i->cifsAttrs = fattr->cf_cifsattrs;
> +       if (fattr->cf_flags & CIFS_FATTR_WINATTRS_VALID) {
> +               cifs_i->cifsAttrs = fattr->cf_cifsattrs;
> +               cifs_i->btime = fattr->cf_btime;
> +               cifs_i->btime_valid = true;
> +       }
>
>         if (fattr->cf_flags & CIFS_FATTR_NEED_REVAL)
>                 cifs_i->time = 0;
> @@ -284,18 +292,22 @@ cifs_unix_basic_to_fattr(struct cifs_fattr *fattr, FILE_UNIX_BASIC_INFO *info,
>                 u64 id = le64_to_cpu(info->Uid);
>                 if (id < ((uid_t)-1)) {
>                         kuid_t uid = make_kuid(&init_user_ns, id);
> -                       if (uid_valid(uid))
> +                       if (uid_valid(uid)) {
>                                 fattr->cf_uid = uid;
> +                               fattr->cf_flags |= CIFS_FATTR_UID_FAKED;
> +                       }
>                 }
>         }
> -
> +
>         fattr->cf_gid = cifs_sb->mnt_gid;
>         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)) {
>                 u64 id = le64_to_cpu(info->Gid);
>                 if (id < ((gid_t)-1)) {
>                         kgid_t gid = make_kgid(&init_user_ns, id);
> -                       if (gid_valid(gid))
> +                       if (gid_valid(gid)) {
>                                 fattr->cf_gid = gid;
> +                               fattr->cf_flags |= CIFS_FATTR_GID_FAKED;
> +                       }
>                 }
>         }
>
> @@ -324,7 +336,8 @@ cifs_create_dfs_fattr(struct cifs_fattr *fattr, struct super_block *sb)
>         fattr->cf_ctime = CURRENT_TIME;
>         fattr->cf_mtime = CURRENT_TIME;
>         fattr->cf_nlink = 2;
> -       fattr->cf_flags |= CIFS_FATTR_DFS_REFERRAL;
> +       fattr->cf_flags |= CIFS_FATTR_DFS_REFERRAL |
> +               CIFS_FATTR_UID_FAKED | CIFS_FATTR_GID_FAKED;
>  }
>
>  static int
> @@ -590,6 +603,7 @@ cifs_all_info_to_fattr(struct cifs_fattr *fattr, FILE_ALL_INFO *info,
>         struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
>
>         memset(fattr, 0, sizeof(*fattr));
> +       fattr->cf_flags = CIFS_FATTR_WINATTRS_VALID;
>         fattr->cf_cifsattrs = le32_to_cpu(info->Attributes);
>         if (info->DeletePending)
>                 fattr->cf_flags |= CIFS_FATTR_DELETE_PENDING;
> @@ -601,6 +615,7 @@ cifs_all_info_to_fattr(struct cifs_fattr *fattr, FILE_ALL_INFO *info,
>
>         fattr->cf_ctime = cifs_NTtimeToUnix(info->ChangeTime);
>         fattr->cf_mtime = cifs_NTtimeToUnix(info->LastWriteTime);
> +       fattr->cf_btime = cifs_NTtimeToUnix(info->CreationTime);
>
>         if (adjust_tz) {
>                 fattr->cf_ctime.tv_sec += tcon->ses->server->timeAdj;
> @@ -1887,7 +1902,8 @@ int cifs_revalidate_file_attr(struct file *filp)
>         return rc;
>  }
>
> -int cifs_revalidate_dentry_attr(struct dentry *dentry)
> +int cifs_revalidate_dentry_attr(struct dentry *dentry,
> +                               bool want_extra_bits, bool force)
>  {
>         unsigned int xid;
>         int rc = 0;
> @@ -1898,7 +1914,7 @@ int cifs_revalidate_dentry_attr(struct dentry *dentry)
>         if (inode == NULL)
>                 return -ENOENT;
>
> -       if (!cifs_inode_needs_reval(inode))
> +       if (!force && !cifs_inode_needs_reval(inode))
>                 return rc;
>
>         xid = get_xid();
> @@ -1915,9 +1931,12 @@ int cifs_revalidate_dentry_attr(struct dentry *dentry)
>                  full_path, inode, inode->i_count.counter,
>                  dentry, dentry->d_time, jiffies);
>
> -       if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext)
> +       if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext) {
>                 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
> -       else
> +               if (rc != 0)
> +                       goto out;
> +       }
> +       if (!cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext || want_extra_bits)
>                 rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
>                                          xid, NULL);
>
> @@ -1940,12 +1959,13 @@ int cifs_revalidate_file(struct file *filp)
>  }
>
>  /* revalidate a dentry's inode attributes */
> -int cifs_revalidate_dentry(struct dentry *dentry)
> +int cifs_revalidate_dentry(struct dentry *dentry,
> +                          bool want_extra_bits, bool force)
>  {
>         int rc;
>         struct inode *inode = d_inode(dentry);
>
> -       rc = cifs_revalidate_dentry_attr(dentry);
> +       rc = cifs_revalidate_dentry_attr(dentry, want_extra_bits, force);
>         if (rc)
>                 return rc;
>
> @@ -1958,28 +1978,62 @@ int cifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
>         struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb);
>         struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
>         struct inode *inode = d_inode(dentry);
> +       struct cifsInodeInfo *cifs_i = CIFS_I(inode);
> +       bool force = stat->query_flags & AT_FORCE_ATTR_SYNC;
> +       bool want_extra_bits = false;
> +       u32 info, ioc = 0;
> +       u32 attrs;
>         int rc;
>
> -       /*
> -        * We need to be sure that all dirty pages are written and the server
> -        * has actual ctime, mtime and file length.
> -        */
> -       if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
> -           inode->i_mapping->nrpages != 0) {
> -               rc = filemap_fdatawait(inode->i_mapping);
> -               if (rc) {
> -                       mapping_set_error(inode->i_mapping, rc);
> -                       return rc;
> +       if (cifs_i->uid_faked)
> +               stat->request_mask &= ~STATX_UID;
> +       if (cifs_i->gid_faked)
> +               stat->request_mask &= ~STATX_GID;
> +
> +       if ((stat->request_mask & STATX_BTIME && !cifs_i->btime_valid) ||
> +           stat->request_mask & STATX_IOC_FLAGS)
> +               want_extra_bits = force = true;
> +
> +       if (!(stat->query_flags & AT_NO_ATTR_SYNC)) {
> +               /* Unless we're explicitly told not to sync, we need to be sure
> +                * that all dirty pages are written and the server has actual
> +                * ctime, mtime and file length.
> +                */
> +               bool flush = force;
> +
> +               if (stat->request_mask &
> +                   (STATX_CTIME | STATX_MTIME | STATX_SIZE))
> +                       flush = true;
> +
> +               if (flush &&
> +                   !CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
> +                   inode->i_mapping->nrpages != 0) {
> +                       rc = filemap_fdatawait(inode->i_mapping);
> +                       if (rc) {
> +                               mapping_set_error(inode->i_mapping, rc);
> +                               return rc;
> +                       }
>                 }
> -       }
>
> -       rc = cifs_revalidate_dentry_attr(dentry);
> -       if (rc)
> -               return rc;
> +               rc = cifs_revalidate_dentry(dentry, want_extra_bits, force);
> +               if (rc)
> +                       return rc;
> +       }
>
>         generic_fillattr(inode, stat);
>         stat->blksize = CIFS_MAX_MSGSIZE;
> -       stat->ino = CIFS_I(inode)->uniqueid;
> +
> +       info = STATX_INFO_REMOTE | STATX_INFO_NONSYSTEM_OWNERSHIP;
> +
> +       if (cifs_i->btime_valid) {
> +               stat->btime = cifs_i->btime;
> +               stat->result_mask |= STATX_BTIME;
> +       }
> +
> +       /* We don't promise an inode number if we made one up */
> +       stat->ino = cifs_i->uniqueid;
> +       if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM))
> +               stat->result_mask &= ~STATX_INO;
>
>         /*
>          * If on a multiuser mount without unix extensions or cifsacl being
> @@ -1993,8 +2047,24 @@ int cifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
>                         stat->uid = current_fsuid();
>                 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID))
>                         stat->gid = current_fsgid();
> +               stat->result_mask &= ~(STATX_UID | STATX_GID);
>         }
> -       return rc;
> +
> +       attrs = cifs_i->cifsAttrs;
> +       if (attrs & ATTR_TEMPORARY)     info |= STATX_INFO_TEMPORARY;
> +       if (attrs & ATTR_REPARSE)       info |= STATX_INFO_REPARSE_POINT;
> +       if (attrs & ATTR_OFFLINE)       info |= STATX_INFO_OFFLINE;
> +       if (attrs & ATTR_ENCRYPTED)     info |= STATX_INFO_ENCRYPTED;
> +       stat->information |= info;
> +
> +       if (attrs & ATTR_READONLY)      ioc |= FS_IMMUTABLE_FL;
> +       if (attrs & ATTR_COMPRESSED)    ioc |= FS_COMPR_FL;
> +       if (attrs & ATTR_HIDDEN)        ioc |= FS_HIDDEN_FL;
> +       if (attrs & ATTR_SYSTEM)        ioc |= FS_SYSTEM_FL;
> +       if (attrs & ATTR_ARCHIVE)       ioc |= FS_ARCHIVE_FL;
> +       stat->ioc_flags |= ioc;
> +
> +       return 0;
>  }
>
>  static int cifs_truncate_page(struct address_space *mapping, loff_t from)
>
> --
> To unsubscribe from this list: send the line "unsubscribe linux-nfs" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at  http://vger.kernel.org/majordomo-info.html



-- 
Thanks,

Steve

Re: [PATCH 07/12] statx: CIFS: Return enhanced attributes

[Steve French]

Is it worth storing the same creation time twice (in slightly
different formats, struct timespec and u64 DCE time) in cifsInodeInfo?

On Fri, Nov 20, 2015 at 8:55 AM, David Howells <dhowells@redhat.com> wrote:
> Return enhanced attributes from the CIFS filesystem.  This includes the
> following:
>
>  (1) Return the file creation time as btime.  We assume that the creation
>      time won't change over the life of the inode.
>
>  (2) Set STATX_INFO_AUTOMOUNT on referral/submount directories.
>
>  (3) Unset STATX_INO if we made up the inode number and didn't get it from
>      the server.
>
>  (4) Unset STATX_[UG]ID if we are either returning values passed to mount
>      and/or the server doesn't return them.
>
>  (5) Set STATX_IOC_FLAGS and map various Windows file attributes to
>      FS_xxx_FL flags in st_ioc_flags, fetching them from the server if we
>      don't have them yet or don't have a current copy.  This includes the
>      following:
>
>         ATTR_READONLY   -> FS_IMMUTABLE_FL
>         ATTR_COMPRESSED -> FS_COMPR_FL
>         ATTR_HIDDEN     -> FS_HIDDEN_FL
>         ATTR_SYSTEM     -> FS_SYSTEM_FL
>         ATTR_ARCHIVE    -> FS_ARCHIVE_FL
>
>  (6) Set certain STATX_INFO_xxx to reflect other Windows file attributes:
>
>         ATTR_TEMPORARY  -> STATX_INFO_TEMPORARY;
>         ATTR_REPARSE    -> STATX_INFO_REPARSE_POINT;
>         ATTR_OFFLINE    -> STATX_INFO_OFFLINE;
>         ATTR_ENCRYPTED  -> STATX_INFO_ENCRYPTED;
>
>  (7) Set STATX_INFO_REMOTE on all files fetched by CIFS.
>
>  (8) Set STATX_INFO_NONSYSTEM_OWNERSHIP on all files as they all have
>      Windows ownership details too.
>
> Furthermore, what cifs_getattr() does can be controlled as follows:
>
>  (1) If AT_NO_ATTR_SYNC is indicated then this will suppress the flushing
>      of outstanding writes and the rereading of the inode's attributes with
>      the server as detailed below.
>
>  (2) Otherwise:
>
>      (a) If AT_FORCE_ATTR_SYNC is indicated, or mtime, ctime or size are
>          requested then the outstanding writes will be written to the
>          server first.
>
>      (b) The inode's attributes will be reread from the server:
>
>          (i) if AT_FORCE_ATTR_SYNC is indicated;
>
>         (ii) if the cached attributes have expired;
>
>        (iii) extra attributes are requested that aren't normally stored.
>
> If the inode isn't synchronised, then the cached attributes will be used -
> even if expired - without reference to the server.  Some attributes may be
> unavailable that would otherwise be provided.
>
> Note that cifs_revalidate_dentry() will issue an extra operation to get the
> FILE_ALL_INFO in addition to the FILE_UNIX_BASIC_INFO if it needs to
> collect creation time and attributes on behalf of cifs_getattr().
>
> [NOTE: THIS PATCH IS UNTESTED!]
>
> Signed-off-by: David Howells <dhowells@redhat.com>
> ---
>
>  fs/cifs/cifsfs.h   |    4 +-
>  fs/cifs/cifsglob.h |    8 +++
>  fs/cifs/dir.c      |    2 -
>  fs/cifs/inode.c    |  124 +++++++++++++++++++++++++++++++++++++++++-----------
>  4 files changed, 108 insertions(+), 30 deletions(-)
>
> diff --git a/fs/cifs/cifsfs.h b/fs/cifs/cifsfs.h
> index c3cc1609025f..fb38d47d84de 100644
> --- a/fs/cifs/cifsfs.h
> +++ b/fs/cifs/cifsfs.h
> @@ -71,9 +71,9 @@ extern int cifs_rmdir(struct inode *, struct dentry *);
>  extern int cifs_rename2(struct inode *, struct dentry *, struct inode *,
>                         struct dentry *, unsigned int);
>  extern int cifs_revalidate_file_attr(struct file *filp);
> -extern int cifs_revalidate_dentry_attr(struct dentry *);
> +extern int cifs_revalidate_dentry_attr(struct dentry *, bool, bool);
>  extern int cifs_revalidate_file(struct file *filp);
> -extern int cifs_revalidate_dentry(struct dentry *);
> +extern int cifs_revalidate_dentry(struct dentry *, bool, bool);
>  extern int cifs_invalidate_mapping(struct inode *inode);
>  extern int cifs_revalidate_mapping(struct inode *inode);
>  extern int cifs_zap_mapping(struct inode *inode);
> diff --git a/fs/cifs/cifsglob.h b/fs/cifs/cifsglob.h
> index b406a32deb1f..493e40a15b86 100644
> --- a/fs/cifs/cifsglob.h
> +++ b/fs/cifs/cifsglob.h
> @@ -1152,7 +1152,11 @@ struct cifsInodeInfo {
>         unsigned long flags;
>         spinlock_t writers_lock;
>         unsigned int writers;           /* Number of writers on this inode */
> +       bool btime_valid:1;             /* stored creation time is valid */
> +       bool uid_faked:1;               /* true if i_uid is faked */
> +       bool gid_faked:1;               /* true if i_gid is faked */
>         unsigned long time;             /* jiffies of last update of inode */
> +       struct timespec btime;          /* creation time */
>         u64  server_eof;                /* current file size on server -- protected by i_lock */
>         u64  uniqueid;                  /* server inode number */
>         u64  createtime;                /* creation time on server */
> @@ -1365,6 +1369,9 @@ struct dfs_info3_param {
>  #define CIFS_FATTR_NEED_REVAL          0x4
>  #define CIFS_FATTR_INO_COLLISION       0x8
>  #define CIFS_FATTR_UNKNOWN_NLINK       0x10
> +#define CIFS_FATTR_WINATTRS_VALID      0x20    /* T if cf_btime and cf_cifsattrs valid */
> +#define CIFS_FATTR_UID_FAKED           0x40    /* T if cf_uid is faked */
> +#define CIFS_FATTR_GID_FAKED           0x80    /* T if cf_gid is faked */
>
>  struct cifs_fattr {
>         u32             cf_flags;
> @@ -1382,6 +1389,7 @@ struct cifs_fattr {
>         struct timespec cf_atime;
>         struct timespec cf_mtime;
>         struct timespec cf_ctime;
> +       struct timespec cf_btime;
>  };
>
>  static inline void free_dfs_info_param(struct dfs_info3_param *param)
> diff --git a/fs/cifs/dir.c b/fs/cifs/dir.c
> index c3eb998a99bd..4984f04b0677 100644
> --- a/fs/cifs/dir.c
> +++ b/fs/cifs/dir.c
> @@ -792,7 +792,7 @@ cifs_d_revalidate(struct dentry *direntry, unsigned int flags)
>                 return -ECHILD;
>
>         if (d_really_is_positive(direntry)) {
> -               if (cifs_revalidate_dentry(direntry))
> +               if (cifs_revalidate_dentry(direntry, false, false))
>                         return 0;
>                 else {
>                         /*
> diff --git a/fs/cifs/inode.c b/fs/cifs/inode.c
> index 6b66dd5d1540..fcb024efbd4b 100644
> --- a/fs/cifs/inode.c
> +++ b/fs/cifs/inode.c
> @@ -166,13 +166,21 @@ cifs_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr)
>         cifs_nlink_fattr_to_inode(inode, fattr);
>         inode->i_uid = fattr->cf_uid;
>         inode->i_gid = fattr->cf_gid;
> +       if (fattr->cf_flags & CIFS_FATTR_UID_FAKED)
> +               cifs_i->uid_faked = true;
> +       if (fattr->cf_flags & CIFS_FATTR_GID_FAKED)
> +               cifs_i->gid_faked = true;
>
>         /* if dynperm is set, don't clobber existing mode */
>         if (inode->i_state & I_NEW ||
>             !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM))
>                 inode->i_mode = fattr->cf_mode;
>
> -       cifs_i->cifsAttrs = fattr->cf_cifsattrs;
> +       if (fattr->cf_flags & CIFS_FATTR_WINATTRS_VALID) {
> +               cifs_i->cifsAttrs = fattr->cf_cifsattrs;
> +               cifs_i->btime = fattr->cf_btime;
> +               cifs_i->btime_valid = true;
> +       }
>
>         if (fattr->cf_flags & CIFS_FATTR_NEED_REVAL)
>                 cifs_i->time = 0;
> @@ -284,18 +292,22 @@ cifs_unix_basic_to_fattr(struct cifs_fattr *fattr, FILE_UNIX_BASIC_INFO *info,
>                 u64 id = le64_to_cpu(info->Uid);
>                 if (id < ((uid_t)-1)) {
>                         kuid_t uid = make_kuid(&init_user_ns, id);
> -                       if (uid_valid(uid))
> +                       if (uid_valid(uid)) {
>                                 fattr->cf_uid = uid;
> +                               fattr->cf_flags |= CIFS_FATTR_UID_FAKED;
> +                       }
>                 }
>         }
> -
> +
>         fattr->cf_gid = cifs_sb->mnt_gid;
>         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)) {
>                 u64 id = le64_to_cpu(info->Gid);
>                 if (id < ((gid_t)-1)) {
>                         kgid_t gid = make_kgid(&init_user_ns, id);
> -                       if (gid_valid(gid))
> +                       if (gid_valid(gid)) {
>                                 fattr->cf_gid = gid;
> +                               fattr->cf_flags |= CIFS_FATTR_GID_FAKED;
> +                       }
>                 }
>         }
>
> @@ -324,7 +336,8 @@ cifs_create_dfs_fattr(struct cifs_fattr *fattr, struct super_block *sb)
>         fattr->cf_ctime = CURRENT_TIME;
>         fattr->cf_mtime = CURRENT_TIME;
>         fattr->cf_nlink = 2;
> -       fattr->cf_flags |= CIFS_FATTR_DFS_REFERRAL;
> +       fattr->cf_flags |= CIFS_FATTR_DFS_REFERRAL |
> +               CIFS_FATTR_UID_FAKED | CIFS_FATTR_GID_FAKED;
>  }
>
>  static int
> @@ -590,6 +603,7 @@ cifs_all_info_to_fattr(struct cifs_fattr *fattr, FILE_ALL_INFO *info,
>         struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
>
>         memset(fattr, 0, sizeof(*fattr));
> +       fattr->cf_flags = CIFS_FATTR_WINATTRS_VALID;
>         fattr->cf_cifsattrs = le32_to_cpu(info->Attributes);
>         if (info->DeletePending)
>                 fattr->cf_flags |= CIFS_FATTR_DELETE_PENDING;
> @@ -601,6 +615,7 @@ cifs_all_info_to_fattr(struct cifs_fattr *fattr, FILE_ALL_INFO *info,
>
>         fattr->cf_ctime = cifs_NTtimeToUnix(info->ChangeTime);
>         fattr->cf_mtime = cifs_NTtimeToUnix(info->LastWriteTime);
> +       fattr->cf_btime = cifs_NTtimeToUnix(info->CreationTime);
>
>         if (adjust_tz) {
>                 fattr->cf_ctime.tv_sec += tcon->ses->server->timeAdj;
> @@ -1887,7 +1902,8 @@ int cifs_revalidate_file_attr(struct file *filp)
>         return rc;
>  }
>
> -int cifs_revalidate_dentry_attr(struct dentry *dentry)
> +int cifs_revalidate_dentry_attr(struct dentry *dentry,
> +                               bool want_extra_bits, bool force)
>  {
>         unsigned int xid;
>         int rc = 0;
> @@ -1898,7 +1914,7 @@ int cifs_revalidate_dentry_attr(struct dentry *dentry)
>         if (inode == NULL)
>                 return -ENOENT;
>
> -       if (!cifs_inode_needs_reval(inode))
> +       if (!force && !cifs_inode_needs_reval(inode))
>                 return rc;
>
>         xid = get_xid();
> @@ -1915,9 +1931,12 @@ int cifs_revalidate_dentry_attr(struct dentry *dentry)
>                  full_path, inode, inode->i_count.counter,
>                  dentry, dentry->d_time, jiffies);
>
> -       if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext)
> +       if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext) {
>                 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
> -       else
> +               if (rc != 0)
> +                       goto out;
> +       }
> +       if (!cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext || want_extra_bits)
>                 rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
>                                          xid, NULL);
>
> @@ -1940,12 +1959,13 @@ int cifs_revalidate_file(struct file *filp)
>  }
>
>  /* revalidate a dentry's inode attributes */
> -int cifs_revalidate_dentry(struct dentry *dentry)
> +int cifs_revalidate_dentry(struct dentry *dentry,
> +                          bool want_extra_bits, bool force)
>  {
>         int rc;
>         struct inode *inode = d_inode(dentry);
>
> -       rc = cifs_revalidate_dentry_attr(dentry);
> +       rc = cifs_revalidate_dentry_attr(dentry, want_extra_bits, force);
>         if (rc)
>                 return rc;
>
> @@ -1958,28 +1978,62 @@ int cifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
>         struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb);
>         struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
>         struct inode *inode = d_inode(dentry);
> +       struct cifsInodeInfo *cifs_i = CIFS_I(inode);
> +       bool force = stat->query_flags & AT_FORCE_ATTR_SYNC;
> +       bool want_extra_bits = false;
> +       u32 info, ioc = 0;
> +       u32 attrs;
>         int rc;
>
> -       /*
> -        * We need to be sure that all dirty pages are written and the server
> -        * has actual ctime, mtime and file length.
> -        */
> -       if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
> -           inode->i_mapping->nrpages != 0) {
> -               rc = filemap_fdatawait(inode->i_mapping);
> -               if (rc) {
> -                       mapping_set_error(inode->i_mapping, rc);
> -                       return rc;
> +       if (cifs_i->uid_faked)
> +               stat->request_mask &= ~STATX_UID;
> +       if (cifs_i->gid_faked)
> +               stat->request_mask &= ~STATX_GID;
> +
> +       if ((stat->request_mask & STATX_BTIME && !cifs_i->btime_valid) ||
> +           stat->request_mask & STATX_IOC_FLAGS)
> +               want_extra_bits = force = true;
> +
> +       if (!(stat->query_flags & AT_NO_ATTR_SYNC)) {
> +               /* Unless we're explicitly told not to sync, we need to be sure
> +                * that all dirty pages are written and the server has actual
> +                * ctime, mtime and file length.
> +                */
> +               bool flush = force;
> +
> +               if (stat->request_mask &
> +                   (STATX_CTIME | STATX_MTIME | STATX_SIZE))
> +                       flush = true;
> +
> +               if (flush &&
> +                   !CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
> +                   inode->i_mapping->nrpages != 0) {
> +                       rc = filemap_fdatawait(inode->i_mapping);
> +                       if (rc) {
> +                               mapping_set_error(inode->i_mapping, rc);
> +                               return rc;
> +                       }
>                 }
> -       }
>
> -       rc = cifs_revalidate_dentry_attr(dentry);
> -       if (rc)
> -               return rc;
> +               rc = cifs_revalidate_dentry(dentry, want_extra_bits, force);
> +               if (rc)
> +                       return rc;
> +       }
>
>         generic_fillattr(inode, stat);
>         stat->blksize = CIFS_MAX_MSGSIZE;
> -       stat->ino = CIFS_I(inode)->uniqueid;
> +
> +       info = STATX_INFO_REMOTE | STATX_INFO_NONSYSTEM_OWNERSHIP;
> +
> +       if (cifs_i->btime_valid) {
> +               stat->btime = cifs_i->btime;
> +               stat->result_mask |= STATX_BTIME;
> +       }
> +
> +       /* We don't promise an inode number if we made one up */
> +       stat->ino = cifs_i->uniqueid;
> +       if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM))
> +               stat->result_mask &= ~STATX_INO;
>
>         /*
>          * If on a multiuser mount without unix extensions or cifsacl being
> @@ -1993,8 +2047,24 @@ int cifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
>                         stat->uid = current_fsuid();
>                 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID))
>                         stat->gid = current_fsgid();
> +               stat->result_mask &= ~(STATX_UID | STATX_GID);
>         }
> -       return rc;
> +
> +       attrs = cifs_i->cifsAttrs;
> +       if (attrs & ATTR_TEMPORARY)     info |= STATX_INFO_TEMPORARY;
> +       if (attrs & ATTR_REPARSE)       info |= STATX_INFO_REPARSE_POINT;
> +       if (attrs & ATTR_OFFLINE)       info |= STATX_INFO_OFFLINE;
> +       if (attrs & ATTR_ENCRYPTED)     info |= STATX_INFO_ENCRYPTED;
> +       stat->information |= info;
> +
> +       if (attrs & ATTR_READONLY)      ioc |= FS_IMMUTABLE_FL;
> +       if (attrs & ATTR_COMPRESSED)    ioc |= FS_COMPR_FL;
> +       if (attrs & ATTR_HIDDEN)        ioc |= FS_HIDDEN_FL;
> +       if (attrs & ATTR_SYSTEM)        ioc |= FS_SYSTEM_FL;
> +       if (attrs & ATTR_ARCHIVE)       ioc |= FS_ARCHIVE_FL;
> +       stat->ioc_flags |= ioc;
> +
> +       return 0;
>  }
>
>  static int cifs_truncate_page(struct address_space *mapping, loff_t from)
>
> --
> To unsubscribe from this list: send the line "unsubscribe linux-nfs" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at  http://vger.kernel.org/majordomo-info.html



-- 
Thanks,

Steve

Re: [PATCH 01/12] Ext4: Fix extended timestamp encoding and decoding

[Andreas Dilger]

[-- Attachment #1: Type: text/plain, Size: 12599 bytes --]

On Nov 20, 2015, at 7:54 AM, David Howells <dhowells-H+wXaHxf7aLQT0dZR+AlfA@public.gmane.org> wrote:
> 
> The handling of extended timestamps in Ext4 is broken as can be seen in the
> output of the test program attached below:
> 
> time     extra   bad decode        good decode         bad encode  good encode
> ======== =====   ================= =================   =========== ===========
> ffffffff     0 >  ffffffffffffffff  ffffffffffffffff > *ffffffff 3  ffffffff 0
> 80000000     0 >  ffffffff80000000  ffffffff80000000 > *80000000 3  80000000 0
> 00000000     0 >                 0                 0 >  00000000 0  00000000 0
> 7fffffff     0 >          7fffffff          7fffffff >  7fffffff 0  7fffffff 0
> 80000000     1 > *ffffffff80000000          80000000 > *80000000 0  80000000 1
> ffffffff     1 > *ffffffffffffffff          ffffffff > *ffffffff 0  ffffffff 1
> 00000000     1 >         100000000         100000000 >  00000000 1  00000000 1
> 7fffffff     1 >         17fffffff         17fffffff >  7fffffff 1  7fffffff 1
> 80000000     2 > *ffffffff80000000         180000000 > *80000000 1  80000000 2
> ffffffff     2 > *ffffffffffffffff         1ffffffff > *ffffffff 1  ffffffff 2
> 00000000     2 >         200000000         200000000 >  00000000 2  00000000 2
> 7fffffff     2 >         27fffffff         27fffffff >  7fffffff 2  7fffffff 2
> 80000000     3 > *ffffffff80000000         280000000 > *80000000 2  80000000 3
> ffffffff     3 > *ffffffffffffffff         2ffffffff > *ffffffff 2  ffffffff 3
> 00000000     3 >         300000000         300000000 >  00000000 3  00000000 3
> 7fffffff     3 >         37fffffff         37fffffff >  7fffffff 3  7fffffff 3
> 
> The values marked with asterisks are wrong.
> 
> The problem is that with a 64-bit time, in ext4_decode_extra_time() the
> epoch value is just OR'd with the sign-extended time - which, if negative,
> has all of the upper 32 bits set anyway.  We need to add the epoch instead
> of OR'ing it.  In ext4_encode_extra_time(), the reverse operation needs to
> take place as the 32-bit part of the number of seconds needs to be
> subtracted from the 64-bit value before the epoch is shifted down.
> 
> Since the epoch is presumably unsigned, this has the slightly strange
> effect of, for epochs > 0, putting the 0x80000000-0xffffffff range before
> the 0x00000000-0x7fffffff range.
> 
> This affects all kernels from v2.6.23-rc1 onwards.
> 
> The test program:
> 
> 	#include <stdio.h>
> 
> 	#define EXT4_FITS_IN_INODE(x, y, z) 1
> 	#define EXT4_EPOCH_BITS 2
> 	#define EXT4_EPOCH_MASK ((1 << EXT4_EPOCH_BITS) - 1)
> 	#define EXT4_NSEC_MASK  (~0UL << EXT4_EPOCH_BITS)
> 
> 	#define le32_to_cpu(x) (x)
> 	#define cpu_to_le32(x) (x)
> 	typedef unsigned int __le32;
> 	typedef unsigned int u32;
> 	typedef signed int s32;
> 	typedef unsigned long long __u64;
> 	typedef signed long long s64;
> 
> 	struct timespec {
> 		long long	tv_sec;			/* seconds */
> 		long		tv_nsec;		/* nanoseconds */
> 	};
> 
> 	struct ext4_inode_info {
> 		struct timespec i_crtime;
> 	};
> 
> 	struct ext4_inode {
> 		__le32  i_crtime;       /* File Creation time */
> 		__le32  i_crtime_extra; /* extra FileCreationtime (nsec << 2 | epoch) */
> 	};
> 
> 	/* Incorrect implementation */
> 	static inline void ext4_decode_extra_time_bad(struct timespec *time, __le32 extra)
> 	{
> 	       if (sizeof(time->tv_sec) > 4)
> 		       time->tv_sec |= (__u64)(le32_to_cpu(extra) & EXT4_EPOCH_MASK)
> 				       << 32;
> 	       time->tv_nsec = (le32_to_cpu(extra) & EXT4_NSEC_MASK) >> EXT4_EPOCH_BITS;
> 	}
> 
> 	static inline __le32 ext4_encode_extra_time_bad(struct timespec *time)
> 	{
> 	       return cpu_to_le32((sizeof(time->tv_sec) > 4 ?
> 				   (time->tv_sec >> 32) & EXT4_EPOCH_MASK : 0) |
> 				  ((time->tv_nsec << EXT4_EPOCH_BITS) & EXT4_NSEC_MASK));
> 	}
> 
> 	/* Fixed implementation */
> 	static inline void ext4_decode_extra_time_good(struct timespec *time, __le32 _extra)
> 	{
> 		u32 extra = le32_to_cpu(_extra);
> 		u32 epoch = extra & EXT4_EPOCH_MASK;
> 
> 		time->tv_sec = (s32)time->tv_sec + ((s64)epoch  << 32);
> 		time->tv_nsec = (extra & EXT4_NSEC_MASK) >> EXT4_EPOCH_BITS;
> 	}
> 
> 	static inline __le32 ext4_encode_extra_time_good(struct timespec *time)
> 	{
> 		u32 extra;
> 		s64 epoch = time->tv_sec - (s32)time->tv_sec;
> 
> 		extra = (epoch >> 32) & EXT4_EPOCH_MASK;
> 		extra |= (time->tv_nsec << EXT4_EPOCH_BITS) & EXT4_NSEC_MASK;
> 		return cpu_to_le32(extra);
> 	}
> 
> 	#define EXT4_INODE_GET_XTIME_BAD(xtime, inode, raw_inode)		\
> 	do {									       \
> 		(inode)->xtime.tv_sec = (signed)le32_to_cpu((raw_inode)->xtime);       \
> 		if (EXT4_FITS_IN_INODE(raw_inode, EXT4_I(inode), xtime ## _extra))     \
> 			ext4_decode_extra_time_bad(&(inode)->xtime,		\
> 						   raw_inode->xtime ## _extra);	\
> 		else								       \
> 			(inode)->xtime.tv_nsec = 0;				       \
> 	} while (0)
> 
> 	#define EXT4_INODE_SET_XTIME_BAD(xtime, inode, raw_inode)		\
> 	do {									       \
> 		(raw_inode)->xtime = cpu_to_le32((inode)->xtime.tv_sec);	       \
> 		if (EXT4_FITS_IN_INODE(raw_inode, EXT4_I(inode), xtime ## _extra))     \
> 			(raw_inode)->xtime ## _extra =				       \
> 				ext4_encode_extra_time_bad(&(inode)->xtime);	\
> 	} while (0)
> 
> 	#define EXT4_INODE_GET_XTIME_GOOD(xtime, inode, raw_inode)		\
> 	do {									       \
> 		(inode)->xtime.tv_sec = (signed)le32_to_cpu((raw_inode)->xtime);       \
> 		if (EXT4_FITS_IN_INODE(raw_inode, EXT4_I(inode), xtime ## _extra))     \
> 			ext4_decode_extra_time_good(&(inode)->xtime,			       \
> 					       raw_inode->xtime ## _extra);	\
> 		else								       \
> 			(inode)->xtime.tv_nsec = 0;				       \
> 	} while (0)
> 
> 	#define EXT4_INODE_SET_XTIME_GOOD(xtime, inode, raw_inode)		\
> 	do {									       \
> 		(raw_inode)->xtime = cpu_to_le32((inode)->xtime.tv_sec);	       \
> 		if (EXT4_FITS_IN_INODE(raw_inode, EXT4_I(inode), xtime ## _extra))     \
> 			(raw_inode)->xtime ## _extra =				       \
> 				ext4_encode_extra_time_good(&(inode)->xtime);	\
> 	} while (0)
> 
> 	static const struct test {
> 		unsigned crtime;
> 		unsigned extra;
> 		long long sec;
> 		int nsec;
> 	} tests[] = {
> 		// crtime	extra		tv_sec			tv_nsec
> 		0xffffffff,	0x00000000,	0xffffffffffffffff,	0,
> 		0x80000000,	0x00000000,	0xffffffff80000000,	0,
> 		0x00000000,	0x00000000,	0x0000000000000000,	0,
> 		0x7fffffff,	0x00000000,	0x000000007fffffff,	0,
> 		0x80000000,	0x00000001,	0x0000000080000000,	0,
> 		0xffffffff,	0x00000001,	0x00000000ffffffff,	0,
> 		0x00000000,	0x00000001,	0x0000000100000000,	0,
> 		0x7fffffff,	0x00000001,	0x000000017fffffff,	0,
> 		0x80000000,	0x00000002,	0x0000000180000000,	0,
> 		0xffffffff,	0x00000002,	0x00000001ffffffff,	0,
> 		0x00000000,	0x00000002,	0x0000000200000000,	0,
> 		0x7fffffff,	0x00000002,	0x000000027fffffff,	0,
> 		0x80000000,	0x00000003,	0x0000000280000000,	0,
> 		0xffffffff,	0x00000003,	0x00000002ffffffff,	0,
> 		0x00000000,	0x00000003,	0x0000000300000000,	0,
> 		0x7fffffff,	0x00000003,	0x000000037fffffff,	0,
> 	};
> 
> 	int main()
> 	{
> 		struct ext4_inode_info ii_bad, ii_good;
> 		struct ext4_inode raw, *praw = &raw;
> 		struct ext4_inode raw_bad, *praw_bad = &raw_bad;
> 		struct ext4_inode raw_good, *praw_good = &raw_good;
> 		const struct test *t;
> 		int i, ret = 0;
> 
> 		printf("time     extra   bad decode        good decode         bad encode  good encode\n");
> 		printf("======== =====   ================= =================   =========== ===========\n");
> 		for (i = 0; i < sizeof(tests) / sizeof(t[0]); i++) {
> 			t = &tests[i];
> 			raw.i_crtime = t->crtime;
> 			raw.i_crtime_extra = t->extra;
> 			printf("%08x %5d > ", t->crtime, t->extra);
> 
> 			EXT4_INODE_GET_XTIME_BAD(i_crtime, &ii_bad, praw);
> 			EXT4_INODE_GET_XTIME_GOOD(i_crtime, &ii_good, praw);
> 			if (ii_bad.i_crtime.tv_sec != t->sec ||
> 			    ii_bad.i_crtime.tv_nsec != t->nsec)
> 				printf("*");
> 			else
> 				printf(" ");
> 			printf("%16llx", ii_bad.i_crtime.tv_sec);
> 			printf(" ");
> 			if (ii_good.i_crtime.tv_sec != t->sec ||
> 			    ii_good.i_crtime.tv_nsec != t->nsec) {
> 				printf("*");
> 				ret = 1;
> 			} else {
> 				printf(" ");
> 			}
> 			printf("%16llx", ii_good.i_crtime.tv_sec);
> 
> 			EXT4_INODE_SET_XTIME_BAD(i_crtime, &ii_good, praw_bad);
> 			EXT4_INODE_SET_XTIME_GOOD(i_crtime, &ii_good, praw_good);
> 
> 			printf(" > ");
> 			if (raw_bad.i_crtime != raw.i_crtime ||
> 			    raw_bad.i_crtime_extra != raw.i_crtime_extra)
> 				printf("*");
> 			else
> 				printf(" ");
> 			printf("%08llx %d", raw_bad.i_crtime, raw_bad.i_crtime_extra);
> 			printf(" ");
> 
> 			if (raw_good.i_crtime != raw.i_crtime ||
> 			    raw_good.i_crtime_extra != raw.i_crtime_extra) {
> 				printf("*");
> 				ret = 1;
> 			} else {
> 				printf(" ");
> 			}
> 			printf("%08llx %d", raw_good.i_crtime, raw_good.i_crtime_extra);
> 			printf("\n");
> 		}
> 
> 		return ret;
> 	}
> 
> Signed-off-by: David Howells <dhowells-H+wXaHxf7aLQT0dZR+AlfA@public.gmane.org>
> ---
> 
> fs/ext4/ext4.h |   22 +++++++++++++---------
> 1 file changed, 13 insertions(+), 9 deletions(-)
> 
> diff --git a/fs/ext4/ext4.h b/fs/ext4/ext4.h
> index fd1f28be5296..31efcd78bf51 100644
> --- a/fs/ext4/ext4.h
> +++ b/fs/ext4/ext4.h
> @@ -723,19 +723,23 @@ struct move_extent {
> 	<= (EXT4_GOOD_OLD_INODE_SIZE +			\
> 	    (einode)->i_extra_isize))			\
> 
> -static inline __le32 ext4_encode_extra_time(struct timespec *time)
> +static inline void ext4_decode_extra_time(struct timespec *time, __le32 _extra)
> {
> -       return cpu_to_le32((sizeof(time->tv_sec) > 4 ?
> -			   (time->tv_sec >> 32) & EXT4_EPOCH_MASK : 0) |
> -                          ((time->tv_nsec << EXT4_EPOCH_BITS) & EXT4_NSEC_MASK));
> +	u32 extra = le32_to_cpu(_extra);
> +	u32 epoch = extra & EXT4_EPOCH_MASK;
> +
> +	time->tv_sec = (s32)time->tv_sec + ((s64)epoch  << 32);

Minor nit - two spaces before "<<".

> +	time->tv_nsec = (extra & EXT4_NSEC_MASK) >> EXT4_EPOCH_BITS;
> }
> 
> -static inline void ext4_decode_extra_time(struct timespec *time, __le32 extra)
> +static inline __le32 ext4_encode_extra_time(struct timespec *time)
> {
> -       if (sizeof(time->tv_sec) > 4)
> -	       time->tv_sec |= (__u64)(le32_to_cpu(extra) & EXT4_EPOCH_MASK)
> -			       << 32;
> -       time->tv_nsec = (le32_to_cpu(extra) & EXT4_NSEC_MASK) >> EXT4_EPOCH_BITS;
> +	u32 extra;
> +	s64 epoch = time->tv_sec - (s32)time->tv_sec;
> +
> +	extra = (epoch >> 32) & EXT4_EPOCH_MASK;
> +	extra |= (time->tv_nsec << EXT4_EPOCH_BITS) & EXT4_NSEC_MASK;
> +	return cpu_to_le32(extra);
> }

David, thanks for moving this patch forward.

It would have been easier to review if the order of encode and decode
functions had not been reversed... :-)

It would be good to get a comment block in the code describing the encoding:

/*
 * We need is an encoding that preserves the times for extra epoch "00":
 *
 * extra                          add to 32-bit
 * epoch                          tv_sec to get
 * bits   decoded 64-bit tv_sec   64-bit value    valid time range
 * 0     -0x80000000..-0x00000001  0x000000000    1901-12-13..1969-12-31
 * 0     0x000000000..0x07fffffff  0x000000000    1970-01-01..2038-01-19
 * 1     0x080000000..0x0ffffffff  0x100000000    2038-01-19..2106-02-07
 * 1     0x100000000..0x17fffffff  0x100000000    2106-02-07..2174-02-25
 * 2     0x180000000..0x1ffffffff  0x200000000    2174-02-25..2242-03-16
 * 2     0x200000000..0x27fffffff  0x200000000    2242-03-16..2310-04-04
 * 3     0x280000000..0x2ffffffff  0x300000000    2310-04-04..2378-04-22
 * 3     0x300000000..0x37fffffff  0x300000000    2378-04-22..2446-05-10
 *
 * Note that previous versions of the kernel on 64-bit systems would
 * incorrectly use extra epoch bits 1,1 for dates between 1901 and 1970.
 * e2fsck will correct this, assuming that it is run on the affected
 * filesystem before 2242.
 */


The only other question is whether you compile tested this on a 32-bit
system?  IIRC, the "sizeof(time->tv_sec)" check was to avoid compiler
warnings due to assigning values too large for the data type, and (to
a lesser extent) avoiding overhead on those systems.

If there is no 32-bit compile warning then I'm fine with this as-is,
since systems with 32-bit tv_sec are going to be broken at that point
in any case.

Cheers, Andreas






[-- Attachment #2: Message signed with OpenPGP using GPGMail --]
[-- Type: application/pgp-signature, Size: 833 bytes --]

Re: [PATCH 01/12] Ext4: Fix extended timestamp encoding and decoding

[Andreas Dilger]

[-- Attachment #1: Type: text/plain, Size: 12541 bytes --]

On Nov 20, 2015, at 7:54 AM, David Howells <dhowells@redhat.com> wrote:
> 
> The handling of extended timestamps in Ext4 is broken as can be seen in the
> output of the test program attached below:
> 
> time     extra   bad decode        good decode         bad encode  good encode
> ======== =====   ================= =================   =========== ===========
> ffffffff     0 >  ffffffffffffffff  ffffffffffffffff > *ffffffff 3  ffffffff 0
> 80000000     0 >  ffffffff80000000  ffffffff80000000 > *80000000 3  80000000 0
> 00000000     0 >                 0                 0 >  00000000 0  00000000 0
> 7fffffff     0 >          7fffffff          7fffffff >  7fffffff 0  7fffffff 0
> 80000000     1 > *ffffffff80000000          80000000 > *80000000 0  80000000 1
> ffffffff     1 > *ffffffffffffffff          ffffffff > *ffffffff 0  ffffffff 1
> 00000000     1 >         100000000         100000000 >  00000000 1  00000000 1
> 7fffffff     1 >         17fffffff         17fffffff >  7fffffff 1  7fffffff 1
> 80000000     2 > *ffffffff80000000         180000000 > *80000000 1  80000000 2
> ffffffff     2 > *ffffffffffffffff         1ffffffff > *ffffffff 1  ffffffff 2
> 00000000     2 >         200000000         200000000 >  00000000 2  00000000 2
> 7fffffff     2 >         27fffffff         27fffffff >  7fffffff 2  7fffffff 2
> 80000000     3 > *ffffffff80000000         280000000 > *80000000 2  80000000 3
> ffffffff     3 > *ffffffffffffffff         2ffffffff > *ffffffff 2  ffffffff 3
> 00000000     3 >         300000000         300000000 >  00000000 3  00000000 3
> 7fffffff     3 >         37fffffff         37fffffff >  7fffffff 3  7fffffff 3
> 
> The values marked with asterisks are wrong.
> 
> The problem is that with a 64-bit time, in ext4_decode_extra_time() the
> epoch value is just OR'd with the sign-extended time - which, if negative,
> has all of the upper 32 bits set anyway.  We need to add the epoch instead
> of OR'ing it.  In ext4_encode_extra_time(), the reverse operation needs to
> take place as the 32-bit part of the number of seconds needs to be
> subtracted from the 64-bit value before the epoch is shifted down.
> 
> Since the epoch is presumably unsigned, this has the slightly strange
> effect of, for epochs > 0, putting the 0x80000000-0xffffffff range before
> the 0x00000000-0x7fffffff range.
> 
> This affects all kernels from v2.6.23-rc1 onwards.
> 
> The test program:
> 
> 	#include <stdio.h>
> 
> 	#define EXT4_FITS_IN_INODE(x, y, z) 1
> 	#define EXT4_EPOCH_BITS 2
> 	#define EXT4_EPOCH_MASK ((1 << EXT4_EPOCH_BITS) - 1)
> 	#define EXT4_NSEC_MASK  (~0UL << EXT4_EPOCH_BITS)
> 
> 	#define le32_to_cpu(x) (x)
> 	#define cpu_to_le32(x) (x)
> 	typedef unsigned int __le32;
> 	typedef unsigned int u32;
> 	typedef signed int s32;
> 	typedef unsigned long long __u64;
> 	typedef signed long long s64;
> 
> 	struct timespec {
> 		long long	tv_sec;			/* seconds */
> 		long		tv_nsec;		/* nanoseconds */
> 	};
> 
> 	struct ext4_inode_info {
> 		struct timespec i_crtime;
> 	};
> 
> 	struct ext4_inode {
> 		__le32  i_crtime;       /* File Creation time */
> 		__le32  i_crtime_extra; /* extra FileCreationtime (nsec << 2 | epoch) */
> 	};
> 
> 	/* Incorrect implementation */
> 	static inline void ext4_decode_extra_time_bad(struct timespec *time, __le32 extra)
> 	{
> 	       if (sizeof(time->tv_sec) > 4)
> 		       time->tv_sec |= (__u64)(le32_to_cpu(extra) & EXT4_EPOCH_MASK)
> 				       << 32;
> 	       time->tv_nsec = (le32_to_cpu(extra) & EXT4_NSEC_MASK) >> EXT4_EPOCH_BITS;
> 	}
> 
> 	static inline __le32 ext4_encode_extra_time_bad(struct timespec *time)
> 	{
> 	       return cpu_to_le32((sizeof(time->tv_sec) > 4 ?
> 				   (time->tv_sec >> 32) & EXT4_EPOCH_MASK : 0) |
> 				  ((time->tv_nsec << EXT4_EPOCH_BITS) & EXT4_NSEC_MASK));
> 	}
> 
> 	/* Fixed implementation */
> 	static inline void ext4_decode_extra_time_good(struct timespec *time, __le32 _extra)
> 	{
> 		u32 extra = le32_to_cpu(_extra);
> 		u32 epoch = extra & EXT4_EPOCH_MASK;
> 
> 		time->tv_sec = (s32)time->tv_sec + ((s64)epoch  << 32);
> 		time->tv_nsec = (extra & EXT4_NSEC_MASK) >> EXT4_EPOCH_BITS;
> 	}
> 
> 	static inline __le32 ext4_encode_extra_time_good(struct timespec *time)
> 	{
> 		u32 extra;
> 		s64 epoch = time->tv_sec - (s32)time->tv_sec;
> 
> 		extra = (epoch >> 32) & EXT4_EPOCH_MASK;
> 		extra |= (time->tv_nsec << EXT4_EPOCH_BITS) & EXT4_NSEC_MASK;
> 		return cpu_to_le32(extra);
> 	}
> 
> 	#define EXT4_INODE_GET_XTIME_BAD(xtime, inode, raw_inode)		\
> 	do {									       \
> 		(inode)->xtime.tv_sec = (signed)le32_to_cpu((raw_inode)->xtime);       \
> 		if (EXT4_FITS_IN_INODE(raw_inode, EXT4_I(inode), xtime ## _extra))     \
> 			ext4_decode_extra_time_bad(&(inode)->xtime,		\
> 						   raw_inode->xtime ## _extra);	\
> 		else								       \
> 			(inode)->xtime.tv_nsec = 0;				       \
> 	} while (0)
> 
> 	#define EXT4_INODE_SET_XTIME_BAD(xtime, inode, raw_inode)		\
> 	do {									       \
> 		(raw_inode)->xtime = cpu_to_le32((inode)->xtime.tv_sec);	       \
> 		if (EXT4_FITS_IN_INODE(raw_inode, EXT4_I(inode), xtime ## _extra))     \
> 			(raw_inode)->xtime ## _extra =				       \
> 				ext4_encode_extra_time_bad(&(inode)->xtime);	\
> 	} while (0)
> 
> 	#define EXT4_INODE_GET_XTIME_GOOD(xtime, inode, raw_inode)		\
> 	do {									       \
> 		(inode)->xtime.tv_sec = (signed)le32_to_cpu((raw_inode)->xtime);       \
> 		if (EXT4_FITS_IN_INODE(raw_inode, EXT4_I(inode), xtime ## _extra))     \
> 			ext4_decode_extra_time_good(&(inode)->xtime,			       \
> 					       raw_inode->xtime ## _extra);	\
> 		else								       \
> 			(inode)->xtime.tv_nsec = 0;				       \
> 	} while (0)
> 
> 	#define EXT4_INODE_SET_XTIME_GOOD(xtime, inode, raw_inode)		\
> 	do {									       \
> 		(raw_inode)->xtime = cpu_to_le32((inode)->xtime.tv_sec);	       \
> 		if (EXT4_FITS_IN_INODE(raw_inode, EXT4_I(inode), xtime ## _extra))     \
> 			(raw_inode)->xtime ## _extra =				       \
> 				ext4_encode_extra_time_good(&(inode)->xtime);	\
> 	} while (0)
> 
> 	static const struct test {
> 		unsigned crtime;
> 		unsigned extra;
> 		long long sec;
> 		int nsec;
> 	} tests[] = {
> 		// crtime	extra		tv_sec			tv_nsec
> 		0xffffffff,	0x00000000,	0xffffffffffffffff,	0,
> 		0x80000000,	0x00000000,	0xffffffff80000000,	0,
> 		0x00000000,	0x00000000,	0x0000000000000000,	0,
> 		0x7fffffff,	0x00000000,	0x000000007fffffff,	0,
> 		0x80000000,	0x00000001,	0x0000000080000000,	0,
> 		0xffffffff,	0x00000001,	0x00000000ffffffff,	0,
> 		0x00000000,	0x00000001,	0x0000000100000000,	0,
> 		0x7fffffff,	0x00000001,	0x000000017fffffff,	0,
> 		0x80000000,	0x00000002,	0x0000000180000000,	0,
> 		0xffffffff,	0x00000002,	0x00000001ffffffff,	0,
> 		0x00000000,	0x00000002,	0x0000000200000000,	0,
> 		0x7fffffff,	0x00000002,	0x000000027fffffff,	0,
> 		0x80000000,	0x00000003,	0x0000000280000000,	0,
> 		0xffffffff,	0x00000003,	0x00000002ffffffff,	0,
> 		0x00000000,	0x00000003,	0x0000000300000000,	0,
> 		0x7fffffff,	0x00000003,	0x000000037fffffff,	0,
> 	};
> 
> 	int main()
> 	{
> 		struct ext4_inode_info ii_bad, ii_good;
> 		struct ext4_inode raw, *praw = &raw;
> 		struct ext4_inode raw_bad, *praw_bad = &raw_bad;
> 		struct ext4_inode raw_good, *praw_good = &raw_good;
> 		const struct test *t;
> 		int i, ret = 0;
> 
> 		printf("time     extra   bad decode        good decode         bad encode  good encode\n");
> 		printf("======== =====   ================= =================   =========== ===========\n");
> 		for (i = 0; i < sizeof(tests) / sizeof(t[0]); i++) {
> 			t = &tests[i];
> 			raw.i_crtime = t->crtime;
> 			raw.i_crtime_extra = t->extra;
> 			printf("%08x %5d > ", t->crtime, t->extra);
> 
> 			EXT4_INODE_GET_XTIME_BAD(i_crtime, &ii_bad, praw);
> 			EXT4_INODE_GET_XTIME_GOOD(i_crtime, &ii_good, praw);
> 			if (ii_bad.i_crtime.tv_sec != t->sec ||
> 			    ii_bad.i_crtime.tv_nsec != t->nsec)
> 				printf("*");
> 			else
> 				printf(" ");
> 			printf("%16llx", ii_bad.i_crtime.tv_sec);
> 			printf(" ");
> 			if (ii_good.i_crtime.tv_sec != t->sec ||
> 			    ii_good.i_crtime.tv_nsec != t->nsec) {
> 				printf("*");
> 				ret = 1;
> 			} else {
> 				printf(" ");
> 			}
> 			printf("%16llx", ii_good.i_crtime.tv_sec);
> 
> 			EXT4_INODE_SET_XTIME_BAD(i_crtime, &ii_good, praw_bad);
> 			EXT4_INODE_SET_XTIME_GOOD(i_crtime, &ii_good, praw_good);
> 
> 			printf(" > ");
> 			if (raw_bad.i_crtime != raw.i_crtime ||
> 			    raw_bad.i_crtime_extra != raw.i_crtime_extra)
> 				printf("*");
> 			else
> 				printf(" ");
> 			printf("%08llx %d", raw_bad.i_crtime, raw_bad.i_crtime_extra);
> 			printf(" ");
> 
> 			if (raw_good.i_crtime != raw.i_crtime ||
> 			    raw_good.i_crtime_extra != raw.i_crtime_extra) {
> 				printf("*");
> 				ret = 1;
> 			} else {
> 				printf(" ");
> 			}
> 			printf("%08llx %d", raw_good.i_crtime, raw_good.i_crtime_extra);
> 			printf("\n");
> 		}
> 
> 		return ret;
> 	}
> 
> Signed-off-by: David Howells <dhowells@redhat.com>
> ---
> 
> fs/ext4/ext4.h |   22 +++++++++++++---------
> 1 file changed, 13 insertions(+), 9 deletions(-)
> 
> diff --git a/fs/ext4/ext4.h b/fs/ext4/ext4.h
> index fd1f28be5296..31efcd78bf51 100644
> --- a/fs/ext4/ext4.h
> +++ b/fs/ext4/ext4.h
> @@ -723,19 +723,23 @@ struct move_extent {
> 	<= (EXT4_GOOD_OLD_INODE_SIZE +			\
> 	    (einode)->i_extra_isize))			\
> 
> -static inline __le32 ext4_encode_extra_time(struct timespec *time)
> +static inline void ext4_decode_extra_time(struct timespec *time, __le32 _extra)
> {
> -       return cpu_to_le32((sizeof(time->tv_sec) > 4 ?
> -			   (time->tv_sec >> 32) & EXT4_EPOCH_MASK : 0) |
> -                          ((time->tv_nsec << EXT4_EPOCH_BITS) & EXT4_NSEC_MASK));
> +	u32 extra = le32_to_cpu(_extra);
> +	u32 epoch = extra & EXT4_EPOCH_MASK;
> +
> +	time->tv_sec = (s32)time->tv_sec + ((s64)epoch  << 32);

Minor nit - two spaces before "<<".

> +	time->tv_nsec = (extra & EXT4_NSEC_MASK) >> EXT4_EPOCH_BITS;
> }
> 
> -static inline void ext4_decode_extra_time(struct timespec *time, __le32 extra)
> +static inline __le32 ext4_encode_extra_time(struct timespec *time)
> {
> -       if (sizeof(time->tv_sec) > 4)
> -	       time->tv_sec |= (__u64)(le32_to_cpu(extra) & EXT4_EPOCH_MASK)
> -			       << 32;
> -       time->tv_nsec = (le32_to_cpu(extra) & EXT4_NSEC_MASK) >> EXT4_EPOCH_BITS;
> +	u32 extra;
> +	s64 epoch = time->tv_sec - (s32)time->tv_sec;
> +
> +	extra = (epoch >> 32) & EXT4_EPOCH_MASK;
> +	extra |= (time->tv_nsec << EXT4_EPOCH_BITS) & EXT4_NSEC_MASK;
> +	return cpu_to_le32(extra);
> }

David, thanks for moving this patch forward.

It would have been easier to review if the order of encode and decode
functions had not been reversed... :-)

It would be good to get a comment block in the code describing the encoding:

/*
 * We need is an encoding that preserves the times for extra epoch "00":
 *
 * extra                          add to 32-bit
 * epoch                          tv_sec to get
 * bits   decoded 64-bit tv_sec   64-bit value    valid time range
 * 0     -0x80000000..-0x00000001  0x000000000    1901-12-13..1969-12-31
 * 0     0x000000000..0x07fffffff  0x000000000    1970-01-01..2038-01-19
 * 1     0x080000000..0x0ffffffff  0x100000000    2038-01-19..2106-02-07
 * 1     0x100000000..0x17fffffff  0x100000000    2106-02-07..2174-02-25
 * 2     0x180000000..0x1ffffffff  0x200000000    2174-02-25..2242-03-16
 * 2     0x200000000..0x27fffffff  0x200000000    2242-03-16..2310-04-04
 * 3     0x280000000..0x2ffffffff  0x300000000    2310-04-04..2378-04-22
 * 3     0x300000000..0x37fffffff  0x300000000    2378-04-22..2446-05-10
 *
 * Note that previous versions of the kernel on 64-bit systems would
 * incorrectly use extra epoch bits 1,1 for dates between 1901 and 1970.
 * e2fsck will correct this, assuming that it is run on the affected
 * filesystem before 2242.
 */


The only other question is whether you compile tested this on a 32-bit
system?  IIRC, the "sizeof(time->tv_sec)" check was to avoid compiler
warnings due to assigning values too large for the data type, and (to
a lesser extent) avoiding overhead on those systems.

If there is no 32-bit compile warning then I'm fine with this as-is,
since systems with 32-bit tv_sec are going to be broken at that point
in any case.

Cheers, Andreas






[-- Attachment #2: Message signed with OpenPGP using GPGMail --]
[-- Type: application/pgp-signature, Size: 833 bytes --]

Re: [PATCH 01/12] Ext4: Fix extended timestamp encoding and decoding

[Theodore Ts'o]

This is the patch I would prefer to use (and in fact which I have
added to the ext4 tree):

There are issues with 32-bit vs 64-bit encoding of times before
January 1, 1970, which are handled with this patch which is not
handled with what you have in your patch series.  So I'd prefer if you
drop this patch, and I'll get this sent to Linus as a bug fix for 4.4.

Cheers,

					- Ted


commit e0d738b05d484487b7e1e3c6d537da8bbef80c86
Author: David Turner <novalis@novalis.org>
Date:   Tue Nov 24 14:34:37 2015 -0500

    ext4: Fix handling of extended tv_sec
    In ext4, the bottom two bits of {a,c,m}time_extra are used to extend
    the {a,c,m}time fields, deferring the year 2038 problem to the year
    2446.
    
    When decoding these extended fields, for times whose bottom 32 bits
    would represent a negative number, sign extension causes the 64-bit
    extended timestamp to be negative as well, which is not what's
    intended.  This patch corrects that issue, so that the only negative
    {a,c,m}times are those between 1901 and 1970 (as per 32-bit signed
    timestamps).
    
    Some older kernels might have written pre-1970 dates with 1,1 in the
    extra bits.  This patch treats those incorrectly-encoded dates as
    pre-1970, instead of post-2311, until kernel 4.20 is released.
    Hopefully by then e2fsck will have fixed up the bad data.
    
    Also add a comment explaining the encoding of ext4's extra {a,c,m}time
    bits.
    
    Signed-off-by: David Turner <novalis@novalis.org>
    Signed-off-by: Theodore Ts'o <tytso@mit.edu>
    Reported-by: Mark Harris <mh8928@yahoo.com>
    Bugzilla: https://bugzilla.kernel.org/show_bug.cgi?id=23732
    Cc: stable@vger.kernel.org

diff --git a/fs/ext4/ext4.h b/fs/ext4/ext4.h
index 750063f..fddce29 100644
--- a/fs/ext4/ext4.h
+++ b/fs/ext4/ext4.h
@@ -26,6 +26,7 @@
 #include <linux/seqlock.h>
 #include <linux/mutex.h>
 #include <linux/timer.h>
+#include <linux/version.h>
 #include <linux/wait.h>
 #include <linux/blockgroup_lock.h>
 #include <linux/percpu_counter.h>
@@ -727,19 +728,53 @@ struct move_extent {
 	<= (EXT4_GOOD_OLD_INODE_SIZE +			\
 	    (einode)->i_extra_isize))			\
 
+/*
+ * We use an encoding that preserves the times for extra epoch "00":
+ *
+ * extra  msb of                         adjust for signed
+ * epoch  32-bit                         32-bit tv_sec to
+ * bits   time    decoded 64-bit tv_sec  64-bit tv_sec      valid time range
+ * 0 0    1    -0x80000000..-0x00000001  0x000000000 1901-12-13..1969-12-31
+ * 0 0    0    0x000000000..0x07fffffff  0x000000000 1970-01-01..2038-01-19
+ * 0 1    1    0x080000000..0x0ffffffff  0x100000000 2038-01-19..2106-02-07
+ * 0 1    0    0x100000000..0x17fffffff  0x100000000 2106-02-07..2174-02-25
+ * 1 0    1    0x180000000..0x1ffffffff  0x200000000 2174-02-25..2242-03-16
+ * 1 0    0    0x200000000..0x27fffffff  0x200000000 2242-03-16..2310-04-04
+ * 1 1    1    0x280000000..0x2ffffffff  0x300000000 2310-04-04..2378-04-22
+ * 1 1    0    0x300000000..0x37fffffff  0x300000000 2378-04-22..2446-05-10
+ *
+ * Note that previous versions of the kernel on 64-bit systems would
+ * incorrectly use extra epoch bits 1,1 for dates between 1901 and
+ * 1970.  e2fsck will correct this, assuming that it is run on the
+ * affected filesystem before 2242.
+ */
+
 static inline __le32 ext4_encode_extra_time(struct timespec *time)
 {
-       return cpu_to_le32((sizeof(time->tv_sec) > 4 ?
-			   (time->tv_sec >> 32) & EXT4_EPOCH_MASK : 0) |
-                          ((time->tv_nsec << EXT4_EPOCH_BITS) & EXT4_NSEC_MASK));
+	u32 extra = sizeof(time->tv_sec) > 4 ?
+		((time->tv_sec - (s32)time->tv_sec) >> 32) & EXT4_EPOCH_MASK : 0;
+	return cpu_to_le32(extra | (time->tv_nsec << EXT4_EPOCH_BITS));
 }
 
 static inline void ext4_decode_extra_time(struct timespec *time, __le32 extra)
 {
-       if (sizeof(time->tv_sec) > 4)
-	       time->tv_sec |= (__u64)(le32_to_cpu(extra) & EXT4_EPOCH_MASK)
-			       << 32;
-       time->tv_nsec = (le32_to_cpu(extra) & EXT4_NSEC_MASK) >> EXT4_EPOCH_BITS;
+	if (unlikely(sizeof(time->tv_sec) > 4 &&
+			(extra & cpu_to_le32(EXT4_EPOCH_MASK)))) {
+#if LINUX_VERSION_CODE < KERNEL_VERSION(4,20,0)
+		/* Handle legacy encoding of pre-1970 dates with epoch
+		 * bits 1,1.  We assume that by kernel version 4.20,
+		 * everyone will have run fsck over the affected
+		 * filesystems to correct the problem.
+		 */
+		u64 extra_bits = le32_to_cpu(extra) & EXT4_EPOCH_MASK;
+		if (extra_bits == 3)
+			extra_bits = 0;
+		time->tv_sec += extra_bits << 32;
+#else
+		time->tv_sec += (u64)(le32_to_cpu(extra) & EXT4_EPOCH_MASK) << 32;
+#endif
+	}
+	time->tv_nsec = (le32_to_cpu(extra) & EXT4_NSEC_MASK) >> EXT4_EPOCH_BITS;
 }
 
 #define EXT4_INODE_SET_XTIME(xtime, inode, raw_inode)			       \

Re: [PATCH 02/12] statx: Provide IOC flags for Windows fs attributes

[Theodore Ts'o]

On Fri, Nov 20, 2015 at 02:54:47PM +0000, David Howells wrote:
> Provide IOC flags for Windows fs attributes so that they can be retrieved (or
> even altered) using the FS_IOC_[GS]ETFLAGS ioctl and read using statx().

We have a real problem with numberspace used by FS_IOC_[GS]ETFLAGS.
This ioctl was originally defined for use with ext2, but then later on
other file systems decided they wanted to use the same ioctl for their
file system, and so now we have the situation where some of the bits
are used in a way where they are intended to be file system
independent, and some are file system specific.  And ext[234] use
these bits as its on-disk encoding --- which given that
FS_IOC[GS]ETFLAGS was originally ext[234] specific, is understandable,
but it makes things really messy at this point.

So for example, the bits you have chosen are in conflict with ext4's use:

#define EXT4_INLINE_DATA_FL		0x10000000 /* Inode has inline data. */
#define EXT4_PROJINHERIT_FL		0x20000000 /* Create with parents projid */

> +#define FS_HIDDEN_FL			0x10000000 /* Windows hidden file attribute */
> +#define FS_SYSTEM_FL			0x20000000 /* Windows system file attribute */
> +#define FS_ARCHIVE_FL			0x40000000 /* Windows archive file attribute */


As a result, I would suggest that we not try to use the
FS_IOC_[GS]ETFLAGS number scheme for any new interface, so we're at
least not making a bad situation worse.

The only reason why some other file systems have chosen to use
FS_IOC_[GS]ETFLAGS, instead of defining their own ioctl, is so they
can use lsattr/chattr from e2fsprogs instead of creating their own
utility.  But for statx, there isn't a good reason use the same flags
number space.  At the very least, can we use a new flags field for the
Windows file attributes?  It's not like lsattr/chattr has the ability
to set those flags today anyway.  So we might as well use a new flags
field and a new flags numberspace for them.

						- Ted

Re: [PATCH 02/12] statx: Provide IOC flags for Windows fs attributes

[Theodore Ts'o]

On Fri, Nov 20, 2015 at 02:54:47PM +0000, David Howells wrote:
> Provide IOC flags for Windows fs attributes so that they can be retrieved (or
> even altered) using the FS_IOC_[GS]ETFLAGS ioctl and read using statx().

We have a real problem with numberspace used by FS_IOC_[GS]ETFLAGS.
This ioctl was originally defined for use with ext2, but then later on
other file systems decided they wanted to use the same ioctl for their
file system, and so now we have the situation where some of the bits
are used in a way where they are intended to be file system
independent, and some are file system specific.  And ext[234] use
these bits as its on-disk encoding --- which given that
FS_IOC[GS]ETFLAGS was originally ext[234] specific, is understandable,
but it makes things really messy at this point.

So for example, the bits you have chosen are in conflict with ext4's use:

#define EXT4_INLINE_DATA_FL		0x10000000 /* Inode has inline data. */
#define EXT4_PROJINHERIT_FL		0x20000000 /* Create with parents projid */

> +#define FS_HIDDEN_FL			0x10000000 /* Windows hidden file attribute */
> +#define FS_SYSTEM_FL			0x20000000 /* Windows system file attribute */
> +#define FS_ARCHIVE_FL			0x40000000 /* Windows archive file attribute */


As a result, I would suggest that we not try to use the
FS_IOC_[GS]ETFLAGS number scheme for any new interface, so we're at
least not making a bad situation worse.

The only reason why some other file systems have chosen to use
FS_IOC_[GS]ETFLAGS, instead of defining their own ioctl, is so they
can use lsattr/chattr from e2fsprogs instead of creating their own
utility.  But for statx, there isn't a good reason use the same flags
number space.  At the very least, can we use a new flags field for the
Windows file attributes?  It's not like lsattr/chattr has the ability
to set those flags today anyway.  So we might as well use a new flags
field and a new flags numberspace for them.

						- Ted

Re: [PATCH 01/12] Ext4: Fix extended timestamp encoding and decoding

[Arnd Bergmann]

On Tuesday 24 November 2015 14:36:46 Theodore Ts'o wrote:
> This is the patch I would prefer to use (and in fact which I have
> added to the ext4 tree):
> 
> There are issues with 32-bit vs 64-bit encoding of times before
> January 1, 1970, which are handled with this patch which is not
> handled with what you have in your patch series.  So I'd prefer if you
> drop this patch, and I'll get this sent to Linus as a bug fix for 4.4.

I'm happy with either one. Apparently both Davids have arrived with
almost the same algorithm and implementation, with the exception of
the pre-1970 handling you mention there.

	Arnd

Re: [PATCH 01/12] Ext4: Fix extended timestamp encoding and decoding

[Arnd Bergmann]

On Tuesday 24 November 2015 14:36:46 Theodore Ts'o wrote:
> This is the patch I would prefer to use (and in fact which I have
> added to the ext4 tree):
> 
> There are issues with 32-bit vs 64-bit encoding of times before
> January 1, 1970, which are handled with this patch which is not
> handled with what you have in your patch series.  So I'd prefer if you
> drop this patch, and I'll get this sent to Linus as a bug fix for 4.4.

I'm happy with either one. Apparently both Davids have arrived with
almost the same algorithm and implementation, with the exception of
the pre-1970 handling you mention there.

	Arnd

Re: [PATCH 03/12] statx: Add a system call to make enhanced file info available

[Dave Chinner]

On Fri, Nov 20, 2015 at 02:54:57PM +0000, David Howells wrote:
> The defined bits in st_ioc_flags are the usual FS_xxx_FL, plus some extra
> flags that might be supplied by the filesystem.  Note that Ext4 returns
> flags outside of {EXT4,FS}_FL_USER_VISIBLE in response to FS_IOC_GETFLAGS.
> Should {EXT4,FS}_FL_USER_VISIBLE be extended to cover them?  Or should the
> extra flags be suppressed?

Quite frankly, we should not expose flags owned by a filesystem like
this. Create a new set of flagsi that are exposed by the syscall,
and every filesystem is responsible for translating their internal
flag values to the syscall flag values....

> The defined bits in the st_information field give local system data on a
> file, how it is accessed, where it is and what it does:
> 
> 	STATX_INFO_ENCRYPTED		File is encrypted
> 	STATX_INFO_TEMPORARY		File is temporary (NTFS/CIFS/deleted)
> 	STATX_INFO_FABRICATED		File was made up by filesystem
> 	STATX_INFO_KERNEL_API		File is kernel API (eg: procfs/sysfs)
> 	STATX_INFO_REMOTE		File is remote
> 	STATX_INFO_OFFLINE		File is offline (CIFS)
> 	STATX_INFO_AUTOMOUNT		Dir is automount trigger
> 	STATX_INFO_AUTODIR		Dir provides unlisted automounts
> 	STATX_INFO_NONSYSTEM_OWNERSHIP	File has non-system ownership details
> 	STATX_INFO_REPARSE_POINT	File is reparse point (NTFS/CIFS)

	STATX_INFO_XATTR		File/dir has extended attrs

... just like these STATX_INFO flags are filesystem independent...

And, FWIW, I'd like to see more than one local filesystem supported
in the initial patchset (e.g. btrfs) and also have all their
inode/fs flags exposed so we don't end up encoding weird
ext4-specific feature quirks into the API.....

Cheers,

Dave.
-- 
Dave Chinner
david-FqsqvQoI3Ljby3iVrkZq2A@public.gmane.org

Re: [PATCH 03/12] statx: Add a system call to make enhanced file info available

[Dave Chinner]

On Fri, Nov 20, 2015 at 02:54:57PM +0000, David Howells wrote:
> The defined bits in st_ioc_flags are the usual FS_xxx_FL, plus some extra
> flags that might be supplied by the filesystem.  Note that Ext4 returns
> flags outside of {EXT4,FS}_FL_USER_VISIBLE in response to FS_IOC_GETFLAGS.
> Should {EXT4,FS}_FL_USER_VISIBLE be extended to cover them?  Or should the
> extra flags be suppressed?

Quite frankly, we should not expose flags owned by a filesystem like
this. Create a new set of flagsi that are exposed by the syscall,
and every filesystem is responsible for translating their internal
flag values to the syscall flag values....

> The defined bits in the st_information field give local system data on a
> file, how it is accessed, where it is and what it does:
> 
> 	STATX_INFO_ENCRYPTED		File is encrypted
> 	STATX_INFO_TEMPORARY		File is temporary (NTFS/CIFS/deleted)
> 	STATX_INFO_FABRICATED		File was made up by filesystem
> 	STATX_INFO_KERNEL_API		File is kernel API (eg: procfs/sysfs)
> 	STATX_INFO_REMOTE		File is remote
> 	STATX_INFO_OFFLINE		File is offline (CIFS)
> 	STATX_INFO_AUTOMOUNT		Dir is automount trigger
> 	STATX_INFO_AUTODIR		Dir provides unlisted automounts
> 	STATX_INFO_NONSYSTEM_OWNERSHIP	File has non-system ownership details
> 	STATX_INFO_REPARSE_POINT	File is reparse point (NTFS/CIFS)

	STATX_INFO_XATTR		File/dir has extended attrs

... just like these STATX_INFO flags are filesystem independent...

And, FWIW, I'd like to see more than one local filesystem supported
in the initial patchset (e.g. btrfs) and also have all their
inode/fs flags exposed so we don't end up encoding weird
ext4-specific feature quirks into the API.....

Cheers,

Dave.
-- 
Dave Chinner
david@fromorbit.com

Re: [RFC][PATCH 00/12] Enhanced file stat system call

[J. Bruce Fields]

On Fri, Nov 20, 2015 at 04:28:35PM +0000, David Howells wrote:
> Martin Steigerwald <martin-3kZCPVa5dk2azgQtNeiOUg@public.gmane.org> wrote:
> 
> > Any plans to add limitations of filesystem to the call like maximum file
> > size?  I know its mostly relevant for just for FAT32, but on any account
> > rather than trying to write 4 GiB and then file, it would be good to at some
> > time get a dialog at the beginning of the copy.
> 
> Adding filesystem limits can be done.  I got a shopping list of things people
> wanted a while back and I've worked off of that list.  I can add other things
> - that's on of the reasons I left room for expansion.

I ran across systemd/src/basic/path-util.c:fd_is_mount_point() the other
day, and the contortions it goes through made me wonder if we should
also add mnt_id and/or an is_mountpoint boolean--it's annoying to have
to do name_to_handle_at() (not supported on all filesystems) just to get
mnt_id.

(Looking at it now I see it falls back on reading mount id from
/proc/self/fdinfo/<fd>.  Maybe that's good enough.  May depend on
whether there's a potential user that doesn't want to assume access to
/proc?)

--b.

Re: [RFC][PATCH 00/12] Enhanced file stat system call

[J. Bruce Fields]

On Fri, Nov 20, 2015 at 04:28:35PM +0000, David Howells wrote:
> Martin Steigerwald <martin@lichtvoll.de> wrote:
> 
> > Any plans to add limitations of filesystem to the call like maximum file
> > size?  I know its mostly relevant for just for FAT32, but on any account
> > rather than trying to write 4 GiB and then file, it would be good to at some
> > time get a dialog at the beginning of the copy.
> 
> Adding filesystem limits can be done.  I got a shopping list of things people
> wanted a while back and I've worked off of that list.  I can add other things
> - that's on of the reasons I left room for expansion.

I ran across systemd/src/basic/path-util.c:fd_is_mount_point() the other
day, and the contortions it goes through made me wonder if we should
also add mnt_id and/or an is_mountpoint boolean--it's annoying to have
to do name_to_handle_at() (not supported on all filesystems) just to get
mnt_id.

(Looking at it now I see it falls back on reading mount id from
/proc/self/fdinfo/<fd>.  Maybe that's good enough.  May depend on
whether there's a potential user that doesn't want to assume access to
/proc?)

--b.

Re: [RFC][PATCH 00/12] Enhanced file stat system call

[Andreas Dilger]

[-- Attachment #1: Type: text/plain, Size: 1643 bytes --]

On Nov 25, 2015, at 10:51 AM, J. Bruce Fields <bfields-uC3wQj2KruNg9hUCZPvPmw@public.gmane.org> wrote:
> 
> On Fri, Nov 20, 2015 at 04:28:35PM +0000, David Howells wrote:
>> Martin Steigerwald <martin-3kZCPVa5dk2azgQtNeiOUg@public.gmane.org> wrote:
>> 
>>> Any plans to add limitations of filesystem to the call like maximum file
>>> size?  I know its mostly relevant for just for FAT32, but on any account
>>> rather than trying to write 4 GiB and then file, it would be good to at some
>>> time get a dialog at the beginning of the copy.
>> 
>> Adding filesystem limits can be done.  I got a shopping list of things people
>> wanted a while back and I've worked off of that list.  I can add other things
>> - that's on of the reasons I left room for expansion.
> 
> I ran across systemd/src/basic/path-util.c:fd_is_mount_point() the other
> day, and the contortions it goes through made me wonder if we should
> also add mnt_id and/or an is_mountpoint boolean--it's annoying to have
> to do name_to_handle_at() (not supported on all filesystems) just to get
> mnt_id.
> 
> (Looking at it now I see it falls back on reading mount id from
> /proc/self/fdinfo/<fd>.  Maybe that's good enough.  May depend on
> whether there's a potential user that doesn't want to assume access to
> /proc?)

IMHO, it should be possible to get information about a file or directory
from the file itself (i.e. statx() or fsinfo() on the path/fd), rather than
having to grub around in a /proc file that the application magically has to
know about, and parse text files there for every file being handled.

Cheers, Andreas






[-- Attachment #2: Message signed with OpenPGP using GPGMail --]
[-- Type: application/pgp-signature, Size: 833 bytes --]

Re: [RFC][PATCH 00/12] Enhanced file stat system call

[Andreas Dilger]

[-- Attachment #1: Type: text/plain, Size: 1589 bytes --]

On Nov 25, 2015, at 10:51 AM, J. Bruce Fields <bfields@fieldses.org> wrote:
> 
> On Fri, Nov 20, 2015 at 04:28:35PM +0000, David Howells wrote:
>> Martin Steigerwald <martin@lichtvoll.de> wrote:
>> 
>>> Any plans to add limitations of filesystem to the call like maximum file
>>> size?  I know its mostly relevant for just for FAT32, but on any account
>>> rather than trying to write 4 GiB and then file, it would be good to at some
>>> time get a dialog at the beginning of the copy.
>> 
>> Adding filesystem limits can be done.  I got a shopping list of things people
>> wanted a while back and I've worked off of that list.  I can add other things
>> - that's on of the reasons I left room for expansion.
> 
> I ran across systemd/src/basic/path-util.c:fd_is_mount_point() the other
> day, and the contortions it goes through made me wonder if we should
> also add mnt_id and/or an is_mountpoint boolean--it's annoying to have
> to do name_to_handle_at() (not supported on all filesystems) just to get
> mnt_id.
> 
> (Looking at it now I see it falls back on reading mount id from
> /proc/self/fdinfo/<fd>.  Maybe that's good enough.  May depend on
> whether there's a potential user that doesn't want to assume access to
> /proc?)

IMHO, it should be possible to get information about a file or directory
from the file itself (i.e. statx() or fsinfo() on the path/fd), rather than
having to grub around in a /proc file that the application magically has to
know about, and parse text files there for every file being handled.

Cheers, Andreas






[-- Attachment #2: Message signed with OpenPGP using GPGMail --]
[-- Type: application/pgp-signature, Size: 833 bytes --]

Re: [RFC][PATCH 00/12] Enhanced file stat system call

[David Howells]

Christoph Hellwig <hch@infradead.org> wrote:

> from a quick look the statx bits looks fine in general.  I think Ted
> last time had a problem with the IOC flag allocation, so you might
> want to ping him.

Yeah - he commented on that.

> But fsinfo with the multiplexer and the void pointer is just horrible.
> What were you thinking there?

I think the fsinfo data struct probably wants splitting up.  Now this could be
done in a number of ways, including:

 (1) By adding multiple syscalls (statfsx, fsinfo, netfsinfo, ...) but each
     one needs a bit in the kernel to handle the basics (path/fd lookup,
     security check, buffer allocation and freeing, ...) which could all be in
     common - hence the mux method.

 (2) Adding an argument to the fsinfo syscall since it has at least one
     syscall argument spare.

 (3) Offloading some of the bits to standardised xattr calls.  The large
     string fields (domain name, volume name, ...) would seem to be obvious
     candidates for this.

Given that the core VFS gets to manage the contents of the buffer, it
shouldn't be as controversial as pioctl().

David

Re: [PATCH 01/12] Ext4: Fix extended timestamp encoding and decoding

[David Howells]

Theodore Ts'o <tytso-3s7WtUTddSA@public.gmane.org> wrote:

> This is the patch I would prefer to use (and in fact which I have
> added to the ext4 tree):
> 
> There are issues with 32-bit vs 64-bit encoding of times before
> January 1, 1970, which are handled with this patch which is not
> handled with what you have in your patch series.  So I'd prefer if you
> drop this patch, and I'll get this sent to Linus as a bug fix for 4.4.

Fine by me.

Acked-by: David Howells <dhowells-H+wXaHxf7aLQT0dZR+AlfA@public.gmane.org>

Re: [PATCH 01/12] Ext4: Fix extended timestamp encoding and decoding

[David Howells]

Theodore Ts'o <tytso@mit.edu> wrote:

> This is the patch I would prefer to use (and in fact which I have
> added to the ext4 tree):
> 
> There are issues with 32-bit vs 64-bit encoding of times before
> January 1, 1970, which are handled with this patch which is not
> handled with what you have in your patch series.  So I'd prefer if you
> drop this patch, and I'll get this sent to Linus as a bug fix for 4.4.

Fine by me.

Acked-by: David Howells <dhowells@redhat.com>

Re: [PATCH 02/12] statx: Provide IOC flags for Windows fs attributes

[David Howells]

Theodore Ts'o <tytso@mit.edu> wrote:

> As a result, I would suggest that we not try to use the
> FS_IOC_[GS]ETFLAGS number scheme for any new interface, so we're at
> least not making a bad situation worse.
> 
> The only reason why some other file systems have chosen to use
> FS_IOC_[GS]ETFLAGS, instead of defining their own ioctl, is so they
> can use lsattr/chattr from e2fsprogs instead of creating their own
> utility.  But for statx, there isn't a good reason use the same flags
> number space.  At the very least, can we use a new flags field for the
> Windows file attributes?  It's not like lsattr/chattr has the ability
> to set those flags today anyway.  So we might as well use a new flags
> field and a new flags numberspace for them.

Hmmm...  I was trying to make it so that these bits would be saved to disk as
part of the IOC flags so that Samba could make use of them.  I guess they'll
have to be stored in an xattr instead.

David

Re: [PATCH 02/12] statx: Provide IOC flags for Windows fs attributes

[David Howells]

David Howells <dhowells-H+wXaHxf7aLQT0dZR+AlfA@public.gmane.org> wrote:

> > As a result, I would suggest that we not try to use the
> > FS_IOC_[GS]ETFLAGS number scheme for any new interface, so we're at
> > least not making a bad situation worse.
> > 
> > The only reason why some other file systems have chosen to use
> > FS_IOC_[GS]ETFLAGS, instead of defining their own ioctl, is so they
> > can use lsattr/chattr from e2fsprogs instead of creating their own
> > utility.  But for statx, there isn't a good reason use the same flags
> > number space.  At the very least, can we use a new flags field for the
> > Windows file attributes?  It's not like lsattr/chattr has the ability
> > to set those flags today anyway.  So we might as well use a new flags
> > field and a new flags numberspace for them.
> 
> Hmmm...  I was trying to make it so that these bits would be saved to disk as
> part of the IOC flags so that Samba could make use of them.  I guess they'll
> have to be stored in an xattr instead.

Or as Dave Chinner suggested, I can put them elsewhere and let the FS deal
with them in its own way.

David
--
To unsubscribe from this list: send the line "unsubscribe linux-nfs" in
the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html

Re: [PATCH 02/12] statx: Provide IOC flags for Windows fs attributes

[David Howells]

David Howells <dhowells@redhat.com> wrote:

> > As a result, I would suggest that we not try to use the
> > FS_IOC_[GS]ETFLAGS number scheme for any new interface, so we're at
> > least not making a bad situation worse.
> > 
> > The only reason why some other file systems have chosen to use
> > FS_IOC_[GS]ETFLAGS, instead of defining their own ioctl, is so they
> > can use lsattr/chattr from e2fsprogs instead of creating their own
> > utility.  But for statx, there isn't a good reason use the same flags
> > number space.  At the very least, can we use a new flags field for the
> > Windows file attributes?  It's not like lsattr/chattr has the ability
> > to set those flags today anyway.  So we might as well use a new flags
> > field and a new flags numberspace for them.
> 
> Hmmm...  I was trying to make it so that these bits would be saved to disk as
> part of the IOC flags so that Samba could make use of them.  I guess they'll
> have to be stored in an xattr instead.

Or as Dave Chinner suggested, I can put them elsewhere and let the FS deal
with them in its own way.

David

Re: [RFC][PATCH 00/12] Enhanced file stat system call

[Andreas Dilger]

[-- Attachment #1: Type: text/plain, Size: 1904 bytes --]

On Nov 26, 2015, at 8:19 AM, David Howells <dhowells@redhat.com> wrote:
> 
> Christoph Hellwig <hch@infradead.org> wrote:
> 
>> from a quick look the statx bits looks fine in general.  I think Ted
>> last time had a problem with the IOC flag allocation, so you might
>> want to ping him.
> 
> Yeah - he commented on that.
> 
>> But fsinfo with the multiplexer and the void pointer is just horrible.
>> What were you thinking there?
> 
> I think the fsinfo data struct probably wants splitting up.

Could we separate the statx() and fsinfo() submissions so that this doesn't
block statx() landing indefinitely?  I think people are generally in support
of statx() as it is today, and it's been _sooo_ long in coming that I'd hate
to see it delayed further.  The statx() syscall definitely has value without
fsinfo() to improve the life of network filesystems.

Cheers, Andreas

>  Now this could be
> done in a number of ways, including:
> 
> (1) By adding multiple syscalls (statfsx, fsinfo, netfsinfo, ...) but each
>     one needs a bit in the kernel to handle the basics (path/fd lookup,
>     security check, buffer allocation and freeing, ...) which could all be in
>     common - hence the mux method.
> 
> (2) Adding an argument to the fsinfo syscall since it has at least one
>     syscall argument spare.
> 
> (3) Offloading some of the bits to standardised xattr calls.  The large
>     string fields (domain name, volume name, ...) would seem to be obvious
>     candidates for this.
> 
> Given that the core VFS gets to manage the contents of the buffer, it
> shouldn't be as controversial as pioctl().
> 
> David
> --
> To unsubscribe from this list: send the line "unsubscribe linux-ext4" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at  http://vger.kernel.org/majordomo-info.html


Cheers, Andreas






[-- Attachment #2: Message signed with OpenPGP using GPGMail --]
[-- Type: application/pgp-signature, Size: 833 bytes --]

Re: [PATCH 02/12] statx: Provide IOC flags for Windows fs attributes

[Andreas Dilger]

[-- Attachment #1: Type: text/plain, Size: 1589 bytes --]

On Nov 26, 2015, at 8:35 AM, David Howells <dhowells-H+wXaHxf7aLQT0dZR+AlfA@public.gmane.org> wrote:
> 
> Theodore Ts'o <tytso-3s7WtUTddSA@public.gmane.org> wrote:
> 
>> As a result, I would suggest that we not try to use the
>> FS_IOC_[GS]ETFLAGS number scheme for any new interface, so we're at
>> least not making a bad situation worse.
>> 
>> The only reason why some other file systems have chosen to use
>> FS_IOC_[GS]ETFLAGS, instead of defining their own ioctl, is so they
>> can use lsattr/chattr from e2fsprogs instead of creating their own
>> utility.  But for statx, there isn't a good reason use the same flags
>> number space.  At the very least, can we use a new flags field for the
>> Windows file attributes?  It's not like lsattr/chattr has the ability
>> to set those flags today anyway.  So we might as well use a new flags
>> field and a new flags numberspace for them.
> 
> Hmmm...  I was trying to make it so that these bits would be saved to disk as
> part of the IOC flags so that Samba could make use of them.  I guess they'll
> have to be stored in an xattr instead.

The flags can be part of the same flags word in the statx() API, and how they
are stored on disk is a filesystem implementation detail.  In some cases, not
all of the flags can be stored on disk (e.g. FAT or whatever) and an error
will be returned.  In other cases they can be stored efficiently as bits in
the inode, and other filesystems may chose to store them as internal xattrs.
That shouldn't be the concern of the statx() syscall.

Cheers, Andreas






[-- Attachment #2: Message signed with OpenPGP using GPGMail --]
[-- Type: application/pgp-signature, Size: 833 bytes --]

Re: [PATCH 02/12] statx: Provide IOC flags for Windows fs attributes

[Andreas Dilger]

[-- Attachment #1: Type: text/plain, Size: 1539 bytes --]

On Nov 26, 2015, at 8:35 AM, David Howells <dhowells@redhat.com> wrote:
> 
> Theodore Ts'o <tytso@mit.edu> wrote:
> 
>> As a result, I would suggest that we not try to use the
>> FS_IOC_[GS]ETFLAGS number scheme for any new interface, so we're at
>> least not making a bad situation worse.
>> 
>> The only reason why some other file systems have chosen to use
>> FS_IOC_[GS]ETFLAGS, instead of defining their own ioctl, is so they
>> can use lsattr/chattr from e2fsprogs instead of creating their own
>> utility.  But for statx, there isn't a good reason use the same flags
>> number space.  At the very least, can we use a new flags field for the
>> Windows file attributes?  It's not like lsattr/chattr has the ability
>> to set those flags today anyway.  So we might as well use a new flags
>> field and a new flags numberspace for them.
> 
> Hmmm...  I was trying to make it so that these bits would be saved to disk as
> part of the IOC flags so that Samba could make use of them.  I guess they'll
> have to be stored in an xattr instead.

The flags can be part of the same flags word in the statx() API, and how they
are stored on disk is a filesystem implementation detail.  In some cases, not
all of the flags can be stored on disk (e.g. FAT or whatever) and an error
will be returned.  In other cases they can be stored efficiently as bits in
the inode, and other filesystems may chose to store them as internal xattrs.
That shouldn't be the concern of the statx() syscall.

Cheers, Andreas






[-- Attachment #2: Message signed with OpenPGP using GPGMail --]
[-- Type: application/pgp-signature, Size: 833 bytes --]

Re: [PATCH 01/12] Ext4: Fix extended timestamp encoding and decoding

[Theodore Ts'o]

On Tue, Nov 24, 2015 at 09:10:53PM +0100, Arnd Bergmann wrote:
> On Tuesday 24 November 2015 14:36:46 Theodore Ts'o wrote:
> > This is the patch I would prefer to use (and in fact which I have
> > added to the ext4 tree):
> > 
> > There are issues with 32-bit vs 64-bit encoding of times before
> > January 1, 1970, which are handled with this patch which is not
> > handled with what you have in your patch series.  So I'd prefer if you
> > drop this patch, and I'll get this sent to Linus as a bug fix for 4.4.
> 
> I'm happy with either one. Apparently both Davids have arrived with
> almost the same algorithm and implementation, with the exception of
> the pre-1970 handling you mention there.

I was doing some testing on x86, which leads me to ask --- what's the
current thinking about post y2038 on 32-bit platforms such as x86?  I
see that there was some talk about using struct timespec64, but we
haven't made the transition in the VFS interfaces yet, despite a
comment in an LWN article from 2014 stating that "the first steps have
been taken; hopefully the rest will follow before too long".

Cheers,

					- Ted

Re: [PATCH 01/12] Ext4: Fix extended timestamp encoding and decoding

[Theodore Ts'o]

On Tue, Nov 24, 2015 at 09:10:53PM +0100, Arnd Bergmann wrote:
> On Tuesday 24 November 2015 14:36:46 Theodore Ts'o wrote:
> > This is the patch I would prefer to use (and in fact which I have
> > added to the ext4 tree):
> > 
> > There are issues with 32-bit vs 64-bit encoding of times before
> > January 1, 1970, which are handled with this patch which is not
> > handled with what you have in your patch series.  So I'd prefer if you
> > drop this patch, and I'll get this sent to Linus as a bug fix for 4.4.
> 
> I'm happy with either one. Apparently both Davids have arrived with
> almost the same algorithm and implementation, with the exception of
> the pre-1970 handling you mention there.

I was doing some testing on x86, which leads me to ask --- what's the
current thinking about post y2038 on 32-bit platforms such as x86?  I
see that there was some talk about using struct timespec64, but we
haven't made the transition in the VFS interfaces yet, despite a
comment in an LWN article from 2014 stating that "the first steps have
been taken; hopefully the rest will follow before too long".

Cheers,

					- Ted

Re: [PATCH 01/12] Ext4: Fix extended timestamp encoding and decoding

[Arnd Bergmann]

On Saturday 28 November 2015 21:45:55 Theodore Ts'o wrote:
> On Tue, Nov 24, 2015 at 09:10:53PM +0100, Arnd Bergmann wrote:
> > On Tuesday 24 November 2015 14:36:46 Theodore Ts'o wrote:
> > > This is the patch I would prefer to use (and in fact which I have
> > > added to the ext4 tree):
> > > 
> > > There are issues with 32-bit vs 64-bit encoding of times before
> > > January 1, 1970, which are handled with this patch which is not
> > > handled with what you have in your patch series.  So I'd prefer if you
> > > drop this patch, and I'll get this sent to Linus as a bug fix for 4.4.
> > 
> > I'm happy with either one. Apparently both Davids have arrived with
> > almost the same algorithm and implementation, with the exception of
> > the pre-1970 handling you mention there.
> 
> I was doing some testing on x86, which leads me to ask --- what's the
> current thinking about post y2038 on 32-bit platforms such as x86?  I
> see that there was some talk about using struct timespec64, but we
> haven't made the transition in the VFS interfaces yet, despite a
> comment in an LWN article from 2014 stating that "the first steps have
> been taken; hopefully the rest will follow before too long".

The approach in my initial VFS series was to introduce 'struct inode_time',
but I have basically abandoned that idea now, after we decided to introduce
'timespec64' inside of the kernel and use that for other subsystems.
The rought plan is now to have separate time64_t and u32 seconds/nanoseconds
values in 'struct inode', 'struct iattr' and 'struct kstat' and use
inline functions or macros to extract or set them as time64_t or timespec64
in file system code, but that code is not written yet.

I'm mostly coordinating the y2038 work at the moment, but that means that
a lot of the work is going into individual drivers that a single person
can easily handle. We've had a couple of people who tried looking at VFS,
but none of them followed through, so it got delayed a bit. However,
Deepa Dinamani is now looking y2038 for VFS and individual file systems
as part of her Outreachy internship and I'm optimistic that we'll soon
be making progress again here with her work.

The other large missing piece is the system call implementation. I have
posted a series earlier this year before my parental leave, and it's
currently lacking review from libc folks, and blocked on me to update
the series and post it again.

	Arnd

Re: [PATCH 01/12] Ext4: Fix extended timestamp encoding and decoding

[Arnd Bergmann]

On Saturday 28 November 2015 21:45:55 Theodore Ts'o wrote:
> On Tue, Nov 24, 2015 at 09:10:53PM +0100, Arnd Bergmann wrote:
> > On Tuesday 24 November 2015 14:36:46 Theodore Ts'o wrote:
> > > This is the patch I would prefer to use (and in fact which I have
> > > added to the ext4 tree):
> > > 
> > > There are issues with 32-bit vs 64-bit encoding of times before
> > > January 1, 1970, which are handled with this patch which is not
> > > handled with what you have in your patch series.  So I'd prefer if you
> > > drop this patch, and I'll get this sent to Linus as a bug fix for 4.4.
> > 
> > I'm happy with either one. Apparently both Davids have arrived with
> > almost the same algorithm and implementation, with the exception of
> > the pre-1970 handling you mention there.
> 
> I was doing some testing on x86, which leads me to ask --- what's the
> current thinking about post y2038 on 32-bit platforms such as x86?  I
> see that there was some talk about using struct timespec64, but we
> haven't made the transition in the VFS interfaces yet, despite a
> comment in an LWN article from 2014 stating that "the first steps have
> been taken; hopefully the rest will follow before too long".

The approach in my initial VFS series was to introduce 'struct inode_time',
but I have basically abandoned that idea now, after we decided to introduce
'timespec64' inside of the kernel and use that for other subsystems.
The rought plan is now to have separate time64_t and u32 seconds/nanoseconds
values in 'struct inode', 'struct iattr' and 'struct kstat' and use
inline functions or macros to extract or set them as time64_t or timespec64
in file system code, but that code is not written yet.

I'm mostly coordinating the y2038 work at the moment, but that means that
a lot of the work is going into individual drivers that a single person
can easily handle. We've had a couple of people who tried looking at VFS,
but none of them followed through, so it got delayed a bit. However,
Deepa Dinamani is now looking y2038 for VFS and individual file systems
as part of her Outreachy internship and I'm optimistic that we'll soon
be making progress again here with her work.

The other large missing piece is the system call implementation. I have
posted a series earlier this year before my parental leave, and it's
currently lacking review from libc folks, and blocked on me to update
the series and post it again.

	Arnd

Re: [PATCH 01/12] Ext4: Fix extended timestamp encoding and decoding

[Theodore Ts'o]

On Sun, Nov 29, 2015 at 10:30:39PM +0100, Arnd Bergmann wrote:
> The other large missing piece is the system call implementation. I have
> posted a series earlier this year before my parental leave, and it's
> currently lacking review from libc folks, and blocked on me to update
> the series and post it again.

I assume that this also means there hasn't been much thought about
userspace support above libc?  i.e., how to take a 64-bit time64_t (or
changing the size of time_t) and translating that to a string using
some kind of version of ctime() and asctime(), and how to parse a
post-2038 date string and turning it into a 64-bit time_t on a 32-bit
platform?

The reason why I'm asking is because I'm thinking about how to add the
appropriate regression test support to e2fsprogs for 32-bit platforms.
I'm probably going to just skip the tests on architectures where
sizeof(time_t) == 4 for now, since with a 32-bit time_t adding support
for post-2038 in a e2fsprogs-specific way is (a) something I don't
have time for, and (b) probably a waste of time since presumably we
will either need to have a more general solution, or simply decide to
give up on 32-bit platforms by 2038....

Cheers,

   	       	     	    	      	 - Ted

Re: [PATCH 01/12] Ext4: Fix extended timestamp encoding and decoding

[Arnd Bergmann]

On Monday 30 November 2015 09:16:05 Theodore Ts'o wrote:
> On Sun, Nov 29, 2015 at 10:30:39PM +0100, Arnd Bergmann wrote:
> > The other large missing piece is the system call implementation. I have
> > posted a series earlier this year before my parental leave, and it's
> > currently lacking review from libc folks, and blocked on me to update
> > the series and post it again.
> 
> I assume that this also means there hasn't been much thought about
> userspace support above libc?  i.e., how to take a 64-bit time64_t (or
> changing the size of time_t) and translating that to a string using
> some kind of version of ctime() and asctime(), and how to parse a
> post-2038 date string and turning it into a 64-bit time_t on a 32-bit
> platform?
> 
> The reason why I'm asking is because I'm thinking about how to add the
> appropriate regression test support to e2fsprogs for 32-bit platforms.
> I'm probably going to just skip the tests on architectures where
> sizeof(time_t) == 4 for now, since with a 32-bit time_t adding support
> for post-2038 in a e2fsprogs-specific way is (a) something I don't
> have time for, and (b) probably a waste of time since presumably we
> will either need to have a more general solution, or simply decide to
> give up on 32-bit platforms by 2038....

We are definitely going to be using 32-bit embedded platforms in 2038,
but we won't be using a 32-bit time_t then, so basing the check on
sizeof(time_t) sounds reasonable. I assume most generic distros will
stay with 32-bit time_t for compatibility reasons and just not give
long term support for 32-bit architectures, while the embedded
distros will move over to 64-bit time_t, but on those you recompile
all user space for each product anyway.

The glibc functions should all work with a 64-bit time_t as they do
today on 64-bit architectures. There is an open discussion on how
you move to 64-bit time_t. With the current
glibc plan at https://sourceware.org/glibc/wiki/Y2038ProofnessDesign,
you will have to set -D_TIME_BITS=64 to enable it explicitly, but
I'd also like to see a way to build a glibc that defaults to that
and does not allow backwards compatibility, which is important for
folks that want to ship a system that has they can guarantee to
survive 2038.

	Arnd
--
To unsubscribe from this list: send the line "unsubscribe linux-nfs" in
the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html

Re: [PATCH 01/12] Ext4: Fix extended timestamp encoding and decoding

[Arnd Bergmann]

On Monday 30 November 2015 09:16:05 Theodore Ts'o wrote:
> On Sun, Nov 29, 2015 at 10:30:39PM +0100, Arnd Bergmann wrote:
> > The other large missing piece is the system call implementation. I have
> > posted a series earlier this year before my parental leave, and it's
> > currently lacking review from libc folks, and blocked on me to update
> > the series and post it again.
> 
> I assume that this also means there hasn't been much thought about
> userspace support above libc?  i.e., how to take a 64-bit time64_t (or
> changing the size of time_t) and translating that to a string using
> some kind of version of ctime() and asctime(), and how to parse a
> post-2038 date string and turning it into a 64-bit time_t on a 32-bit
> platform?
> 
> The reason why I'm asking is because I'm thinking about how to add the
> appropriate regression test support to e2fsprogs for 32-bit platforms.
> I'm probably going to just skip the tests on architectures where
> sizeof(time_t) == 4 for now, since with a 32-bit time_t adding support
> for post-2038 in a e2fsprogs-specific way is (a) something I don't
> have time for, and (b) probably a waste of time since presumably we
> will either need to have a more general solution, or simply decide to
> give up on 32-bit platforms by 2038....

We are definitely going to be using 32-bit embedded platforms in 2038,
but we won't be using a 32-bit time_t then, so basing the check on
sizeof(time_t) sounds reasonable. I assume most generic distros will
stay with 32-bit time_t for compatibility reasons and just not give
long term support for 32-bit architectures, while the embedded
distros will move over to 64-bit time_t, but on those you recompile
all user space for each product anyway.

The glibc functions should all work with a 64-bit time_t as they do
today on 64-bit architectures. There is an open discussion on how
you move to 64-bit time_t. With the current
glibc plan at https://sourceware.org/glibc/wiki/Y2038ProofnessDesign,
you will have to set -D_TIME_BITS=64 to enable it explicitly, but
I'd also like to see a way to build a glibc that defaults to that
and does not allow backwards compatibility, which is important for
folks that want to ship a system that has they can guarantee to
survive 2038.

	Arnd

Re: [PATCH 01/12] Ext4: Fix extended timestamp encoding and decoding

[Elmar Stellnberger]

On 30.11.2015 15:16, Theodore Ts'o wrote:
> On Sun, Nov 29, 2015 at 10:30:39PM +0100, Arnd Bergmann wrote:
>> The other large missing piece is the system call implementation. I have
>> posted a series earlier this year before my parental leave, and it's
>> currently lacking review from libc folks, and blocked on me to update
>> the series and post it again.
>
> I assume that this also means there hasn't been much thought about
> userspace support above libc?  i.e., how to take a 64-bit time64_t (or
> changing the size of time_t) and translating that to a string using
> some kind of version of ctime() and asctime(), and how to parse a
> post-2038 date string and turning it into a 64-bit time_t on a 32-bit
> platform?
>

   Arnd, I would just like to tell you how much I welcome your decision 
for a new __kernel_time64_t!
   As a time[64]_t is basically well defined counting artificial seconds 
since the epoch (1970-01-01 00:00) where every year divisible by four is 
a leap year that is for the meanwhile already sufficient to make use of 
your new type. I just think about the Mayan calendar application which I 
have implemented last year (Though I have not brought it to a 
publishable state yet). A single typedef should be sufficient to let it 
make use of time64_t (it directly uses this type as well as long long 
internally for its calculations rather than the glibc time format 
functions).

Re: [PATCH 03/12] statx: Add a system call to make enhanced file info available

[Pavel Machek]

Hi!

> ===============
> NEW SYSTEM CALL
> ===============
> 
> The new system call is:
> 
> 	int ret = statx(int dfd,
> 			const char *filename,
> 			unsigned int flags,
> 			unsigned int mask,
> 			struct statx *buffer);

Should this be called stat5, so that when new, even more improved stat
comes, it does not have to be called statxx?

> The dfd, filename and flags parameters indicate the file to query.  There
> is no equivalent of lstat() as that can be emulated with statx() by passing
> AT_SYMLINK_NOFOLLOW in flags.  There is also no equivalent of fstat() as
> that can be emulated by passing a NULL filename to statx() with the fd of
> interest in dfd.

Dunno. Of course you can multiplex everything.

But fstat() is really different operation to stat() -- tell me about
my file descriptor vs. tell me about this filename, and ptrace (and
some "security" solutions) might want to allow one but disallow the
second. I'd not group them together..

									Pavel
-- 
(english) http://www.livejournal.com/~pavelmachek
(cesky, pictures) http://atrey.karlin.mff.cuni.cz/~pavel/picture/horses/blog.html
--
To unsubscribe from this list: send the line "unsubscribe linux-nfs" in
the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html

Re: [PATCH 03/12] statx: Add a system call to make enhanced file info available

[Pavel Machek]

Hi!

> ===============
> NEW SYSTEM CALL
> ===============
> 
> The new system call is:
> 
> 	int ret = statx(int dfd,
> 			const char *filename,
> 			unsigned int flags,
> 			unsigned int mask,
> 			struct statx *buffer);

Should this be called stat5, so that when new, even more improved stat
comes, it does not have to be called statxx?

> The dfd, filename and flags parameters indicate the file to query.  There
> is no equivalent of lstat() as that can be emulated with statx() by passing
> AT_SYMLINK_NOFOLLOW in flags.  There is also no equivalent of fstat() as
> that can be emulated by passing a NULL filename to statx() with the fd of
> interest in dfd.

Dunno. Of course you can multiplex everything.

But fstat() is really different operation to stat() -- tell me about
my file descriptor vs. tell me about this filename, and ptrace (and
some "security" solutions) might want to allow one but disallow the
second. I'd not group them together..

									Pavel
-- 
(english) http://www.livejournal.com/~pavelmachek
(cesky, pictures) http://atrey.karlin.mff.cuni.cz/~pavel/picture/horses/blog.html

Re: [PATCH 03/12] statx: Add a system call to make enhanced file info available

[David Howells]

Pavel Machek <pavel@ucw.cz> wrote:

> But fstat() is really different operation to stat() -- tell me about
> my file descriptor vs. tell me about this filename, and ptrace (and
> some "security" solutions) might want to allow one but disallow the
> second. I'd not group them together..

You can argue it either way.  I think Linus came down on the side of combining
them.

David