[thirdparty/util-linux.git] / misc-utils / fincore.c

/*
 * fincore - count pages of file contents in core
 *
 * Copyright (C) 2017 Red Hat, Inc. All rights reserved.
 * Written by Masatake YAMATO <yamato@redhat.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it would be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#include <sys/mman.h>
#include <sys/stat.h>
#include <unistd.h>
#include <getopt.h>
#include <stdio.h>
#include <string.h>

#include "c.h"
#include "nls.h"
#include "closestream.h"
#include "xalloc.h"
#include "strutils.h"
#include "blkdev.h"

#include "libsmartcols.h"

/* For large files, mmap is called in iterative way.
   Window is the unit of vma prepared in each mmap
   calling.

   Window size depends on page size.
   e.g. 128MB on x86_64. ( = N_PAGES_IN_WINDOW * 4096 ). */
#define N_PAGES_IN_WINDOW ((size_t)(32 * 1024))


struct colinfo {
	const char * const name;
	double whint;
	int flags;
	const char *help;
};

enum {
	COL_PAGES,
	COL_SIZE,
	COL_FILE,
	COL_RES
};

static const struct colinfo infos[] = {
	[COL_PAGES]  = { "PAGES",    1, SCOLS_FL_RIGHT, N_("file data resident in memory in pages")},
	[COL_RES]    = { "RES",      5, SCOLS_FL_RIGHT, N_("file data resident in memory in bytes")},
	[COL_SIZE]   = { "SIZE",     5, SCOLS_FL_RIGHT, N_("size of the file")},
	[COL_FILE]   = { "FILE",     4, 0, N_("file name")},
};

static int columns[ARRAY_SIZE(infos) * 2] = {-1};
static size_t ncolumns;

struct fincore_control {
	const size_t pagesize;

	struct libscols_table *tb;		/* output */

	unsigned int bytes : 1,
		     noheadings : 1,
		     raw : 1,
		     json : 1;
};


static int column_name_to_id(const char *name, size_t namesz)
{
	size_t i;

	for (i = 0; i < ARRAY_SIZE(infos); i++) {
		const char *cn = infos[i].name;

		if (!strncasecmp(name, cn, namesz) && !*(cn + namesz))
			return i;
	}
	warnx(_("unknown column: %s"), name);
	return -1;
}

static int get_column_id(int num)
{
	assert(num >= 0);
	assert((size_t) num < ncolumns);
	assert(columns[num] < (int) ARRAY_SIZE(infos));
	return columns[num];
}

static const struct colinfo *get_column_info(int num)
{
	return &infos[ get_column_id(num) ];
}

static int add_output_data(struct fincore_control *ctl,
			   const char *name,
			   off_t file_size,
			   off_t count_incore)
{
	size_t i;
	char *tmp;
	struct libscols_line *ln;

	assert(ctl);
	assert(ctl->tb);

	ln = scols_table_new_line(ctl->tb, NULL);
	if (!ln)
		err(EXIT_FAILURE, _("failed to allocate output line"));

	for (i = 0; i < ncolumns; i++) {
		int rc = 0;

		switch(get_column_id(i)) {
		case COL_FILE:
			rc = scols_line_set_data(ln, i, name);
			break;
		case COL_PAGES:
			xasprintf(&tmp, "%jd",  (intmax_t) count_incore);
			rc = scols_line_refer_data(ln, i, tmp);
			break;
		case COL_RES:
		{
			uintmax_t res = (uintmax_t) count_incore * ctl->pagesize;

			if (ctl->bytes)
				xasprintf(&tmp, "%ju", res);
			else
				tmp = size_to_human_string(SIZE_SUFFIX_1LETTER, res);
			rc = scols_line_refer_data(ln, i, tmp);
			break;
		}
		case COL_SIZE:
			if (ctl->bytes)
				xasprintf(&tmp, "%jd", (intmax_t) file_size);
			else
				tmp = size_to_human_string(SIZE_SUFFIX_1LETTER, file_size);
			rc = scols_line_refer_data(ln, i, tmp);
			break;
		default:
			return -EINVAL;
		}

		if (rc)
			err(EXIT_FAILURE, _("failed to add output data"));
	}

	return 0;
}

