logo

utils-std

Collection of commonly available Unix tools git clone https://anongit.hacktivis.me/git/utils-std.git/

df.c (11818B)

    

  1. // utils-std: Collection of commonly available Unix tools
  2. // SPDX-FileCopyrightText: 2017 Haelwenn (lanodan) Monnier <contact+utils@hacktivis.me>
  3. // SPDX-License-Identifier: MPL-2.0
  5. #define _POSIX_C_SOURCE 202405L
  6. #define _DEFAULT_SOURCE // mntent in glibc 2.19+
  8. #include "../config.h"
  9. #include "../lib/reallocarray.h"
  10. #include "../libutils/getopt_nolong.h"
  11. #include "../libutils/humanize.h"
  13. #include <ctype.h> // iscntrl, isspace
  14. #include <errno.h> // errno
  15. #include <mntent.h>
  16. #include <stdbool.h>
  17. #include <stdint.h>
  18. #include <stdio.h>    // printf
  19. #include <stdlib.h>   // abort, exit
  20. #include <string.h>   // strerror
  21. #include <sys/stat.h> // stat, dev_t
  22. #include <sys/statvfs.h>
  23. #include <unistd.h> // getopt
  24. #ifdef HAS_GETOPT_LONG
  25. #include <getopt.h>
  26. #endif
  28. #define STR(s) #s
  30. /*
  31.  * Rough idea of builtin filesystems in Linux 6.12.31:
  32.  * $ grep -RI '\bregister_filesystem(' /usr/src/linux/fs/ | wc -l
  33.  * 79
  34.  */
  35. #define DF_MNT_TYPE_MAX 128
  37. // Grabbed from OpenRC rc-functions.sh
  38. // clang-format off
  39. static const char *net_fs_list[] = {
  40. 	"afs", "ceph", "cifs", "coda", "davfs", "fuse", "fuse.glusterfs",
  41. 	"fuse.sshfs", "gfs", "glusterfs", "lustre", "ncpfs", "nfs", "nfs4",
  42. 	"ocfs2", "shfs", "smbfs"
  43. };
  44. // clang-format on
  46. blksize_t forced_bsize = 0;
  47. const char *argv0 = "df";
  49. // Replaces control characters and whitespaces with '?' in-place (no allocation)
  50. static void
  51. static_escape(char *str)
  52. {
  53. 	for(size_t i = 0; i < strlen(str); i++)
  54. 		if(iscntrl(str[i]) || isspace(str[i])) str[i] = '?';
  55. }
  57. int
  58. main(int argc, char *argv[])
  59. {
  60. 	bool opt_P = false, opt_h = false, opt_a = false, opt_T = false, opt_l = false, opt_i = false;
  61. 	int fs_col_width = 20;
  62. 	dev_t *devices = NULL;
  64. 	size_t excluded_count = 0;
  65. 	static char *excluded[DF_MNT_TYPE_MAX];
  67. 	size_t only_count = 0;
  68. 	static char *only[DF_MNT_TYPE_MAX];
  70. #ifdef HAS_GETOPT_LONG
  71. 	// Strictly for GNUisms compatibility so no long-only options
  72. 	// clang-format off
  73. 	static struct option opts[] = {
  74. 		{"all", no_argument, NULL, 'a'},
  75. 		{"human-readable", no_argument, NULL, 'h'},
  76. 		{"inodes", no_argument, NULL, 'i'},
  77. 		{"local", no_argument, NULL, 'l'},
  78. 		{"portability", no_argument, NULL, 'P'},
  79. 		{"type", required_argument, NULL, 't'},
  80. 		{"exclude-type", required_argument, NULL, 'x'},
  81. 		{0, 0, 0, 0},
  82. 	};
  83. 	// clang-format on
  85. 	// Need + as first character to get POSIX-style option parsing
  86. 	for(int c = -1; (c = getopt_long(argc, argv, "+:ahilPkTt:x:", opts, NULL)) != -1;)
  87. #else
  88. 	for(int c = -1; (c = getopt_nolong(argc, argv, ":ahilPkTt:x:")) != -1;)
  89. #endif
  90. 	{
  91. 		switch(c)
  92. 		{
  93. 		case 'a':
  94. 			opt_a = true;
  95. 			break;
  96. 		case 'P':
  97. 			if(forced_bsize == 0) forced_bsize = 512;
  99. 			opt_P = true;
  100. 			break;
  101. 		case 'k':
  102. 			forced_bsize = 1024;
  103. 			break;
  104. 		case 'h':
  105. 			opt_h = true;
  106. 			fs_col_width = 30;
  107. 			break;
  108. 		case 'i':
  109. 			opt_i = true;
  110. 			break;
  111. 		case 'l':
  112. 			opt_l = true;
  113. 			break;
  114. 		case 'T':
  115. 			opt_T = true;
  116. 			break;
  117. 		case 't':
  118. 			if(only_count >= (DF_MNT_TYPE_MAX - 1))
  119. 			{
  120. 				fprintf(
  121. 				    stderr,
  122. 				    "%s: error: Can only select up to " STR(DF_MNT_TYPE_MAX) " mnt_types via option `-t`\n",
  123. 				    argv0);
  124. 				return 1;
  125. 			}
  127. 			only[only_count++] = optarg;
  128. 			break;
  129. 		case 'x':
  130. 			if(excluded_count >= (DF_MNT_TYPE_MAX - 1))
  131. 			{
  132. 				fprintf(
  133. 				    stderr,
  134. 				    "%s: error: Can only select up to " STR(DF_MNT_TYPE_MAX) " mnt_types via option `-x`\n",
  135. 				    argv0);
  136. 				return 1;
  137. 			}
  139. 			excluded[excluded_count++] = optarg;
  140. 			break;
  141. 		case ':':
  142. 			fprintf(stderr, "%s: error: Missing operand for option: '-%c'\n", argv0, optopt);
  143. 			return 1;
  144. 		case '?':
  145. 			GETOPT_UNKNOWN_OPT
  146. 			return 1;
  147. 		}
  148. 	}
  150. 	if(opt_P && opt_T)
  151. 	{
  152. 		fprintf(stderr, "%s: error: Options -P and -T are incompatible\n", argv0);
  153. 		return 1;
  154. 	}
  156. 	if(opt_P) opt_h = false;
  158. 	argc -= optind;
  159. 	argv += optind;
  161. 	int args_left = argc != 0 ? argc : 1;
  163. 	bool tty_out = isatty(1);
  164. 	int col_width = tty_out ? 10 : 0;
  166. 	if(!tty_out)
  167. 	{
  168. 		errno = 0;
  169. 		fs_col_width = 0;
  170. 	}
  172. 	dev_t *arg_devs = NULL;
  174. 	if(argc > 0)
  175. 	{
  176. 		arg_devs = calloc(argc, sizeof(dev_t));
  177. 		if(arg_devs == NULL)
  178. 		{
  179. 			fprintf(stderr, "%s: error: Failed to allocate arg_devs array: %s\n", argv0, strerror(errno));
  180. 			return 1;
  181. 		}
  182. 	}
  184. 	for(int i = 0; i < argc; i++)
  185. 	{
  186. 		struct stat file_stats;
  187. 		if(stat(argv[i], &file_stats) != 0)
  188. 		{
  189. 			fprintf(stderr,
  190. 			        "%s: error: Failed getting status for file '%s': %s\n",
  191. 			        argv0,
  192. 			        argv[i],
  193. 			        strerror(errno));
  194. 			goto error;
  195. 		}
  197. 		arg_devs[i] = file_stats.st_dev;
  198. 	}
  200. 	// Begin: Print header
  202. 	printf("%-*s ", fs_col_width, "Filesystem");
  204. 	if(opt_T) printf("%*s ", col_width, "Type");
  206. 	if(opt_i)
  207. 	{
  208. 		printf("%*s %*s %*s ", col_width, "Inodes", col_width, "Iused", col_width, "IFree");
  210. 		if(opt_P)
  211. 			printf("IUse%% Mounted on\n");
  212. 		else
  213. 			printf("IUse%% Mountpoint\n");
  214. 	}
  215. 	else
  216. 	{
  217. 		// cast to (long int) as POSIX.1-2024 defines blksize_t as signed
  218. 		// integer no longer than `long`
  219. 		if(forced_bsize != 0)
  220. 			printf("%ld-blocks ", (long int)forced_bsize);
  221. 		else
  222. 			printf("%*s ", col_width, "Total");
  224. 		printf("%*s %*s ", col_width, "Used", col_width, "Available");
  226. 		if(opt_P)
  227. 			printf("Capacity Mounted on\n");
  228. 		else
  229. 			printf("Use%% Mountpoint\n");
  230. 	}
  231. 	// End: Print header
  233. 	FILE *mounted = setmntent(MOUNTED, "r");
  234. 	if(mounted == NULL)
  235. 	{
  236. 		fprintf(stderr,
  237. 		        "%s: error: Failed opening setmntent(\"" MOUNTED "\", \"r\"): %s\n",
  238. 		        argv0,
  239. 		        strerror(errno));
  240. 		goto error;
  241. 	}
  243. 	// Linux has a configurable limit of maximum mounts which defaults to 100_000
  244. 	// See /proc/sys/fs/mount-max introduced in Linux 4.9 for CVE-2016-6213
  245. 	// https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=d29216842a85c7970c536108e093963f02714498
  246. 	//
  247. 	// Which is way too much to be either stack-allocated or statically allocated:
  248. 	// 100000*sizeof(dev_t) = 100000*8 bytes ≈ 781.25 KiB
  249. 	// So reallocarray to the rescue
  250. 	size_t devices_found = 0;
  251. 	size_t devices_len = 100;
  252. 	devices = reallocarray(NULL, devices_len, sizeof(dev_t));
  253. 	if(!devices)
  254. 	{
  255. 		fprintf(stderr,
  256. 		        "%s: error: Failed to allocate memory for storing (%zd) devices: %s\n",
  257. 		        argv0,
  258. 		        devices_len,
  259. 		        strerror(errno));
  260. 		goto error;
  261. 	}
  263. 	// Even with argc>0 we still need to go over mntent for the filesystem mountpoint and type
  264. 	while(args_left > 0)
  265. 	{
  266. 		struct mntent *mntent = getmntent(mounted);
  267. 		if(mntent == NULL) break;
  269. 		if(excluded_count > 0)
  270. 		{
  271. 			bool exclude = false;
  273. 			for(size_t i = 0; i < excluded_count; i++)
  274. 				if(strcmp(excluded[i], mntent->mnt_type) == 0)
  275. 				{
  276. 					exclude = true;
  277. 					break;
  278. 				}
  280. 			if(exclude) continue;
  281. 		}
  283. 		if(only_count > 0)
  284. 		{
  285. 			bool include = false;
  287. 			for(size_t i = 0; i < only_count; i++)
  288. 				if(strcmp(only[i], mntent->mnt_type) == 0)
  289. 				{
  290. 					include = true;
  291. 					break;
  292. 				}
  294. 			if(!include) continue;
  295. 		}
  297. 		if(opt_l)
  298. 		{
  299. 			bool remote = false;
  301. 			for(size_t i = 0; i < sizeof(net_fs_list) / sizeof(char *); i++)
  302. 				if(strcmp(net_fs_list[i], mntent->mnt_type) == 0)
  303. 				{
  304. 					remote = true;
  305. 					break;
  306. 				}
  308. 			if(remote) continue;
  309. 		}
  311. 		struct stat file_stats;
  312. 		if(!opt_a || argc > 0)
  313. 		{
  314. 			if(stat(mntent->mnt_dir, &file_stats) != 0)
  315. 			{
  316. 				fprintf(stderr,
  317. 				        "%s: warning: Failed getting status for file '%s': %s\n",
  318. 				        argv0,
  319. 				        mntent->mnt_dir,
  320. 				        strerror(errno));
  321. 				errno = 0;
  322. 			}
  323. 		}
  325. 		if(argc > 0)
  326. 		{
  327. 			bool found = false;
  328. 			for(int i = 0; i < argc; i++)
  329. 				if(arg_devs[i] == file_stats.st_dev)
  330. 				{
  331. 					found = true;
  332. 					break;
  333. 				}
  335. 			if(!found) continue;
  337. 			args_left--;
  338. 		}
  340. 		if(!opt_a)
  341. 		{
  342. 			bool dupe = false;
  343. 			for(size_t i = 0; i < devices_found; i++)
  344. 				if(devices[i] == file_stats.st_dev)
  345. 				{
  346. 					dupe = true;
  347. 					break;
  348. 				}
  350. 			if(dupe) continue;
  352. 			if(devices_found + 1 >= devices_len)
  353. 			{
  354. 				devices_len *= 2;
  355. 				if(devices_len <= 0) abort();
  357. 				devices = reallocarray(devices, devices_len, sizeof(dev_t));
  359. 				if(!devices)
  360. 				{
  361. 					fprintf(stderr,
  362. 					        "%s: error: Failed to allocate memory for storing (%zd) devices: %s\n",
  363. 					        argv0,
  364. 					        devices_len,
  365. 					        strerror(errno));
  366. 					goto error;
  367. 				}
  368. 			}
  370. 			devices[devices_found++] = file_stats.st_dev;
  371. 		}
  373. 		// Note: musl prior to 1.2.5 has broken getmntent when octal sequences and carriage return is used
  374. 		// https://git.musl-libc.org/cgit/musl/commit/src/misc/mntent.c?id=f314e133929b6379eccc632bef32eaebb66a7335
  375. 		// https://git.musl-libc.org/cgit/musl/commit/src/misc/mntent.c?id=ee1d39bc1573c1ae49ee6b658938b56bbef95a6c
  376. 		struct statvfs stats;
  377. 		if(statvfs(mntent->mnt_dir, &stats) != 0)
  378. 		{
  379. 			fprintf(stderr,
  380. 			        "%s: warning: Failed getting statistics for filesystem '%s': %s\n",
  381. 			        argv0,
  382. 			        mntent->mnt_dir,
  383. 			        strerror(errno));
  384. 			errno = 0;
  386. 			static_escape(mntent->mnt_fsname);
  387. 			static_escape(mntent->mnt_dir);
  389. 			if(opt_a)
  390. 			{
  391. 				printf("%-*s ", fs_col_width, mntent->mnt_fsname);
  393. 				if(opt_T) printf("%*s ", col_width, mntent->mnt_type);
  395. 				printf("%*s ", col_width, "-");       // total
  396. 				printf("%*s ", col_width, "-");       // used
  397. 				printf("%*s ", col_width, "-");       // free
  398. 				printf("%*s ", tty_out ? 3 : 0, "-"); // percent
  399. 				printf("%s\n", mntent->mnt_dir);
  400. 			}
  402. 			continue;
  403. 		}
  405. 		// Skip null filesystems
  406. 		if(!opt_a && stats.f_blocks == 0) continue;
  408. 		// Needs to be done after calling statvfs(3) and stat(3)
  409. 		static_escape(mntent->mnt_fsname);
  410. 		static_escape(mntent->mnt_dir);
  412. 		printf("%-*s ", fs_col_width, mntent->mnt_fsname);
  414. 		if(opt_T) printf("%*s ", col_width, mntent->mnt_type);
  416. 		if(opt_i)
  417. 		{
  418. 			intmax_t used = stats.f_files - stats.f_ffree;
  419. 			intmax_t percent = (used / stats.f_files) * 100;
  421. 			if(opt_h && !opt_P)
  422. 			{
  423. 				struct si_scale total_scl = dtosi(stats.f_files, false);
  424. 				struct si_scale used_scl = dtosi(used, false);
  425. 				struct si_scale free_scl = dtosi(stats.f_ffree, false);
  427. 				int width_num = tty_out ? col_width - 1 : 0;
  428. 				int width_pre = tty_out ? 1 : 0;
  430. 				printf("%*.2f%-*s ", width_num, total_scl.number, width_pre, total_scl.prefix);
  431. 				printf("%*.2f%-*s ", width_num, used_scl.number, width_pre, used_scl.prefix);
  432. 				printf("%*.2f%-*s ", width_num, free_scl.number, width_pre, free_scl.prefix);
  433. 			}
  434. 			else
  435. 			{
  436. 				printf("%*jd ", col_width, (intmax_t)stats.f_files);
  437. 				printf("%*jd ", col_width, used);
  438. 				printf("%*jd ", col_width, (intmax_t)stats.f_ffree);
  439. 			}
  441. 			printf("%*jd%% ", tty_out ? 4 : 0, percent);
  442. 			printf("%s\n", mntent->mnt_dir);
  444. 			continue;
  445. 		}
  447. 		intmax_t percent = 0;
  448. 		intmax_t total = stats.f_frsize * (stats.f_blocks != 0 ? stats.f_blocks : 1);
  449. 		intmax_t free = stats.f_bfree * (stats.f_bsize != 0 ? stats.f_bsize : 1);
  450. 		intmax_t used = total - free;
  452. 		if(used + free)
  453. 		{
  454. 			percent = (used * 100) / (used + free);
  455. 			if(used * 100 != percent * (used + free)) percent++;
  456. 		}
  458. 		if(forced_bsize != 0)
  459. 		{
  460. 			total /= forced_bsize;
  461. 			free /= forced_bsize;
  462. 			used /= forced_bsize;
  463. 		}
  465. 		if(opt_h && !opt_P)
  466. 		{
  467. 			struct si_scale total_scl = dtosi(total, true);
  468. 			struct si_scale used_scl = dtosi(used, true);
  469. 			struct si_scale free_scl = dtosi(free, true);
  471. 			int width_num = tty_out ? col_width - 3 : 0;
  472. 			int width_pre = tty_out ? 3 : 0;
  474. 			printf("%*.2f%-*s ", width_num, total_scl.number, width_pre, total_scl.prefix);
  475. 			printf("%*.2f%-*s ", width_num, used_scl.number, width_pre, used_scl.prefix);
  476. 			printf("%*.2f%-*s ", width_num, free_scl.number, width_pre, free_scl.prefix);
  477. 		}
  478. 		else
  479. 		{
  480. 			printf("%*jd ", col_width, total);
  481. 			printf("%*jd ", col_width, used);
  482. 			printf("%*jd ", col_width, free);
  483. 		}
  485. 		printf("%*jd%% ", tty_out ? 3 : 0, percent);
  486. 		printf("%s\n", mntent->mnt_dir);
  487. 	}
  489. 	endmntent(mounted);
  491. 	free(devices);
  492. 	free(arg_devs);
  494. 	return 0;
  496. error:
  497. 	free(devices);
  498. 	free(arg_devs);
  500. 	return 1;
  501. }