[thirdparty/xfsprogs-dev.git] / quota / quot.c

/*
 * Copyright (c) 2005 Silicon Graphics, Inc.
 * All Rights Reserved.
 *
 * 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.
 *
 * 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 the Free Software Foundation,
 * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

#include <stdbool.h>
#include "command.h"
#include <ctype.h>
#include <pwd.h>
#include <grp.h>
#include "init.h"
#include "quota.h"

typedef struct du {
	struct du	*next;
	__uint64_t	blocks;
	__uint64_t	blocks30;
	__uint64_t	blocks60;
	__uint64_t	blocks90;
	__uint64_t	nfiles;
	__uint32_t	id;
} du_t;

#define	TSIZE		500
static __uint64_t	sizes[TSIZE];
static __uint64_t	overflow;

#define	NDU		60000
#define	DUHASH		8209
static du_t		du[3][NDU];
static du_t		*duhash[3][DUHASH];
static int		ndu[3];	/* #usr/grp/prj */

#define NBSTAT 		4069

static time_t now;
static cmdinfo_t quot_cmd;

static void
quot_help(void)
{
	printf(_(
"\n"
" display a summary of filesystem ownership\n"
"\n"
" -a -- summarise for all local XFS filesystem mount points\n"
" -c -- display three columns giving file size in kilobytes, number of files\n"
"       of that size, and cumulative total of kilobytes in that size or\n"
"       smaller file.  The last row is used as an overflow bucket and is the\n"
"       total of all files greater than 500 kilobytes.\n"
" -v -- display three columns containing the number of kilobytes not\n"
"       accessed in the last 30, 60, and 90 days.\n"
" -g -- display group summary\n"
" -p -- display project summary\n"
" -u -- display user summary\n"
" -b -- display number of blocks used\n"
" -i -- display number of inodes used\n"
" -r -- display number of realtime blocks used\n"
" -n -- skip identifier-to-name translations, just report IDs\n"
" -N -- suppress the initial header\n"
" -f -- send output to a file\n"
" The (optional) user/group/project can be specified either by name or by\n"
" number (i.e. uid/gid/projid).\n"
"\n"));
}

static void
quot_bulkstat_add(
	xfs_bstat_t	*p,
	uint		flags)
{
	du_t		*dp;
	du_t		**hp;
	__uint64_t	size;
	__uint32_t	i, id;

	if ((p->bs_mode & S_IFMT) == 0)
		return;
	size = howmany((p->bs_blocks * p->bs_blksize), 0x400ULL);

	if (flags & HISTOGRAM_FLAG) {
		if (!(S_ISDIR(p->bs_mode) || S_ISREG(p->bs_mode)))
			return;
		if (size >= TSIZE) {
			overflow += size;
			size = TSIZE - 1;
		}
		sizes[(int)size]++;
		return;
	}
	for (i = 0; i < 3; i++) {
		id = (i == 0) ? p->bs_uid : ((i == 1) ?
			p->bs_gid : bstat_get_projid(p));
		hp = &duhash[i][id % DUHASH];
		for (dp = *hp; dp; dp = dp->next)
			if (dp->id == id)
				break;
		if (dp == NULL) {
			if (ndu[i] >= NDU)
				return;
			dp = &du[i][(ndu[i]++)];
			dp->next = *hp;
			*hp = dp;
			dp->id = id;
			dp->nfiles = 0;
			dp->blocks = 0;
			dp->blocks30 = 0;
			dp->blocks60 = 0;
			dp->blocks90 = 0;
		}
		dp->blocks += size;

		if (now - p->bs_atime.tv_sec > 30 * (60*60*24))
			dp->blocks30 += size;
		if (now - p->bs_atime.tv_sec > 60 * (60*60*24))
			dp->blocks60 += size;
		if (now - p->bs_atime.tv_sec > 90 * (60*60*24))
			dp->blocks90 += size;
		dp->nfiles++;
	}
}

