/* Test the statx() system call. * * Note that the output of this program is intended to look like the output of * /bin/stat where possible. * * 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_STATX_SYNC_TYPE 0x6000 #define AT_STATX_SYNC_AS_STAT 0x0000 #define AT_STATX_FORCE_SYNC 0x2000 #define AT_STATX_DONT_SYNC 0x4000 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, struct statx_timestamp *ts) { struct tm tm; time_t tim; char buffer[100]; int len; tim = ts->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", ts->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->stx_mask); printf(" "); if (stx->stx_mask & STATX_SIZE) printf(" Size: %-15llu", (unsigned long long)stx->stx_size); if (stx->stx_mask & STATX_BLOCKS) printf(" Blocks: %-10llu", (unsigned long long)stx->stx_blocks); printf(" IO Block: %-6llu", (unsigned long long)stx->stx_blksize); if (stx->stx_mask & STATX_TYPE) { switch (stx->stx_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->stx_mode & S_IFMT); break; } } else { printf(" no type\n"); } sprintf(buffer, "%02x:%02x", stx->stx_dev_major, stx->stx_dev_minor); printf("Device: %-15s", buffer); if (stx->stx_mask & STATX_INO) printf(" Inode: %-11llu", (unsigned long long) stx->stx_ino); if (stx->stx_mask & STATX_NLINK) printf(" Links: %-5u", stx->stx_nlink); if (stx->stx_mask & STATX_TYPE) { switch (stx->stx_mode & S_IFMT) { case S_IFBLK: case S_IFCHR: printf(" Device type: %u,%u", stx->stx_rdev_major, stx->stx_rdev_minor); break; } } printf("\n"); if (stx->stx_mask & STATX_MODE) printf("Access: (%04o/%c%c%c%c%c%c%c%c%c%c) ", stx->stx_mode & 07777, ft, stx->stx_mode & S_IRUSR ? 'r' : '-', stx->stx_mode & S_IWUSR ? 'w' : '-', stx->stx_mode & S_IXUSR ? 'x' : '-', stx->stx_mode & S_IRGRP ? 'r' : '-', stx->stx_mode & S_IWGRP ? 'w' : '-', stx->stx_mode & S_IXGRP ? 'x' : '-', stx->stx_mode & S_IROTH ? 'r' : '-', stx->stx_mode & S_IWOTH ? 'w' : '-', stx->stx_mode & S_IXOTH ? 'x' : '-'); if (stx->stx_mask & STATX_UID) printf("Uid: %5d ", stx->stx_uid); if (stx->stx_mask & STATX_GID) printf("Gid: %5d\n", stx->stx_gid); if (stx->stx_mask & STATX_ATIME) print_time("Access: ", &stx->stx_atime); if (stx->stx_mask & STATX_MTIME) print_time("Modify: ", &stx->stx_mtime); if (stx->stx_mask & STATX_CTIME) print_time("Change: ", &stx->stx_ctime); if (stx->stx_mask & STATX_BTIME) print_time(" Birth: ", &stx->stx_btime); if (stx->stx_attributes_mask) { unsigned char bits, mbits; int loop, byte; static char attr_representation[64 + 1] = /* STATX_ATTR_ flags: */ "????????" /* 63-56 */ "????????" /* 55-48 */ "????????" /* 47-40 */ "????????" /* 39-32 */ "????????" /* 31-24 0x00000000-ff000000 */ "????????" /* 23-16 0x00000000-00ff0000 */ "???me???" /* 15- 8 0x00000000-0000ff00 */ "?dai?c??" /* 7- 0 0x00000000-000000ff */ ; printf("Attributes: %016llx (", stx->stx_attributes); for (byte = 64 - 8; byte >= 0; byte -= 8) { bits = stx->stx_attributes >> byte; mbits = stx->stx_attributes_mask >> byte; for (loop = 7; loop >= 0; loop--) { int bit = byte + loop; if (!(mbits & 0x80)) putchar('.'); /* Not supported */ else if (bits & 0x80) putchar(attr_representation[63 - bit]); else putchar('-'); /* Not set */ bits <<= 1; mbits <<= 1; } if (byte) putchar(' '); } printf(")\n"); } } 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; for (argv++; *argv; argv++) { if (strcmp(*argv, "-F") == 0) { atflag &= ~AT_STATX_SYNC_TYPE; atflag |= AT_STATX_FORCE_SYNC; continue; } if (strcmp(*argv, "-D") == 0) { atflag &= ~AT_STATX_SYNC_TYPE; atflag |= AT_STATX_DONT_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; }