Re: [PATCH] Add a pair of system calls to make extended file stats available [ver #3]

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



hi David,

On Fri, Jul 2, 2010 at 7:36 AM, Michael Kerrisk <mtk.manpages@xxxxxxxxx> wrote:
> Hi David,
>
> [Please CC linux-api@ on patches that change the API/ABI]
>
> On Thu, Jul 1, 2010 at 1:36 AM, David Howells <dhowells@xxxxxxxxxx> wrote:
>> Add a pair of system calls to make extended file stats available, including
>> file creation time, inode version and data version where available through the
>> underlying filesystem.
>
> Just some random thoughts here. I've not tried to guess the overhead
> of these ideas...
>
> * Include information from the "inode_info" structure, most notably
> i_flags, but perhaps other info as well.

I see you put a patch for the above for comment. Thanks.

> * Return a bit mask indicating the presence of additional information
> associated with the i-node. Here, I am thinking of flags that indicate
> that the file has any of the following: capabilities, an ACL, and
> extended attributes (obviously a superset of the previous). I could
> imagine some apps that, having got the xstat info, would be interested
> to obtain some of this other info.

What did you think about the above idea?

Cheers,

Michael


> Obviously, the above only make sense if the overhead of providing the
> extra information is low.
>
>> [This depends on the previously posted pair of patches to (a) constify a number
>>  of syscall string and buffer arguments and (b) rearrange AFS's use of
>>  i_version and i_generation].
>>
>> The following structures are defined for their use:
>>
>>        struct xstat_parameters {
>>                unsigned long long      request_mask;
>>        };
>>
>>        struct xstat_dev {
>>                unsigned int            major, minor;
>>        };
>>
>>        struct xstat_time {
>>                unsigned long long      tv_sec, tv_nsec;
>>        };
>>
>>        struct xstat {
>>                unsigned int            st_mode;
>>                unsigned int            st_nlink;
>>                unsigned int            st_uid;
>>                unsigned int            st_gid;
>>                struct xstat_dev        st_rdev;
>>                struct xstat_dev        st_dev;
>>                struct xstat_time       st_atime;
>>                struct xstat_time       st_mtime;
>>                struct xstat_time       st_ctime;
>>                struct xstat_time       st_btime;
>>                unsigned long long      st_ino;
>>                unsigned long long      st_size;
>>                unsigned long long      st_blksize;
>>                unsigned long long      st_blocks;
>>                unsigned long long      st_gen;
>>                unsigned long long      st_data_version;
>>                unsigned long long      st_result_mask;
>>                unsigned long long      st_extra_results[0];
>>        };
>>
>> where st_btime is the file creation time, st_gen is the inode generation
>> (i_generation), st_data_version is the data version number (i_version),
>> request_mask and st_result_mask are bitmasks of data desired/provided and
>> st_extra_results[] is where as-yet undefined fields are appended.
>>
>> The defined bits in request_mask and st_result_mask are:
>>
>>        XSTAT_REQUEST_MODE              Want/got st_mode
>>        XSTAT_REQUEST_NLINK             Want/got st_nlink
>>        XSTAT_REQUEST_UID               Want/got st_uid
>>        XSTAT_REQUEST_GID               Want/got st_gid
>>        XSTAT_REQUEST_RDEV              Want/got st_rdev
>>        XSTAT_REQUEST_ATIME             Want/got st_atime
>>        XSTAT_REQUEST_MTIME             Want/got st_mtime
>>        XSTAT_REQUEST_CTIME             Want/got st_ctime
>>        XSTAT_REQUEST_INO               Want/got st_ino
>>        XSTAT_REQUEST_SIZE              Want/got st_size
>>        XSTAT_REQUEST_BLOCKS            Want/got st_blocks
>>        XSTAT_REQUEST__BASIC_STATS      The stuff in the normal stat struct
>>        XSTAT_REQUEST_BTIME             Want/got st_btime
>>        XSTAT_REQUEST_GEN               Want/got st_gen
>>        XSTAT_REQUEST_DATA_VERSION      Want/got st_data_version
>>        XSTAT_REQUEST__EXTENDED_STATS   The stuff in the xstat struct
>>        XSTAT_REQUEST__ALL_STATS        The defined set of requestables
>>
>> The system calls are:
>>
>>        ssize_t ret = xstat(int dfd,
>>                            const char *filename,
>>                            unsigned flags,
>>                            const struct xstat_parameters *params,
>>                            struct xstat *buffer,
>>                            size_t buflen);
>>
>>        ssize_t ret = fxstat(unsigned fd,
>>                             unsigned flags,
>>                             const struct xstat_parameters *params,
>>                             struct xstat *buffer,
>>                             size_t buflen);
>>
>>
>> The dfd, filename, flags and fd parameters indicate the file to query.  There
>> is no equivalent of lstat() as that can be emulated with xstat() by passing
>> AT_SYMLINK_NOFOLLOW in flags.
>>
>> AT_FORCE_ATTR_SYNC can also be set in flags.  This will require a network
>> filesystem to synchronise its attributes with the server.
>>
>> When the system call is executed, the request_mask bitmask is read from the
>> parameter block to work out what the user is requesting.  If params is NULL,
>> then request_mask will be assumed to be XSTAT_REQUEST__GET_ANYWAY.
>>
>> The request_mask should be set by the caller to specify extra results that the
>> caller may desire.  These come in a number of classes:
>>
>>  (0) dev, blksize.
>>
>>     These are local data and are always available.
>>
>>  (1) mode, nlinks, uid, gid, [amc]time, ino, size, blocks.
>>
>>     These will be returned whether the caller asks for them or not.  The
>>     corresponding bits in result_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.
>>
>>  (2) rdev.
>>
>>     As for class (1), but this won't be returned if the file is not a blockdev
>>     or chardev.  The bit will be cleared if the value is not returned.
>>
>>  (3) File creation time, inode generation and data version.
>>
>>     These will be returned if available whether the caller asked for them or
>>     not.  The corresponding bits in result_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.
>>
>>  (4) Extra results.
>>
>>     These will only be returned if the caller asked for them by setting their
>>     bits in request_mask.  They will be placed in the buffer after the xstat
>>     struct in ascending result_mask bit order.  Any bit set in request_mask
>>     mask will be left set in result_mask if the result is available and
>>     cleared otherwise.
>>
>>     The pointer into the results list will be rounded up to the nearest 8-byte
>>     boundary after each result is written in.  The size of each extra result
>>     is specific to the definition for that result.
>>
>>     No extra results are currently defined.
>>
>> If the buffer is insufficiently big, the syscall returns the amount of space it
>> will need to write the complete result set and returns a partial result in the
>> buffer.
>>
>> At the moment, this will only work on x86_64 as it requires system calls to be
>> wired up.
>>
>>
>> ===========
>> FILESYSTEMS
>> ===========
>>
>> The following filesystems have been modified to make use of this facility:
>>
>>  (*) Ext4.  This will return the creation time and inode version number for all
>>     files.  It will, however, only return the data version number for
>>     directories unless the I_VERSION option is set on the filesystem.
>>
>>  (*) AFS.  This will return the vnode ID uniquifier as the inode version and
>>     the AFS data version number as the data version.  There is no file
>>     creation time available.
>>
>>     AFS should go to the server if AT_FORCE_ATTR_SYNC is specified.
>>
>>  (*) NFS.  This will return the change attribute if NFSv4 only.  No other extra
>>     values are returned at this time.
>>
>>     If AT_FORCE_ATTR_SYNC is set or mtime, ctime or data_version (NFSv4 only)
>>     are asked for then the outstanding writes will be written to the server
>>     first.
>>
>>     If AT_FORCE_ATTR_SYNC is set or atime is requested then the attributes
>>     will be reread unconditionally, otherwise if any of data version (NFSv4
>>     only) XSTAT_REQUEST__BASIC_STATS are requested, then the attributes will
>>     be reread if the cached attributes have expired.
>>
>>
>> =======
>> TESTING
>> =======
>>
>> The following test program can be used to test the xstat system call:
>>
>>        #define _GNU_SOURCE
>>        #define _ATFILE_SOURCE
>>        #include <stdio.h>
>>        #include <stdlib.h>
>>        #include <string.h>
>>        #include <unistd.h>
>>        #include <fcntl.h>
>>        #include <time.h>
>>        #include <sys/syscall.h>
>>        #include <sys/stat.h>
>>        #include <sys/types.h>
>>
>>        #define AT_FORCE_ATTR_SYNC      0x800
>>
>>        struct xstat_parameters {
>>                unsigned long long      request_mask;
>>        #define XSTAT_REQUEST_MODE              0x00000001ULL
>>        #define XSTAT_REQUEST_NLINK             0x00000002ULL
>>        #define XSTAT_REQUEST_UID               0x00000004ULL
>>        #define XSTAT_REQUEST_GID               0x00000008ULL
>>        #define XSTAT_REQUEST_RDEV              0x00000010ULL
>>        #define XSTAT_REQUEST_ATIME             0x00000020ULL
>>        #define XSTAT_REQUEST_MTIME             0x00000040ULL
>>        #define XSTAT_REQUEST_CTIME             0x00000080ULL
>>        #define XSTAT_REQUEST_INO               0x00000100ULL
>>        #define XSTAT_REQUEST_SIZE              0x00000200ULL
>>        #define XSTAT_REQUEST_BLOCKS            0x00000400ULL
>>        #define XSTAT_REQUEST__BASIC_STATS      0x000007ffULL
>>        #define XSTAT_REQUEST_BTIME             0x00000800ULL
>>        #define XSTAT_REQUEST_GEN               0x00001000ULL
>>        #define XSTAT_REQUEST_DATA_VERSION      0x00002000ULL
>>        #define XSTAT_REQUEST__EXTENDED_STATS   0x00003fffULL
>>        #define XSTAT_REQUEST__ALL_STATS        0x00003fffULL
>>        };
>>
>>        struct xstat_dev {
>>                unsigned int    major;
>>                unsigned int    minor;
>>        };
>>
>>        struct xstat_time {
>>                unsigned long long      tv_sec;
>>                unsigned long long      tv_nsec;
>>        };
>>
>>        struct xstat {
>>                unsigned int            st_mode;
>>                unsigned int            st_nlink;
>>                unsigned int            st_uid;
>>                unsigned int            st_gid;
>>                struct xstat_dev        st_rdev;
>>                struct xstat_dev        st_dev;
>>                struct xstat_time       st_atim;
>>                struct xstat_time       st_mtim;
>>                struct xstat_time       st_ctim;
>>                struct xstat_time       st_btim;
>>                unsigned long long      st_ino;
>>                unsigned long long      st_size;
>>                unsigned long long      st_blksize;
>>                unsigned long long      st_blocks;
>>                unsigned long long      st_gen;
>>                unsigned long long      st_data_version;
>>                unsigned long long      st_result_mask;
>>                unsigned long long      st_extra_results[0];
>>        };
>>
>>        #define __NR_xstat                              300
>>        #define __NR_fxstat                             301
>>
>>        static __attribute__((unused))
>>        ssize_t xstat(int dfd, const char *filename, unsigned flags,
>>                      struct xstat_parameters *params,
>>                      struct xstat *buffer, size_t bufsize)
>>        {
>>                return syscall(__NR_xstat, dfd, filename, flags,
>>                               params, buffer, bufsize);
>>        }
>>
>>        static __attribute__((unused))
>>        ssize_t fxstat(int fd, unsigned flags,
>>                       struct xstat_parameters *params,
>>                       struct xstat *buffer, size_t bufsize)
>>        {
>>                return syscall(__NR_fxstat, fd, flags,
>>                               params, buffer, bufsize);
>>        }
>>
>>        static void print_time(const char *field, const struct xstat_time *xstm)
>>        {
>>                struct tm tm;
>>                time_t tim;
>>                char buffer[100];
>>                int len;
>>
>>                tim = xstm->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(".%09llu", xstm->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_xstat(struct xstat *xst)
>>        {
>>                char buffer[256], ft;
>>
>>                printf("results=%llx\n", xst->st_result_mask);
>>
>>                printf(" ");
>>                if (xst->st_result_mask & XSTAT_REQUEST_SIZE)
>>                        printf(" Size: %-15llu", xst->st_size);
>>                if (xst->st_result_mask & XSTAT_REQUEST_BLOCKS)
>>                        printf(" Blocks: %-10llu", xst->st_blocks);
>>                printf(" IO Block: %-6llu ", xst->st_blksize);
>>                if (xst->st_result_mask & XSTAT_REQUEST_MODE) {
>>                        switch (xst->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", xst->st_mode & S_IFMT);
>>                                ft = '?';
>>                                break;
>>                        }
>>                }
>>
>>                sprintf(buffer, "%02x:%02x", xst->st_dev.major, xst->st_dev.minor);
>>                printf("Device: %-15s", buffer);
>>                if (xst->st_result_mask & XSTAT_REQUEST_INO)
>>                        printf(" Inode: %-11llu", xst->st_ino);
>>                if (xst->st_result_mask & XSTAT_REQUEST_SIZE)
>>                        printf(" Links: %-5u", xst->st_nlink);
>>                if (xst->st_result_mask & XSTAT_REQUEST_RDEV)
>>                        printf(" Device type: %u,%u",
>>                               xst->st_rdev.major, xst->st_rdev.minor);
>>                printf("\n");
>>
>>                if (xst->st_result_mask & XSTAT_REQUEST_MODE)
>>                        printf("Access: (%04o/%c%c%c%c%c%c%c%c%c%c)  ",
>>                               xst->st_mode & 07777,
>>                               ft,
>>                               xst->st_mode & S_IRUSR ? 'r' : '-',
>>                               xst->st_mode & S_IWUSR ? 'w' : '-',
>>                               xst->st_mode & S_IXUSR ? 'x' : '-',
>>                               xst->st_mode & S_IRGRP ? 'r' : '-',
>>                               xst->st_mode & S_IWGRP ? 'w' : '-',
>>                               xst->st_mode & S_IXGRP ? 'x' : '-',
>>                               xst->st_mode & S_IROTH ? 'r' : '-',
>>                               xst->st_mode & S_IWOTH ? 'w' : '-',
>>                               xst->st_mode & S_IXOTH ? 'x' : '-');
>>                if (xst->st_result_mask & XSTAT_REQUEST_UID)
>>                        printf("Uid: %d   \n", xst->st_uid);
>>                if (xst->st_result_mask & XSTAT_REQUEST_GID)
>>                        printf("Gid: %u\n", xst->st_gid);
>>
>>                if (xst->st_result_mask & XSTAT_REQUEST_ATIME)
>>                        print_time("Access: ", &xst->st_atim);
>>                if (xst->st_result_mask & XSTAT_REQUEST_MTIME)
>>                        print_time("Modify: ", &xst->st_mtim);
>>                if (xst->st_result_mask & XSTAT_REQUEST_CTIME)
>>                        print_time("Change: ", &xst->st_ctim);
>>                if (xst->st_result_mask & XSTAT_REQUEST_BTIME)
>>                        print_time("Create: ", &xst->st_btim);
>>
>>                if (xst->st_result_mask & XSTAT_REQUEST_GEN)
>>                        printf("Inode version: %llxh\n", xst->st_gen);
>>                if (xst->st_result_mask & XSTAT_REQUEST_DATA_VERSION)
>>                        printf("Data version: %llxh\n", xst->st_data_version);
>>        }
>>
>>        int main(int argc, char **argv)
>>        {
>>                struct xstat_parameters params;
>>                struct xstat xst;
>>                int ret, atflag = AT_SYMLINK_NOFOLLOW;
>>
>>                unsigned long long query =
>>                        XSTAT_REQUEST__BASIC_STATS |
>>                        XSTAT_REQUEST_BTIME |
>>                        XSTAT_REQUEST_GEN |
>>                        XSTAT_REQUEST_DATA_VERSION;
>>
>>                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, "-O") == 0) {
>>                                query &= ~XSTAT_REQUEST__BASIC_STATS;
>>                                continue;
>>                        }
>>
>>                        memset(&xst, 0xbf, sizeof(xst));
>>                        params.request_mask = query;
>>                        ret = xstat(AT_FDCWD, *argv, atflag, &params, &xst, sizeof(xst));
>>                        printf("xstat(%s) = %d\n", *argv, ret);
>>                        if (ret < 0) {
>>                                perror(*argv);
>>                                exit(1);
>>                        }
>>
>>                        dump_xstat(&xst);
>>                }
>>                return 0;
>>        }
>>
>> Just compile and run, passing it paths to the files you want to examine:
>>
>>        [root@andromeda ~]# /tmp/xstat -O /dev/tty
>>        xstat(/dev/tty) = 152
>>        results=7ff
>>          Size: 0               Blocks: 0          IO Block: 4096    character special file
>>        Device: 00:0f           Inode: 246         Links: 1     Device type: 5,0
>>        Access: (0666/crw-rw-rw-)  Uid: 0
>>        Gid: 5
>>        Access: 2010-06-30 16:25:01.813517001+0100
>>        Modify: 2010-06-30 16:25:01.813517001+0100
>>        Change: 2010-06-30 16:25:01.813517001+0100
>>
>>        [root@andromeda ~]# /tmp/xstat /var/cache/fscache/cache/
>>        xstat(/var/cache/fscache/cache/) = 152
>>        results=3fef
>>          Size: 4096            Blocks: 16         IO Block: 4096    directory
>>        Device: 08:06           Inode: 130561      Links: 3
>>        Access: (0700/drwx------)  Uid: 0
>>        Gid: 0
>>        Access: 2010-06-29 18:16:33.680703545+0100
>>        Modify: 2010-06-29 18:16:20.132786632+0100
>>        Change: 2010-06-29 18:16:20.132786632+0100
>>        Create: 2010-06-25 15:17:39.471199293+0100
>>        Inode version: f585ab70h
>>        Data version: 2h
>>
>> Signed-off-by: David Howells <dhowells@xxxxxxxxxx>
>> ---
>>
>>  arch/x86/include/asm/unistd_32.h |    4 +
>>  arch/x86/include/asm/unistd_64.h |    4 +
>>  fs/afs/inode.c                   |   11 +-
>>  fs/ecryptfs/inode.c              |    2
>>  fs/ext4/ext4.h                   |    2
>>  fs/ext4/file.c                   |    2
>>  fs/ext4/inode.c                  |   27 +++++-
>>  fs/ext4/namei.c                  |    2
>>  fs/ext4/symlink.c                |    2
>>  fs/nfs/inode.c                   |   46 +++++++---
>>  fs/nfsd/nfs3proc.c               |    2
>>  fs/nfsd/nfs3xdr.c                |    4 +
>>  fs/nfsd/nfs4xdr.c                |    4 +
>>  fs/nfsd/nfsproc.c                |    6 +
>>  fs/nfsd/nfsxdr.c                 |    2
>>  fs/stat.c                        |  175 ++++++++++++++++++++++++++++++++++----
>>  include/linux/fcntl.h            |    1
>>  include/linux/fs.h               |    2
>>  include/linux/stat.h             |  103 ++++++++++++++++++++++
>>  include/linux/syscalls.h         |    9 ++
>>  20 files changed, 368 insertions(+), 42 deletions(-)
>>
>> diff --git a/arch/x86/include/asm/unistd_32.h b/arch/x86/include/asm/unistd_32.h
>> index beb9b5f..a9953cc 100644
>> --- a/arch/x86/include/asm/unistd_32.h
>> +++ b/arch/x86/include/asm/unistd_32.h
>> @@ -343,10 +343,12 @@
>>  #define __NR_rt_tgsigqueueinfo 335
>>  #define __NR_perf_event_open   336
>>  #define __NR_recvmmsg          337
>> +#define __NR_xstat             338
>> +#define __NR_fxstat            339
>>
>>  #ifdef __KERNEL__
>>
>> -#define NR_syscalls 338
>> +#define NR_syscalls 340
>>
>>  #define __ARCH_WANT_IPC_PARSE_VERSION
>>  #define __ARCH_WANT_OLD_READDIR
>> diff --git a/arch/x86/include/asm/unistd_64.h b/arch/x86/include/asm/unistd_64.h
>> index ff4307b..c90d240 100644
>> --- a/arch/x86/include/asm/unistd_64.h
>> +++ b/arch/x86/include/asm/unistd_64.h
>> @@ -663,6 +663,10 @@ __SYSCALL(__NR_rt_tgsigqueueinfo, sys_rt_tgsigqueueinfo)
>>  __SYSCALL(__NR_perf_event_open, sys_perf_event_open)
>>  #define __NR_recvmmsg                          299
>>  __SYSCALL(__NR_recvmmsg, sys_recvmmsg)
>> +#define __NR_xstat                             300
>> +__SYSCALL(__NR_xstat, sys_xstat)
>> +#define __NR_fxstat                            301
>> +__SYSCALL(__NR_fxstat, sys_fxstat)
>>
>>  #ifndef __NO_STUBS
>>  #define __ARCH_WANT_OLD_READDIR
>> diff --git a/fs/afs/inode.c b/fs/afs/inode.c
>> index ee3190a..f624c5a 100644
>> --- a/fs/afs/inode.c
>> +++ b/fs/afs/inode.c
>> @@ -300,16 +300,17 @@ 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;
>> -
>> -       inode = dentry->d_inode;
>> +       struct inode *inode = dentry->d_inode;
>>
>>        _enter("{ ino=%lu v=%u }", inode->i_ino, inode->i_generation);
>>
>>        generic_fillattr(inode, stat);
>> +
>> +       stat->result_mask |= XSTAT_REQUEST_GEN | XSTAT_REQUEST_DATA_VERSION;
>> +       stat->gen = inode->i_generation;
>> +       stat->data_version = inode->i_version;
>>        return 0;
>>  }
>>
>> diff --git a/fs/ecryptfs/inode.c b/fs/ecryptfs/inode.c
>> index 31ef525..0b02272 100644
>> --- a/fs/ecryptfs/inode.c
>> +++ b/fs/ecryptfs/inode.c
>> @@ -994,6 +994,8 @@ int ecryptfs_getattr(struct vfsmount *mnt, struct dentry *dentry,
>>        struct kstat lower_stat;
>>        int rc;
>>
>> +       lower_stat.query_flags = stat->query_flags;
>> +       lower_stat.request_mask = stat->request_mask | XSTAT_REQUEST_BLOCKS;
>>        rc = vfs_getattr(ecryptfs_dentry_to_lower_mnt(dentry),
>>                         ecryptfs_dentry_to_lower(dentry), &lower_stat);
>>        if (!rc) {
>> diff --git a/fs/ext4/ext4.h b/fs/ext4/ext4.h
>> index 19a4de5..96823f3 100644
>> --- a/fs/ext4/ext4.h
>> +++ b/fs/ext4/ext4.h
>> @@ -1571,6 +1571,8 @@ extern int  ext4_write_inode(struct inode *, struct writeback_control *);
>>  extern int  ext4_setattr(struct dentry *, struct iattr *);
>>  extern int  ext4_getattr(struct vfsmount *mnt, struct dentry *dentry,
>>                                struct kstat *stat);
>> +extern int  ext4_file_getattr(struct vfsmount *mnt, struct dentry *dentry,
>> +                               struct kstat *stat);
>>  extern void ext4_delete_inode(struct inode *);
>>  extern int  ext4_sync_inode(handle_t *, struct inode *);
>>  extern void ext4_dirty_inode(struct inode *);
>> diff --git a/fs/ext4/file.c b/fs/ext4/file.c
>> index 5313ae4..18c29ab 100644
>> --- a/fs/ext4/file.c
>> +++ b/fs/ext4/file.c
>> @@ -150,7 +150,7 @@ const struct file_operations ext4_file_operations = {
>>  const struct inode_operations ext4_file_inode_operations = {
>>        .truncate       = ext4_truncate,
>>        .setattr        = ext4_setattr,
>> -       .getattr        = ext4_getattr,
>> +       .getattr        = ext4_file_getattr,
>>  #ifdef CONFIG_EXT4_FS_XATTR
>>        .setxattr       = generic_setxattr,
>>        .getxattr       = generic_getxattr,
>> diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
>> index 42272d6..f9a730a 100644
>> --- a/fs/ext4/inode.c
>> +++ b/fs/ext4/inode.c
>> @@ -5550,12 +5550,33 @@ err_out:
>>  int ext4_getattr(struct vfsmount *mnt, struct dentry *dentry,
>>                 struct kstat *stat)
>>  {
>> -       struct inode *inode;
>> -       unsigned long delalloc_blocks;
>> +       struct inode *inode = dentry->d_inode;
>>
>> -       inode = dentry->d_inode;
>>        generic_fillattr(inode, stat);
>>
>> +       stat->result_mask |= XSTAT_REQUEST_BTIME;
>> +       stat->btime.tv_sec = EXT4_I(inode)->i_crtime.tv_sec;
>> +       stat->btime.tv_nsec = EXT4_I(inode)->i_crtime.tv_nsec;
>> +
>> +       if (inode->i_ino != EXT4_ROOT_INO) {
>> +               stat->result_mask |= XSTAT_REQUEST_GEN;
>> +               stat->gen = inode->i_generation;
>> +       }
>> +       if (S_ISDIR(inode->i_mode) || test_opt(inode->i_sb, I_VERSION)) {
>> +               stat->result_mask |= XSTAT_REQUEST_DATA_VERSION;
>> +               stat->data_version = inode->i_version;
>> +       }
>> +       return 0;
>> +}
>> +
>> +int ext4_file_getattr(struct vfsmount *mnt, struct dentry *dentry,
>> +                     struct kstat *stat)
>> +{
>> +       struct inode *inode = dentry->d_inode;
>> +       unsigned long delalloc_blocks;
>> +
>> +       ext4_getattr(mnt, dentry, stat);
>> +
>>        /*
>>         * We can't update i_blocks if the block allocation is delayed
>>         * otherwise in the case of system crash before the real block
>> diff --git a/fs/ext4/namei.c b/fs/ext4/namei.c
>> index a43e661..0f776c7 100644
>> --- a/fs/ext4/namei.c
>> +++ b/fs/ext4/namei.c
>> @@ -2542,6 +2542,7 @@ const struct inode_operations ext4_dir_inode_operations = {
>>        .mknod          = ext4_mknod,
>>        .rename         = ext4_rename,
>>        .setattr        = ext4_setattr,
>> +       .getattr        = ext4_getattr,
>>  #ifdef CONFIG_EXT4_FS_XATTR
>>        .setxattr       = generic_setxattr,
>>        .getxattr       = generic_getxattr,
>> @@ -2554,6 +2555,7 @@ const struct inode_operations ext4_dir_inode_operations = {
>>
>>  const struct inode_operations ext4_special_inode_operations = {
>>        .setattr        = ext4_setattr,
>> +       .getattr        = ext4_getattr,
>>  #ifdef CONFIG_EXT4_FS_XATTR
>>        .setxattr       = generic_setxattr,
>>        .getxattr       = generic_getxattr,
>> diff --git a/fs/ext4/symlink.c b/fs/ext4/symlink.c
>> index ed9354a..d8fe7fb 100644
>> --- a/fs/ext4/symlink.c
>> +++ b/fs/ext4/symlink.c
>> @@ -35,6 +35,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,
>>  #ifdef CONFIG_EXT4_FS_XATTR
>>        .setxattr       = generic_setxattr,
>>        .getxattr       = generic_getxattr,
>> @@ -47,6 +48,7 @@ const struct inode_operations ext4_fast_symlink_inode_operations = {
>>        .readlink       = generic_readlink,
>>        .follow_link    = ext4_follow_link,
>>        .setattr        = ext4_setattr,
>> +       .getattr        = ext4_getattr,
>>  #ifdef CONFIG_EXT4_FS_XATTR
>>        .setxattr       = generic_setxattr,
>>        .getxattr       = generic_getxattr,
>> diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c
>> index 099b351..8c6de96 100644
>> --- a/fs/nfs/inode.c
>> +++ b/fs/nfs/inode.c
>> @@ -495,11 +495,21 @@ void nfs_setattr_update_inode(struct inode *inode, struct iattr *attr)
>>  int nfs_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
>>  {
>>        struct inode *inode = dentry->d_inode;
>> +       unsigned force = stat->query_flags & AT_FORCE_ATTR_SYNC;
>>        int need_atime = NFS_I(inode)->cache_validity & NFS_INO_INVALID_ATIME;
>>        int err;
>>
>> -       /* 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 &= ~XSTAT_REQUEST_DATA_VERSION;
>> +
>> +       /* Flush out writes to the server in order to update c/mtime
>> +        * or data version if the user wants them */
>> +       if ((force || stat->request_mask & (XSTAT_REQUEST_MTIME |
>> +                                           XSTAT_REQUEST_CTIME |
>> +                                           XSTAT_REQUEST_DATA_VERSION
>> +                                           )) &&
>> +           S_ISREG(inode->i_mode)
>> +           ) {
>>                err = filemap_write_and_wait(inode->i_mapping);
>>                if (err)
>>                        goto out;
>> @@ -514,18 +524,30 @@ 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)))
>> +       if (!(stat->request_mask & XSTAT_REQUEST_ATIME) ||
>> +           (mnt->mnt_flags & MNT_NOATIME) ||
>> +           ((mnt->mnt_flags & MNT_NODIRATIME) && S_ISDIR(inode->i_mode)))
>>                need_atime = 0;
>>
>> -       if (need_atime)
>> -               err = __nfs_revalidate_inode(NFS_SERVER(inode), inode);
>> -       else
>> -               err = nfs_revalidate_inode(NFS_SERVER(inode), inode);
>> -       if (!err) {
>> -               generic_fillattr(inode, stat);
>> -               stat->ino = nfs_compat_user_ino64(NFS_FILEID(inode));
>> +       if (force || stat->request_mask & (XSTAT_REQUEST__BASIC_STATS |
>> +                                          XSTAT_REQUEST_DATA_VERSION)
>> +           ) {
>> +               if (force || need_atime)
>> +                       err = __nfs_revalidate_inode(NFS_SERVER(inode), inode);
>> +               else
>> +                       err = nfs_revalidate_inode(NFS_SERVER(inode), inode);
>> +               if (err)
>> +                       goto out;
>>        }
>> +
>> +       generic_fillattr(inode, stat);
>> +       stat->ino = nfs_compat_user_ino64(NFS_FILEID(inode));
>> +
>> +       if (stat->request_mask & XSTAT_REQUEST_DATA_VERSION) {
>> +               stat->data_version = NFS_I(inode)->change_attr;
>> +               stat->result_mask |= XSTAT_REQUEST_DATA_VERSION;
>> +       }
>> +
>>  out:
>>        return err;
>>  }
>> @@ -770,7 +792,7 @@ int nfs_revalidate_inode(struct nfs_server *server, struct inode *inode)
>>  static int nfs_invalidate_mapping(struct inode *inode, struct address_space *mapping)
>>  {
>>        struct nfs_inode *nfsi = NFS_I(inode);
>> -
>> +
>>        if (mapping->nrpages != 0) {
>>                int ret = invalidate_inode_pages2(mapping);
>>                if (ret < 0)
>> diff --git a/fs/nfsd/nfs3proc.c b/fs/nfsd/nfs3proc.c
>> index 3d68f45..310ff05 100644
>> --- a/fs/nfsd/nfs3proc.c
>> +++ b/fs/nfsd/nfs3proc.c
>> @@ -55,6 +55,8 @@ nfsd3_proc_getattr(struct svc_rqst *rqstp, struct nfsd_fhandle  *argp,
>>        if (nfserr)
>>                RETURN_STATUS(nfserr);
>>
>> +       resp->stat.query_flags = 0;
>> +       resp->stat.request_mask = XSTAT_REQUEST__EXTENDED_STATS;
>>        err = vfs_getattr(resp->fh.fh_export->ex_path.mnt,
>>                          resp->fh.fh_dentry, &resp->stat);
>>        nfserr = nfserrno(err);
>> diff --git a/fs/nfsd/nfs3xdr.c b/fs/nfsd/nfs3xdr.c
>> index 2a533a0..eaa3c3b 100644
>> --- a/fs/nfsd/nfs3xdr.c
>> +++ b/fs/nfsd/nfs3xdr.c
>> @@ -205,6 +205,8 @@ encode_post_op_attr(struct svc_rqst *rqstp, __be32 *p, struct svc_fh *fhp)
>>                int err;
>>                struct kstat stat;
>>
>> +               stat.query_flags = 0;
>> +               stat.request_mask = XSTAT_REQUEST__EXTENDED_STATS;
>>                err = vfs_getattr(fhp->fh_export->ex_path.mnt, dentry, &stat);
>>                if (!err) {
>>                        *p++ = xdr_one;         /* attributes follow */
>> @@ -257,6 +259,8 @@ void fill_post_wcc(struct svc_fh *fhp)
>>        if (fhp->fh_post_saved)
>>                printk("nfsd: inode locked twice during operation.\n");
>>
>> +       fhp->fh_post_attr.query_flags = 0;
>> +       fhp->fh_post_attr.request_mask = XSTAT_REQUEST__EXTENDED_STATS;
>>        err = vfs_getattr(fhp->fh_export->ex_path.mnt, fhp->fh_dentry,
>>                        &fhp->fh_post_attr);
>>        fhp->fh_post_change = fhp->fh_dentry->d_inode->i_version;
>> diff --git a/fs/nfsd/nfs4xdr.c b/fs/nfsd/nfs4xdr.c
>> index ac17a70..e9d1b59 100644
>> --- a/fs/nfsd/nfs4xdr.c
>> +++ b/fs/nfsd/nfs4xdr.c
>> @@ -1769,6 +1769,8 @@ nfsd4_encode_fattr(struct svc_fh *fhp, struct svc_export *exp,
>>                        goto out;
>>        }
>>
>> +       stat.query_flags = 0;
>> +       stat.request_mask = XSTAT_REQUEST__EXTENDED_STATS;
>>        err = vfs_getattr(exp->ex_path.mnt, dentry, &stat);
>>        if (err)
>>                goto out_nfserr;
>> @@ -2139,6 +2141,8 @@ out_acl:
>>                                if (path.dentry != path.mnt->mnt_root)
>>                                        break;
>>                        }
>> +                       stat.query_flags = 0;
>> +                       stat.request_mask = XSTAT_REQUEST__EXTENDED_STATS;
>>                        err = vfs_getattr(path.mnt, path.dentry, &stat);
>>                        path_put(&path);
>>                        if (err)
>> diff --git a/fs/nfsd/nfsproc.c b/fs/nfsd/nfsproc.c
>> index a047ad6..7c0e74b 100644
>> --- a/fs/nfsd/nfsproc.c
>> +++ b/fs/nfsd/nfsproc.c
>> @@ -26,6 +26,8 @@ static __be32
>>  nfsd_return_attrs(__be32 err, struct nfsd_attrstat *resp)
>>  {
>>        if (err) return err;
>> +       resp->stat.query_flags = 0;
>> +       resp->stat.request_mask = XSTAT_REQUEST__EXTENDED_STATS;
>>        return nfserrno(vfs_getattr(resp->fh.fh_export->ex_path.mnt,
>>                                    resp->fh.fh_dentry,
>>                                    &resp->stat));
>> @@ -34,6 +36,8 @@ static __be32
>>  nfsd_return_dirop(__be32 err, struct nfsd_diropres *resp)
>>  {
>>        if (err) return err;
>> +       resp->stat.query_flags = 0;
>> +       resp->stat.request_mask = XSTAT_REQUEST__EXTENDED_STATS;
>>        return nfserrno(vfs_getattr(resp->fh.fh_export->ex_path.mnt,
>>                                    resp->fh.fh_dentry,
>>                                    &resp->stat));
>> @@ -150,6 +154,8 @@ nfsd_proc_read(struct svc_rqst *rqstp, struct nfsd_readargs *argp,
>>                                  &resp->count);
>>
>>        if (nfserr) return nfserr;
>> +       resp->stat.query_flags = 0;
>> +       resp->stat.request_mask = XSTAT_REQUEST__EXTENDED_STATS;
>>        return nfserrno(vfs_getattr(resp->fh.fh_export->ex_path.mnt,
>>                                    resp->fh.fh_dentry,
>>                                    &resp->stat));
>> diff --git a/fs/nfsd/nfsxdr.c b/fs/nfsd/nfsxdr.c
>> index 4ce005d..a595fb6 100644
>> --- a/fs/nfsd/nfsxdr.c
>> +++ b/fs/nfsd/nfsxdr.c
>> @@ -197,6 +197,8 @@ encode_fattr(struct svc_rqst *rqstp, __be32 *p, struct svc_fh *fhp,
>>  __be32 *nfs2svc_encode_fattr(struct svc_rqst *rqstp, __be32 *p, struct svc_fh *fhp)
>>  {
>>        struct kstat stat;
>> +       stat.query_flags = 0;
>> +       stat.request_mask = XSTAT_REQUEST__EXTENDED_STATS;
>>        vfs_getattr(fhp->fh_export->ex_path.mnt, fhp->fh_dentry, &stat);
>>        return encode_fattr(rqstp, p, fhp, &stat);
>>  }
>> diff --git a/fs/stat.c b/fs/stat.c
>> index 12e90e2..2fb1527 100644
>> --- a/fs/stat.c
>> +++ b/fs/stat.c
>> @@ -33,6 +33,9 @@ void generic_fillattr(struct inode *inode, struct kstat *stat)
>>        stat->size = i_size_read(inode);
>>        stat->blocks = inode->i_blocks;
>>        stat->blksize = (1 << inode->i_blkbits);
>> +       stat->result_mask |= XSTAT_REQUEST__BASIC_STATS & ~XSTAT_REQUEST_RDEV;
>> +       if (unlikely(S_ISBLK(stat->mode) || S_ISCHR(stat->mode)))
>> +               stat->result_mask |= XSTAT_REQUEST_RDEV;
>>  }
>>
>>  EXPORT_SYMBOL(generic_fillattr);
>> @@ -42,6 +45,8 @@ int vfs_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
>>        struct inode *inode = dentry->d_inode;
>>        int retval;
>>
>> +       stat->result_mask = 0;
>> +
>>        retval = security_inode_getattr(mnt, dentry);
>>        if (retval)
>>                return retval;
>> @@ -55,41 +60,64 @@ int vfs_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
>>
>>  EXPORT_SYMBOL(vfs_getattr);
>>
>> -int vfs_fstat(unsigned int fd, struct kstat *stat)
>> +/*
>> + * VFS entrypoint to get extended stats by file descriptor
>> + */
>> +int vfs_fxstat(unsigned int fd, int flags, struct kstat *stat)
>>  {
>>        struct file *f = fget(fd);
>>        int error = -EBADF;
>>
>> +       if (flags & ~KSTAT_QUERY_FLAGS)
>> +               return -EINVAL;
>> +       stat->query_flags = flags;
>> +
>>        if (f) {
>>                error = vfs_getattr(f->f_path.mnt, f->f_path.dentry, stat);
>>                fput(f);
>>        }
>>        return error;
>>  }
>> +EXPORT_SYMBOL(vfs_fxstat);
>> +
>> +int vfs_fstat(unsigned int fd, struct kstat *stat)
>> +{
>> +       stat->request_mask = XSTAT_REQUEST__BASIC_STATS;
>> +       return vfs_fxstat(fd, 0, stat);
>> +}
>>  EXPORT_SYMBOL(vfs_fstat);
>>
>> -int vfs_fstatat(int dfd, const char __user *filename, struct kstat *stat,
>> -               int flag)
>> +/*
>> + * VFS entrypoint to get extended stats by filename
>> + */
>> +int vfs_xstat(int dfd, const char __user *filename, int flags,
>> +             struct kstat *stat)
>>  {
>>        struct path path;
>> -       int error = -EINVAL;
>> -       int lookup_flags = 0;
>> +       int error, lookup_flags;
>>
>> -       if ((flag & ~AT_SYMLINK_NOFOLLOW) != 0)
>> -               goto out;
>> +       if (flags & ~(AT_SYMLINK_NOFOLLOW | KSTAT_QUERY_FLAGS))
>> +               return -EINVAL;
>>
>> -       if (!(flag & AT_SYMLINK_NOFOLLOW))
>> -               lookup_flags |= LOOKUP_FOLLOW;
>> +       stat->query_flags = flags;
>> +       lookup_flags = (flags & AT_SYMLINK_NOFOLLOW) ? 0 : LOOKUP_FOLLOW;
>>
>>        error = user_path_at(dfd, filename, lookup_flags, &path);
>> -       if (error)
>> -               goto out;
>> -
>> -       error = vfs_getattr(path.mnt, path.dentry, stat);
>> -       path_put(&path);
>> -out:
>> +       if (!error) {
>> +               error = vfs_getattr(path.mnt, path.dentry, stat);
>> +               path_put(&path);
>> +       }
>>        return error;
>>  }
>> +EXPORT_SYMBOL(vfs_xstat);
>> +
>> +int vfs_fstatat(int dfd, const char __user *filename, struct kstat *stat,
>> +               int flags)
>> +{
>> +       stat->request_mask = XSTAT_REQUEST__BASIC_STATS;
>> +       stat->query_flags = 0;
>> +       return vfs_xstat(dfd, filename, flags, stat);
>> +}
>>  EXPORT_SYMBOL(vfs_fstatat);
>>
>>  int vfs_stat(const char __user *name, struct kstat *stat)
>> @@ -115,7 +143,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",
>> @@ -140,7 +168,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;
>> @@ -222,7 +250,7 @@ static int cp_new_stat(struct kstat *stat, struct stat __user *statbuf)
>>  #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;
>> @@ -408,6 +436,117 @@ SYSCALL_DEFINE4(fstatat64, int, dfd, const char __user *, filename,
>>  }
>>  #endif /* __ARCH_WANT_STAT64 */
>>
>> +/*
>> + * Get the xstat parameters if supplied
>> + */
>> +static int xstat_get_params(struct xstat_parameters __user *_params,
>> +                           struct kstat *stat)
>> +{
>> +       struct xstat_parameters params;
>> +
>> +       memset(stat, 0xde, sizeof(*stat));      // DEBUGGING
>> +
>> +       if (_params) {
>> +               if (copy_from_user(&params, _params, sizeof(params)) != 0)
>> +                       return -EFAULT;
>> +               stat->request_mask =
>> +                       params.request_mask & XSTAT_REQUEST__ALL_STATS;
>> +       } else {
>> +               stat->request_mask = XSTAT_REQUEST__EXTENDED_STATS;
>> +       }
>> +       stat->result_mask = 0;
>> +       return 0;
>> +}
>> +
>> +/*
>> + * copy the extended stats to userspace and return the amount of data written
>> + * into the buffer
>> + */
>> +static long xstat_set_result(struct kstat *stat,
>> +                            struct xstat __user *buffer, size_t bufsize)
>> +{
>> +       struct xstat tmp;
>> +       size_t copy;
>> +
>> +       /* transfer the fixed results */
>> +       memset(&tmp, 0, sizeof(tmp));
>> +       tmp.st_result_mask      = stat->result_mask;
>> +       tmp.st_mode             = stat->mode;
>> +       tmp.st_nlink            = stat->nlink;
>> +       tmp.st_uid              = stat->uid;
>> +       tmp.st_gid              = stat->gid;
>> +       tmp.st_blksize          = stat->blksize;
>> +       tmp.st_rdev.major       = MAJOR(stat->rdev);
>> +       tmp.st_rdev.minor       = MINOR(stat->rdev);
>> +       tmp.st_dev.major        = MAJOR(stat->dev);
>> +       tmp.st_dev.minor        = MINOR(stat->dev);
>> +       tmp.st_atime.tv_sec     = stat->atime.tv_sec;
>> +       tmp.st_atime.tv_nsec    = stat->atime.tv_nsec;
>> +       tmp.st_mtime.tv_sec     = stat->mtime.tv_sec;
>> +       tmp.st_mtime.tv_nsec    = stat->mtime.tv_nsec;
>> +       tmp.st_ctime.tv_sec     = stat->ctime.tv_sec;
>> +       tmp.st_ctime.tv_nsec    = stat->ctime.tv_nsec;
>> +       tmp.st_ino              = stat->ino;
>> +       tmp.st_size             = stat->size;
>> +       tmp.st_blocks           = stat->blocks;
>> +
>> +       if (tmp.st_result_mask & XSTAT_REQUEST_BTIME) {
>> +               tmp.st_btime.tv_sec     = stat->btime.tv_sec;
>> +               tmp.st_btime.tv_nsec    = stat->btime.tv_nsec;
>> +       }
>> +       if (tmp.st_result_mask & XSTAT_REQUEST_GEN)
>> +               tmp.st_gen              = stat->gen;
>> +       if (tmp.st_result_mask & XSTAT_REQUEST_DATA_VERSION)
>> +               tmp.st_data_version     = stat->data_version;
>> +
>> +       copy = sizeof(tmp);
>> +       if (copy > bufsize)
>> +               copy = bufsize;
>> +       if (copy_to_user(buffer, &tmp, copy) != 0)
>> +               return -EFAULT;
>> +       return sizeof(tmp);
>> +}
>> +
>> +/*
>> + * System call to get extended stats by path
>> + */
>> +SYSCALL_DEFINE6(xstat,
>> +               int, dfd, const char __user *, filename, unsigned, atflag,
>> +               struct xstat_parameters __user *, params,
>> +               struct xstat __user *, buffer, size_t, bufsize)
>> +{
>> +       struct kstat stat;
>> +       int error;
>> +
>> +       error = xstat_get_params(params, &stat);
>> +       if (error != 0)
>> +               return error;
>> +       error = vfs_xstat(dfd, filename, atflag, &stat);
>> +       if (error)
>> +               return error;
>> +       return xstat_set_result(&stat, buffer, bufsize);
>> +}
>> +
>> +/*
>> + * System call to get extended stats by file descriptor
>> + */
>> +SYSCALL_DEFINE5(fxstat, unsigned int, fd, unsigned int, flags,
>> +               struct xstat_parameters __user *, params,
>> +               struct xstat __user *, buffer, size_t, bufsize)
>> +{
>> +       struct kstat stat;
>> +       int error;
>> +
>> +       error = xstat_get_params(params, &stat);
>> +       if (error < 0)
>> +               return error;
>> +       error = vfs_fxstat(fd, flags, &stat);
>> +       if (error)
>> +               return error;
>> +
>> +       return xstat_set_result(&stat, buffer, bufsize);
>> +}
>> +
>>  /* 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/fcntl.h b/include/linux/fcntl.h
>> index afc00af..bcf8083 100644
>> --- a/include/linux/fcntl.h
>> +++ b/include/linux/fcntl.h
>> @@ -45,6 +45,7 @@
>>  #define AT_REMOVEDIR           0x200   /* Remove directory instead of
>>                                            unlinking file.  */
>>  #define AT_SYMLINK_FOLLOW      0x400   /* Follow symbolic links.  */
>> +#define AT_FORCE_ATTR_SYNC     0x800   /* Force the attributes to be sync'd with the server */
>>
>>  #ifdef __KERNEL__
>>
>> diff --git a/include/linux/fs.h b/include/linux/fs.h
>> index a18bcea..9ce2119 100644
>> --- a/include/linux/fs.h
>> +++ b/include/linux/fs.h
>> @@ -2343,6 +2343,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 611c398..e0b89e4 100644
>> --- a/include/linux/stat.h
>> +++ b/include/linux/stat.h
>> @@ -46,6 +46,99 @@
>>
>>  #endif
>>
>> +/*
>> + * Extended stat structures
>> + */
>> +struct xstat_parameters {
>> +       /* Query request/result mask
>> +        *
>> +        * Bits should be set in request_mask to request particular items
>> +        * before calling xstat() or fxstat().
>> +        *
>> +        * For each item in the set XSTAT_REQUEST__EXTENDED_STATS:
>> +        *
>> +        * - if not available at all, the bit will be cleared before returning
>> +        *   and the field will be cleared; otherwise,
>> +        *
>> +        * - if AT_FORCE_ATTR_SYNC is set, then the datum will be synchronised
>> +        *   to the server and the bit will be set on return; otherwise,
>> +        *
>> +        * - if requested, the datum will be synchronised to a server or other
>> +        *   hardware if out of date before being returned, and the bit will be
>> +        *   set on return; 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 bit will be cleared before returning, and the field will be
>> +         *   cleared.
>> +        *
>> +        * For each item not in the set XSTAT_REQUEST__EXTENDED_STATS
>> +        *
>> +        * - if not available at all, the bit will be cleared, and no result
>> +         *   data will be returned; otherwise,
>> +        *
>> +        * - if requested, the datum will be synchronised to a server or other
>> +        *   hardware before being appended if necessary, and the bit will be
>> +        *   set on return; otherwise,
>> +        *
>> +        * - the bit will be cleared, and no result data will be returned.
>> +        *
>> +        * Items in XSTAT_REQUEST__BASIC_STATS may be marked unavailable on
>> +        * return, but they will have a value installed for compatibility
>> +        * purposes.
>> +        */
>> +       unsigned long long      request_mask;
>> +#define XSTAT_REQUEST_MODE             0x00000001ULL   /* want/got st_mode */
>> +#define XSTAT_REQUEST_NLINK            0x00000002ULL   /* want/got st_nlink */
>> +#define XSTAT_REQUEST_UID              0x00000004ULL   /* want/got st_uid */
>> +#define XSTAT_REQUEST_GID              0x00000008ULL   /* want/got st_gid */
>> +#define XSTAT_REQUEST_RDEV             0x00000010ULL   /* want/got st_rdev */
>> +#define XSTAT_REQUEST_ATIME            0x00000020ULL   /* want/got st_atime */
>> +#define XSTAT_REQUEST_MTIME            0x00000040ULL   /* want/got st_mtime */
>> +#define XSTAT_REQUEST_CTIME            0x00000080ULL   /* want/got st_ctime */
>> +#define XSTAT_REQUEST_INO              0x00000100ULL   /* want/got st_ino */
>> +#define XSTAT_REQUEST_SIZE             0x00000200ULL   /* want/got st_size */
>> +#define XSTAT_REQUEST_BLOCKS           0x00000400ULL   /* want/got st_blocks */
>> +#define XSTAT_REQUEST__BASIC_STATS     0x000007ffULL   /* the stuff in the normal stat struct */
>> +#define XSTAT_REQUEST_BTIME            0x00000800ULL   /* want/got st_btime */
>> +#define XSTAT_REQUEST_GEN              0x00001000ULL   /* want/got st_gen */
>> +#define XSTAT_REQUEST_DATA_VERSION     0x00002000ULL   /* want/got st_data_version */
>> +#define XSTAT_REQUEST__EXTENDED_STATS  0x00003fffULL   /* the stuff in the xstat struct */
>> +#define XSTAT_REQUEST__ALL_STATS       0x00003fffULL   /* the defined set of requestables */
>> +};
>> +
>> +struct xstat_dev {
>> +       unsigned int            major, minor;
>> +};
>> +
>> +struct xstat_time {
>> +       unsigned long long      tv_sec, tv_nsec;
>> +};
>> +
>> +struct xstat {
>> +       unsigned int            st_mode;        /* file mode */
>> +       unsigned int            st_nlink;       /* number of hard links */
>> +       unsigned int            st_uid;         /* user ID of owner */
>> +       unsigned int            st_gid;         /* group ID of owner */
>> +       struct xstat_dev        st_rdev;        /* device ID of special file */
>> +       struct xstat_dev        st_dev;         /* ID of device containing file */
>> +       struct xstat_time       st_atime;       /* last access time */
>> +       struct xstat_time       st_mtime;       /* last data modification time */
>> +       struct xstat_time       st_ctime;       /* last attribute change time */
>> +       struct xstat_time       st_btime;       /* file creation time */
>> +       unsigned long long      st_ino;         /* inode number */
>> +       unsigned long long      st_size;        /* file size */
>> +       unsigned long long      st_blksize;     /* block size for filesystem I/O */
>> +       unsigned long long      st_blocks;      /* number of 512-byte blocks allocated */
>> +       unsigned long long      st_gen;         /* inode generation number */
>> +       unsigned long long      st_data_version; /* data version number */
>> +       unsigned long long      st_result_mask; /* what requests were written */
>> +       unsigned long long      st_extra_results[0]; /* extra requested results */
>> +};
>> +
>>  #ifdef __KERNEL__
>>  #define S_IRWXUGO      (S_IRWXU|S_IRWXG|S_IRWXO)
>>  #define S_IALLUGO      (S_ISUID|S_ISGID|S_ISVTX|S_IRWXUGO)
>> @@ -67,14 +160,20 @@ struct kstat {
>>        uid_t           uid;
>>        gid_t           gid;
>>        dev_t           rdev;
>> +       unsigned int    query_flags;            /* operational flags */
>> +#define KSTAT_QUERY_FLAGS (AT_FORCE_ATTR_SYNC)
>>        loff_t          size;
>> -       struct timespec  atime;
>> +       struct timespec atime;
>>        struct timespec mtime;
>>        struct timespec ctime;
>> +       struct timespec btime;                  /* file creation time */
>>        unsigned long   blksize;
>>        unsigned long long      blocks;
>> +       u64             request_mask;           /* what fields the user asked for */
>> +       u64             result_mask;            /* what fields the user got */
>> +       u64             gen;                    /* inode generation */
>> +       u64             data_version;
>>  };
>>
>>  #endif
>> -
>>  #endif
>> diff --git a/include/linux/syscalls.h b/include/linux/syscalls.h
>> index 8812a63..5d68b4c 100644
>> --- a/include/linux/syscalls.h
>> +++ b/include/linux/syscalls.h
>> @@ -44,6 +44,8 @@ struct shmid_ds;
>>  struct sockaddr;
>>  struct stat;
>>  struct stat64;
>> +struct xstat_parameters;
>> +struct xstat;
>>  struct statfs;
>>  struct statfs64;
>>  struct __sysctl_args;
>> @@ -824,4 +826,11 @@ asmlinkage long sys_mmap_pgoff(unsigned long addr, unsigned long len,
>>                        unsigned long fd, unsigned long pgoff);
>>  asmlinkage long sys_old_mmap(struct mmap_arg_struct __user *arg);
>>
>> +asmlinkage long sys_xstat(int, const char __user *, unsigned,
>> +                         struct xstat_parameters __user *,
>> +                         struct xstat __user *, size_t);
>> +asmlinkage long sys_fxstat(unsigned, unsigned,
>> +                          struct xstat_parameters __user *,
>> +                          struct xstat __user *, size_t);
>> +
>>  #endif
>>
>> --
>> To unsubscribe from this list: send the line "unsubscribe linux-fsdevel" in
>> the body of a message to majordomo@xxxxxxxxxxxxxxx
>> More majordomo info at  http://vger.kernel.org/majordomo-info.html
>>
>
>
>
> --
> Michael Kerrisk Linux man-pages maintainer;
> http://www.kernel.org/doc/man-pages/
> Author of "The Linux Programming Interface", http://blog.man7.org/
> --
> To unsubscribe from this list: send the line "unsubscribe linux-api" in
> the body of a message to majordomo@xxxxxxxxxxxxxxx
> More majordomo info at  http://vger.kernel.org/majordomo-info.html
>



-- 
Michael Kerrisk
Linux man-pages maintainer; http://www.kernel.org/doc/man-pages/
Author of "The Linux Programming Interface" http://blog.man7.org/
--
To unsubscribe from this list: send the line "unsubscribe linux-fsdevel" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at  http://vger.kernel.org/majordomo-info.html


[Index of Archives]     [Linux Ext4 Filesystem]     [Union Filesystem]     [Filesystem Testing]     [Ceph Users]     [Ecryptfs]     [AutoFS]     [Kernel Newbies]     [Share Photos]     [Security]     [Netfilter]     [Bugtraq]     [Yosemite News]     [MIPS Linux]     [ARM Linux]     [Linux Security]     [Linux Cachefs]     [Reiser Filesystem]     [Linux RAID]     [Samba]     [Device Mapper]     [CEPH Development]
  Powered by Linux