static void
quot_bulkstat_mount(
	char			*fsdir,
	uint			flags)
{
	xfs_fsop_bulkreq_t	bulkreq;
	xfs_bstat_t		*buf;
	__u64			last = 0;
	__s32			count;
	int			i, sts, fsfd;
	du_t			**dp;

	/*
	 * Initialize tables between checks; because of the qsort
	 * in report() the hash tables must be rebuilt each time.
	 */
	for (sts = 0; sts < TSIZE; sts++)
		sizes[sts] = 0;
	overflow = 0;
	for (i = 0; i < 3; i++)
		for (dp = duhash[i]; dp < &duhash[i][DUHASH]; dp++)
			*dp = NULL;
	ndu[0] = ndu[1] = ndu[2] = 0;

	fsfd = open(fsdir, O_RDONLY);
	if (fsfd < 0) {
		perror(fsdir);
		return;
	}

	buf = (xfs_bstat_t *)calloc(NBSTAT, sizeof(xfs_bstat_t));
	if (!buf) {
		perror("calloc");
		close(fsfd);
		return;
	}

	bulkreq.lastip = &last;
	bulkreq.icount = NBSTAT;
	bulkreq.ubuffer = buf;
	bulkreq.ocount = &count;

	while ((sts = xfsctl(fsdir, fsfd, XFS_IOC_FSBULKSTAT, &bulkreq)) == 0) {
		if (count == 0)
			break;
		for (i = 0; i < count; i++)
			quot_bulkstat_add(&buf[i], flags);
	}
	if (sts < 0)
		perror("XFS_IOC_FSBULKSTAT"),
	free(buf);
	close(fsfd);
}

static int
qcompare(
	du_t		*p1,
	du_t		*p2)
{
	if (p1->blocks > p2->blocks)
		return -1;
	if (p1->blocks < p2->blocks)
		return 1;
	if (p1->id > p2->id)
		return 1;
	else if (p1->id < p2->id)
		return -1;
	return 0;
}

typedef char *(*idtoname_t)(__uint32_t);

static void
quot_report_mount_any_type(
	FILE		*fp,
	du_t		*dp,
	int		count,
	idtoname_t	names,
	uint		form,
	uint		type,
	fs_path_t	*mount,
	uint		flags)
{
	char		*cp;

	fprintf(fp, _("%s (%s) %s:\n"),
		mount->fs_name, mount->fs_dir, type_to_string(type));
	qsort(dp, count, sizeof(dp[0]),
		(int (*)(const void *, const void *))qcompare);
	for (; dp < &dp[count]; dp++) {
		if (dp->blocks == 0)
			return;
		fprintf(fp, "%8llu    ", (unsigned long long) dp->blocks);
		if (form & XFS_INODE_QUOTA)
			fprintf(fp, "%8llu    ",
				(unsigned long long) dp->nfiles);
		if (!(flags & NO_LOOKUP_FLAG) &&
		    ((cp = (names)(dp->id)) != NULL))
			fprintf(fp, "%-8.8s", cp);
		else
			fprintf(fp, "#%-7d", dp->id);
		if (flags & VERBOSE_FLAG)
			fprintf(fp, "    %8llu    %8llu    %8llu",
			       (unsigned long long) dp->blocks30,
			       (unsigned long long) dp->blocks60,
			       (unsigned long long) dp->blocks90);
		fputc('\n', fp);
	}
}

static void
quot_report_mount(
	FILE		*fp,
	uint		form,
	uint		type,
	fs_path_t	*mount,
	uint		flags)
{
	switch (type) {
	case XFS_GROUP_QUOTA:
		quot_report_mount_any_type(fp, du[1], ndu[1], gid_to_name,
						form, type, mount, flags);
		break;
	case XFS_PROJ_QUOTA:
		quot_report_mount_any_type(fp, du[2], ndu[2], prid_to_name,
						form, type, mount, flags);
		break;
	case XFS_USER_QUOTA:
		quot_report_mount_any_type(fp, du[0], ndu[0], uid_to_name,
						form, type, mount, flags);
	}
}

