logo

utils-std

Collection of commonly available Unix tools

df.c (7915B)

    

  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 200809L
  6. #define _DEFAULT_SOURCE // mntent in glibc 2.19+
  8. #include "../lib/humanize.h"
  10. #include <assert.h>
  11. #include <ctype.h> // iscntrl, isspace
  12. #include <errno.h> // errno
  13. #include <mntent.h>
  14. #include <stdbool.h>
  15. #include <stdio.h>    // printf
  16. #include <stdlib.h>   // abort, exit
  17. #include <string.h>   // strerror
  18. #include <sys/stat.h> // stat, dev_t
  19. #include <sys/statvfs.h>
  20. #include <unistd.h> // getopt
  22. // Grabbed from OpenRC rc-functions.sh
  23. // clang-format off
  24. static const char *net_fs_list[] = {
  25. 	"afs", "ceph", "cifs", "coda", "davfs", "fuse", "fuse.glusterfs",
  26. 	"fuse.sshfs", "gfs", "glusterfs", "lustre", "ncpfs", "nfs", "nfs4",
  27. 	"ocfs2", "shfs", "smbfs"
  28. };
  29. // clang-format on
  31. blksize_t forced_bsize = 0;
  33. // Replaces control characters and whitespaces with '?' in-place (no allocation)
  34. static void
  35. static_escape(char *str)
  36. {
  37. 	for(size_t i = 0; i < strlen(str); i++)
  38. 		if(iscntrl(str[i]) || isspace(str[i])) str[i] = '?';
  39. }
  41. int
  42. main(int argc, char *argv[])
  43. {
  44. 	bool opt_P = false, opt_h = false, opt_a = false, opt_T = false, opt_l = false;
  45. 	int fs_col_width = 20;
  47. 	size_t excluded_count = 0;
  48. 	char *excluded[4096];
  50. 	size_t only_count = 0;
  51. 	char *only[4096];
  53. 	int c = EOF;
  54. 	while((c = getopt(argc, argv, ":ahlPkTt:x:")) != EOF)
  55. 	{
  56. 		switch(c)
  57. 		{
  58. 		case 'a':
  59. 			opt_a = true;
  60. 			break;
  61. 		case 'P':
  62. 			if(forced_bsize == 0) forced_bsize = 512;
  64. 			opt_P = true;
  65. 			break;
  66. 		case 'k':
  67. 			forced_bsize = 1024;
  68. 			break;
  69. 		case 'h':
  70. 			opt_h = true;
  71. 			fs_col_width = 30;
  72. 			break;
  73. 		case 'l':
  74. 			opt_l = true;
  75. 			break;
  76. 		case 'T':
  77. 			opt_T = true;
  78. 			break;
  79. 		case 't':
  80. 			only[only_count++] = optarg;
  81. 			break;
  82. 		case 'x':
  83. 			excluded[excluded_count++] = optarg;
  84. 			break;
  85. 		case ':':
  86. 			fprintf(stderr, "df: Error: Missing operand for option: '-%c'\n", optopt);
  87. 			return 1;
  88. 		case '?':
  89. 			fprintf(stderr, "df: Error: Unrecognised option: '-%c'\n", optopt);
  90. 			return 1;
  91. 		}
  92. 	}
  94. 	if(opt_P && opt_T)
  95. 	{
  96. 		fprintf(stderr, "df: Options -P and -T are incompatible\n");
  97. 		return 1;
  98. 	}
  100. 	if(opt_P) opt_h = false;
  102. 	argc -= optind;
  103. 	argv += optind;
  105. 	int args_left = argc != 0 ? argc : 1;
  107. 	bool tty_out = isatty(1);
  108. 	int col_width = tty_out ? 10 : 0;
  110. 	if(!tty_out)
  111. 	{
  112. 		errno = 0;
  113. 		fs_col_width = 0;
  114. 	}
  116. 	dev_t *arg_devs = NULL;
  118. 	if(argc > 0)
  119. 	{
  120. 		arg_devs = calloc(argc, sizeof(dev_t));
  121. 		if(arg_devs == NULL)
  122. 		{
  123. 			fprintf(stderr, "df: Failed to allocate arg_devs array: %s\n", strerror(errno));
  124. 			return 1;
  125. 		}
  126. 	}
  128. 	assert(errno == 0);
  130. 	for(int i = 0; i < argc; i++)
  131. 	{
  132. 		struct stat file_stats;
  133. 		if(stat(argv[i], &file_stats) != 0)
  134. 		{
  135. 			fprintf(stderr, "df: Error stat(\"%s\", _): %s\n", argv[i], strerror(errno));
  136. 			goto error;
  137. 		}
  139. 		arg_devs[i] = file_stats.st_dev;
  140. 	}
  142. 	// Begin: Print header
  144. 	printf("%-*s ", fs_col_width, "Filesystem");
  146. 	if(opt_T) printf("%*s ", col_width, "Type");
  148. 	if(forced_bsize != 0)
  149. 		printf("%zd-blocks ", forced_bsize);
  150. 	else
  151. 		printf("%*s ", col_width, "Total");
  153. 	printf("%*s %*s ", col_width, "Used", col_width, "Available");
  155. 	if(opt_P)
  156. 		printf("Capacity Mounted on\n");
  157. 	else
  158. 		printf("Use%% Mountpoint\n");
  160. 	// End: Print header
  162. 	assert(errno == 0);
  163. 	FILE *mounted = setmntent(MOUNTED, "r");
  164. 	if(mounted == NULL)
  165. 	{
  166. 		fprintf(stderr, "df: Error opening setmntent(\"" MOUNTED "\", \"r\"): %s", strerror(errno));
  167. 		goto error;
  168. 	}
  170. 	// FIXME: Fix maximum number of mount entries / devices
  171. 	dev_t devices[4096];
  172. 	size_t devices_found = 0;
  174. 	// Even with argc>0 we still need to go over mntent for the filesystem mountpoint and type
  175. 	while(args_left > 0)
  176. 	{
  177. 		struct mntent *mntent = getmntent(mounted);
  178. 		if(mntent == NULL) break;
  180. 		if(excluded_count > 0)
  181. 		{
  182. 			bool exclude = false;
  184. 			for(size_t i = 0; i < excluded_count; i++)
  185. 				if(strcmp(excluded[i], mntent->mnt_type) == 0)
  186. 				{
  187. 					exclude = true;
  188. 					break;
  189. 				}
  191. 			if(exclude) continue;
  192. 		}
  194. 		if(only_count > 0)
  195. 		{
  196. 			bool include = false;
  198. 			for(size_t i = 0; i < only_count; i++)
  199. 				if(strcmp(only[i], mntent->mnt_type) == 0)
  200. 				{
  201. 					include = true;
  202. 					break;
  203. 				}
  205. 			if(!include) continue;
  206. 		}
  208. 		if(opt_l)
  209. 		{
  210. 			bool remote = false;
  212. 			for(size_t i = 0; i < sizeof(net_fs_list) / sizeof(char *); i++)
  213. 				if(strcmp(net_fs_list[i], mntent->mnt_type) == 0)
  214. 				{
  215. 					remote = true;
  216. 					break;
  217. 				}
  219. 			if(remote) continue;
  220. 		}
  222. 		assert(errno == 0);
  223. 		struct stat file_stats;
  224. 		if(!opt_a || argc > 0)
  225. 		{
  226. 			if(stat(mntent->mnt_dir, &file_stats) != 0)
  227. 			{
  228. 				fprintf(stderr, "df: Warning stat(\"%s\", _): %s\n", mntent->mnt_dir, strerror(errno));
  229. 				errno = 0;
  230. 			}
  231. 		}
  233. 		if(argc > 0)
  234. 		{
  235. 			bool found = false;
  236. 			for(int i = 0; i < argc; i++)
  237. 				if(arg_devs[i] == file_stats.st_dev)
  238. 				{
  239. 					found = true;
  240. 					break;
  241. 				}
  243. 			if(!found) continue;
  245. 			args_left--;
  246. 		}
  248. 		if(!opt_a)
  249. 		{
  250. 			bool dupe = false;
  251. 			for(size_t i = 0; i < devices_found; i++)
  252. 				if(devices[i] == file_stats.st_dev)
  253. 				{
  254. 					dupe = true;
  255. 					break;
  256. 				}
  258. 			if(dupe) continue;
  260. 			if(devices_found >= 4096)
  261. 				fprintf(stderr,
  262. 				        "df: Warning: Reached maximum amount of devices which can be deduplicated\n");
  264. 			devices[devices_found++] = file_stats.st_dev;
  265. 		}
  267. 		// Note: musl prior to 1.2.5 has broken getmntent when octal sequences and carriage return is used
  268. 		// https://git.musl-libc.org/cgit/musl/commit/src/misc/mntent.c?id=f314e133929b6379eccc632bef32eaebb66a7335
  269. 		// https://git.musl-libc.org/cgit/musl/commit/src/misc/mntent.c?id=ee1d39bc1573c1ae49ee6b658938b56bbef95a6c
  270. 		assert(errno == 0);
  271. 		struct statvfs stats;
  272. 		if(statvfs(mntent->mnt_dir, &stats) != 0)
  273. 		{
  274. 			fprintf(stderr, "df: Warning: statvfs(\"%s\", _): %s\n", mntent->mnt_dir, strerror(errno));
  275. 			errno = 0;
  277. 			static_escape(mntent->mnt_fsname);
  278. 			static_escape(mntent->mnt_dir);
  280. 			if(opt_a)
  281. 			{
  282. 				printf("%-*s ", fs_col_width, mntent->mnt_fsname);
  284. 				if(opt_T) printf("%*s ", col_width, mntent->mnt_type);
  286. 				printf("%*s ", col_width, "-");       // total
  287. 				printf("%*s ", col_width, "-");       // used
  288. 				printf("%*s ", col_width, "-");       // free
  289. 				printf("%*s ", tty_out ? 3 : 0, "-"); // percent
  290. 				printf("%s\n", mntent->mnt_dir);
  291. 			}
  293. 			continue;
  294. 		}
  296. 		// Skip null filesystems
  297. 		if(!opt_a && stats.f_blocks == 0) continue;
  299. 		// Needs to be done after calling statvfs(3) and stat(3)
  300. 		static_escape(mntent->mnt_fsname);
  301. 		static_escape(mntent->mnt_dir);
  303. 		off_t percent = 0;
  304. 		off_t total = stats.f_frsize * (stats.f_blocks != 0 ? stats.f_blocks : 1);
  305. 		off_t free = stats.f_bfree * (stats.f_bsize != 0 ? stats.f_bsize : 1);
  306. 		off_t used = total - free;
  308. 		if(used + free)
  309. 		{
  310. 			percent = (used * 100) / (used + free);
  311. 			if(used * 100 != percent * (used + free)) percent++;
  312. 		}
  314. 		if(forced_bsize != 0)
  315. 		{
  316. 			total /= forced_bsize;
  317. 			free /= forced_bsize;
  318. 			used /= forced_bsize;
  319. 		}
  321. 		printf("%-*s ", fs_col_width, mntent->mnt_fsname);
  323. 		if(opt_T) printf("%*s ", col_width, mntent->mnt_type);
  325. 		if(opt_h && !opt_P)
  326. 		{
  327. 			struct si_scale total_scl = dtosi(total, true);
  328. 			struct si_scale used_scl = dtosi(used, true);
  329. 			struct si_scale free_scl = dtosi(free, true);
  331. 			int width_num = tty_out ? col_width - 3 : 0;
  332. 			int width_pre = tty_out ? 3 : 0;
  334. 			printf("%*.2f%-*s ", width_num, total_scl.number, width_pre, total_scl.prefix);
  335. 			printf("%*.2f%-*s ", width_num, used_scl.number, width_pre, used_scl.prefix);
  336. 			printf("%*.2f%-*s ", width_num, free_scl.number, width_pre, free_scl.prefix);
  337. 		}
  338. 		else
  339. 		{
  340. 			printf("%*zd ", col_width, total);
  341. 			printf("%*zd ", col_width, used);
  342. 			printf("%*zd ", col_width, free);
  343. 		}
  345. 		printf("%*zd%% ", tty_out ? 3 : 0, percent);
  346. 		printf("%s\n", mntent->mnt_dir);
  347. 	}
  349. 	endmntent(mounted);
  351. 	if(argc > 0) free(arg_devs);
  353. 	return 0;
  355. error:
  356. 	if(argc > 0) free(arg_devs);
  358. 	return 1;
  359. }