[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 "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 *name;
	double whint;
	int flags;
	const char *help;
};

enum {
	COL_PAGES,
	COL_SIZE,
	COL_FILE,
	COL_RES
};

static 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;
	void  *window = NULL;
	int rc = 0;
	int warned_once = 0;

	for (file_offset = 0; file_offset < file_size; file_offset += window_size) {
		size_t len;

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

		window = mmap(window, len, PROT_NONE, MAP_PRIVATE, fd, file_offset);
		if (window == MAP_FAILED) {
			if (!warned_once) {
				rc = -EINVAL;
				warn(_("failed to do mmap: %s"), name);
				warned_once = 1;
			}
			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,
			struct stat *sb,
			off_t *count_incore)
{
	int fd;
	int rc = 0;

	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_ISDIR(sb->st_mode))
		rc = 1;			/* ignore */

	else if (sb->st_size)
		rc = fincore_fd(ctl, fd, name, sb->st_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(_(" -r, --raw             use raw output format\n"), out);

	fputs(USAGE_SEPARATOR, out);
	fputs(USAGE_HELP, out);
	fputs(USAGE_VERSION, out);

	fprintf(out, USAGE_COLUMNS);

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

	fprintf(out, 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);
	atexit(close_stdout);

	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':
			printf(UTIL_LINUX_VERSION);
			return 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);

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

	for(; optind < argc; optind++) {
		char *name = argv[optind];
		struct stat sb;
		off_t count_incore = 0;

		switch (fincore_name(&ctl, name, &sb, &count_incore)) {
		case 0:
			add_output_data(&ctl, name, sb.st_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"
	33	#include "strutils.h"
	34
	35	#include "libsmartcols.h"
a921a7de MY	36
	37	/* For large files, mmap is called in iterative way.
	38	Window is the unit of vma prepared in each mmap
	39	calling.
	40
	41	Window size depends on page size.
	42	e.g. 128MB on x86_64. ( = N_PAGES_IN_WINDOW * 4096 ). */
452089fa	43	#define N_PAGES_IN_WINDOW ((size_t)(32 * 1024))
a921a7de	44
3e37d7b7 KZ	45
	46	struct colinfo {
	47	const char *name;
	48	double whint;
	49	int flags;
	50	const char *help;
	51	};
	52
	53	enum {
	54	COL_PAGES,
	55	COL_SIZE,
e4e8b57b KZ	56	COL_FILE,
e4e8b57b KZ	57	COL_RES
3e37d7b7 KZ	58	};
	59
	60	static struct colinfo infos[] = {
0508f347 YC	61	[COL_PAGES] = { "PAGES", 1, SCOLS_FL_RIGHT, N_("file data resident in memory in pages")},
0508f347 YC	62	[COL_RES] = { "RES", 5, SCOLS_FL_RIGHT, N_("file data resident in memory in bytes")},
3e37d7b7 KZ	63	[COL_SIZE] = { "SIZE", 5, SCOLS_FL_RIGHT, N_("size of the file")},
	64	[COL_FILE] = { "FILE", 4, 0, N_("file name")},
	65	};
	66
	67	static int columns[ARRAY_SIZE(infos) * 2] = {-1};
	68	static size_t ncolumns;
	69
	70	struct fincore_control {
452089fa	71	const size_t pagesize;
3e37d7b7 KZ	72
	73	struct libscols_table tb; / output */
	74
3f91dd88	75	unsigned int bytes : 1,
9b48766f KZ	76	noheadings : 1,
	77	raw : 1,
	78	json : 1;
3e37d7b7 KZ	79	};
3e37d7b7 KZ	80
a921a7de	81
3e37d7b7 KZ	82	static int column_name_to_id(const char *name, size_t namesz)
	83	{
	84	size_t i;
	85
	86	for (i = 0; i < ARRAY_SIZE(infos); i++) {
	87	const char *cn = infos[i].name;
	88
	89	if (!strncasecmp(name, cn, namesz) && !*(cn + namesz))
	90	return i;
	91	}
	92	warnx(_("unknown column: %s"), name);
	93	return -1;
	94	}
	95
	96	static int get_column_id(int num)
a921a7de	97	{
3e37d7b7 KZ	98	assert(num >= 0);
	99	assert((size_t) num < ncolumns);
	100	assert(columns[num] < (int) ARRAY_SIZE(infos));
	101	return columns[num];
a921a7de MY	102	}
a921a7de MY	103
3e37d7b7	104	static const struct colinfo *get_column_info(int num)
a921a7de	105	{
3e37d7b7	106	return &infos[ get_column_id(num) ];
a921a7de MY	107	}
a921a7de MY	108
3e37d7b7 KZ	109	static int add_output_data(struct fincore_control *ctl,
	110	const char *name,
	111	off_t file_size,
	112	off_t count_incore)
	113	{
	114	size_t i;
	115	char *tmp;
	116	struct libscols_line *ln;
	117
	118	assert(ctl);
	119	assert(ctl->tb);
	120
	121	ln = scols_table_new_line(ctl->tb, NULL);
	122	if (!ln)
780ce22c	123	err(EXIT_FAILURE, _("failed to allocate output line"));
3e37d7b7 KZ	124
3e37d7b7 KZ	125	for (i = 0; i < ncolumns; i++) {
b7ebf49c KZ	126	int rc = 0;
b7ebf49c KZ	127
3e37d7b7 KZ	128	switch(get_column_id(i)) {
3e37d7b7 KZ	129	case COL_FILE:
b7ebf49c	130	rc = scols_line_set_data(ln, i, name);
3e37d7b7 KZ	131	break;
	132	case COL_PAGES:
	133	xasprintf(&tmp, "%jd", (intmax_t) count_incore);
b7ebf49c	134	rc = scols_line_refer_data(ln, i, tmp);
3e37d7b7	135	break;
e4e8b57b KZ	136	case COL_RES:
	137	{
	138	uintmax_t res = (uintmax_t) count_incore * ctl->pagesize;
	139
	140	if (ctl->bytes)
	141	xasprintf(&tmp, "%ju", res);
	142	else
	143	tmp = size_to_human_string(SIZE_SUFFIX_1LETTER, res);
b7ebf49c	144	rc = scols_line_refer_data(ln, i, tmp);
e4e8b57b KZ	145	break;
e4e8b57b KZ	146	}
3e37d7b7 KZ	147	case COL_SIZE:
	148	if (ctl->bytes)
	149	xasprintf(&tmp, "%jd", (intmax_t) file_size);
	150	else
	151	tmp = size_to_human_string(SIZE_SUFFIX_1LETTER, file_size);
b7ebf49c	152	rc = scols_line_refer_data(ln, i, tmp);
3e37d7b7 KZ	153	break;
	154	default:
	155	return -EINVAL;
	156	}
b7ebf49c KZ	157
	158	if (rc)
	159	err(EXIT_FAILURE, _("failed to add output data"));
3e37d7b7 KZ	160	}
	161
	162	return 0;
	163	}
	164
	165	static int do_mincore(struct fincore_control *ctl,
	166	void *window, const size_t len,
	167	const char *name,
	168	off_t *count_incore)
a921a7de MY	169	{
a921a7de MY	170	static unsigned char vec[N_PAGES_IN_WINDOW];
3e37d7b7	171	int n = (len / ctl->pagesize) + ((len % ctl->pagesize)? 1: 0);
a921a7de MY	172
	173	if (mincore (window, len, vec) < 0) {
	174	warn(_("failed to do mincore: %s"), name);
b57fe43c	175	return -errno;
a921a7de MY	176	}
	177
	178	while (n > 0)
	179	{
	180	if (vec[--n] & 0x1)
	181	{
	182	vec[n] = 0;
	183	(*count_incore)++;
	184	}
	185	}
	186
b57fe43c	187	return 0;
a921a7de MY	188	}
a921a7de MY	189
3e37d7b7 KZ	190	static int fincore_fd (struct fincore_control *ctl,
	191	int fd,
	192	const char *name,
a921a7de MY	193	off_t file_size,
	194	off_t *count_incore)
	195	{
452089fa	196	size_t window_size = N_PAGES_IN_WINDOW * ctl->pagesize;
a921a7de MY	197	off_t file_offset;
a921a7de MY	198	void *window = NULL;
b57fe43c	199	int rc = 0;
a921a7de MY	200	int warned_once = 0;
	201
	202	for (file_offset = 0; file_offset < file_size; file_offset += window_size) {
	203	size_t len;
	204
	205	len = file_size - file_offset;
	206	if (len >= window_size)
	207	len = window_size;
	208
	209	window = mmap(window, len, PROT_NONE, MAP_PRIVATE, fd, file_offset);
	210	if (window == MAP_FAILED) {
	211	if (!warned_once) {
b57fe43c	212	rc = -EINVAL;
a921a7de MY	213	warn(_("failed to do mmap: %s"), name);
	214	warned_once = 1;
	215	}
	216	break;
	217	}
	218
3e37d7b7	219	rc = do_mincore(ctl, window, len, name, count_incore);
b57fe43c KZ	220	if (rc)
b57fe43c KZ	221	break;
a921a7de MY	222
	223	munmap (window, len);
	224	}
	225
b57fe43c	226	return rc;
a921a7de MY	227	}
a921a7de MY	228
3e37d7b7 KZ	229	/*
	230	* Returns: <0 on error, 0 success, 1 ignore.
	231	*/
	232	static int fincore_name(struct fincore_control *ctl,
	233	const char *name,
	234	struct stat *sb,
	235	off_t *count_incore)
a921a7de MY	236	{
a921a7de MY	237	int fd;
b57fe43c	238	int rc = 0;
a921a7de MY	239
	240	if ((fd = open (name, O_RDONLY)) < 0) {
	241	warn(_("failed to open: %s"), name);
cff1c113	242	return -errno;
a921a7de MY	243	}
	244
	245	if (fstat (fd, sb) < 0) {
	246	warn(_("failed to do fstat: %s"), name);
b9dc8d07	247	close (fd);
b57fe43c	248	return -errno;
a921a7de MY	249	}
a921a7de MY	250
3e37d7b7 KZ	251	if (S_ISDIR(sb->st_mode))
	252	rc = 1; /* ignore */
	253
	254	else if (sb->st_size)
	255	rc = fincore_fd(ctl, fd, name, sb->st_size, count_incore);
a921a7de MY	256
a921a7de MY	257	close (fd);
b57fe43c	258	return rc;
a921a7de MY	259	}
a921a7de MY	260
86be6a32	261	static void __attribute__((__noreturn__)) usage(void)
3f91dd88	262	{
86be6a32	263	FILE *out = stdout;
c5cb5412 KZ	264	size_t i;
c5cb5412 KZ	265
3f91dd88 KZ	266	fputs(USAGE_HEADER, out);
	267	fprintf(out, _(" %s [options] file...\n"), program_invocation_short_name);
	268
	269	fputs(USAGE_OPTIONS, out);
9b48766f	270	fputs(_(" -J, --json use JSON output format\n"), out);
c5cb5412 KZ	271	fputs(_(" -b, --bytes print sizes in bytes rather than in human readable format\n"), out);
	272	fputs(_(" -n, --noheadings don't print headings\n"), out);
	273	fputs(_(" -o, --output <list> output columns\n"), out);
9b48766f	274	fputs(_(" -r, --raw use raw output format\n"), out);
3f91dd88 KZ	275
	276	fputs(USAGE_SEPARATOR, out);
	277	fputs(USAGE_HELP, out);
	278	fputs(USAGE_VERSION, out);
	279
c3a4cfc5	280	fprintf(out, USAGE_COLUMNS);
c5cb5412 KZ	281
	282	for (i = 0; i < ARRAY_SIZE(infos); i++)
	283	fprintf(out, " %11s %s\n", infos[i].name, _(infos[i].help));
	284
3f91dd88 KZ	285	fprintf(out, USAGE_MAN_TAIL("fincore(1)"));
3f91dd88 KZ	286
86be6a32	287	exit(EXIT_SUCCESS);
3f91dd88 KZ	288	}
3f91dd88 KZ	289
a921a7de MY	290	int main(int argc, char ** argv)
	291	{
	292	int c;
3e37d7b7	293	size_t i;
b57fe43c	294	int rc = EXIT_SUCCESS;
c5cb5412	295	char *outarg = NULL;
a921a7de	296
3e37d7b7	297	struct fincore_control ctl = {
c5cb5412	298	.pagesize = getpagesize()
3e37d7b7 KZ	299	};
3e37d7b7 KZ	300
a921a7de	301	static const struct option longopts[] = {
3f91dd88 KZ	302	{ "bytes", no_argument, NULL, 'b' },
3f91dd88 KZ	303	{ "noheadings", no_argument, NULL, 'n' },
c5cb5412	304	{ "output", required_argument, NULL, 'o' },
a921a7de MY	305	{ "version", no_argument, NULL, 'V' },
a921a7de MY	306	{ "help", no_argument, NULL, 'h' },
9b48766f KZ	307	{ "json", no_argument, NULL, 'J' },
9b48766f KZ	308	{ "raw", no_argument, NULL, 'r' },
a921a7de MY	309	{ NULL, 0, NULL, 0 },
	310	};
	311
	312	setlocale(LC_ALL, "");
	313	bindtextdomain(PACKAGE, LOCALEDIR);
	314	textdomain(PACKAGE);
	315	atexit(close_stdout);
	316
9b48766f	317	while ((c = getopt_long (argc, argv, "bno:JrVh", longopts, NULL)) != -1) {
a921a7de	318	switch (c) {
3f91dd88 KZ	319	case 'b':
	320	ctl.bytes = 1;
	321	break;
	322	case 'n':
	323	ctl.noheadings = 1;
	324	break;
c5cb5412 KZ	325	case 'o':
	326	outarg = optarg;
	327	break;
9b48766f KZ	328	case 'J':
	329	ctl.json = 1;
	330	break;
	331	case 'r':
	332	ctl.raw = 1;
	333	break;
a921a7de MY	334	case 'V':
	335	printf(UTIL_LINUX_VERSION);
	336	return EXIT_SUCCESS;
	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);
a921a7de	373
3e37d7b7	374	if (!scols_table_new_column(ctl.tb, col->name, col->whint, col->flags))
780ce22c	375	err(EXIT_FAILURE, _("failed to allocate output column"));
3e37d7b7	376	}
b57fe43c	377
a921a7de MY	378	for(; optind < argc; optind++) {
	379	char *name = argv[optind];
	380	struct stat sb;
	381	off_t count_incore = 0;
	382
3e37d7b7 KZ	383	switch (fincore_name(&ctl, name, &sb, &count_incore)) {
	384	case 0:
	385	add_output_data(&ctl, name, sb.st_size, count_incore);
	386	break;
	387	case 1:
	388	break; /* ignore */
	389	default:
b57fe43c	390	rc = EXIT_FAILURE;
3e37d7b7	391	break;
a921a7de MY	392	}
	393	}
	394
3e37d7b7 KZ	395	scols_print_table(ctl.tb);
	396	scols_unref_table(ctl.tb);
	397
b57fe43c	398	return rc;
a921a7de	399	}