test-statx.c 6.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /* Test the statx() system call.
  3. *
  4. * Note that the output of this program is intended to look like the output of
  5. * /bin/stat where possible.
  6. *
  7. * Copyright (C) 2015 Red Hat, Inc. All Rights Reserved.
  8. * Written by David Howells (dhowells@redhat.com)
  9. */
  10. #define _GNU_SOURCE
  11. #define _ATFILE_SOURCE
  12. #include <stdio.h>
  13. #include <stdlib.h>
  14. #include <string.h>
  15. #include <unistd.h>
  16. #include <ctype.h>
  17. #include <errno.h>
  18. #include <time.h>
  19. #include <sys/syscall.h>
  20. #include <sys/types.h>
  21. #include <linux/stat.h>
  22. #include <linux/fcntl.h>
  23. #define statx foo
  24. #define statx_timestamp foo_timestamp
  25. struct statx;
  26. struct statx_timestamp;
  27. #include <sys/stat.h>
  28. #undef statx
  29. #undef statx_timestamp
  30. #define AT_STATX_SYNC_TYPE 0x6000
  31. #define AT_STATX_SYNC_AS_STAT 0x0000
  32. #define AT_STATX_FORCE_SYNC 0x2000
  33. #define AT_STATX_DONT_SYNC 0x4000
  34. #ifndef __NR_statx
  35. #define __NR_statx -1
  36. #endif
  37. static __attribute__((unused))
  38. ssize_t statx(int dfd, const char *filename, unsigned flags,
  39. unsigned int mask, struct statx *buffer)
  40. {
  41. return syscall(__NR_statx, dfd, filename, flags, mask, buffer);
  42. }
  43. static void print_time(const char *field, struct statx_timestamp *ts)
  44. {
  45. struct tm tm;
  46. time_t tim;
  47. char buffer[100];
  48. int len;
  49. tim = ts->tv_sec;
  50. if (!localtime_r(&tim, &tm)) {
  51. perror("localtime_r");
  52. exit(1);
  53. }
  54. len = strftime(buffer, 100, "%F %T", &tm);
  55. if (len == 0) {
  56. perror("strftime");
  57. exit(1);
  58. }
  59. printf("%s", field);
  60. fwrite(buffer, 1, len, stdout);
  61. printf(".%09u", ts->tv_nsec);
  62. len = strftime(buffer, 100, "%z", &tm);
  63. if (len == 0) {
  64. perror("strftime2");
  65. exit(1);
  66. }
  67. fwrite(buffer, 1, len, stdout);
  68. printf("\n");
  69. }
  70. static void dump_statx(struct statx *stx)
  71. {
  72. char buffer[256], ft = '?';
  73. printf("results=%x\n", stx->stx_mask);
  74. printf(" ");
  75. if (stx->stx_mask & STATX_SIZE)
  76. printf(" Size: %-15llu", (unsigned long long)stx->stx_size);
  77. if (stx->stx_mask & STATX_BLOCKS)
  78. printf(" Blocks: %-10llu", (unsigned long long)stx->stx_blocks);
  79. printf(" IO Block: %-6llu", (unsigned long long)stx->stx_blksize);
  80. if (stx->stx_mask & STATX_TYPE) {
  81. switch (stx->stx_mode & S_IFMT) {
  82. case S_IFIFO: printf(" FIFO\n"); ft = 'p'; break;
  83. case S_IFCHR: printf(" character special file\n"); ft = 'c'; break;
  84. case S_IFDIR: printf(" directory\n"); ft = 'd'; break;
  85. case S_IFBLK: printf(" block special file\n"); ft = 'b'; break;
  86. case S_IFREG: printf(" regular file\n"); ft = '-'; break;
  87. case S_IFLNK: printf(" symbolic link\n"); ft = 'l'; break;
  88. case S_IFSOCK: printf(" socket\n"); ft = 's'; break;
  89. default:
  90. printf(" unknown type (%o)\n", stx->stx_mode & S_IFMT);
  91. break;
  92. }
  93. } else {
  94. printf(" no type\n");
  95. }
  96. sprintf(buffer, "%02x:%02x", stx->stx_dev_major, stx->stx_dev_minor);
  97. printf("Device: %-15s", buffer);
  98. if (stx->stx_mask & STATX_INO)
  99. printf(" Inode: %-11llu", (unsigned long long) stx->stx_ino);
  100. if (stx->stx_mask & STATX_NLINK)
  101. printf(" Links: %-5u", stx->stx_nlink);
  102. if (stx->stx_mask & STATX_TYPE) {
  103. switch (stx->stx_mode & S_IFMT) {
  104. case S_IFBLK:
  105. case S_IFCHR:
  106. printf(" Device type: %u,%u",
  107. stx->stx_rdev_major, stx->stx_rdev_minor);
  108. break;
  109. }
  110. }
  111. printf("\n");
  112. if (stx->stx_mask & STATX_MODE)
  113. printf("Access: (%04o/%c%c%c%c%c%c%c%c%c%c) ",
  114. stx->stx_mode & 07777,
  115. ft,
  116. stx->stx_mode & S_IRUSR ? 'r' : '-',
  117. stx->stx_mode & S_IWUSR ? 'w' : '-',
  118. stx->stx_mode & S_IXUSR ? 'x' : '-',
  119. stx->stx_mode & S_IRGRP ? 'r' : '-',
  120. stx->stx_mode & S_IWGRP ? 'w' : '-',
  121. stx->stx_mode & S_IXGRP ? 'x' : '-',
  122. stx->stx_mode & S_IROTH ? 'r' : '-',
  123. stx->stx_mode & S_IWOTH ? 'w' : '-',
  124. stx->stx_mode & S_IXOTH ? 'x' : '-');
  125. if (stx->stx_mask & STATX_UID)
  126. printf("Uid: %5d ", stx->stx_uid);
  127. if (stx->stx_mask & STATX_GID)
  128. printf("Gid: %5d\n", stx->stx_gid);
  129. if (stx->stx_mask & STATX_ATIME)
  130. print_time("Access: ", &stx->stx_atime);
  131. if (stx->stx_mask & STATX_MTIME)
  132. print_time("Modify: ", &stx->stx_mtime);
  133. if (stx->stx_mask & STATX_CTIME)
  134. print_time("Change: ", &stx->stx_ctime);
  135. if (stx->stx_mask & STATX_BTIME)
  136. print_time(" Birth: ", &stx->stx_btime);
  137. if (stx->stx_attributes_mask) {
  138. unsigned char bits, mbits;
  139. int loop, byte;
  140. static char attr_representation[64 + 1] =
  141. /* STATX_ATTR_ flags: */
  142. "????????" /* 63-56 */
  143. "????????" /* 55-48 */
  144. "????????" /* 47-40 */
  145. "????????" /* 39-32 */
  146. "????????" /* 31-24 0x00000000-ff000000 */
  147. "????????" /* 23-16 0x00000000-00ff0000 */
  148. "???me???" /* 15- 8 0x00000000-0000ff00 */
  149. "?dai?c??" /* 7- 0 0x00000000-000000ff */
  150. ;
  151. printf("Attributes: %016llx (",
  152. (unsigned long long)stx->stx_attributes);
  153. for (byte = 64 - 8; byte >= 0; byte -= 8) {
  154. bits = stx->stx_attributes >> byte;
  155. mbits = stx->stx_attributes_mask >> byte;
  156. for (loop = 7; loop >= 0; loop--) {
  157. int bit = byte + loop;
  158. if (!(mbits & 0x80))
  159. putchar('.'); /* Not supported */
  160. else if (bits & 0x80)
  161. putchar(attr_representation[63 - bit]);
  162. else
  163. putchar('-'); /* Not set */
  164. bits <<= 1;
  165. mbits <<= 1;
  166. }
  167. if (byte)
  168. putchar(' ');
  169. }
  170. printf(")\n");
  171. }
  172. }
  173. static void dump_hex(unsigned long long *data, int from, int to)
  174. {
  175. unsigned offset, print_offset = 1, col = 0;
  176. from /= 8;
  177. to = (to + 7) / 8;
  178. for (offset = from; offset < to; offset++) {
  179. if (print_offset) {
  180. printf("%04x: ", offset * 8);
  181. print_offset = 0;
  182. }
  183. printf("%016llx", data[offset]);
  184. col++;
  185. if ((col & 3) == 0) {
  186. printf("\n");
  187. print_offset = 1;
  188. } else {
  189. printf(" ");
  190. }
  191. }
  192. if (!print_offset)
  193. printf("\n");
  194. }
  195. int main(int argc, char **argv)
  196. {
  197. struct statx stx;
  198. int ret, raw = 0, atflag = AT_SYMLINK_NOFOLLOW;
  199. unsigned int mask = STATX_BASIC_STATS | STATX_BTIME;
  200. for (argv++; *argv; argv++) {
  201. if (strcmp(*argv, "-F") == 0) {
  202. atflag &= ~AT_STATX_SYNC_TYPE;
  203. atflag |= AT_STATX_FORCE_SYNC;
  204. continue;
  205. }
  206. if (strcmp(*argv, "-D") == 0) {
  207. atflag &= ~AT_STATX_SYNC_TYPE;
  208. atflag |= AT_STATX_DONT_SYNC;
  209. continue;
  210. }
  211. if (strcmp(*argv, "-L") == 0) {
  212. atflag &= ~AT_SYMLINK_NOFOLLOW;
  213. continue;
  214. }
  215. if (strcmp(*argv, "-O") == 0) {
  216. mask &= ~STATX_BASIC_STATS;
  217. continue;
  218. }
  219. if (strcmp(*argv, "-A") == 0) {
  220. atflag |= AT_NO_AUTOMOUNT;
  221. continue;
  222. }
  223. if (strcmp(*argv, "-R") == 0) {
  224. raw = 1;
  225. continue;
  226. }
  227. memset(&stx, 0xbf, sizeof(stx));
  228. ret = statx(AT_FDCWD, *argv, atflag, mask, &stx);
  229. printf("statx(%s) = %d\n", *argv, ret);
  230. if (ret < 0) {
  231. perror(*argv);
  232. exit(1);
  233. }
  234. if (raw)
  235. dump_hex((unsigned long long *)&stx, 0, sizeof(stx));
  236. dump_statx(&stx);
  237. }
  238. return 0;
  239. }