[mirror_ubuntu-eoan-kernel.git] / samples / vfs / test-statx.c

// SPDX-License-Identifier: GPL-2.0-or-later
/* 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)
 */

#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>
#define statx foo
#define statx_timestamp foo_timestamp
#include <sys/stat.h>
#undef statx
#undef statx_timestamp

#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

#ifndef __NR_statx
#define __NR_statx -1
#endif

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