tunefs.c revision 1.51
1 /* $NetBSD: tunefs.c,v 1.51 2020/04/09 14:44:38 christos 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.51 2020/04/09 14:44:38 christos 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 <stdio.h> 66 #include <stdlib.h> 67 #include <string.h> 68 #include <unistd.h> 69 #include <util.h> 70 71 /* the optimization warning string template */ 72 #define OPTWARN "should optimize for %s with minfree %s %d%%" 73 74 union { 75 struct fs sb; 76 char data[MAXBSIZE]; 77 } sbun, buf; 78 #define sblock sbun.sb 79 80 int fi; 81 long dev_bsize = 512; 82 int needswap = 0; 83 int is_ufs2 = 0; 84 off_t sblockloc; 85 int userquota = 0; 86 int groupquota = 0; 87 #define Q2_EN (1) 88 #define Q2_IGN (0) 89 #define Q2_DIS (-1) 90 91 static off_t sblock_try[] = SBLOCKSEARCH; 92 93 static void bwrite(daddr_t, char *, int, const char *); 94 static void bread(daddr_t, char *, int, const char *); 95 static void change_log_info(long long); 96 static void getsb(struct fs *, const char *); 97 static int openpartition(const char *, int, char *, size_t); 98 static void show_log_info(void); 99 __dead static void usage(void); 100 101 int 102 main(int argc, char *argv[]) 103 { 104 int i, ch, Aflag, Fflag, Nflag, openflags; 105 const char *special, *chg[2]; 106 char device[MAXPATHLEN]; 107 int maxbpg, minfree, optim, secsize; 108 int avgfilesize, avgfpdir, active; 109 long long logfilesize; 110 int secshift, fsbtodb; 111 struct statvfs sfs; 112 113 Aflag = Fflag = Nflag = 0; 114 maxbpg = minfree = optim = secsize = -1; 115 avgfilesize = avgfpdir = -1; 116 logfilesize = -1; 117 secshift = 0; 118 chg[FS_OPTSPACE] = "space"; 119 chg[FS_OPTTIME] = "time"; 120 121 while ((ch = getopt(argc, argv, "AFNe:g:h:l:m:o:q:S:")) != -1) { 122 switch (ch) { 123 124 case 'A': 125 Aflag++; 126 break; 127 128 case 'F': 129 Fflag++; 130 break; 131 132 case 'N': 133 Nflag++; 134 break; 135 136 case 'e': 137 maxbpg = strsuftoll( 138 "maximum blocks per file in a cylinder group", 139 optarg, 1, INT_MAX); 140 break; 141 142 case 'g': 143 avgfilesize = strsuftoll("average file size", optarg, 144 1, INT_MAX); 145 break; 146 147 case 'h': 148 avgfpdir = strsuftoll( 149 "expected number of files per directory", 150 optarg, 1, INT_MAX); 151 break; 152 153 case 'l': 154 logfilesize = strsuftoll("journal log file size", 155 optarg, 0, INT_MAX); 156 break; 157 158 case 'm': 159 minfree = strsuftoll("minimum percentage of free space", 160 optarg, 0, 99); 161 break; 162 163 case 'o': 164 if (strcmp(optarg, chg[FS_OPTSPACE]) == 0) 165 optim = FS_OPTSPACE; 166 else if (strcmp(optarg, chg[FS_OPTTIME]) == 0) 167 optim = FS_OPTTIME; 168 else 169 errx(10, 170 "bad %s (options are `space' or `time')", 171 "optimization preference"); 172 break; 173 case 'q': 174 if (strcmp(optarg, "user") == 0) 175 userquota = Q2_EN; 176 else if (strcmp(optarg, "group") == 0) 177 groupquota = Q2_EN; 178 else if (strcmp(optarg, "nouser") == 0) 179 userquota = Q2_DIS; 180 else if (strcmp(optarg, "nogroup") == 0) 181 groupquota = Q2_DIS; 182 else 183 errx(11, "invalid quota type %s", optarg); 184 break; 185 case 'S': 186 secsize = strsuftoll("physical sector size", 187 optarg, 0, INT_MAX); 188 secshift = ffs(secsize) - 1; 189 if (secsize != 0 && 1 << secshift != secsize) 190 errx(12, "sector size %d is not a power of two", secsize); 191 break; 192 default: 193 usage(); 194 } 195 } 196 argc -= optind; 197 argv += optind; 198 if (argc != 1) 199 usage(); 200 201 special = argv[0]; 202 openflags = Nflag ? O_RDONLY : O_RDWR; 203 if (Fflag) 204 fi = open(special, openflags); 205 else { 206 fi = openpartition(special, openflags, device, sizeof(device)); 207 special = device; 208 } 209 active = fstatvfs(fi, &sfs) != -1; 210 if (fi == -1) 211 err(1, "%s", special); 212 getsb(&sblock, special); 213 214 #define CHANGEVAL(old, new, type, suffix) do \ 215 if ((new) != -1) { \ 216 if ((new) == (old)) \ 217 warnx("%s remains unchanged at %d%s", \ 218 (type), (old), (suffix)); \ 219 else { \ 220 warnx("%s changes from %d%s to %d%s", \ 221 (type), (old), (suffix), (new), (suffix)); \ 222 (old) = (new); \ 223 } \ 224 } while (/* CONSTCOND */0) 225 226 warnx("tuning %s", special); 227 CHANGEVAL(sblock.fs_maxbpg, maxbpg, 228 "maximum blocks per file in a cylinder group", ""); 229 CHANGEVAL(sblock.fs_minfree, minfree, 230 "minimum percentage of free space", "%"); 231 if (minfree != -1) { 232 if (minfree >= MINFREE && 233 sblock.fs_optim == FS_OPTSPACE) 234 warnx(OPTWARN, "time", ">=", MINFREE); 235 if (minfree < MINFREE && 236 sblock.fs_optim == FS_OPTTIME) 237 warnx(OPTWARN, "space", "<", MINFREE); 238 } 239 if (optim != -1) { 240 if (sblock.fs_optim == optim) { 241 warnx("%s remains unchanged as %s", 242 "optimization preference", 243 chg[optim]); 244 } else { 245 warnx("%s changes from %s to %s", 246 "optimization preference", 247 chg[sblock.fs_optim], chg[optim]); 248 sblock.fs_optim = optim; 249 if (sblock.fs_minfree >= MINFREE && 250 optim == FS_OPTSPACE) 251 warnx(OPTWARN, "time", ">=", MINFREE); 252 if (sblock.fs_minfree < MINFREE && 253 optim == FS_OPTTIME) 254 warnx(OPTWARN, "space", "<", MINFREE); 255 } 256 } 257 if (secsize != -1) { 258 if (secsize == 0) { 259 secsize = sblock.fs_fsize / FFS_FSBTODB(&sblock, 1); 260 secshift = ffs(secsize) - 1; 261 } 262 263 if (secshift < DEV_BSHIFT) 264 warnx("sector size must be at least %d", DEV_BSIZE); 265 else if (secshift > sblock.fs_fshift) 266 warnx("sector size %d cannot be larger than fragment size %d", 267 secsize, sblock.fs_fsize); 268 else { 269 fsbtodb = sblock.fs_fshift - secshift; 270 if (fsbtodb == sblock.fs_fsbtodb) { 271 warnx("sector size remains unchanged as %d", 272 sblock.fs_fsize / FFS_FSBTODB(&sblock, 1)); 273 } else { 274 warnx("sector size changed from %d to %d", 275 sblock.fs_fsize / FFS_FSBTODB(&sblock, 1), 276 secsize); 277 sblock.fs_fsbtodb = fsbtodb; 278 } 279 } 280 } 281 CHANGEVAL(sblock.fs_avgfilesize, avgfilesize, 282 "average file size", ""); 283 CHANGEVAL(sblock.fs_avgfpdir, avgfpdir, 284 "expected number of files per directory", ""); 285 286 if (logfilesize >= 0) 287 change_log_info(logfilesize); 288 if (userquota == Q2_EN || groupquota == Q2_EN) 289 sblock.fs_flags |= FS_DOQUOTA2; 290 if (sblock.fs_flags & FS_DOQUOTA2) { 291 sblock.fs_quota_magic = Q2_HEAD_MAGIC; 292 switch(userquota) { 293 case Q2_EN: 294 if ((sblock.fs_quota_flags & FS_Q2_DO_TYPE(USRQUOTA)) 295 == 0) { 296 printf("enabling user quotas\n"); 297 sblock.fs_quota_flags |= 298 FS_Q2_DO_TYPE(USRQUOTA); 299 sblock.fs_quotafile[USRQUOTA] = 0; 300 } 301 break; 302 case Q2_DIS: 303 if ((sblock.fs_quota_flags & FS_Q2_DO_TYPE(USRQUOTA)) 304 != 0) { 305 printf("disabling user quotas\n"); 306 sblock.fs_quota_flags &= 307 ~FS_Q2_DO_TYPE(USRQUOTA); 308 } 309 } 310 switch(groupquota) { 311 case Q2_EN: 312 if ((sblock.fs_quota_flags & FS_Q2_DO_TYPE(GRPQUOTA)) 313 == 0) { 314 printf("enabling group quotas\n"); 315 sblock.fs_quota_flags |= 316 FS_Q2_DO_TYPE(GRPQUOTA); 317 sblock.fs_quotafile[GRPQUOTA] = 0; 318 } 319 break; 320 case Q2_DIS: 321 if ((sblock.fs_quota_flags & FS_Q2_DO_TYPE(GRPQUOTA)) 322 != 0) { 323 printf("disabling group quotas\n"); 324 sblock.fs_quota_flags &= 325 ~FS_Q2_DO_TYPE(GRPQUOTA); 326 } 327 } 328 } 329 /* 330 * if we disabled all quotas, FS_DOQUOTA2 and associated inode(s) will 331 * be cleared by kernel or fsck. 332 */ 333 334 if (Nflag) { 335 printf("tunefs: current settings of %s\n", special); 336 printf("\tmaximum contiguous block count %d\n", 337 sblock.fs_maxcontig); 338 printf("\tmaximum blocks per file in a cylinder group %d\n", 339 sblock.fs_maxbpg); 340 printf("\tminimum percentage of free space %d%%\n", 341 sblock.fs_minfree); 342 printf("\toptimization preference: %s\n", chg[sblock.fs_optim]); 343 printf("\taverage file size: %d\n", sblock.fs_avgfilesize); 344 printf("\texpected number of files per directory: %d\n", 345 sblock.fs_avgfpdir); 346 show_log_info(); 347 printf("\tquotas"); 348 if (sblock.fs_flags & FS_DOQUOTA2) { 349 if (sblock.fs_quota_flags & FS_Q2_DO_TYPE(USRQUOTA)) { 350 printf(" user"); 351 if (sblock.fs_quota_flags & 352 FS_Q2_DO_TYPE(GRPQUOTA)) 353 printf(","); 354 } 355 if (sblock.fs_quota_flags & FS_Q2_DO_TYPE(GRPQUOTA)) 356 printf(" group"); 357 printf(" enabled\n"); 358 } else { 359 printf(" disabled\n"); 360 } 361 printf("tunefs: no changes made\n"); 362 exit(0); 363 } 364 365 memcpy(&buf, (char *)&sblock, SBLOCKSIZE); 366 if (needswap) 367 ffs_sb_swap((struct fs*)&buf, (struct fs*)&buf); 368 369 /* write superblock to original coordinates (use old dev_bsize!) */ 370 bwrite(sblockloc, buf.data, SBLOCKSIZE, special); 371 372 if (active) { 373 struct ufs_args args; 374 args.fspec = sfs.f_mntfromname; 375 if (mount(MOUNT_FFS, sfs.f_mntonname, sfs.f_flag | MNT_UPDATE, 376 &args, sizeof args) == -1) 377 warn("mount"); 378 else 379 printf("%s: mount of %s on %s updated\n", 380 getprogname(), sfs.f_mntfromname, sfs.f_mntonname); 381 } 382 383 384 /* correct dev_bsize from possibly changed superblock data */ 385 dev_bsize = sblock.fs_fsize / FFS_FSBTODB(&sblock, 1); 386 387 if (Aflag) 388 for (i = 0; i < sblock.fs_ncg; i++) 389 bwrite(FFS_FSBTODB(&sblock, cgsblock(&sblock, i)), 390 buf.data, SBLOCKSIZE, special); 391 close(fi); 392 exit(0); 393 } 394 395 static void 396 show_log_info(void) 397 { 398 const char *loc; 399 uint64_t size, blksize, logsize; 400 int print; 401 402 switch (sblock.fs_journal_location) { 403 case UFS_WAPBL_JOURNALLOC_NONE: 404 print = blksize = 0; 405 /* nothing */ 406 break; 407 case UFS_WAPBL_JOURNALLOC_END_PARTITION: 408 loc = "end of partition"; 409 size = sblock.fs_journallocs[UFS_WAPBL_EPART_COUNT]; 410 blksize = sblock.fs_journallocs[UFS_WAPBL_EPART_BLKSZ]; 411 print = 1; 412 break; 413 case UFS_WAPBL_JOURNALLOC_IN_FILESYSTEM: 414 loc = "in filesystem"; 415 size = sblock.fs_journallocs[UFS_WAPBL_INFS_COUNT]; 416 blksize = sblock.fs_journallocs[UFS_WAPBL_INFS_BLKSZ]; 417 print = 1; 418 break; 419 default: 420 loc = "unknown"; 421 size = blksize = 0; 422 print = 1; 423 break; 424 } 425 426 if (print) { 427 logsize = size * blksize; 428 429 printf("\tjournal log file location: %s\n", loc); 430 printf("\tjournal log file size: "); 431 if (logsize == 0) 432 printf("0\n"); 433 else { 434 char sizebuf[8]; 435 humanize_number(sizebuf, 6, size * blksize, "B", 436 HN_AUTOSCALE, HN_B | HN_NOSPACE | HN_DECIMAL); 437 printf("%s (%" PRId64 " bytes)", sizebuf, logsize); 438 } 439 printf("\n"); 440 printf("\tjournal log flags:"); 441 if (sblock.fs_journal_flags & UFS_WAPBL_FLAGS_CREATE_LOG) 442 printf(" create-log"); 443 if (sblock.fs_journal_flags & UFS_WAPBL_FLAGS_CLEAR_LOG) 444 printf(" clear-log"); 445 printf("\n"); 446 } 447 } 448 449 static void 450 change_log_info(long long logfilesize) 451 { 452 /* 453 * NOTES: 454 * - only operate on in-filesystem log sizes 455 * - can't change size of existing log 456 * - if current is same, no action 457 * - if current is zero and new is non-zero, set flag to create log 458 * on next mount 459 * - if current is non-zero and new is zero, set flag to clear log 460 * on next mount 461 */ 462 int in_fs_log; 463 uint64_t old_size; 464 465 old_size = 0; 466 switch (sblock.fs_journal_location) { 467 case UFS_WAPBL_JOURNALLOC_END_PARTITION: 468 in_fs_log = 0; 469 old_size = sblock.fs_journallocs[UFS_WAPBL_EPART_COUNT] * 470 sblock.fs_journallocs[UFS_WAPBL_EPART_BLKSZ]; 471 break; 472 473 case UFS_WAPBL_JOURNALLOC_IN_FILESYSTEM: 474 in_fs_log = 1; 475 old_size = sblock.fs_journallocs[UFS_WAPBL_INFS_COUNT] * 476 sblock.fs_journallocs[UFS_WAPBL_INFS_BLKSZ]; 477 break; 478 479 case UFS_WAPBL_JOURNALLOC_NONE: 480 default: 481 in_fs_log = 0; 482 old_size = 0; 483 break; 484 } 485 486 if (logfilesize == 0) { 487 /* 488 * Don't clear out the locators - the kernel might need 489 * these to find the log! Just set the "clear the log" 490 * flag and let the kernel do the rest. 491 */ 492 sblock.fs_journal_flags |= UFS_WAPBL_FLAGS_CLEAR_LOG; 493 sblock.fs_journal_flags &= ~UFS_WAPBL_FLAGS_CREATE_LOG; 494 warnx("log file size cleared from %" PRIu64 "", old_size); 495 return; 496 } 497 498 if (!in_fs_log && logfilesize > 0 && old_size > 0) 499 errx(1, "Can't change size of non-in-filesystem log"); 500 501 if (old_size == (uint64_t)logfilesize && logfilesize > 0) { 502 /* no action */ 503 warnx("log file size remains unchanged at %lld", logfilesize); 504 return; 505 } 506 507 if (old_size == 0) { 508 /* create new log of desired size next mount */ 509 sblock.fs_journal_location = UFS_WAPBL_JOURNALLOC_IN_FILESYSTEM; 510 sblock.fs_journallocs[UFS_WAPBL_INFS_ADDR] = 0; 511 sblock.fs_journallocs[UFS_WAPBL_INFS_COUNT] = logfilesize; 512 sblock.fs_journallocs[UFS_WAPBL_INFS_BLKSZ] = 0; 513 sblock.fs_journallocs[UFS_WAPBL_INFS_INO] = 0; 514 sblock.fs_journal_flags |= UFS_WAPBL_FLAGS_CREATE_LOG; 515 sblock.fs_journal_flags &= ~UFS_WAPBL_FLAGS_CLEAR_LOG; 516 warnx("log file size set to %lld", logfilesize); 517 } else { 518 errx(1, 519 "Can't change existing log size from %" PRIu64 " to %lld", 520 old_size, logfilesize); 521 } 522 } 523 524 static void 525 usage(void) 526 { 527 528 fprintf(stderr, "usage: tunefs [-AFN] tuneup-options special-device\n"); 529 fprintf(stderr, "where tuneup-options are:\n"); 530 fprintf(stderr, "\t-e maximum blocks per file in a cylinder group\n"); 531 fprintf(stderr, "\t-g average file size\n"); 532 fprintf(stderr, "\t-h expected number of files per directory\n"); 533 fprintf(stderr, "\t-l journal log file size (`0' to clear journal)\n"); 534 fprintf(stderr, "\t-m minimum percentage of free space\n"); 535 fprintf(stderr, "\t-o optimization preference (`space' or `time')\n"); 536 fprintf(stderr, "\t-q quota type (`[no]user' or `[no]group')\n"); 537 fprintf(stderr, "\t-S sector size\n"); 538 exit(2); 539 } 540 541 static void 542 getsb(struct fs *fs, const char *file) 543 { 544 int i; 545 546 for (i = 0; ; i++) { 547 if (sblock_try[i] == -1) 548 errx(5, "cannot find filesystem superblock"); 549 bread(sblock_try[i] / dev_bsize, (char *)fs, SBLOCKSIZE, file); 550 switch(fs->fs_magic) { 551 case FS_UFS2_MAGIC: 552 is_ufs2 = 1; 553 /*FALLTHROUGH*/ 554 case FS_UFS1_MAGIC: 555 break; 556 case FS_UFS2_MAGIC_SWAPPED: 557 is_ufs2 = 1; 558 /*FALLTHROUGH*/ 559 case FS_UFS1_MAGIC_SWAPPED: 560 warnx("%s: swapping byte order", file); 561 needswap = 1; 562 ffs_sb_swap(fs, fs); 563 break; 564 default: 565 continue; 566 } 567 if (!is_ufs2 && sblock_try[i] == SBLOCK_UFS2) 568 continue; 569 if ((is_ufs2 || fs->fs_old_flags & FS_FLAGS_UPDATED) 570 && fs->fs_sblockloc != sblock_try[i]) 571 continue; 572 break; 573 } 574 575 dev_bsize = fs->fs_fsize / FFS_FSBTODB(fs, 1); 576 sblockloc = sblock_try[i] / dev_bsize; 577 } 578 579 static void 580 bwrite(daddr_t blk, char *buffer, int size, const char *file) 581 { 582 off_t offset; 583 584 offset = (off_t)blk * dev_bsize; 585 if (lseek(fi, offset, SEEK_SET) == -1) 586 err(6, "%s: seeking to %lld", file, (long long)offset); 587 if (write(fi, buffer, size) != size) 588 err(7, "%s: writing %d bytes", file, size); 589 } 590 591 static void 592 bread(daddr_t blk, char *buffer, int cnt, const char *file) 593 { 594 off_t offset; 595 int i; 596 597 offset = (off_t)blk * dev_bsize; 598 if (lseek(fi, offset, SEEK_SET) == -1) 599 err(4, "%s: seeking to %lld", file, (long long)offset); 600 if ((i = read(fi, buffer, cnt)) != cnt) 601 errx(5, "%s: short read", file); 602 } 603 604 static int 605 openpartition(const char *name, int flags, char *device, size_t devicelen) 606 { 607 char specname[MAXPATHLEN]; 608 char rawname[MAXPATHLEN]; 609 const char *special, *raw; 610 struct fstab *fs; 611 int fd, oerrno; 612 613 fs = getfsfile(name); 614 special = fs ? fs->fs_spec : name; 615 616 raw = getfsspecname(specname, sizeof(specname), special); 617 if (raw == NULL) 618 err(1, "%s: %s", name, specname); 619 special = getdiskrawname(rawname, sizeof(rawname), raw); 620 if (special == NULL) 621 special = raw; 622 623 fd = opendisk(special, flags, device, devicelen, 0); 624 if (fd == -1 && errno == ENOENT) { 625 oerrno = errno; 626 strlcpy(device, special, devicelen); 627 errno = oerrno; 628 } 629 return (fd); 630 } 631
Indexes created Tue Sep 30 20:09:53 GMT 2025