1 /* $NetBSD: tunefs.c,v 1.58 2023/01/07 19:41:30 chs Exp $ */ 2 3 /* 4 * Copyright (c) 1983, 1993 5 * The Regents of the University of California. All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. Neither the name of the University nor the names of its contributors 16 * may be used to endorse or promote products derived from this software 17 * without specific prior written permission. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 22 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 29 * SUCH DAMAGE. 30 */ 31 32 #include <sys/cdefs.h> 33 #ifndef lint 34 __COPYRIGHT("@(#) Copyright (c) 1983, 1993\ 35 The Regents of the University of California. All rights reserved."); 36 #endif /* not lint */ 37 38 #ifndef lint 39 #if 0 40 static char sccsid[] = "@(#)tunefs.c 8.3 (Berkeley) 5/3/95"; 41 #else 42 __RCSID("$NetBSD: tunefs.c,v 1.58 2023/01/07 19:41:30 chs Exp $"); 43 #endif 44 #endif /* not lint */ 45 46 /* 47 * tunefs: change layout parameters to an existing file system. 48 */ 49 #include <sys/param.h> 50 #include <sys/statvfs.h> 51 52 #include <ufs/ffs/fs.h> 53 #include <ufs/ffs/ffs_extern.h> 54 #include <ufs/ufs/ufs_wapbl.h> 55 #include <ufs/ufs/ufsmount.h> 56 #include <ufs/ufs/quota2.h> 57 58 #include <machine/bswap.h> 59 60 #include <err.h> 61 #include <errno.h> 62 #include <fcntl.h> 63 #include <fstab.h> 64 #include <paths.h> 65 #include <stdbool.h> 66 #include <stdio.h> 67 #include <stdlib.h> 68 #include <string.h> 69 #include <unistd.h> 70 #include <util.h> 71 72 /* the optimization warning string template */ 73 #define OPTWARN "should optimize for %s with minfree %s %d%%" 74 75 union { 76 struct fs sb; 77 char data[MAXBSIZE]; 78 } sbun, buf; 79 #define sblock sbun.sb 80 81 int fi; 82 long dev_bsize = 512; 83 int needswap = 0; 84 int is_ufs2 = 0; 85 int extattr = 0; 86 off_t sblockloc; 87 int userquota = 0; 88 int groupquota = 0; 89 #define Q2_EN (1) 90 #define Q2_IGN (0) 91 #define Q2_DIS (-1) 92 93 static off_t sblock_try[] = SBLOCKSEARCH; 94 95 static void bwrite(daddr_t, char *, int, const char *); 96 static void bread(daddr_t, char *, int, const char *); 97 static void change_log_info(long long); 98 static void getsb(struct fs *, const char *); 99 static int openpartition(const char *, int, char *, size_t); 100 static int isactive(int, struct statvfs *); 101 static void show_log_info(void); 102 __dead static void usage(void); 103 104 int 105 main(int argc, char *argv[]) 106 { 107 int ch, aflag, pflag, Aflag, Fflag, Nflag, openflags; 108 const char *special, *chg[2]; 109 char device[MAXPATHLEN]; 110 int maxbpg, minfree, optim, secsize; 111 uint32_t i, avgfilesize, avgfpdir; 112 bool active; 113 long long logfilesize; 114 int secshift, fsbtodb; 115 const char *avalue, *pvalue, *name; 116 struct statvfs sfs; 117 118 aflag = pflag = Aflag = Fflag = Nflag = 0; 119 avalue = pvalue = NULL; 120 maxbpg = minfree = optim = secsize = -1; 121 avgfilesize = avgfpdir = -1; 122 logfilesize = -1; 123 secshift = 0; 124 chg[FS_OPTSPACE] = "space"; 125 chg[FS_OPTTIME] = "time"; 126 127 while ((ch = getopt(argc, argv, "AFNa:e:g:h:l:m:o:p:q:S:")) != -1) { 128 switch (ch) { 129 130 case 'A': 131 Aflag++; 132 break; 133 134 case 'F': 135 Fflag++; 136 break; 137 138 case 'N': 139 Nflag++; 140 break; 141 142 case 'a': 143 name = "ACLs"; 144 avalue = optarg; 145 if (strcmp(avalue, "enable") && 146 strcmp(avalue, "disable")) { 147 errx(10, "bad %s (options are %s)", 148 name, "`enable' or `disable'"); 149 } 150 aflag = 1; 151 break; 152 153 case 'e': 154 maxbpg = strsuftoll( 155 "maximum blocks per file in a cylinder group", 156 optarg, 1, INT_MAX); 157 break; 158 159 case 'g': 160 avgfilesize = strsuftoll("average file size", optarg, 161 1, INT_MAX); 162 break; 163 164 case 'h': 165 avgfpdir = strsuftoll( 166 "expected number of files per directory", 167 optarg, 1, INT_MAX); 168 break; 169 170 case 'l': 171 logfilesize = strsuftoll("journal log file size", 172 optarg, 0, INT_MAX); 173 break; 174 175 case 'm': 176 minfree = strsuftoll("minimum percentage of free space", 177 optarg, 0, 99); 178 break; 179 180 case 'o': 181 if (strcmp(optarg, chg[FS_OPTSPACE]) == 0) 182 optim = FS_OPTSPACE; 183 else if (strcmp(optarg, chg[FS_OPTTIME]) == 0) 184 optim = FS_OPTTIME; 185 else 186 errx(10, 187 "bad %s (options are `space' or `time')", 188 "optimization preference"); 189 break; 190 191 case 'p': 192 name = "POSIX1e ACLs"; 193 pvalue = optarg; 194 if (strcmp(pvalue, "enable") && 195 strcmp(pvalue, "disable")) { 196 errx(10, "bad %s (options are %s)", 197 name, "`enable' or `disable'"); 198 } 199 pflag = 1; 200 break; 201 202 case 'q': 203 if (strcmp(optarg, "user") == 0) 204 userquota = Q2_EN; 205 else if (strcmp(optarg, "group") == 0) 206 groupquota = Q2_EN; 207 else if (strcmp(optarg, "nouser") == 0) 208 userquota = Q2_DIS; 209 else if (strcmp(optarg, "nogroup") == 0) 210 groupquota = Q2_DIS; 211 else 212 errx(11, "invalid quota type %s", optarg); 213 break; 214 215 case 'S': 216 secsize = strsuftoll("physical sector size", 217 optarg, 0, INT_MAX); 218 secshift = ffs(secsize) - 1; 219 if (secsize != 0 && 1 << secshift != secsize) 220 errx(12, "sector size %d is not a power of two", secsize); 221 break; 222 223 default: 224 usage(); 225 } 226 } 227 argc -= optind; 228 argv += optind; 229 if (argc != 1) 230 usage(); 231 232 special = argv[0]; 233 openflags = Nflag ? O_RDONLY : O_RDWR; 234 if (Fflag) 235 fi = open(special, openflags); 236 else { 237 fi = openpartition(special, openflags, device, sizeof(device)); 238 special = device; 239 } 240 if (fi == -1) 241 err(1, "%s", special); 242 active = !Fflag && isactive(fi, &sfs); 243 getsb(&sblock, special); 244 245 #define CHANGEVAL(old, new, type, suffix) do \ 246 if ((uint32_t)(new) != (uint32_t)-1) { \ 247 if ((new) == (old)) \ 248 warnx("%s remains unchanged at %d%s", \ 249 (type), (old), (suffix)); \ 250 else { \ 251 warnx("%s changes from %d%s to %d%s", \ 252 (type), (old), (suffix), (new), (suffix)); \ 253 (old) = (new); \ 254 } \ 255 } while (/* CONSTCOND */0) 256 257 warnx("tuning %s", special); 258 CHANGEVAL(sblock.fs_maxbpg, maxbpg, 259 "maximum blocks per file in a cylinder group", ""); 260 CHANGEVAL(sblock.fs_minfree, minfree, 261 "minimum percentage of free space", "%"); 262 if (minfree != -1) { 263 if (minfree >= MINFREE && 264 sblock.fs_optim == FS_OPTSPACE) 265 warnx(OPTWARN, "time", ">=", MINFREE); 266 if (minfree < MINFREE && 267 sblock.fs_optim == FS_OPTTIME) 268 warnx(OPTWARN, "space", "<", MINFREE); 269 } 270 if (optim != -1) { 271 if (sblock.fs_optim == optim) { 272 warnx("%s remains unchanged as %s", 273 "optimization preference", 274 chg[optim]); 275 } else { 276 warnx("%s changes from %s to %s", 277 "optimization preference", 278 chg[sblock.fs_optim], chg[optim]); 279 sblock.fs_optim = optim; 280 if (sblock.fs_minfree >= MINFREE && 281 optim == FS_OPTSPACE) 282 warnx(OPTWARN, "time", ">=", MINFREE); 283 if (sblock.fs_minfree < MINFREE && 284 optim == FS_OPTTIME) 285 warnx(OPTWARN, "space", "<", MINFREE); 286 } 287 } 288 if (secsize != -1) { 289 if (secsize == 0) { 290 secsize = sblock.fs_fsize / FFS_FSBTODB(&sblock, 1); 291 secshift = ffs(secsize) - 1; 292 } 293 294 if (secshift < DEV_BSHIFT) 295 warnx("sector size must be at least %d", DEV_BSIZE); 296 else if (secshift > sblock.fs_fshift) 297 warnx("sector size %d cannot be larger than fragment size %d", 298 secsize, sblock.fs_fsize); 299 else { 300 fsbtodb = sblock.fs_fshift - secshift; 301 if (fsbtodb == sblock.fs_fsbtodb) { 302 warnx("sector size remains unchanged as %d", 303 sblock.fs_fsize / FFS_FSBTODB(&sblock, 1)); 304 } else { 305 warnx("sector size changed from %d to %d", 306 sblock.fs_fsize / FFS_FSBTODB(&sblock, 1), 307 secsize); 308 sblock.fs_fsbtodb = fsbtodb; 309 } 310 } 311 } 312 CHANGEVAL(sblock.fs_avgfilesize, avgfilesize, 313 "average file size", ""); 314 CHANGEVAL(sblock.fs_avgfpdir, avgfpdir, 315 "expected number of files per directory", ""); 316 317 if (logfilesize >= 0) 318 change_log_info(logfilesize); 319 if (userquota == Q2_EN || groupquota == Q2_EN) 320 sblock.fs_flags |= FS_DOQUOTA2; 321 if (sblock.fs_flags & FS_DOQUOTA2) { 322 sblock.fs_quota_magic = Q2_HEAD_MAGIC; 323 switch(userquota) { 324 case Q2_EN: 325 if ((sblock.fs_quota_flags & FS_Q2_DO_TYPE(USRQUOTA)) 326 == 0) { 327 printf("enabling user quotas\n"); 328 sblock.fs_quota_flags |= 329 FS_Q2_DO_TYPE(USRQUOTA); 330 sblock.fs_quotafile[USRQUOTA] = 0; 331 } 332 break; 333 case Q2_DIS: 334 if ((sblock.fs_quota_flags & FS_Q2_DO_TYPE(USRQUOTA)) 335 != 0) { 336 printf("disabling user quotas\n"); 337 sblock.fs_quota_flags &= 338 ~FS_Q2_DO_TYPE(USRQUOTA); 339 } 340 } 341 switch(groupquota) { 342 case Q2_EN: 343 if ((sblock.fs_quota_flags & FS_Q2_DO_TYPE(GRPQUOTA)) 344 == 0) { 345 printf("enabling group quotas\n"); 346 sblock.fs_quota_flags |= 347 FS_Q2_DO_TYPE(GRPQUOTA); 348 sblock.fs_quotafile[GRPQUOTA] = 0; 349 } 350 break; 351 case Q2_DIS: 352 if ((sblock.fs_quota_flags & FS_Q2_DO_TYPE(GRPQUOTA)) 353 != 0) { 354 printf("disabling group quotas\n"); 355 sblock.fs_quota_flags &= 356 ~FS_Q2_DO_TYPE(GRPQUOTA); 357 } 358 } 359 } 360 /* 361 * if we disabled all quotas, FS_DOQUOTA2 and associated inode(s) will 362 * be cleared by kernel or fsck. 363 */ 364 if (aflag) { 365 name = "NFSv4 ACLs"; 366 if (strcmp(avalue, "enable") == 0) { 367 if (is_ufs2 && !extattr) { 368 warnx("%s not supported by this fs", name); 369 } else if (sblock.fs_flags & FS_NFS4ACLS) { 370 warnx("%s remains unchanged as enabled", name); 371 } else if (sblock.fs_flags & FS_POSIX1EACLS) { 372 warnx("%s and POSIX.1e ACLs are mutually " 373 "exclusive", name); 374 } else { 375 sblock.fs_flags |= FS_NFS4ACLS; 376 printf("%s set\n", name); 377 } 378 } else if (strcmp(avalue, "disable") == 0) { 379 if ((~sblock.fs_flags & FS_NFS4ACLS) == FS_NFS4ACLS) { 380 warnx("%s remains unchanged as disabled", 381 name); 382 } else { 383 sblock.fs_flags &= ~FS_NFS4ACLS; 384 printf("%s cleared\n", name); 385 } 386 } 387 } 388 389 if (pflag) { 390 name = "POSIX1e ACLs"; 391 if (strcmp(pvalue, "enable") == 0) { 392 if (is_ufs2 && !extattr) { 393 warnx("%s not supported by this fs", name); 394 } else if (sblock.fs_flags & FS_POSIX1EACLS) { 395 warnx("%s remains unchanged as enabled", name); 396 } else if (sblock.fs_flags & FS_NFS4ACLS) { 397 warnx("%s and ACLs are mutually " 398 "exclusive", name); 399 } else { 400 sblock.fs_flags |= FS_POSIX1EACLS; 401 printf("%s set\n", name); 402 } 403 } else if (strcmp(pvalue, "disable") == 0) { 404 if ((~sblock.fs_flags & FS_POSIX1EACLS) == 405 FS_POSIX1EACLS) { 406 warnx("%s remains unchanged as disabled", 407 name); 408 } else { 409 sblock.fs_flags &= ~FS_POSIX1EACLS; 410 printf("%s cleared\n", name); 411 } 412 } 413 } 414 415 if (Nflag) { 416 printf("%s: current settings of %s\n", getprogname(), special); 417 printf("\tmaximum contiguous block count %d\n", 418 sblock.fs_maxcontig); 419 printf("\tmaximum blocks per file in a cylinder group %d\n", 420 sblock.fs_maxbpg); 421 printf("\tminimum percentage of free space %d%%\n", 422 sblock.fs_minfree); 423 printf("\toptimization preference: %s\n", chg[sblock.fs_optim]); 424 printf("\taverage file size: %d\n", sblock.fs_avgfilesize); 425 printf("\texpected number of files per directory: %d\n", 426 sblock.fs_avgfpdir); 427 show_log_info(); 428 printf("\tquotas"); 429 if (sblock.fs_flags & FS_DOQUOTA2) { 430 if (sblock.fs_quota_flags & FS_Q2_DO_TYPE(USRQUOTA)) { 431 printf(" user"); 432 if (sblock.fs_quota_flags & 433 FS_Q2_DO_TYPE(GRPQUOTA)) 434 printf(","); 435 } 436 if (sblock.fs_quota_flags & FS_Q2_DO_TYPE(GRPQUOTA)) 437 printf(" group"); 438 printf(" enabled\n"); 439 } else { 440 printf(" disabled\n"); 441 } 442 printf("\tPOSIX.1e ACLs %s\n", 443 (sblock.fs_flags & FS_POSIX1EACLS) ? "enabled" : "disabled"); 444 printf("\tNFS4 ACLs %s\n", 445 (sblock.fs_flags & FS_NFS4ACLS) ? "enabled" : "disabled"); 446 printf("%s: no changes made\n", getprogname()); 447 return 0; 448 } 449 450 memcpy(&buf, (char *)&sblock, SBLOCKSIZE); 451 if (needswap) 452 ffs_sb_swap((struct fs*)&buf, (struct fs*)&buf); 453 454 /* write superblock to original coordinates (use old dev_bsize!) */ 455 bwrite(sblockloc, buf.data, SBLOCKSIZE, special); 456 457 if (active) { 458 struct ufs_args args; 459 args.fspec = sfs.f_mntfromname; 460 if (mount(MOUNT_FFS, sfs.f_mntonname, sfs.f_flag | MNT_UPDATE, 461 &args, sizeof args) == -1) 462 warn("mount"); 463 else 464 printf("%s: mount of %s on %s updated\n", 465 getprogname(), sfs.f_mntfromname, sfs.f_mntonname); 466 } 467 468 469 /* correct dev_bsize from possibly changed superblock data */ 470 dev_bsize = sblock.fs_fsize / FFS_FSBTODB(&sblock, 1); 471 472 if (Aflag) 473 for (i = 0; i < sblock.fs_ncg; i++) 474 bwrite(FFS_FSBTODB(&sblock, cgsblock(&sblock, i)), 475 buf.data, SBLOCKSIZE, special); 476 close(fi); 477 exit(0); 478 } 479 480 static int 481 isactive(int fd, struct statvfs *rsfs) 482 { 483 struct stat st0, st; 484 struct statvfs *sfs; 485 int n; 486 487 if (fstat(fd, &st0) == -1) { 488 warn("stat"); 489 return 0; 490 } 491 492 if ((n = getmntinfo(&sfs, 0)) == -1) { 493 warn("getmntinfo"); 494 return 0; 495 } 496 497 for (int i = 0; i < n; i++) { 498 if (stat(sfs[i].f_mntfromname, &st) == -1) 499 continue; 500 if (st.st_rdev != st0.st_rdev) 501 continue; 502 *rsfs = sfs[i]; 503 return 1; 504 505 } 506 return 0; 507 } 508 509 static void 510 show_log_info(void) 511 { 512 const char *loc; 513 uint64_t size, blksize, logsize; 514 int print; 515 516 switch (sblock.fs_journal_location) { 517 case UFS_WAPBL_JOURNALLOC_NONE: 518 print = blksize = 0; 519 /* nothing */ 520 break; 521 case UFS_WAPBL_JOURNALLOC_END_PARTITION: 522 loc = "end of partition"; 523 size = sblock.fs_journallocs[UFS_WAPBL_EPART_COUNT]; 524 blksize = sblock.fs_journallocs[UFS_WAPBL_EPART_BLKSZ]; 525 print = 1; 526 break; 527 case UFS_WAPBL_JOURNALLOC_IN_FILESYSTEM: 528 loc = "in filesystem"; 529 size = sblock.fs_journallocs[UFS_WAPBL_INFS_COUNT]; 530 blksize = sblock.fs_journallocs[UFS_WAPBL_INFS_BLKSZ]; 531 print = 1; 532 break; 533 default: 534 loc = "unknown"; 535 size = blksize = 0; 536 print = 1; 537 break; 538 } 539 540 if (print) { 541 logsize = size * blksize; 542 543 printf("\tjournal log file location: %s\n", loc); 544 printf("\tjournal log file size: "); 545 if (logsize == 0) 546 printf("0\n"); 547 else { 548 char sizebuf[8]; 549 humanize_number(sizebuf, 6, size * blksize, "B", 550 HN_AUTOSCALE, HN_B | HN_NOSPACE | HN_DECIMAL); 551 printf("%s (%" PRId64 " bytes)", sizebuf, logsize); 552 } 553 printf("\n"); 554 printf("\tjournal log flags:"); 555 if (sblock.fs_journal_flags & UFS_WAPBL_FLAGS_CREATE_LOG) 556 printf(" create-log"); 557 if (sblock.fs_journal_flags & UFS_WAPBL_FLAGS_CLEAR_LOG) 558 printf(" clear-log"); 559 printf("\n"); 560 } 561 } 562 563 static void 564 change_log_info(long long logfilesize) 565 { 566 /* 567 * NOTES: 568 * - only operate on in-filesystem log sizes 569 * - can't change size of existing log 570 * - if current is same, no action 571 * - if current is zero and new is non-zero, set flag to create log 572 * on next mount 573 * - if current is non-zero and new is zero, set flag to clear log 574 * on next mount 575 */ 576 int in_fs_log; 577 uint64_t old_size; 578 579 old_size = 0; 580 switch (sblock.fs_journal_location) { 581 case UFS_WAPBL_JOURNALLOC_END_PARTITION: 582 in_fs_log = 0; 583 old_size = sblock.fs_journallocs[UFS_WAPBL_EPART_COUNT] * 584 sblock.fs_journallocs[UFS_WAPBL_EPART_BLKSZ]; 585 break; 586 587 case UFS_WAPBL_JOURNALLOC_IN_FILESYSTEM: 588 in_fs_log = 1; 589 old_size = sblock.fs_journallocs[UFS_WAPBL_INFS_COUNT] * 590 sblock.fs_journallocs[UFS_WAPBL_INFS_BLKSZ]; 591 break; 592 593 case UFS_WAPBL_JOURNALLOC_NONE: 594 default: 595 in_fs_log = 0; 596 old_size = 0; 597 break; 598 } 599 600 if (logfilesize == 0) { 601 /* 602 * Don't clear out the locators - the kernel might need 603 * these to find the log! Just set the "clear the log" 604 * flag and let the kernel do the rest. 605 */ 606 sblock.fs_journal_flags |= UFS_WAPBL_FLAGS_CLEAR_LOG; 607 sblock.fs_journal_flags &= ~UFS_WAPBL_FLAGS_CREATE_LOG; 608 warnx("log file size cleared from %" PRIu64 "", old_size); 609 return; 610 } 611 612 if (!in_fs_log && logfilesize > 0 && old_size > 0) 613 errx(1, "Can't change size of non-in-filesystem log"); 614 615 if (old_size == (uint64_t)logfilesize && logfilesize > 0) { 616 /* no action */ 617 warnx("log file size remains unchanged at %lld", logfilesize); 618 return; 619 } 620 621 if (old_size == 0) { 622 /* create new log of desired size next mount */ 623 sblock.fs_journal_location = UFS_WAPBL_JOURNALLOC_IN_FILESYSTEM; 624 sblock.fs_journallocs[UFS_WAPBL_INFS_ADDR] = 0; 625 sblock.fs_journallocs[UFS_WAPBL_INFS_COUNT] = logfilesize; 626 sblock.fs_journallocs[UFS_WAPBL_INFS_BLKSZ] = 0; 627 sblock.fs_journallocs[UFS_WAPBL_INFS_INO] = 0; 628 sblock.fs_journal_flags |= UFS_WAPBL_FLAGS_CREATE_LOG; 629 sblock.fs_journal_flags &= ~UFS_WAPBL_FLAGS_CLEAR_LOG; 630 warnx("log file size set to %lld", logfilesize); 631 } else { 632 errx(1, 633 "Can't change existing log size from %" PRIu64 " to %lld", 634 old_size, logfilesize); 635 } 636 } 637 638 static void 639 usage(void) 640 { 641 642 fprintf(stderr, "usage: tunefs [-AFN] tuneup-options special-device\n"); 643 fprintf(stderr, "where tuneup-options are:\n"); 644 fprintf(stderr, "\t-a ACLS: `enable' or `disable'\n"); 645 fprintf(stderr, "\t-e maximum blocks per file in a cylinder group\n"); 646 fprintf(stderr, "\t-g average file size\n"); 647 fprintf(stderr, "\t-h expected number of files per directory\n"); 648 fprintf(stderr, "\t-l journal log file size (`0' to clear journal)\n"); 649 fprintf(stderr, "\t-m minimum percentage of free space\n"); 650 fprintf(stderr, "\t-p POSIX.1e ACLS: `enable' or `disable'\n"); 651 fprintf(stderr, "\t-o optimization preference (`space' or `time')\n"); 652 fprintf(stderr, "\t-q quota type (`[no]user' or `[no]group')\n"); 653 fprintf(stderr, "\t-S sector size\n"); 654 exit(2); 655 } 656 657 static void 658 getsb(struct fs *fs, const char *file) 659 { 660 int i; 661 662 for (i = 0; ; i++) { 663 if (sblock_try[i] == -1) 664 errx(5, "cannot find filesystem superblock"); 665 bread(sblock_try[i] / dev_bsize, (char *)fs, SBLOCKSIZE, file); 666 switch(fs->fs_magic) { 667 case FS_UFS2EA_MAGIC: 668 extattr = 1; 669 /*FALLTHROUGH*/ 670 case FS_UFS2_MAGIC: 671 is_ufs2 = 1; 672 /*FALLTHROUGH*/ 673 case FS_UFS1_MAGIC: 674 break; 675 case FS_UFS2EA_MAGIC_SWAPPED: 676 extattr = 1; 677 /*FALLTHROUGH*/ 678 case FS_UFS2_MAGIC_SWAPPED: 679 is_ufs2 = 1; 680 /*FALLTHROUGH*/ 681 case FS_UFS1_MAGIC_SWAPPED: 682 warnx("%s: swapping byte order", file); 683 needswap = 1; 684 ffs_sb_swap(fs, fs); 685 break; 686 default: 687 continue; 688 } 689 if (!is_ufs2 && sblock_try[i] == SBLOCK_UFS2) 690 continue; 691 if ((is_ufs2 || fs->fs_old_flags & FS_FLAGS_UPDATED) 692 && fs->fs_sblockloc != sblock_try[i]) 693 continue; 694 break; 695 } 696 697 dev_bsize = fs->fs_fsize / FFS_FSBTODB(fs, 1); 698 sblockloc = sblock_try[i] / dev_bsize; 699 } 700 701 static void 702 bwrite(daddr_t blk, char *buffer, int size, const char *file) 703 { 704 off_t offset; 705 706 offset = (off_t)blk * dev_bsize; 707 if (lseek(fi, offset, SEEK_SET) == -1) 708 err(6, "%s: seeking to %lld", file, (long long)offset); 709 if (write(fi, buffer, size) != size) 710 err(7, "%s: writing %d bytes", file, size); 711 } 712 713 static void 714 bread(daddr_t blk, char *buffer, int cnt, const char *file) 715 { 716 off_t offset; 717 int i; 718 719 offset = (off_t)blk * dev_bsize; 720 if (lseek(fi, offset, SEEK_SET) == -1) 721 err(4, "%s: seeking to %lld", file, (long long)offset); 722 if ((i = read(fi, buffer, cnt)) != cnt) 723 errx(5, "%s: short read", file); 724 } 725 726 static int 727 openpartition(const char *name, int flags, char *device, size_t devicelen) 728 { 729 char specname[MAXPATHLEN]; 730 char rawname[MAXPATHLEN]; 731 const char *special, *raw; 732 struct fstab *fs; 733 int fd, oerrno; 734 735 fs = getfsfile(name); 736 special = fs ? fs->fs_spec : name; 737 738 raw = getfsspecname(specname, sizeof(specname), special); 739 if (raw == NULL) 740 err(1, "%s: %s", name, specname); 741 special = getdiskrawname(rawname, sizeof(rawname), raw); 742 if (special == NULL) 743 special = raw; 744 745 fd = opendisk(special, flags, device, devicelen, 0); 746 if (fd == -1 && errno == ENOENT) { 747 oerrno = errno; 748 strlcpy(device, special, devicelen); 749 errno = oerrno; 750 } 751 return (fd); 752 } 753
Indexes created Tue Sep 30 11:09:46 GMT 2025