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