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