[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) || S_ISREG(sb.st_mode)) {
		if (blkdev_get_size(fd, size) == 0)
			rc = fincore_fd(ctl, fd, name, *size, count_incore);
		else
			warn(_("failed ioctl to get size: %s"), name);
	} else {
		rc = 1;			/* ignore things like symlinks
					 * and directories*/
	}

	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(_(" -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()
	};

	static const struct option longopts[] = {
		{ "bytes",      no_argument, NULL, 'b' },
		{ "noheadings", no_argument, NULL, 'n' },
		{ "output",     required_argument, NULL, 'o' },
		{ "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 '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
ab0a7517 JU	249	if (S_ISBLK(sb.st_mode) \|\| S_ISREG(sb.st_mode)) {
	250	if (blkdev_get_size(fd, size) == 0)
	251	rc = fincore_fd(ctl, fd, name, *size, count_incore);
	252	else
	253	warn(_("failed ioctl to get size: %s"), name);
	254	} else {
	255	rc = 1; /* ignore things like symlinks
	256	* and directories*/
	257	}
a921a7de MY	258
a921a7de MY	259	close (fd);
b57fe43c	260	return rc;
a921a7de MY	261	}
a921a7de MY	262
86be6a32	263	static void __attribute__((__noreturn__)) usage(void)
3f91dd88	264	{
86be6a32	265	FILE *out = stdout;
c5cb5412 KZ	266	size_t i;
c5cb5412 KZ	267
3f91dd88 KZ	268	fputs(USAGE_HEADER, out);
	269	fprintf(out, _(" %s [options] file...\n"), program_invocation_short_name);
	270
	271	fputs(USAGE_OPTIONS, out);
9b48766f	272	fputs(_(" -J, --json use JSON output format\n"), out);
c5cb5412 KZ	273	fputs(_(" -b, --bytes print sizes in bytes rather than in human readable format\n"), out);
	274	fputs(_(" -n, --noheadings don't print headings\n"), out);
	275	fputs(_(" -o, --output <list> output columns\n"), out);
9b48766f	276	fputs(_(" -r, --raw use raw output format\n"), out);
3f91dd88 KZ	277
3f91dd88 KZ	278	fputs(USAGE_SEPARATOR, out);
f45f3ec3	279	printf(USAGE_HELP_OPTIONS(23));
3f91dd88	280
c3a4cfc5	281	fprintf(out, USAGE_COLUMNS);
c5cb5412 KZ	282
	283	for (i = 0; i < ARRAY_SIZE(infos); i++)
	284	fprintf(out, " %11s %s\n", infos[i].name, _(infos[i].help));
	285
f45f3ec3	286	printf(USAGE_MAN_TAIL("fincore(1)"));
3f91dd88	287
86be6a32	288	exit(EXIT_SUCCESS);
3f91dd88 KZ	289	}
3f91dd88 KZ	290
a921a7de MY	291	int main(int argc, char ** argv)
	292	{
	293	int c;
3e37d7b7	294	size_t i;
b57fe43c	295	int rc = EXIT_SUCCESS;
c5cb5412	296	char *outarg = NULL;
a921a7de	297
3e37d7b7	298	struct fincore_control ctl = {
c5cb5412	299	.pagesize = getpagesize()
3e37d7b7 KZ	300	};
3e37d7b7 KZ	301
a921a7de	302	static const struct option longopts[] = {
3f91dd88 KZ	303	{ "bytes", no_argument, NULL, 'b' },
3f91dd88 KZ	304	{ "noheadings", no_argument, NULL, 'n' },
c5cb5412	305	{ "output", required_argument, NULL, 'o' },
a921a7de MY	306	{ "version", no_argument, NULL, 'V' },
a921a7de MY	307	{ "help", no_argument, NULL, 'h' },
9b48766f KZ	308	{ "json", no_argument, NULL, 'J' },
9b48766f KZ	309	{ "raw", no_argument, NULL, 'r' },
a921a7de MY	310	{ NULL, 0, NULL, 0 },
	311	};
	312
	313	setlocale(LC_ALL, "");
	314	bindtextdomain(PACKAGE, LOCALEDIR);
	315	textdomain(PACKAGE);
2c308875	316	close_stdout_atexit();
a921a7de	317
9b48766f	318	while ((c = getopt_long (argc, argv, "bno:JrVh", longopts, NULL)) != -1) {
a921a7de	319	switch (c) {
3f91dd88 KZ	320	case 'b':
	321	ctl.bytes = 1;
	322	break;
	323	case 'n':
	324	ctl.noheadings = 1;
	325	break;
c5cb5412 KZ	326	case 'o':
	327	outarg = optarg;
	328	break;
9b48766f KZ	329	case 'J':
	330	ctl.json = 1;
	331	break;
	332	case 'r':
	333	ctl.raw = 1;
	334	break;
a921a7de	335	case 'V':
2c308875	336	print_version(EXIT_SUCCESS);
a921a7de	337	case 'h':
86be6a32	338	usage();
a921a7de MY	339	default:
	340	errtryhelp(EXIT_FAILURE);
	341	}
	342	}
	343
	344	if (optind == argc) {
b57fe43c KZ	345	warnx(_("no file specified"));
b57fe43c KZ	346	errtryhelp(EXIT_FAILURE);
a921a7de MY	347	}
a921a7de MY	348
3e37d7b7	349	if (!ncolumns) {
e4e8b57b	350	columns[ncolumns++] = COL_RES;
3e37d7b7 KZ	351	columns[ncolumns++] = COL_PAGES;
	352	columns[ncolumns++] = COL_SIZE;
	353	columns[ncolumns++] = COL_FILE;
	354	}
	355
c5cb5412 KZ	356	if (outarg && string_add_to_idarray(outarg, columns, ARRAY_SIZE(columns),
	357	&ncolumns, column_name_to_id) < 0)
	358	return EXIT_FAILURE;
	359
3e37d7b7 KZ	360	scols_init_debug(0);
	361	ctl.tb = scols_new_table();
	362	if (!ctl.tb)
780ce22c	363	err(EXIT_FAILURE, _("failed to allocate output table"));
3e37d7b7	364
3f91dd88	365	scols_table_enable_noheadings(ctl.tb, ctl.noheadings);
9b48766f KZ	366	scols_table_enable_raw(ctl.tb, ctl.raw);
	367	scols_table_enable_json(ctl.tb, ctl.json);
	368	if (ctl.json)
	369	scols_table_set_name(ctl.tb, "fincore");
3f91dd88	370
3e37d7b7 KZ	371	for (i = 0; i < ncolumns; i++) {
3e37d7b7 KZ	372	const struct colinfo *col = get_column_info(i);
8945d9dc	373	struct libscols_column *cl;
a921a7de	374
8945d9dc KZ	375	cl = scols_table_new_column(ctl.tb, col->name, col->whint, col->flags);
8945d9dc KZ	376	if (!cl)
780ce22c	377	err(EXIT_FAILURE, _("failed to allocate output column"));
8945d9dc KZ	378
	379	if (ctl.json) {
	380	int id = get_column_id(i);
	381
	382	switch (id) {
	383	case COL_FILE:
	384	scols_column_set_json_type(cl, SCOLS_JSON_STRING);
	385	break;
	386	case COL_SIZE:
	387	case COL_RES:
	388	if (!ctl.bytes)
	389	break;
	390	/* fallthrough */
	391	default:
	392	scols_column_set_json_type(cl, SCOLS_JSON_NUMBER);
	393	break;
	394	}
	395	}
3e37d7b7	396	}
b57fe43c	397
a921a7de MY	398	for(; optind < argc; optind++) {
a921a7de MY	399	char *name = argv[optind];
a921a7de	400	off_t count_incore = 0;
ab0a7517	401	unsigned long long size = 0;
a921a7de	402
ab0a7517	403	switch (fincore_name(&ctl, name, &size, &count_incore)) {
3e37d7b7	404	case 0:
ab0a7517	405	add_output_data(&ctl, name, size, count_incore);
3e37d7b7 KZ	406	break;
	407	case 1:
	408	break; /* ignore */
	409	default:
b57fe43c	410	rc = EXIT_FAILURE;
3e37d7b7	411	break;
a921a7de MY	412	}
	413	}
	414
3e37d7b7 KZ	415	scols_print_table(ctl.tb);
	416	scols_unref_table(ctl.tb);
	417
b57fe43c	418	return rc;
a921a7de	419	}