static void
quot_report(
	FILE		*fp,
	uint		form,
	uint		type,
	char		*dir,
	uint		flags)
{
	fs_cursor_t	cursor;
	fs_path_t	*mount;

	now = time(NULL);
	fs_cursor_initialise(dir, FS_MOUNT_POINT, &cursor);
	while ((mount = fs_cursor_next_entry(&cursor))) {
		quot_bulkstat_mount(mount->fs_dir, flags);
		quot_report_mount(fp, form, type, mount, flags);
	}
}

static void
quot_histogram_mount(
	FILE		*fp,
	fs_path_t	*mount,
	uint		flags)
{
	__uint64_t	t = 0;
	int		i;

	fprintf(fp, _("%s (%s):\n"), mount->fs_name, mount->fs_dir);

	for (i = 0; i < TSIZE - 1; i++)
		if (sizes[i] > 0) {
			t += sizes[i] * i;
			fprintf(fp, _("%d\t%llu\t%llu\n"), i,
			       (unsigned long long) sizes[i],
			       (unsigned long long) t);
		}
	fprintf(fp, _("%d\t%llu\t%llu\n"), TSIZE - 1,
		(unsigned long long) sizes[TSIZE - 1],
		(unsigned long long) (overflow + t));
}

static void
quot_histogram(
	FILE		*fp,
	char		*dir,
	uint		flags)
{
	fs_cursor_t	cursor;
	fs_path_t	*mount;

	fs_cursor_initialise(dir, FS_MOUNT_POINT, &cursor);
	while ((mount = fs_cursor_next_entry(&cursor))) {
		quot_bulkstat_mount(mount->fs_dir, flags);
		quot_histogram_mount(fp, mount, flags);
	}
}

static void
quot_any_type(
	FILE		*fp,
	uint		form,
	uint		type,
	char		*dir,
	uint		flags)
{
	if (flags & HISTOGRAM_FLAG)
		quot_histogram(fp, dir, flags);
	else
		quot_report(fp, form, type, dir, flags);
}

static int
quot_f(
	int		argc,
	char		**argv)
{
	FILE		*fp = NULL;
	char		*fname = NULL;
	int		c, flags = 0, type = 0, form = 0;

	while ((c = getopt(argc, argv, "abcf:ghinpruv")) != EOF) {
		switch (c) {
		case 'f':
			fname = optarg;
			break;
		case 'b':
			form |= XFS_BLOCK_QUOTA;
			break;
		case 'i':
			form |= XFS_INODE_QUOTA;
			break;
		case 'r':
			form |= XFS_RTBLOCK_QUOTA;
			break;
		case 'g':
			type |= XFS_GROUP_QUOTA;
			break;
		case 'p':
			type |= XFS_PROJ_QUOTA;
			break;
		case 'u':
			type |= XFS_USER_QUOTA;
			break;
		case 'a':
			flags |= ALL_MOUNTS_FLAG;
			break;
		case 'c':
			flags |= HISTOGRAM_FLAG;
			break;
		case 'n':
			flags |= NO_LOOKUP_FLAG;
			break;
		case 'v':
			flags |= VERBOSE_FLAG;
			break;
		default:
			return command_usage(&quot_cmd);
		}
	}

	if (!form)
		form = XFS_BLOCK_QUOTA;

	if (!type) {
		type = XFS_USER_QUOTA;
	} else if (type != XFS_GROUP_QUOTA &&
	           type != XFS_PROJ_QUOTA &&
	           type != XFS_USER_QUOTA) {
		return command_usage(&quot_cmd);
	}

	if ((fp = fopen_write_secure(fname)) == NULL)
		return 0;

	if (argc == optind) {
		if (flags & ALL_MOUNTS_FLAG)
			quot_any_type(fp, form, type, NULL, flags);
		else if (fs_path->fs_flags & FS_MOUNT_POINT)
			quot_any_type(fp, form, type, fs_path->fs_dir, flags);
	} else while (argc > optind) {
		quot_any_type(fp, form, type, argv[optind++], flags);
	}

	if (fname)
		fclose(fp);
	return 0;
}

