quot.c revision 156015 
1/*
2 * Copyright (C) 1991, 1994 Wolfgang Solfrank.
3 * Copyright (C) 1991, 1994 TooLs GmbH.
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 *    notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 *    notice, this list of conditions and the following disclaimer in the
13 *    documentation and/or other materials provided with the distribution.
14 * 3. All advertising materials mentioning features or use of this software
15 *    must display the following acknowledgement:
16 *	This product includes software developed by TooLs GmbH.
17 * 4. The name of TooLs GmbH may not be used to endorse or promote products
18 *    derived from this software without specific prior written permission.
19 *
20 * THIS SOFTWARE IS PROVIDED BY TOOLS GMBH ``AS IS'' AND ANY EXPRESS OR
21 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
22 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
23 * IN NO EVENT SHALL TOOLS GMBH BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
25 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
26 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
27 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
28 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
29 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 */
31
32#include <sys/cdefs.h>
33__FBSDID("$FreeBSD: head/usr.sbin/quot/quot.c 156015 2006-02-25 23:50:15Z dwmalone $");
34
35#include <sys/param.h>
36#include <sys/stdint.h>
37#include <sys/mount.h>
38#include <sys/disklabel.h>
39#include <sys/time.h>
40#include <ufs/ufs/dinode.h>
41#include <ufs/ffs/fs.h>
42
43#include <err.h>
44#include <fcntl.h>
45#include <fstab.h>
46#include <errno.h>
47#include <paths.h>
48#include <pwd.h>
49#include <stdio.h>
50#include <stdlib.h>
51#include <string.h>
52#include <unistd.h>
53
54/* some flags of what to do: */
55static char estimate;
56static char count;
57static char unused;
58static void (*func)(int, struct fs *, char *);
59static long blocksize;
60static char *header;
61static int headerlen;
62
63static union dinode *get_inode(int, struct fs *, ino_t);
64static int	virtualblocks(struct fs *, union dinode *);
65static int	isfree(struct fs *, union dinode *);
66static void	inituser(void);
67static void	usrrehash(void);
68static struct user *user(uid_t);
69static int	cmpusers(const void *, const void *);
70static void	uses(uid_t, daddr_t, time_t);
71static void	initfsizes(void);
72static void	dofsizes(int, struct fs *, char *);
73static void	douser(int, struct fs *, char *);
74static void	donames(int, struct fs *, char *);
75static void	usage(void);
76static void	quot(char *, char *);
77
78/*
79 * Original BSD quot doesn't round to number of frags/blocks,
80 * doesn't account for indirection blocks and gets it totally
81 * wrong if the	size is a multiple of the blocksize.
82 * The new code always counts the number of 512 byte blocks
83 * instead of the number of kilobytes and converts them	to
84 * kByte when done (on request).
85 *
86 * Due to the size of modern disks, we must cast intermediate
87 * values to 64 bits to prevent potential overflows.
88 */
89#ifdef	COMPAT
90#define	SIZE(n)	(n)
91#else
92#define	SIZE(n) ((int)(((quad_t)(n) * 512 + blocksize - 1)/blocksize))
93#endif
94
95#define	INOCNT(fs)	((fs)->fs_ipg)
96#define	INOSZ(fs) \
97	(((fs)->fs_magic == FS_UFS1_MAGIC ? sizeof(struct ufs1_dinode) : \
98	sizeof(struct ufs2_dinode)) * INOCNT(fs))
99
100union dinode {
101	struct ufs1_dinode dp1;
102	struct ufs2_dinode dp2;
103};
104#define	DIP(fs, dp, field) \
105	(((fs)->fs_magic == FS_UFS1_MAGIC) ? \
106	(dp)->dp1.field : (dp)->dp2.field)
107
108static union dinode *
109get_inode(fd,super,ino)
110	int fd;
111	struct fs *super;
112	ino_t ino;
113{
114	static caddr_t ipbuf;
115	static struct cg *cgp;
116	static ino_t last;
117	static int cg;
118	struct ufs2_dinode *di2;
119
120	if (fd < 0) {		/* flush cache */
121		if (ipbuf) {
122			free(ipbuf);
123			ipbuf = 0;
124			if (super->fs_magic == FS_UFS2_MAGIC) {
125				free(cgp);
126				cgp = 0;
127			}
128		}
129		return 0;
130	}
131
132	if (!ipbuf || ino < last || ino >= last + INOCNT(super)) {
133		if (super->fs_magic == FS_UFS2_MAGIC &&
134		    (!cgp || cg != ino_to_cg(super, ino))) {
135			cg = ino_to_cg(super, ino);
136			if (!cgp && !(cgp = malloc(super->fs_cgsize)))
137				errx(1, "allocate cg");
138			if (lseek(fd, (off_t)cgtod(super, cg) << super->fs_fshift, 0) < 0)
139				err(1, "lseek cg");
140			if (read(fd, cgp, super->fs_cgsize) != super->fs_cgsize)
141				err(1, "read cg");
142			if (!cg_chkmagic(cgp))
143				errx(1, "cg has bad magic");
144		}
145		if (!ipbuf
146		    && !(ipbuf = malloc(INOSZ(super))))
147			errx(1, "allocate inodes");
148		last = (ino / INOCNT(super)) * INOCNT(super);
149		if (lseek(fd, (off_t)ino_to_fsba(super, last) << super->fs_fshift, 0) < (off_t)0
150		    || read(fd, ipbuf, INOSZ(super)) != (ssize_t)INOSZ(super))
151			err(1, "read inodes");
152	}
153
154	if (super->fs_magic == FS_UFS1_MAGIC)
155		return ((union dinode *)
156		    &((struct ufs1_dinode *)ipbuf)[ino % INOCNT(super)]);
157	di2 = &((struct ufs2_dinode *)ipbuf)[ino % INOCNT(super)];
158	/* If the inode is unused, it might be unallocated too, so zero it. */
159	if (isclr(cg_inosused(cgp), ino % super->fs_ipg))
160		bzero(di2, sizeof (*di2));
161	return ((union dinode *)di2);
162}
163
164#ifdef	COMPAT
165#define	actualblocks(fs, dp)	(DIP(fs, dp, di_blocks) / 2)
166#else
167#define	actualblocks(fs, dp)	DIP(fs, dp, di_blocks)
168#endif
169
170static int virtualblocks(super, dp)
171	struct fs *super;
172	union dinode *dp;
173{
174	register off_t nblk, sz;
175
176	sz = DIP(super, dp, di_size);
177#ifdef	COMPAT
178	if (lblkno(super,sz) >= NDADDR) {
179		nblk = blkroundup(super,sz);
180		if (sz == nblk)
181			nblk += super->fs_bsize;
182	}
183
184	return sz / 1024;
185
186#else	/* COMPAT */
187
188	if (lblkno(super,sz) >= NDADDR) {
189		nblk = blkroundup(super,sz);
190		sz = lblkno(super,nblk);
191		sz = (sz - NDADDR + NINDIR(super) - 1) / NINDIR(super);
192		while (sz > 0) {
193			nblk += sz * super->fs_bsize;
194			/* sz - 1 rounded up */
195			sz = (sz - 1 + NINDIR(super) - 1) / NINDIR(super);
196		}
197	} else
198		nblk = fragroundup(super,sz);
199
200	return nblk / 512;
201#endif	/* COMPAT */
202}
203
204static int
205isfree(super, dp)
206	struct fs *super;
207	union dinode *dp;
208{
209#ifdef	COMPAT
210	return (DIP(super, dp, di_mode) & IFMT) == 0;
211#else	/* COMPAT */
212
213	switch (DIP(super, dp, di_mode) & IFMT) {
214	case IFIFO:
215	case IFLNK:		/* should check FASTSYMLINK? */
216	case IFDIR:
217	case IFREG:
218		return 0;
219	case IFCHR:
220	case IFBLK:
221	case IFSOCK:
222	case IFWHT:
223	case 0:
224		return 1;
225	default:
226		errx(1, "unknown IFMT 0%o", DIP(super, dp, di_mode) & IFMT);
227	}
228#endif
229}
230
231static struct user {
232	uid_t uid;
233	char *name;
234	daddr_t space;
235	long count;
236	daddr_t spc30;
237	daddr_t spc60;
238	daddr_t spc90;
239} *users;
240static int nusers;
241
242static void
243inituser()
244{
245	register int i;
246	register struct user *usr;
247
248	if (!nusers) {
249		nusers = 8;
250		if (!(users =
251		    (struct user *)calloc(nusers,sizeof(struct user))))
252			errx(1, "allocate users");
253	} else {
254		for (usr = users, i = nusers; --i >= 0; usr++) {
255			usr->space = usr->spc30 = usr->spc60 = usr->spc90 = 0;
256			usr->count = 0;
257		}
258	}
259}
260
261static void
262usrrehash()
263{
264	register int i;
265	register struct user *usr, *usrn;
266	struct user *svusr;
267
268	svusr = users;
269	nusers <<= 1;
270	if (!(users = (struct user *)calloc(nusers,sizeof(struct user))))
271		errx(1, "allocate users");
272	for (usr = svusr, i = nusers >> 1; --i >= 0; usr++) {
273		for (usrn = users + (usr->uid&(nusers - 1)); usrn->name;
274		    usrn--) {
275			if (usrn <= users)
276				usrn = users + nusers;
277		}
278		*usrn = *usr;
279	}
280}
281
282static struct user *
283user(uid)
284	uid_t uid;
285{
286	register struct user *usr;
287	register int i;
288	struct passwd *pwd;
289
290	while (1) {
291		for (usr = users + (uid&(nusers - 1)), i = nusers; --i >= 0;
292		    usr--) {
293			if (!usr->name) {
294				usr->uid = uid;
295
296				if (!(pwd = getpwuid(uid))) {
297					if ((usr->name = (char *)malloc(7)))
298						sprintf(usr->name,"#%d",uid);
299				} else {
300					if ((usr->name = (char *)
301					    malloc(strlen(pwd->pw_name) + 1)))
302						strcpy(usr->name,pwd->pw_name);
303				}
304				if (!usr->name)
305					errx(1, "allocate users");
306
307				return usr;
308
309			} else if (usr->uid == uid)
310				return usr;
311
312			if (usr <= users)
313				usr = users + nusers;
314		}
315		usrrehash();
316	}
317}
318
319static int
320cmpusers(v1,v2)
321	const void *v1, *v2;
322{
323	const struct user *u1, *u2;
324	u1 = (const struct user *)v1;
325	u2 = (const struct user *)v2;
326
327	return u2->space - u1->space;
328}
329
330#define	sortusers(users)	(qsort((users),nusers,sizeof(struct user), \
331				    cmpusers))
332
333static void
334uses(uid,blks,act)
335	uid_t uid;
336	daddr_t blks;
337	time_t act;
338{
339	static time_t today;
340	register struct user *usr;
341
342	if (!today)
343		time(&today);
344
345	usr = user(uid);
346	usr->count++;
347	usr->space += blks;
348
349	if (today - act > 90L * 24L * 60L * 60L)
350		usr->spc90 += blks;
351	if (today - act > 60L * 24L * 60L * 60L)
352		usr->spc60 += blks;
353	if (today - act > 30L * 24L * 60L * 60L)
354		usr->spc30 += blks;
355}
356
357#ifdef	COMPAT
358#define	FSZCNT	500
359#else
360#define	FSZCNT	512
361#endif
362struct fsizes {
363	struct fsizes *fsz_next;
364	daddr_t fsz_first, fsz_last;
365	ino_t fsz_count[FSZCNT];
366	daddr_t fsz_sz[FSZCNT];
367} *fsizes;
368
369static void
370initfsizes()
371{
372	register struct fsizes *fp;
373	register int i;
374
375	for (fp = fsizes; fp; fp = fp->fsz_next) {
376		for (i = FSZCNT; --i >= 0;) {
377			fp->fsz_count[i] = 0;
378			fp->fsz_sz[i] = 0;
379		}
380	}
381}
382
383static void
384dofsizes(fd, super, name)
385	int fd;
386	struct fs *super;
387	char *name;
388{
389	ino_t inode, maxino;
390	union dinode *dp;
391	daddr_t sz, ksz;
392	struct fsizes *fp, **fsp;
393	register int i;
394
395	maxino = super->fs_ncg * super->fs_ipg - 1;
396#ifdef	COMPAT
397	if (!(fsizes = (struct fsizes *)malloc(sizeof(struct fsizes))))
398		errx(1, "allocate fsize structure");
399#endif	/* COMPAT */
400	for (inode = 0; inode < maxino; inode++) {
401		errno = 0;
402		if ((dp = get_inode(fd,super,inode))
403#ifdef	COMPAT
404		    && ((DIP(super, dp, di_mode) & IFMT) == IFREG
405			|| (DIP(super, dp, di_mode) & IFMT) == IFDIR)
406#else	/* COMPAT */
407		    && !isfree(super, dp)
408#endif	/* COMPAT */
409		    ) {
410			sz = estimate ? virtualblocks(super, dp) :
411			    actualblocks(super, dp);
412#ifdef	COMPAT
413			if (sz >= FSZCNT) {
414				fsizes->fsz_count[FSZCNT-1]++;
415				fsizes->fsz_sz[FSZCNT-1] += sz;
416			} else {
417				fsizes->fsz_count[sz]++;
418				fsizes->fsz_sz[sz] += sz;
419			}
420#else	/* COMPAT */
421			ksz = SIZE(sz);
422			for (fsp = &fsizes; (fp = *fsp); fsp = &fp->fsz_next) {
423				if (ksz < fp->fsz_last)
424					break;
425			}
426			if (!fp || ksz < fp->fsz_first) {
427				if (!(fp = (struct fsizes *)
428				    malloc(sizeof(struct fsizes))))
429					errx(1, "allocate fsize structure");
430				fp->fsz_next = *fsp;
431				*fsp = fp;
432				fp->fsz_first = (ksz / FSZCNT) * FSZCNT;
433				fp->fsz_last = fp->fsz_first + FSZCNT;
434				for (i = FSZCNT; --i >= 0;) {
435					fp->fsz_count[i] = 0;
436					fp->fsz_sz[i] = 0;
437				}
438			}
439			fp->fsz_count[ksz % FSZCNT]++;
440			fp->fsz_sz[ksz % FSZCNT] += sz;
441#endif	/* COMPAT */
442		} else if (errno) {
443			err(1, "%s", name);
444		}
445	}
446	sz = 0;
447	for (fp = fsizes; fp; fp = fp->fsz_next) {
448		for (i = 0; i < FSZCNT; i++) {
449			if (fp->fsz_count[i])
450				printf("%jd\t%jd\t%d\n",
451				    (intmax_t)(fp->fsz_first + i),
452				    (intmax_t)fp->fsz_count[i],
453				    SIZE(sz += fp->fsz_sz[i]));
454		}
455	}
456}
457
458static void
459douser(fd, super, name)
460	int fd;
461	struct fs *super;
462	char *name;
463{
464	ino_t inode, maxino;
465	struct user *usr, *usrs;
466	union dinode *dp;
467	register int n;
468
469	maxino = super->fs_ncg * super->fs_ipg - 1;
470	for (inode = 0; inode < maxino; inode++) {
471		errno = 0;
472		if ((dp = get_inode(fd,super,inode))
473		    && !isfree(super, dp))
474			uses(DIP(super, dp, di_uid),
475			    estimate ? virtualblocks(super, dp) :
476				actualblocks(super, dp),
477			    DIP(super, dp, di_atime));
478		else if (errno) {
479			err(1, "%s", name);
480		}
481	}
482	if (!(usrs = (struct user *)malloc(nusers * sizeof(struct user))))
483		errx(1, "allocate users");
484	bcopy(users,usrs,nusers * sizeof(struct user));
485	sortusers(usrs);
486	for (usr = usrs, n = nusers; --n >= 0 && usr->count; usr++) {
487		printf("%5d",SIZE(usr->space));
488		if (count)
489			printf("\t%5ld",usr->count);
490		printf("\t%-8s",usr->name);
491		if (unused)
492			printf("\t%5d\t%5d\t%5d",
493			       SIZE(usr->spc30),
494			       SIZE(usr->spc60),
495			       SIZE(usr->spc90));
496		printf("\n");
497	}
498	free(usrs);
499}
500
501static void
502donames(fd, super, name)
503	int fd;
504	struct fs *super;
505	char *name;
506{
507	int c;
508	ino_t inode;
509	ino_t maxino;
510	union dinode *dp;
511
512	maxino = super->fs_ncg * super->fs_ipg - 1;
513	/* first skip the name of the filesystem */
514	while ((c = getchar()) != EOF && (c < '0' || c > '9'))
515		while ((c = getchar()) != EOF && c != '\n');
516	ungetc(c,stdin);
517	while (scanf("%u",&inode) == 1) {
518		if (inode > maxino) {
519			warnx("illegal inode %d",inode);
520			return;
521		}
522		errno = 0;
523		if ((dp = get_inode(fd,super,inode))
524		    && !isfree(super, dp)) {
525			printf("%s\t",user(DIP(super, dp, di_uid))->name);
526			/* now skip whitespace */
527			while ((c = getchar()) == ' ' || c == '\t');
528			/* and print out the remainder of the input line */
529			while (c != EOF && c != '\n') {
530				putchar(c);
531				c = getchar();
532			}
533			putchar('\n');
534		} else {
535			if (errno) {
536				err(1, "%s", name);
537			}
538			/* skip this line */
539			while ((c = getchar()) != EOF && c != '\n');
540		}
541		if (c == EOF)
542			break;
543	}
544}
545
546static void
547usage()
548{
549#ifdef	COMPAT
550	fprintf(stderr,"usage: quot [-nfcvha] [filesystem ...]\n");
551#else	/* COMPAT */
552	fprintf(stderr,"usage: quot [-acfhknv] [filesystem ...]\n");
553#endif	/* COMPAT */
554	exit(1);
555}
556
557/*
558 * Possible superblock locations ordered from most to least likely.
559 */
560static int sblock_try[] = SBLOCKSEARCH;
561static char superblock[SBLOCKSIZE];
562
563void
564quot(name,mp)
565	char *name, *mp;
566{
567	int i, fd;
568	struct fs *fs;
569
570	get_inode(-1, NULL, 0);		/* flush cache */
571	inituser();
572	initfsizes();
573	if ((fd = open(name,0)) < 0) {
574		warn("%s", name);
575		close(fd);
576		return;
577	}
578	for (i = 0; sblock_try[i] != -1; i++) {
579		if (lseek(fd, sblock_try[i], 0) != sblock_try[i]) {
580			close(fd);
581			return;
582		}
583		if (read(fd, superblock, SBLOCKSIZE) != SBLOCKSIZE) {
584			close(fd);
585			return;
586		}
587		fs = (struct fs *)superblock;
588		if ((fs->fs_magic == FS_UFS1_MAGIC ||
589		     (fs->fs_magic == FS_UFS2_MAGIC &&
590		      fs->fs_sblockloc == sblock_try[i])) &&
591		    fs->fs_bsize <= MAXBSIZE &&
592		    fs->fs_bsize >= sizeof(struct fs))
593			break;
594	}
595	if (sblock_try[i] == -1) {
596		warnx("%s: not a BSD filesystem",name);
597		close(fd);
598		return;
599	}
600	printf("%s:",name);
601	if (mp)
602		printf(" (%s)",mp);
603	putchar('\n');
604	(*func)(fd, fs, name);
605	close(fd);
606}
607
608int
609main(argc,argv)
610	int argc;
611	char **argv;
612{
613	char all = 0;
614	struct statfs *mp;
615	struct fstab *fs;
616	char dev[MNAMELEN + 1];
617	char *nm;
618	int cnt;
619
620	func = douser;
621#ifndef	COMPAT
622	header = getbsize(&headerlen,&blocksize);
623#endif
624	while (--argc > 0 && **++argv == '-') {
625		while (*++*argv) {
626			switch (**argv) {
627			case 'n':
628				func = donames;
629				break;
630			case 'c':
631				func = dofsizes;
632				break;
633			case 'a':
634				all = 1;
635				break;
636			case 'f':
637				count = 1;
638				break;
639			case 'h':
640				estimate = 1;
641				break;
642#ifndef	COMPAT
643			case 'k':
644				blocksize = 1024;
645				break;
646#endif	/* COMPAT */
647			case 'v':
648				unused = 1;
649				break;
650			default:
651				usage();
652			}
653		}
654	}
655	if (all) {
656		cnt = getmntinfo(&mp,MNT_NOWAIT);
657		for (; --cnt >= 0; mp++) {
658			if (!strncmp(mp->f_fstypename, "ufs", MFSNAMELEN)) {
659				if ((nm = strrchr(mp->f_mntfromname,'/'))) {
660					sprintf(dev,"%s%s",_PATH_DEV,nm + 1);
661					nm = dev;
662				} else
663					nm = mp->f_mntfromname;
664				quot(nm,mp->f_mntonname);
665			}
666		}
667	}
668	while (--argc >= 0) {
669		if ((fs = getfsfile(*argv)) != NULL)
670			quot(fs->fs_spec, 0);
671		else
672			quot(*argv,0);
673		argv++;
674	}
675	return 0;
676}
677