static int do_mincore(struct fincore_control *ctl,
		      void *window, const size_t len,
		      const char *name,
		      off_t *count_incore)
{
	static unsigned char vec[N_PAGES_IN_WINDOW];
	int n = (len / ctl->pagesize) + ((len % ctl->pagesize)? 1: 0);

	if (mincore (window, len, vec) < 0) {
		warn(_("failed to do mincore: %s"), name);
		return -errno;
	}

	while (n > 0)
	{
		if (vec[--n] & 0x1)
		{
			vec[n] = 0;
			(*count_incore)++;
		}
	}

	return 0;
}

static int fincore_fd (struct fincore_control *ctl,
		       int fd,
		       const char *name,
		       off_t file_size,
		       off_t *count_incore)
{
	size_t window_size = N_PAGES_IN_WINDOW * ctl->pagesize;
	off_t file_offset, len;
	int rc = 0;

	for (file_offset = 0; file_offset < file_size; file_offset += len) {
		void  *window = NULL;

		len = file_size - file_offset;
		if (len >= (off_t) window_size)
			len = window_size;

		/* PROT_NONE is enough for Linux, but qemu-user wants PROT_READ */
		window = mmap(window, len, PROT_READ, MAP_PRIVATE, fd, file_offset);
		if (window == MAP_FAILED) {
			rc = -EINVAL;
			warn(_("failed to do mmap: %s"), name);
			break;
		}

		rc = do_mincore(ctl, window, len, name, count_incore);
		if (rc)
			break;

		munmap (window, len);
	}

	return rc;
}

/*
 * Returns: <0 on error, 0 success, 1 ignore.
 */
static int fincore_name(struct fincore_control *ctl,
			const char *name,
			unsigned long long *size,
			off_t *count_incore)
{
	int fd;
	int rc = 0;
	struct stat sb;

	if ((fd = open (name, O_RDONLY)) < 0) {
		warn(_("failed to open: %s"), name);
		return -errno;
	}

	if (fstat (fd, &sb) < 0) {
		warn(_("failed to do fstat: %s"), name);
		close (fd);
		return -errno;
	}

	if (S_ISBLK(sb.st_mode)) {
		rc = blkdev_get_size(fd, size);
		if (rc)
			warn(_("failed ioctl to get size: %s"), name);
	} else if (S_ISREG(sb.st_mode)) {
		*size = sb.st_size;
	} else {
		rc = 1;			/* ignore things like symlinks
					 * and directories*/
	}

	if (!rc) {
		rc = fincore_fd(ctl, fd, name, *size, count_incore);
	}

	close (fd);
	return rc;
}

static void __attribute__((__noreturn__)) usage(void)
{
	FILE *out = stdout;
	size_t i;

	fputs(USAGE_HEADER, out);
	fprintf(out, _(" %s [options] file...\n"), program_invocation_short_name);

	fputs(USAGE_OPTIONS, out);
	fputs(_(" -J, --json            use JSON output format\n"), out);
	fputs(_(" -b, --bytes           print sizes in bytes rather than in human readable format\n"), out);
	fputs(_(" -n, --noheadings      don't print headings\n"), out);
	fputs(_(" -o, --output <list>   output columns\n"), out);
	fputs(_("     --output-all      output all columns\n"), out);
	fputs(_(" -r, --raw             use raw output format\n"), out);

	fputs(USAGE_SEPARATOR, out);
	printf(USAGE_HELP_OPTIONS(23));

	fprintf(out, USAGE_COLUMNS);

	for (i = 0; i < ARRAY_SIZE(infos); i++)
		fprintf(out, " %11s  %s\n", infos[i].name, _(infos[i].help));

	printf(USAGE_MAN_TAIL("fincore(1)"));

	exit(EXIT_SUCCESS);
}