void
quot_init(void)
{
	quot_cmd.name = "quot";
	quot_cmd.cfunc = quot_f;
	quot_cmd.argmin = 0;
	quot_cmd.argmax = -1;
	quot_cmd.args = _("[-bir] [-g|-p|-u] [-acv] [-f file]");
	quot_cmd.oneline = _("summarize filesystem ownership");
	quot_cmd.help = quot_help;

	if (expert)
		add_command(&quot_cmd);
}
Commit	Line	Data
5aead01d	1	/*
da23017d NS	2	* Copyright (c) 2005 Silicon Graphics, Inc.
da23017d NS	3	* All Rights Reserved.
5aead01d	4	*
da23017d NS	5	* This program is free software; you can redistribute it and/or
da23017d NS	6	* modify it under the terms of the GNU General Public License as
5aead01d NS	7	* published by the Free Software Foundation.
5aead01d NS	8	*
da23017d NS	9	* This program is distributed in the hope that it would be useful,
	10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	* GNU General Public License for more details.
5aead01d	13	*
da23017d NS	14	* You should have received a copy of the GNU General Public License
	15	* along with this program; if not, write the Free Software Foundation,
	16	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
5aead01d NS	17	*/
5aead01d NS	18
29647c8d	19	#include <stdbool.h>
6b803e5a	20	#include "command.h"
5aead01d NS	21	#include <ctype.h>
	22	#include <pwd.h>
	23	#include <grp.h>
	24	#include "init.h"
	25	#include "quota.h"
	26
	27	typedef struct du {
	28	struct du *next;
	29	__uint64_t blocks;
	30	__uint64_t blocks30;
	31	__uint64_t blocks60;
	32	__uint64_t blocks90;
	33	__uint64_t nfiles;
	34	__uint32_t id;
	35	} du_t;
	36
	37	#define TSIZE 500
	38	static __uint64_t sizes[TSIZE];
	39	static __uint64_t overflow;
	40
	41	#define NDU 60000
	42	#define DUHASH 8209
	43	static du_t du[3][NDU];
	44	static du_t *duhash[3][DUHASH];
	45	static int ndu[3]; /* #usr/grp/prj */
	46
	47	#define NBSTAT 4069
	48
	49	static time_t now;
	50	static cmdinfo_t quot_cmd;
	51
	52	static void
	53	quot_help(void)
	54	{
	55	printf(_(
	56	"\n"
	57	" display a summary of filesystem ownership\n"
	58	"\n"
	59	" -a -- summarise for all local XFS filesystem mount points\n"
	60	" -c -- display three columns giving file size in kilobytes, number of files\n"
	61	" of that size, and cumulative total of kilobytes in that size or\n"
	62	" smaller file. The last row is used as an overflow bucket and is the\n"
	63	" total of all files greater than 500 kilobytes.\n"
	64	" -v -- display three columns containing the number of kilobytes not\n"
	65	" accessed in the last 30, 60, and 90 days.\n"
	66	" -g -- display group summary\n"
	67	" -p -- display project summary\n"
	68	" -u -- display user summary\n"
	69	" -b -- display number of blocks used\n"
	70	" -i -- display number of inodes used\n"
	71	" -r -- display number of realtime blocks used\n"
1774874a NS	72	" -n -- skip identifier-to-name translations, just report IDs\n"
1774874a NS	73	" -N -- suppress the initial header\n"
5aead01d NS	74	" -f -- send output to a file\n"
	75	" The (optional) user/group/project can be specified either by name or by\n"
	76	" number (i.e. uid/gid/projid).\n"
	77	"\n"));
	78	}
	79
	80	static void
	81	quot_bulkstat_add(
	82	xfs_bstat_t *p,
	83	uint flags)
	84	{
	85	du_t *dp;
	86	du_t **hp;
	87	__uint64_t size;
	88	__uint32_t i, id;
	89
	90	if ((p->bs_mode & S_IFMT) == 0)
	91	return;
	92	size = howmany((p->bs_blocks * p->bs_blksize), 0x400ULL);
	93
	94	if (flags & HISTOGRAM_FLAG) {
	95	if (!(S_ISDIR(p->bs_mode) \|\| S_ISREG(p->bs_mode)))
	96	return;
	97	if (size >= TSIZE) {
	98	overflow += size;
	99	size = TSIZE - 1;
	100	}
	101	sizes[(int)size]++;
	102	return;
	103	}
	104	for (i = 0; i < 3; i++) {
	105	id = (i == 0) ? p->bs_uid : ((i == 1) ?
22bc10ed	106	p->bs_gid : bstat_get_projid(p));
5aead01d NS	107	hp = &duhash[i][id % DUHASH];
	108	for (dp = *hp; dp; dp = dp->next)
	109	if (dp->id == id)
	110	break;
5e656dbb	111	if (dp == NULL) {
5aead01d NS	112	if (ndu[i] >= NDU)
	113	return;
	114	dp = &du[i][(ndu[i]++)];
	115	dp->next = *hp;
	116	*hp = dp;
	117	dp->id = id;
	118	dp->nfiles = 0;
	119	dp->blocks = 0;
	120	dp->blocks30 = 0;
	121	dp->blocks60 = 0;
	122	dp->blocks90 = 0;
	123	}
	124	dp->blocks += size;
	125
	126	if (now - p->bs_atime.tv_sec > 30 * (606024))
	127	dp->blocks30 += size;
	128	if (now - p->bs_atime.tv_sec > 60 * (606024))
	129	dp->blocks60 += size;
	130	if (now - p->bs_atime.tv_sec > 90 * (606024))
	131	dp->blocks90 += size;
	132	dp->nfiles++;
	133	}
	134	}
	135
	136	static void
	137	quot_bulkstat_mount(
	138	char *fsdir,
	139	uint flags)
	140	{
	141	xfs_fsop_bulkreq_t bulkreq;
	142	xfs_bstat_t *buf;
d026b19e NS	143	__u64 last = 0;
d026b19e NS	144	__s32 count;
5aead01d NS	145	int i, sts, fsfd;
	146	du_t **dp;
	147
	148	/*
	149	* Initialize tables between checks; because of the qsort
	150	* in report() the hash tables must be rebuilt each time.
	151	*/
	152	for (sts = 0; sts < TSIZE; sts++)
	153	sizes[sts] = 0;
	154	overflow = 0;
	155	for (i = 0; i < 3; i++)
	156	for (dp = duhash[i]; dp < &duhash[i][DUHASH]; dp++)
5e656dbb	157	*dp = NULL;
5aead01d NS	158	ndu[0] = ndu[1] = ndu[2] = 0;
	159
	160	fsfd = open(fsdir, O_RDONLY);
	161	if (fsfd < 0) {
	162	perror(fsdir);
	163	return;
	164	}
	165
	166	buf = (xfs_bstat_t *)calloc(NBSTAT, sizeof(xfs_bstat_t));
	167	if (!buf) {
	168	perror("calloc");
11e06961	169	close(fsfd);
5aead01d NS	170	return;
	171	}
	172
	173	bulkreq.lastip = &last;
	174	bulkreq.icount = NBSTAT;
	175	bulkreq.ubuffer = buf;
	176	bulkreq.ocount = &count;
	177
	178	while ((sts = xfsctl(fsdir, fsfd, XFS_IOC_FSBULKSTAT, &bulkreq)) == 0) {
	179	if (count == 0)
	180	break;
	181	for (i = 0; i < count; i++)
	182	quot_bulkstat_add(&buf[i], flags);
	183	}
	184	if (sts < 0)
	185	perror("XFS_IOC_FSBULKSTAT"),
	186	free(buf);
	187	close(fsfd);
	188	}
	189
	190	static int
	191	qcompare(
	192	du_t *p1,
	193	du_t *p2)
	194	{
	195	if (p1->blocks > p2->blocks)
	196	return -1;
	197	if (p1->blocks < p2->blocks)
	198	return 1;
	199	if (p1->id > p2->id)
	200	return 1;
	201	else if (p1->id < p2->id)
	202	return -1;
	203	return 0;
	204	}
	205
	206	typedef char (idtoname_t)(__uint32_t);
	207
	208	static void
	209	quot_report_mount_any_type(
	210	FILE *fp,
	211	du_t *dp,
	212	int count,
	213	idtoname_t names,
	214	uint form,
	215	uint type,
	216	fs_path_t *mount,
	217	uint flags)
	218	{
	219	char *cp;
	220
	221	fprintf(fp, _("%s (%s) %s:\n"),
	222	mount->fs_name, mount->fs_dir, type_to_string(type));
	223	qsort(dp, count, sizeof(dp[0]),
	224	(int ()(const void , const void *))qcompare);
	225	for (; dp < &dp[count]; dp++) {
	226	if (dp->blocks == 0)
	227	return;
	228	fprintf(fp, "%8llu ", (unsigned long long) dp->blocks);
	229	if (form & XFS_INODE_QUOTA)
	230	fprintf(fp, "%8llu ",
	231	(unsigned long long) dp->nfiles);
1774874a NS	232	if (!(flags & NO_LOOKUP_FLAG) &&
1774874a NS	233	((cp = (names)(dp->id)) != NULL))
5aead01d NS	234	fprintf(fp, "%-8.8s", cp);
	235	else
	236	fprintf(fp, "#%-7d", dp->id);
	237	if (flags & VERBOSE_FLAG)
	238	fprintf(fp, " %8llu %8llu %8llu",
	239	(unsigned long long) dp->blocks30,
	240	(unsigned long long) dp->blocks60,
	241	(unsigned long long) dp->blocks90);
	242	fputc('\n', fp);
	243	}
	244	}
	245
	246	static void
	247	quot_report_mount(
	248	FILE *fp,
	249	uint form,
	250	uint type,
	251	fs_path_t *mount,
	252	uint flags)
	253	{
	254	switch (type) {
	255	case XFS_GROUP_QUOTA:
	256	quot_report_mount_any_type(fp, du[1], ndu[1], gid_to_name,
	257	form, type, mount, flags);
	258	break;
	259	case XFS_PROJ_QUOTA:
	260	quot_report_mount_any_type(fp, du[2], ndu[2], prid_to_name,
	261	form, type, mount, flags);
	262	break;
	263	case XFS_USER_QUOTA:
	264	quot_report_mount_any_type(fp, du[0], ndu[0], uid_to_name,
	265	form, type, mount, flags);
	266	}
	267	}
	268
	269	static void
	270	quot_report(
	271	FILE *fp,
	272	uint form,
	273	uint type,
	274	char *dir,
	275	uint flags)
	276	{
	277	fs_cursor_t cursor;
	278	fs_path_t *mount;
	279
5e656dbb	280	now = time(NULL);
5aead01d NS	281	fs_cursor_initialise(dir, FS_MOUNT_POINT, &cursor);
	282	while ((mount = fs_cursor_next_entry(&cursor))) {
	283	quot_bulkstat_mount(mount->fs_dir, flags);
	284	quot_report_mount(fp, form, type, mount, flags);
	285	}
	286	}
	287
	288	static void
	289	quot_histogram_mount(
	290	FILE *fp,
	291	fs_path_t *mount,
	292	uint flags)
	293	{
	294	__uint64_t t = 0;
	295	int i;
	296
	297	fprintf(fp, _("%s (%s):\n"), mount->fs_name, mount->fs_dir);
	298
	299	for (i = 0; i < TSIZE - 1; i++)
	300	if (sizes[i] > 0) {
	301	t += sizes[i] * i;
	302	fprintf(fp, _("%d\t%llu\t%llu\n"), i,
	303	(unsigned long long) sizes[i],
	304	(unsigned long long) t);
	305	}
	306	fprintf(fp, _("%d\t%llu\t%llu\n"), TSIZE - 1,
	307	(unsigned long long) sizes[TSIZE - 1],
	308	(unsigned long long) (overflow + t));
	309	}
	310
	311	static void
	312	quot_histogram(
	313	FILE *fp,
	314	char *dir,
	315	uint flags)
	316	{
	317	fs_cursor_t cursor;
	318	fs_path_t *mount;
	319
	320	fs_cursor_initialise(dir, FS_MOUNT_POINT, &cursor);
	321	while ((mount = fs_cursor_next_entry(&cursor))) {
	322	quot_bulkstat_mount(mount->fs_dir, flags);
	323	quot_histogram_mount(fp, mount, flags);
	324	}
	325	}
	326
	327	static void
	328	quot_any_type(
	329	FILE *fp,
	330	uint form,
	331	uint type,
	332	char *dir,
	333	uint flags)
	334	{
	335	if (flags & HISTOGRAM_FLAG)
	336	quot_histogram(fp, dir, flags);
	337	else
	338	quot_report(fp, form, type, dir, flags);
	339	}
	340
	341	static int
	342	quot_f(
	343	int argc,
	344	char **argv)