int main(int argc, char ** argv)
{
	int c;
	size_t i;
	int rc = EXIT_SUCCESS;
	char *outarg = NULL;

	struct fincore_control ctl = {
		.pagesize = getpagesize()
	};

	enum {
		OPT_OUTPUT_ALL = CHAR_MAX + 1
	};
	static const struct option longopts[] = {
		{ "bytes",      no_argument, NULL, 'b' },
		{ "noheadings", no_argument, NULL, 'n' },
		{ "output",     required_argument, NULL, 'o' },
		{ "output-all",	no_argument,       NULL, OPT_OUTPUT_ALL },
		{ "version",    no_argument, NULL, 'V' },
		{ "help",	no_argument, NULL, 'h' },
		{ "json",       no_argument, NULL, 'J' },
		{ "raw",        no_argument, NULL, 'r' },
		{ NULL, 0, NULL, 0 },
	};

	setlocale(LC_ALL, "");
	bindtextdomain(PACKAGE, LOCALEDIR);
	textdomain(PACKAGE);
	close_stdout_atexit();

	while ((c = getopt_long (argc, argv, "bno:JrVh", longopts, NULL)) != -1) {
		switch (c) {
		case 'b':
			ctl.bytes = 1;
			break;
		case 'n':
			ctl.noheadings = 1;
			break;
		case 'o':
			outarg = optarg;
			break;
		case OPT_OUTPUT_ALL:
			for (ncolumns = 0; ncolumns < ARRAY_SIZE(infos); ncolumns++)
				columns[ncolumns] = ncolumns;
			break;
		case 'J':
			ctl.json = 1;
			break;
		case 'r':
			ctl.raw = 1;
			break;
		case 'V':
			print_version(EXIT_SUCCESS);
		case 'h':
			usage();
		default:
			errtryhelp(EXIT_FAILURE);
		}
	}

	if (optind == argc) {
		warnx(_("no file specified"));
		errtryhelp(EXIT_FAILURE);
	}

	if (!ncolumns) {
		columns[ncolumns++] = COL_RES;
		columns[ncolumns++] = COL_PAGES;
		columns[ncolumns++] = COL_SIZE;
		columns[ncolumns++] = COL_FILE;
	}

	if (outarg && string_add_to_idarray(outarg, columns, ARRAY_SIZE(columns),
					 &ncolumns, column_name_to_id) < 0)
		return EXIT_FAILURE;

	scols_init_debug(0);
	ctl.tb = scols_new_table();
	if (!ctl.tb)
		err(EXIT_FAILURE, _("failed to allocate output table"));

	scols_table_enable_noheadings(ctl.tb, ctl.noheadings);
	scols_table_enable_raw(ctl.tb, ctl.raw);
	scols_table_enable_json(ctl.tb, ctl.json);
	if (ctl.json)
		scols_table_set_name(ctl.tb, "fincore");

	for (i = 0; i < ncolumns; i++) {
		const struct colinfo *col = get_column_info(i);
		struct libscols_column *cl;

		cl = scols_table_new_column(ctl.tb, col->name, col->whint, col->flags);
		if (!cl)
			err(EXIT_FAILURE, _("failed to allocate output column"));

		if (ctl.json) {
			int id = get_column_id(i);

			switch (id) {
			case COL_FILE:
				scols_column_set_json_type(cl, SCOLS_JSON_STRING);
				break;
			case COL_SIZE:
			case COL_RES:
				if (!ctl.bytes)
					break;
				/* fallthrough */
			default:
				scols_column_set_json_type(cl, SCOLS_JSON_NUMBER);
				break;
			}
		}
	}

	for(; optind < argc; optind++) {
		char *name = argv[optind];
		off_t count_incore = 0;
		unsigned long long size = 0;

		switch (fincore_name(&ctl, name, &size, &count_incore)) {
		case 0:
			add_output_data(&ctl, name, size, count_incore);
			break;
		case 1:
			break; /* ignore */
		default:
			rc = EXIT_FAILURE;
			break;
		}
	}

	scols_print_table(ctl.tb);
	scols_unref_table(ctl.tb);

	return rc;
}
Commit	Line	Data
a921a7de MY	1	/*
	2	* fincore - count pages of file contents in core
	3	*
	4	* Copyright (C) 2017 Red Hat, Inc. All rights reserved.
	5	* Written by Masatake YAMATO <yamato@redhat.com>
	6	*
	7	* This program is free software; you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License as published by
	9	* the Free Software Foundation; either version 2 of the License, or
	10	* (at your option) any later version.
	11	*
	12	* This program is distributed in the hope that it would be useful,
	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	* GNU General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU General Public License along
	18	* with this program; if not, write to the Free Software Foundation, Inc.,
	19	* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*/
	21
	22	#include <sys/mman.h>
	23	#include <sys/stat.h>
	24	#include <unistd.h>
	25	#include <getopt.h>
	26	#include <stdio.h>
	27	#include <string.h>
	28
	29	#include "c.h"
	30	#include "nls.h"
	31	#include "closestream.h"
3e37d7b7 KZ	32	#include "xalloc.h"
3e37d7b7 KZ	33	#include "strutils.h"
ab0a7517	34	#include "blkdev.h"
3e37d7b7 KZ	35
3e37d7b7 KZ	36	#include "libsmartcols.h"
a921a7de MY	37
	38	/* For large files, mmap is called in iterative way.
	39	Window is the unit of vma prepared in each mmap
	40	calling.
	41
	42	Window size depends on page size.
	43	e.g. 128MB on x86_64. ( = N_PAGES_IN_WINDOW * 4096 ). */
452089fa	44	#define N_PAGES_IN_WINDOW ((size_t)(32 * 1024))
a921a7de	45
3e37d7b7 KZ	46
3e37d7b7 KZ	47	struct colinfo {
37b2b3fa	48	const char * const name;
3e37d7b7 KZ	49	double whint;
	50	int flags;
	51	const char *help;
	52	};
	53
	54	enum {
	55	COL_PAGES,
	56	COL_SIZE,
e4e8b57b KZ	57	COL_FILE,
e4e8b57b KZ	58	COL_RES
3e37d7b7 KZ	59	};
3e37d7b7 KZ	60
37b2b3fa	61	static const struct colinfo infos[] = {
0508f347	62	[COL_PAGES] = { "PAGES", 1, SCOLS_FL_RIGHT, N_("file data resident in memory in pages")},
2bb3aa36	63	[COL_RES] = { "RES", 5, SCOLS_FL_RIGHT, N_("file data resident in memory in bytes")},
3e37d7b7 KZ	64	[COL_SIZE] = { "SIZE", 5, SCOLS_FL_RIGHT, N_("size of the file")},
	65	[COL_FILE] = { "FILE", 4, 0, N_("file name")},
	66	};
	67
	68	static int columns[ARRAY_SIZE(infos) * 2] = {-1};
	69	static size_t ncolumns;
	70
	71	struct fincore_control {
452089fa	72	const size_t pagesize;
3e37d7b7 KZ	73
	74	struct libscols_table tb; / output */
	75
3f91dd88	76	unsigned int bytes : 1,
9b48766f KZ	77	noheadings : 1,
	78	raw : 1,
	79	json : 1;
3e37d7b7 KZ	80	};
3e37d7b7 KZ	81
a921a7de	82
3e37d7b7 KZ	83	static int column_name_to_id(const char *name, size_t namesz)
	84	{
	85	size_t i;
	86
	87	for (i = 0; i < ARRAY_SIZE(infos); i++) {
	88	const char *cn = infos[i].name;
	89
	90	if (!strncasecmp(name, cn, namesz) && !*(cn + namesz))
	91	return i;
	92	}
	93	warnx(_("unknown column: %s"), name);
	94	return -1;
	95	}
	96
	97	static int get_column_id(int num)
a921a7de	98	{
3e37d7b7 KZ	99	assert(num >= 0);
	100	assert((size_t) num < ncolumns);
	101	assert(columns[num] < (int) ARRAY_SIZE(infos));
	102	return columns[num];
a921a7de MY	103	}
a921a7de MY	104
3e37d7b7	105	static const struct colinfo *get_column_info(int num)
a921a7de	106	{
3e37d7b7	107	return &infos[ get_column_id(num) ];
a921a7de MY	108	}
a921a7de MY	109
3e37d7b7 KZ	110	static int add_output_data(struct fincore_control *ctl,
	111	const char *name,
	112	off_t file_size,
	113	off_t count_incore)
	114	{
	115	size_t i;
	116	char *tmp;
	117	struct libscols_line *ln;
	118
	119	assert(ctl);
	120	assert(ctl->tb);
	121
	122	ln = scols_table_new_line(ctl->tb, NULL);
	123	if (!ln)
780ce22c	124	err(EXIT_FAILURE, _("failed to allocate output line"));
3e37d7b7 KZ	125
3e37d7b7 KZ	126	for (i = 0; i < ncolumns; i++) {
b7ebf49c KZ	127	int rc = 0;
b7ebf49c KZ	128
3e37d7b7 KZ	129	switch(get_column_id(i)) {
3e37d7b7 KZ	130	case COL_FILE:
b7ebf49c	131	rc = scols_line_set_data(ln, i, name);
3e37d7b7 KZ	132	break;
	133	case COL_PAGES:
	134	xasprintf(&tmp, "%jd", (intmax_t) count_incore);
b7ebf49c	135	rc = scols_line_refer_data(ln, i, tmp);
3e37d7b7	136	break;
e4e8b57b KZ	137	case COL_RES:
	138	{
	139	uintmax_t res = (uintmax_t) count_incore * ctl->pagesize;
	140
	141	if (ctl->bytes)
	142	xasprintf(&tmp, "%ju", res);
	143	else
	144	tmp = size_to_human_string(SIZE_SUFFIX_1LETTER, res);
b7ebf49c	145	rc = scols_line_refer_data(ln, i, tmp);
e4e8b57b KZ	146	break;
e4e8b57b KZ	147	}
3e37d7b7 KZ	148	case COL_SIZE:
	149	if (ctl->bytes)
	150	xasprintf(&tmp, "%jd", (intmax_t) file_size);
	151	else
	152	tmp = size_to_human_string(SIZE_SUFFIX_1LETTER, file_size);
b7ebf49c	153	rc = scols_line_refer_data(ln, i, tmp);
3e37d7b7 KZ	154	break;
	155	default:
	156	return -EINVAL;
	157	}
b7ebf49c KZ	158
	159	if (rc)
	160	err(EXIT_FAILURE, _("failed to add output data"));
3e37d7b7 KZ	161	}
	162
	163	return 0;
	164	}
	165
	166	static int do_mincore(struct fincore_control *ctl,
	167	void *window, const size_t len,
	168	const char *name,
	169	off_t *count_incore)