345	{
346	FILE *fp = NULL;
347	char *fname = NULL;
348	int c, flags = 0, type = 0, form = 0;
349
1774874a	350	while ((c = getopt(argc, argv, "abcf:ghinpruv")) != EOF) {
5aead01d NS	351	switch (c) {
	352	case 'f':
	353	fname = optarg;
	354	break;
	355	case 'b':
	356	form \|= XFS_BLOCK_QUOTA;
	357	break;
	358	case 'i':
	359	form \|= XFS_INODE_QUOTA;
	360	break;
	361	case 'r':
	362	form \|= XFS_RTBLOCK_QUOTA;
	363	break;
	364	case 'g':
c614d3bf	365	type \|= XFS_GROUP_QUOTA;
5aead01d NS	366	break;
5aead01d NS	367	case 'p':
c614d3bf	368	type \|= XFS_PROJ_QUOTA;
5aead01d NS	369	break;
5aead01d NS	370	case 'u':
c614d3bf	371	type \|= XFS_USER_QUOTA;
5aead01d NS	372	break;
	373	case 'a':
	374	flags \|= ALL_MOUNTS_FLAG;
	375	break;
	376	case 'c':
	377	flags \|= HISTOGRAM_FLAG;
	378	break;
1774874a NS	379	case 'n':
	380	flags \|= NO_LOOKUP_FLAG;
	381	break;
5aead01d NS	382	case 'v':
	383	flags \|= VERBOSE_FLAG;
	384	break;
	385	default:
	386	return command_usage(&quot_cmd);
	387	}
	388	}
	389
	390	if (!form)
	391	form = XFS_BLOCK_QUOTA;
	392
c614d3bf	393	if (!type) {
5aead01d	394	type = XFS_USER_QUOTA;
c614d3bf ZL	395	} else if (type != XFS_GROUP_QUOTA &&
	396	type != XFS_PROJ_QUOTA &&
	397	type != XFS_USER_QUOTA) {
	398	return command_usage(&quot_cmd);
	399	}
5aead01d NS	400
	401	if ((fp = fopen_write_secure(fname)) == NULL)
	402	return 0;
	403
fa13a00f NS	404	if (argc == optind) {
	405	if (flags & ALL_MOUNTS_FLAG)
	406	quot_any_type(fp, form, type, NULL, flags);
	407	else if (fs_path->fs_flags & FS_MOUNT_POINT)
	408	quot_any_type(fp, form, type, fs_path->fs_dir, flags);
	409	} else while (argc > optind) {
5aead01d	410	quot_any_type(fp, form, type, argv[optind++], flags);
fa13a00f	411	}
5aead01d NS	412
	413	if (fname)
	414	fclose(fp);
	415	return 0;
	416	}
	417
	418	void
	419	quot_init(void)
	420	{
ad765595	421	quot_cmd.name = "quot";
5aead01d NS	422	quot_cmd.cfunc = quot_f;
	423	quot_cmd.argmin = 0;
	424	quot_cmd.argmax = -1;
c614d3bf	425	quot_cmd.args = _("[-bir] [-g\|-p\|-u] [-acv] [-f file]");
5aead01d NS	426	quot_cmd.oneline = _("summarize filesystem ownership");
	427	quot_cmd.help = quot_help;
	428
	429	if (expert)
	430	add_command(&quot_cmd);
	431	}