a921a7de MY	170	{
a921a7de MY	171	static unsigned char vec[N_PAGES_IN_WINDOW];
3e37d7b7	172	int n = (len / ctl->pagesize) + ((len % ctl->pagesize)? 1: 0);
a921a7de MY	173
	174	if (mincore (window, len, vec) < 0) {
	175	warn(_("failed to do mincore: %s"), name);
b57fe43c	176	return -errno;
a921a7de MY	177	}
	178
	179	while (n > 0)
	180	{
	181	if (vec[--n] & 0x1)
	182	{
	183	vec[n] = 0;
	184	(*count_incore)++;
	185	}
	186	}
	187
b57fe43c	188	return 0;
a921a7de MY	189	}
a921a7de MY	190
3e37d7b7 KZ	191	static int fincore_fd (struct fincore_control *ctl,
	192	int fd,
	193	const char *name,
a921a7de MY	194	off_t file_size,
	195	off_t *count_incore)
	196	{
452089fa	197	size_t window_size = N_PAGES_IN_WINDOW * ctl->pagesize;
fcfe1a5c	198	off_t file_offset, len;
b57fe43c	199	int rc = 0;
a921a7de	200
fcfe1a5c	201	for (file_offset = 0; file_offset < file_size; file_offset += len) {
57940872	202	void *window = NULL;
a921a7de MY	203
a921a7de MY	204	len = file_size - file_offset;
ea62c152	205	if (len >= (off_t) window_size)
a921a7de MY	206	len = window_size;
a921a7de MY	207
cf397444 TW	208	/* PROT_NONE is enough for Linux, but qemu-user wants PROT_READ */
cf397444 TW	209	window = mmap(window, len, PROT_READ, MAP_PRIVATE, fd, file_offset);
a921a7de	210	if (window == MAP_FAILED) {
374cb543 KZ	211	rc = -EINVAL;
374cb543 KZ	212	warn(_("failed to do mmap: %s"), name);
a921a7de MY	213	break;
	214	}
	215
3e37d7b7	216	rc = do_mincore(ctl, window, len, name, count_incore);
b57fe43c KZ	217	if (rc)
b57fe43c KZ	218	break;
a921a7de MY	219
	220	munmap (window, len);
	221	}
	222
b57fe43c	223	return rc;
a921a7de MY	224	}
a921a7de MY	225
3e37d7b7 KZ	226	/*
	227	* Returns: <0 on error, 0 success, 1 ignore.
	228	*/
	229	static int fincore_name(struct fincore_control *ctl,
	230	const char *name,
ab0a7517	231	unsigned long long *size,
3e37d7b7	232	off_t *count_incore)
a921a7de MY	233	{
a921a7de MY	234	int fd;
b57fe43c	235	int rc = 0;
ab0a7517	236	struct stat sb;
a921a7de MY	237
	238	if ((fd = open (name, O_RDONLY)) < 0) {
	239	warn(_("failed to open: %s"), name);
cff1c113	240	return -errno;
a921a7de MY	241	}
a921a7de MY	242
ab0a7517	243	if (fstat (fd, &sb) < 0) {
a921a7de	244	warn(_("failed to do fstat: %s"), name);
b9dc8d07	245	close (fd);
b57fe43c	246	return -errno;
a921a7de MY	247	}
a921a7de MY	248
5a02eb13 JU	249	if (S_ISBLK(sb.st_mode)) {
	250	rc = blkdev_get_size(fd, size);
	251	if (rc)
ab0a7517	252	warn(_("failed ioctl to get size: %s"), name);
5a02eb13 JU	253	} else if (S_ISREG(sb.st_mode)) {
5a02eb13 JU	254	*size = sb.st_size;
ab0a7517 JU	255	} else {
	256	rc = 1; /* ignore things like symlinks
	257	* and directories*/
	258	}
a921a7de	259
5a02eb13 JU	260	if (!rc) {
	261	rc = fincore_fd(ctl, fd, name, *size, count_incore);
	262	}
	263
a921a7de	264	close (fd);
b57fe43c	265	return rc;
a921a7de MY	266	}
a921a7de MY	267
86be6a32	268	static void __attribute__((__noreturn__)) usage(void)
3f91dd88	269	{
86be6a32	270	FILE *out = stdout;
c5cb5412 KZ	271	size_t i;
c5cb5412 KZ	272
3f91dd88 KZ	273	fputs(USAGE_HEADER, out);
	274	fprintf(out, _(" %s [options] file...\n"), program_invocation_short_name);
	275
	276	fputs(USAGE_OPTIONS, out);
9b48766f	277	fputs(_(" -J, --json use JSON output format\n"), out);
c5cb5412 KZ	278	fputs(_(" -b, --bytes print sizes in bytes rather than in human readable format\n"), out);
	279	fputs(_(" -n, --noheadings don't print headings\n"), out);
	280	fputs(_(" -o, --output <list> output columns\n"), out);
1f583cb9	281	fputs(_(" --output-all output all columns\n"), out);
9b48766f	282	fputs(_(" -r, --raw use raw output format\n"), out);
3f91dd88 KZ	283
3f91dd88 KZ	284	fputs(USAGE_SEPARATOR, out);
f45f3ec3	285	printf(USAGE_HELP_OPTIONS(23));
3f91dd88	286
c3a4cfc5	287	fprintf(out, USAGE_COLUMNS);
c5cb5412 KZ	288
	289	for (i = 0; i < ARRAY_SIZE(infos); i++)
	290	fprintf(out, " %11s %s\n", infos[i].name, _(infos[i].help));
	291
f45f3ec3	292	printf(USAGE_MAN_TAIL("fincore(1)"));
3f91dd88	293
86be6a32	294	exit(EXIT_SUCCESS);
3f91dd88 KZ	295	}
3f91dd88 KZ	296
a921a7de MY	297	int main(int argc, char ** argv)
	298	{
	299	int c;
3e37d7b7	300	size_t i;
b57fe43c	301	int rc = EXIT_SUCCESS;
c5cb5412	302	char *outarg = NULL;
a921a7de	303
3e37d7b7	304	struct fincore_control ctl = {
c5cb5412	305	.pagesize = getpagesize()
3e37d7b7 KZ	306	};
3e37d7b7 KZ	307
1f583cb9 TW	308	enum {
	309	OPT_OUTPUT_ALL = CHAR_MAX + 1
	310	};
a921a7de	311	static const struct option longopts[] = {
3f91dd88 KZ	312	{ "bytes", no_argument, NULL, 'b' },
3f91dd88 KZ	313	{ "noheadings", no_argument, NULL, 'n' },
c5cb5412	314	{ "output", required_argument, NULL, 'o' },
1f583cb9	315	{ "output-all", no_argument, NULL, OPT_OUTPUT_ALL },
a921a7de MY	316	{ "version", no_argument, NULL, 'V' },
a921a7de MY	317	{ "help", no_argument, NULL, 'h' },
9b48766f KZ	318	{ "json", no_argument, NULL, 'J' },
9b48766f KZ	319	{ "raw", no_argument, NULL, 'r' },
a921a7de MY	320	{ NULL, 0, NULL, 0 },
	321	};
	322
	323	setlocale(LC_ALL, "");
	324	bindtextdomain(PACKAGE, LOCALEDIR);
	325	textdomain(PACKAGE);
2c308875	326	close_stdout_atexit();
a921a7de	327
9b48766f	328	while ((c = getopt_long (argc, argv, "bno:JrVh", longopts, NULL)) != -1) {
a921a7de	329	switch (c) {
3f91dd88 KZ	330	case 'b':
	331	ctl.bytes = 1;
	332	break;
	333	case 'n':
	334	ctl.noheadings = 1;
	335	break;
c5cb5412 KZ	336	case 'o':
	337	outarg = optarg;
	338	break;
1f583cb9 TW	339	case OPT_OUTPUT_ALL:
	340	for (ncolumns = 0; ncolumns < ARRAY_SIZE(infos); ncolumns++)
	341	columns[ncolumns] = ncolumns;
	342	break;
9b48766f KZ	343	case 'J':
	344	ctl.json = 1;
	345	break;
	346	case 'r':
	347	ctl.raw = 1;
	348	break;
a921a7de	349	case 'V':
2c308875	350	print_version(EXIT_SUCCESS);
a921a7de	351	case 'h':
86be6a32	352	usage();
a921a7de MY	353	default:
	354	errtryhelp(EXIT_FAILURE);
	355	}
	356	}
	357
	358	if (optind == argc) {
b57fe43c KZ	359	warnx(_("no file specified"));
b57fe43c KZ	360	errtryhelp(EXIT_FAILURE);
a921a7de MY	361	}
a921a7de MY	362
3e37d7b7	363	if (!ncolumns) {
e4e8b57b	364	columns[ncolumns++] = COL_RES;
3e37d7b7 KZ	365	columns[ncolumns++] = COL_PAGES;
	366	columns[ncolumns++] = COL_SIZE;
	367	columns[ncolumns++] = COL_FILE;
	368	}
	369
c5cb5412 KZ	370	if (outarg && string_add_to_idarray(outarg, columns, ARRAY_SIZE(columns),
	371	&ncolumns, column_name_to_id) < 0)
	372	return EXIT_FAILURE;
	373
3e37d7b7 KZ	374	scols_init_debug(0);
	375	ctl.tb = scols_new_table();
	376	if (!ctl.tb)
780ce22c	377	err(EXIT_FAILURE, _("failed to allocate output table"));
3e37d7b7	378
3f91dd88	379	scols_table_enable_noheadings(ctl.tb, ctl.noheadings);
9b48766f KZ	380	scols_table_enable_raw(ctl.tb, ctl.raw);
	381	scols_table_enable_json(ctl.tb, ctl.json);
	382	if (ctl.json)
	383	scols_table_set_name(ctl.tb, "fincore");
3f91dd88	384
3e37d7b7 KZ	385	for (i = 0; i < ncolumns; i++) {
3e37d7b7 KZ	386	const struct colinfo *col = get_column_info(i);
8945d9dc	387	struct libscols_column *cl;
a921a7de	388
8945d9dc KZ	389	cl = scols_table_new_column(ctl.tb, col->name, col->whint, col->flags);
8945d9dc KZ	390	if (!cl)
780ce22c	391	err(EXIT_FAILURE, _("failed to allocate output column"));
8945d9dc KZ	392
	393	if (ctl.json) {
	394	int id = get_column_id(i);
	395
	396	switch (id) {
	397	case COL_FILE:
	398	scols_column_set_json_type(cl, SCOLS_JSON_STRING);
	399	break;
	400	case COL_SIZE:
	401	case COL_RES:
	402	if (!ctl.bytes)
	403	break;
	404	/* fallthrough */
	405	default:
	406	scols_column_set_json_type(cl, SCOLS_JSON_NUMBER);
	407	break;
	408	}
	409	}
3e37d7b7	410	}
b57fe43c	411
a921a7de MY	412	for(; optind < argc; optind++) {
a921a7de MY	413	char *name = argv[optind];
a921a7de	414	off_t count_incore = 0;
ab0a7517	415	unsigned long long size = 0;
a921a7de	416
ab0a7517	417	switch (fincore_name(&ctl, name, &size, &count_incore)) {
3e37d7b7	418	case 0:
ab0a7517	419	add_output_data(&ctl, name, size, count_incore);
3e37d7b7 KZ	420	break;
	421	case 1:
	422	break; /* ignore */
	423	default:
b57fe43c	424	rc = EXIT_FAILURE;
3e37d7b7	425	break;
a921a7de MY	426	}
	427	}
	428
3e37d7b7 KZ	429	scols_print_table(ctl.tb);
	430	scols_unref_table(ctl.tb);
	431
b57fe43c	432	return rc;
a921a7de	433	}