sbin/tunefs/tunefs.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-3-Clause
   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 #if 0
  33 #ifndef lint
  34 static const char copyright[] =
  35 "@(#) Copyright (c) 1983, 1993\n\
  36         The Regents of the University of California.  All rights reserved.\n";
  37 #endif /* not lint */
  38
  39 #ifndef lint
  40 static char sccsid[] = "@(#)tunefs.c    8.2 (Berkeley) 4/19/94";
  41 #endif /* not lint */
  42 #endif
  43 #include <sys/cdefs.h>
  44 /*
  45  * tunefs: change layout parameters to an existing file system.
  46  */
  47 #include <sys/param.h>
  48 #include <sys/mount.h>
  49 #include <sys/disklabel.h>
  50 #include <sys/stat.h>
  51
  52 #include <ufs/ufs/ufsmount.h>
  53 #include <ufs/ufs/dinode.h>
  54 #include <ufs/ffs/fs.h>
  55 #include <ufs/ufs/dir.h>
  56
  57 #include <ctype.h>
  58 #include <err.h>
  59 #include <fcntl.h>
  60 #include <fstab.h>
  61 #include <libufs.h>
  62 #include <mntopts.h>
  63 #include <paths.h>
  64 #include <stdio.h>
  65 #include <stdlib.h>
  66 #include <stdint.h>
  67 #include <string.h>
  68 #include <time.h>
  69 #include <unistd.h>
  70
  71 /* the optimization warning string template */
  72 #define OPTWARN "should optimize for %s with minfree %s %d%%"
  73
  74 static int blocks;
  75 static char clrbuf[MAXBSIZE];
  76 static struct uufsd disk;
  77 #define sblock disk.d_fs
  78
  79 static void usage(void);
  80 static void printfs(void);
  81 static int journal_alloc(int64_t size);
  82 static void journal_clear(void);
  83 static void sbdirty(void);
  84
  85 int
  86 main(int argc, char *argv[])
  87 {
  88         const char *avalue, *jvalue, *Jvalue, *Lvalue, *lvalue, *Nvalue, *nvalue;
  89         const char *tvalue;
  90         const char *special;
  91         const char *name;
  92         char *diskname;
  93         int Aflag, aflag, eflag, evalue, fflag, fvalue, jflag, Jflag, kflag;
  94         int kvalue, Lflag, lflag, mflag, mvalue, Nflag, nflag, oflag, ovalue;
  95         int pflag, sflag, svalue, Svalue, tflag;
  96         int ch, found_arg, i;
  97         const char *chg[2];
  98
  99         if (argc < 3)
 100                 usage();
 101         Aflag = aflag = eflag = fflag = jflag = Jflag = kflag = Lflag = 0;
 102         lflag = mflag = Nflag = nflag = oflag = pflag = sflag = tflag = 0;
 103         avalue = jvalue = Jvalue = Lvalue = lvalue = Nvalue = nvalue = NULL;
 104         evalue = fvalue = mvalue = ovalue = svalue = Svalue = 0;
 105         found_arg = 0;          /* At least one arg is required. */
 106         while ((ch = getopt(argc, argv, "Aa:e:f:j:J:k:L:l:m:N:n:o:ps:S:t:"))
 107             != -1)
 108                 switch (ch) {
 109
 110                 case 'A':
 111                         found_arg++;
 112                         Aflag++;
 113                         break;
 114
 115                 case 'a':
 116                         found_arg++;
 117                         name = "POSIX.1e ACLs";
 118                         avalue = optarg;
 119                         if (strcmp(avalue, "enable") &&
 120                             strcmp(avalue, "disable")) {
 121                                 errx(10, "bad %s (options are %s)",
 122                                     name, "`enable' or `disable'");
 123                         }
 124                         aflag = 1;
 125                         break;
 126
 127                 case 'e':
 128                         found_arg++;
 129                         name = "maximum blocks per file in a cylinder group";
 130                         evalue = atoi(optarg);
 131                         if (evalue < 1)
 132                                 errx(10, "%s must be >= 1 (was %s)",
 133                                     name, optarg);
 134                         eflag = 1;
 135                         break;
 136
 137                 case 'f':
 138                         found_arg++;
 139                         name = "average file size";
 140                         fvalue = atoi(optarg);
 141                         if (fvalue < 1)
 142                                 errx(10, "%s must be >= 1 (was %s)",
 143                                     name, optarg);
 144                         fflag = 1;
 145                         break;
 146
 147                 case 'j':
 148                         found_arg++;
 149                         name = "softdep journaled file system";
 150                         jvalue = optarg;
 151                         if (strcmp(jvalue, "enable") &&
 152                             strcmp(jvalue, "disable")) {
 153                                 errx(10, "bad %s (options are %s)",
 154                                     name, "`enable' or `disable'");
 155                         }
 156                         jflag = 1;
 157                         break;
 158
 159                 case 'J':
 160                         found_arg++;
 161                         name = "gjournaled file system";
 162                         Jvalue = optarg;
 163                         if (strcmp(Jvalue, "enable") &&
 164                             strcmp(Jvalue, "disable")) {
 165                                 errx(10, "bad %s (options are %s)",
 166                                     name, "`enable' or `disable'");
 167                         }
 168                         Jflag = 1;
 169                         break;
 170
 171                 case 'k':
 172                         found_arg++;
 173                         name = "space to hold for metadata blocks";
 174                         kvalue = atoi(optarg);
 175                         if (kvalue < 0)
 176                                 errx(10, "bad %s (%s)", name, optarg);
 177                         kflag = 1;
 178                         break;
 179
 180                 case 'L':
 181                         found_arg++;
 182                         name = "volume label";
 183                         Lvalue = optarg;
 184                         i = -1;
 185                         while (isalnum(Lvalue[++i]) || Lvalue[i] == '_' ||
 186                             Lvalue[i] == '-')
 187                                 ;
 188                         if (Lvalue[i] != '\0') {
 189                                 errx(10, "bad %s. Valid characters are "
 190                                     "alphanumerics, dashes, and underscores.",
 191                                     name);
 192                         }
 193                         if (strlen(Lvalue) >= MAXVOLLEN) {
 194                                 errx(10, "bad %s. Length is longer than %d.",
 195                                     name, MAXVOLLEN - 1);
 196                         }
 197                         Lflag = 1;
 198                         break;
 199
 200                 case 'l':
 201                         found_arg++;
 202                         name = "multilabel MAC file system";
 203                         lvalue = optarg;
 204                         if (strcmp(lvalue, "enable") &&
 205                             strcmp(lvalue, "disable")) {
 206                                 errx(10, "bad %s (options are %s)",
 207                                     name, "`enable' or `disable'");
 208                         }
 209                         lflag = 1;
 210                         break;
 211
 212                 case 'm':
 213                         found_arg++;
 214                         name = "minimum percentage of free space";
 215                         mvalue = atoi(optarg);
 216                         if (mvalue < 0 || mvalue > 99)
 217                                 errx(10, "bad %s (%s)", name, optarg);
 218                         mflag = 1;
 219                         break;
 220
 221                 case 'N':
 222                         found_arg++;
 223                         name = "NFSv4 ACLs";
 224                         Nvalue = optarg;
 225                         if (strcmp(Nvalue, "enable") &&
 226                             strcmp(Nvalue, "disable")) {
 227                                 errx(10, "bad %s (options are %s)",
 228                                     name, "`enable' or `disable'");
 229                         }
 230                         Nflag = 1;
 231                         break;
 232
 233                 case 'n':
 234                         found_arg++;
 235                         name = "soft updates";
 236                         nvalue = optarg;
 237                         if (strcmp(nvalue, "enable") != 0 &&
 238                             strcmp(nvalue, "disable") != 0) {
 239                                 errx(10, "bad %s (options are %s)",
 240                                     name, "`enable' or `disable'");
 241                         }
 242                         nflag = 1;
 243                         break;
 244
 245                 case 'o':
 246                         found_arg++;
 247                         name = "optimization preference";
 248                         if (strcmp(optarg, "space") == 0)
 249                                 ovalue = FS_OPTSPACE;
 250                         else if (strcmp(optarg, "time") == 0)
 251                                 ovalue = FS_OPTTIME;
 252                         else
 253                                 errx(10,
 254                                     "bad %s (options are `space' or `time')",
 255                                     name);
 256                         oflag = 1;
 257                         break;
 258
 259                 case 'p':
 260                         found_arg++;
 261                         pflag = 1;
 262                         break;
 263
 264                 case 's':
 265                         found_arg++;
 266                         name = "expected number of files per directory";
 267                         svalue = atoi(optarg);
 268                         if (svalue < 1)
 269                                 errx(10, "%s must be >= 1 (was %s)",
 270                                     name, optarg);
 271                         sflag = 1;
 272                         break;
 273
 274                 case 'S':
 275                         found_arg++;
 276                         name = "Softdep Journal Size";
 277                         Svalue = atoi(optarg);
 278                         if (Svalue < SUJ_MIN)
 279                                 errx(10, "%s must be >= %d (was %s)",
 280                                     name, SUJ_MIN, optarg);
 281                         break;
 282
 283                 case 't':
 284                         found_arg++;
 285                         name = "trim";
 286                         tvalue = optarg;
 287                         if (strcmp(tvalue, "enable") != 0 &&
 288                             strcmp(tvalue, "disable") != 0) {
 289                                 errx(10, "bad %s (options are %s)",
 290                                     name, "`enable' or `disable'");
 291                         }
 292                         tflag = 1;
 293                         break;
 294
 295                 default:
 296                         usage();
 297                 }
 298         argc -= optind;
 299         argv += optind;
 300         if (found_arg == 0 || argc != 1)
 301                 usage();
 302
 303         special = argv[0];
 304         if (ufs_disk_fillout(&disk, special) == -1)
 305                 goto err;
 306         /*
 307          * Check for unclean filesystem.
 308          */
 309         if ((sblock.fs_clean == 0 ||
 310             (sblock.fs_flags & (FS_UNCLEAN | FS_NEEDSFSCK)) != 0) &&
 311             (found_arg > 1 || !pflag))
 312                 errx(1, "%s is not clean - run fsck.\n", special);
 313         if (pflag) {
 314                 printfs();
 315                 exit(0);
 316         }
 317         if (Lflag) {
 318                 name = "volume label";
 319                 strncpy(sblock.fs_volname, Lvalue, MAXVOLLEN);
 320         }
 321         if (aflag) {
 322                 name = "POSIX.1e ACLs";
 323                 if (strcmp(avalue, "enable") == 0) {
 324                         if (sblock.fs_flags & FS_ACLS) {
 325                                 warnx("%s remains unchanged as enabled", name);
 326                         } else if (sblock.fs_flags & FS_NFS4ACLS) {
 327                                 warnx("%s and NFSv4 ACLs are mutually "
 328                                     "exclusive", name);
 329                         } else {
 330                                 sblock.fs_flags |= FS_ACLS;
 331                                 warnx("%s set", name);
 332                         }
 333                 } else if (strcmp(avalue, "disable") == 0) {
 334                         if ((~sblock.fs_flags & FS_ACLS) ==
 335                             FS_ACLS) {
 336                                 warnx("%s remains unchanged as disabled",
 337                                     name);
 338                         } else {
 339                                 sblock.fs_flags &= ~FS_ACLS;
 340                                 warnx("%s cleared", name);
 341                         }
 342                 }
 343         }
 344         if (eflag) {
 345                 name = "maximum blocks per file in a cylinder group";
 346                 if (sblock.fs_maxbpg == evalue)
 347                         warnx("%s remains unchanged as %d", name, evalue);
 348                 else {
 349                         warnx("%s changes from %d to %d",
 350                             name, sblock.fs_maxbpg, evalue);
 351                         sblock.fs_maxbpg = evalue;
 352                 }
 353         }
 354         if (fflag) {
 355                 name = "average file size";
 356                 if (sblock.fs_avgfilesize == (unsigned)fvalue) {
 357                         warnx("%s remains unchanged as %d", name, fvalue);
 358                 }
 359                 else {
 360                         warnx("%s changes from %d to %d",
 361                                         name, sblock.fs_avgfilesize, fvalue);
 362                         sblock.fs_avgfilesize = fvalue;
 363                 }
 364         }
 365         if (jflag) {
 366                 name = "soft updates journaling";
 367                 if (strcmp(jvalue, "enable") == 0) {
 368                         if ((sblock.fs_flags & (FS_DOSOFTDEP | FS_SUJ)) ==
 369                             (FS_DOSOFTDEP | FS_SUJ)) {
 370                                 warnx("%s remains unchanged as enabled", name);
 371                         } else if (sblock.fs_clean == 0) {
 372                                 warnx("%s cannot be enabled until fsck is run",
 373                                     name);
 374                         } else if (journal_alloc(Svalue) != 0) {
 375                                 warnx("%s cannot be enabled", name);
 376                         } else {
 377                                 sblock.fs_flags |= FS_DOSOFTDEP | FS_SUJ;
 378                                 warnx("%s set", name);
 379                         }
 380                 } else if (strcmp(jvalue, "disable") == 0) {
 381                         if ((~sblock.fs_flags & FS_SUJ) == FS_SUJ) {
 382                                 warnx("%s remains unchanged as disabled", name);
 383                         } else {
 384                                 journal_clear();
 385                                 sblock.fs_flags &= ~FS_SUJ;
 386                                 sblock.fs_sujfree = 0;
 387                                 warnx("%s cleared but soft updates still set.",
 388                                     name);
 389
 390                                 warnx("remove .sujournal to reclaim space");
 391                         }
 392                 }
 393         }
 394         if (Jflag) {
 395                 name = "gjournal";
 396                 if (strcmp(Jvalue, "enable") == 0) {
 397                         if (sblock.fs_flags & FS_GJOURNAL) {
 398                                 warnx("%s remains unchanged as enabled", name);
 399                         } else {
 400                                 sblock.fs_flags |= FS_GJOURNAL;
 401                                 warnx("%s set", name);
 402                         }
 403                 } else if (strcmp(Jvalue, "disable") == 0) {
 404                         if ((~sblock.fs_flags & FS_GJOURNAL) ==
 405                             FS_GJOURNAL) {
 406                                 warnx("%s remains unchanged as disabled",
 407                                     name);
 408                         } else {
 409                                 sblock.fs_flags &= ~FS_GJOURNAL;
 410                                 warnx("%s cleared", name);
 411                         }
 412                 }
 413         }
 414         if (kflag) {
 415                 name = "space to hold for metadata blocks";
 416                 if (sblock.fs_metaspace == kvalue)
 417                         warnx("%s remains unchanged as %d", name, kvalue);
 418                 else {
 419                         kvalue = blknum(&sblock, kvalue);
 420                         if (kvalue > sblock.fs_fpg / 2) {
 421                                 kvalue = blknum(&sblock, sblock.fs_fpg / 2);
 422                                 warnx("%s cannot exceed half the file system "
 423                                     "space", name);
 424                         }
 425                         warnx("%s changes from %jd to %d",
 426                                     name, sblock.fs_metaspace, kvalue);
 427                         sblock.fs_metaspace = kvalue;
 428                 }
 429         }
 430         if (lflag) {
 431                 name = "multilabel";
 432                 if (strcmp(lvalue, "enable") == 0) {
 433                         if (sblock.fs_flags & FS_MULTILABEL) {
 434                                 warnx("%s remains unchanged as enabled", name);
 435                         } else {
 436                                 sblock.fs_flags |= FS_MULTILABEL;
 437                                 warnx("%s set", name);
 438                         }
 439                 } else if (strcmp(lvalue, "disable") == 0) {
 440                         if ((~sblock.fs_flags & FS_MULTILABEL) ==
 441                             FS_MULTILABEL) {
 442                                 warnx("%s remains unchanged as disabled",
 443                                     name);
 444                         } else {
 445                                 sblock.fs_flags &= ~FS_MULTILABEL;
 446                                 warnx("%s cleared", name);
 447                         }
 448                 }
 449         }
 450         if (mflag) {
 451                 name = "minimum percentage of free space";
 452                 if (sblock.fs_minfree == mvalue)
 453                         warnx("%s remains unchanged as %d%%", name, mvalue);
 454                 else {
 455                         warnx("%s changes from %d%% to %d%%",
 456                                     name, sblock.fs_minfree, mvalue);
 457                         sblock.fs_minfree = mvalue;
 458                         if (mvalue >= MINFREE && sblock.fs_optim == FS_OPTSPACE)
 459                                 warnx(OPTWARN, "time", ">=", MINFREE);
 460                         if (mvalue < MINFREE && sblock.fs_optim == FS_OPTTIME)
 461                                 warnx(OPTWARN, "space", "<", MINFREE);
 462                 }
 463         }
 464         if (Nflag) {
 465                 name = "NFSv4 ACLs";
 466                 if (strcmp(Nvalue, "enable") == 0) {
 467                         if (sblock.fs_flags & FS_NFS4ACLS) {
 468                                 warnx("%s remains unchanged as enabled", name);
 469                         } else if (sblock.fs_flags & FS_ACLS) {
 470                                 warnx("%s and POSIX.1e ACLs are mutually "
 471                                     "exclusive", name);
 472                         } else {
 473                                 sblock.fs_flags |= FS_NFS4ACLS;
 474                                 warnx("%s set", name);
 475                         }
 476                 } else if (strcmp(Nvalue, "disable") == 0) {
 477                         if ((~sblock.fs_flags & FS_NFS4ACLS) ==
 478                             FS_NFS4ACLS) {
 479                                 warnx("%s remains unchanged as disabled",
 480                                     name);
 481                         } else {
 482                                 sblock.fs_flags &= ~FS_NFS4ACLS;
 483                                 warnx("%s cleared", name);
 484                         }
 485                 }
 486         }
 487         if (nflag) {
 488                 name = "soft updates";
 489                 if (strcmp(nvalue, "enable") == 0) {
 490                         if (sblock.fs_flags & FS_DOSOFTDEP)
 491                                 warnx("%s remains unchanged as enabled", name);
 492                         else if (sblock.fs_clean == 0) {
 493                                 warnx("%s cannot be enabled until fsck is run",
 494                                     name);
 495                         } else {
 496                                 sblock.fs_flags |= FS_DOSOFTDEP;
 497                                 warnx("%s set", name);
 498                         }
 499                 } else if (strcmp(nvalue, "disable") == 0) {
 500                         if ((~sblock.fs_flags & FS_DOSOFTDEP) == FS_DOSOFTDEP)
 501                                 warnx("%s remains unchanged as disabled", name);
 502                         else {
 503                                 sblock.fs_flags &= ~FS_DOSOFTDEP;
 504                                 warnx("%s cleared", name);
 505                         }
 506                 }
 507         }
 508         if (oflag) {
 509                 name = "optimization preference";
 510                 chg[FS_OPTSPACE] = "space";
 511                 chg[FS_OPTTIME] = "time";
 512                 if (sblock.fs_optim == ovalue)
 513                         warnx("%s remains unchanged as %s", name, chg[ovalue]);
 514                 else {
 515                         warnx("%s changes from %s to %s",
 516                                     name, chg[sblock.fs_optim], chg[ovalue]);
 517                         sblock.fs_optim = ovalue;
 518                         if (sblock.fs_minfree >= MINFREE &&
 519                             ovalue == FS_OPTSPACE)
 520                                 warnx(OPTWARN, "time", ">=", MINFREE);
 521                         if (sblock.fs_minfree < MINFREE && ovalue == FS_OPTTIME)
 522                                 warnx(OPTWARN, "space", "<", MINFREE);
 523                 }
 524         }
 525         if (sflag) {
 526                 name = "expected number of files per directory";
 527                 if (sblock.fs_avgfpdir == (unsigned)svalue) {
 528                         warnx("%s remains unchanged as %d", name, svalue);
 529                 }
 530                 else {
 531                         warnx("%s changes from %d to %d",
 532                                         name, sblock.fs_avgfpdir, svalue);
 533                         sblock.fs_avgfpdir = svalue;
 534                 }
 535         }
 536         if (tflag) {
 537                 name = "issue TRIM to the disk";
 538                 if (strcmp(tvalue, "enable") == 0) {
 539                         if (sblock.fs_flags & FS_TRIM)
 540                                 warnx("%s remains unchanged as enabled", name);
 541                         else {
 542                                 sblock.fs_flags |= FS_TRIM;
 543                                 warnx("%s set", name);
 544                         }
 545                 } else if (strcmp(tvalue, "disable") == 0) {
 546                         if ((~sblock.fs_flags & FS_TRIM) == FS_TRIM)
 547                                 warnx("%s remains unchanged as disabled", name);
 548                         else {
 549                                 sblock.fs_flags &= ~FS_TRIM;
 550                                 warnx("%s cleared", name);
 551                         }
 552                 }
 553         }
 554
 555         if (sbwrite(&disk, Aflag) == -1)
 556                 goto err;
 557         diskname = strdup(disk.d_name);
 558         ufs_disk_close(&disk);
 559         chkdoreload(getmntpoint(diskname), warnx);
 560         exit(0);
 561 err:
 562         if (disk.d_error != NULL)
 563                 errx(11, "%s: %s", special, disk.d_error);
 564         else
 565                 err(12, "%s", special);
 566 }
 567
 568 static void
 569 sbdirty(void)
 570 {
 571         disk.d_fs.fs_flags |= FS_UNCLEAN | FS_NEEDSFSCK;
 572         disk.d_fs.fs_clean = 0;
 573 }
 574
 575 static ufs2_daddr_t
 576 journal_balloc(void)
 577 {
 578         ufs2_daddr_t blk;
 579         struct cg *cgp;
 580         int valid;
 581         static int contig = 1;
 582
 583         cgp = &disk.d_cg;
 584         for (;;) {
 585                 blk = cgballoc(&disk);
 586                 if (blk > 0)
 587                         break;
 588                 /*
 589                  * If we failed to allocate a block from this cg, move to
 590                  * the next.
 591                  */
 592                 if (cgwrite(&disk) < 0) {
 593                         warn("Failed to write updated cg");
 594                         return (-1);
 595                 }
 596                 while ((valid = cgread(&disk)) == 1) {
 597                         /*
 598                          * Try to minimize fragmentation by requiring a minimum
 599                          * number of blocks present.
 600                          */
 601                         if (cgp->cg_cs.cs_nbfree > 256 * 1024)
 602                                 break;
 603                         if (contig == 0 && cgp->cg_cs.cs_nbfree)
 604                                 break;
 605                 }
 606                 if (valid)
 607                         continue;
 608                 /*
 609                  * Try once through looking only for large contiguous regions
 610                  * and again taking any space we can find.
 611                  */
 612                 if (contig) {
 613                         contig = 0;
 614                         disk.d_ccg = 0;
 615                         warnx("Journal file fragmented.");
 616                         continue;
 617                 }
 618                 warnx("Failed to find sufficient free blocks for the journal");
 619                 return -1;
 620         }
 621         if (bwrite(&disk, fsbtodb(&sblock, blk), clrbuf,
 622             sblock.fs_bsize) <= 0) {
 623                 warn("Failed to initialize new block");
 624                 return -1;
 625         }
 626         return (blk);
 627 }
 628
 629 /*
 630  * Search a directory block for the SUJ_FILE.
 631  */
 632 static ino_t
 633 dir_search(ufs2_daddr_t blk, int bytes)
 634 {
 635         char block[MAXBSIZE];
 636         struct direct *dp;
 637         int off;
 638
 639         if (bread(&disk, fsbtodb(&sblock, blk), block, bytes) <= 0) {
 640                 warn("Failed to read dir block");
 641                 return (-1);
 642         }
 643         for (off = 0; off < bytes; off += dp->d_reclen) {
 644                 dp = (struct direct *)&block[off];
 645                 if (dp->d_reclen == 0)
 646                         break;
 647                 if (dp->d_ino == 0)
 648                         continue;
 649                 if (dp->d_namlen != strlen(SUJ_FILE))
 650                         continue;
 651                 if (bcmp(dp->d_name, SUJ_FILE, dp->d_namlen) != 0)
 652                         continue;
 653                 return (dp->d_ino);
 654         }
 655
 656         return (0);
 657 }
 658
 659 /*
 660  * Search in the UFS_ROOTINO for the SUJ_FILE.  If it exists we can not enable
 661  * journaling.
 662  */
 663 static ino_t
 664 journal_findfile(void)
 665 {
 666         union dinodep dp;
 667         ino_t ino;
 668         int i;
 669
 670         if (getinode(&disk, &dp, UFS_ROOTINO) != 0) {
 671                 warn("Failed to get root inode: %s", disk.d_error);
 672                 return (-1);
 673         }
 674         if (sblock.fs_magic == FS_UFS1_MAGIC) {
 675                 if ((off_t)dp.dp1->di_size >= lblktosize(&sblock, UFS_NDADDR)) {
 676                         warnx("UFS_ROOTINO extends beyond direct blocks.");
 677                         return (-1);
 678                 }
 679                 for (i = 0; i < UFS_NDADDR; i++) {
 680                         if (dp.dp1->di_db[i] == 0)
 681                                 break;
 682                         if ((ino = dir_search(dp.dp1->di_db[i],
 683                             sblksize(&sblock, (off_t)dp.dp1->di_size, i))) != 0)
 684                                 return (ino);
 685                 }
 686         } else {
 687                 if ((off_t)dp.dp2->di_size >= lblktosize(&sblock, UFS_NDADDR)) {
 688                         warnx("UFS_ROOTINO extends beyond direct blocks.");
 689                         return (-1);
 690                 }
 691                 for (i = 0; i < UFS_NDADDR; i++) {
 692                         if (dp.dp2->di_db[i] == 0)
 693                                 break;
 694                         if ((ino = dir_search(dp.dp2->di_db[i],
 695                             sblksize(&sblock, (off_t)dp.dp2->di_size, i))) != 0)
 696                                 return (ino);
 697                 }
 698         }
 699
 700         return (0);
 701 }
 702
 703 static void
 704 dir_clear_block(const char *block, off_t off)
 705 {
 706         struct direct *dp;
 707
 708         for (; off < sblock.fs_bsize; off += DIRBLKSIZ) {
 709                 dp = (struct direct *)&block[off];
 710                 dp->d_ino = 0;
 711                 dp->d_reclen = DIRBLKSIZ;
 712                 dp->d_type = DT_UNKNOWN;
 713         }
 714 }
 715
 716 /*
 717  * Insert the journal at inode 'ino' into directory blk 'blk' at the first
 718  * free offset of 'off'.  DIRBLKSIZ blocks after off are initialized as
 719  * empty.
 720  */
 721 static int
 722 dir_insert(ufs2_daddr_t blk, off_t off, ino_t ino)
 723 {
 724         struct direct *dp;
 725         char block[MAXBSIZE];
 726
 727         if (bread(&disk, fsbtodb(&sblock, blk), block, sblock.fs_bsize) <= 0) {
 728                 warn("Failed to read dir block");
 729                 return (-1);
 730         }
 731         bzero(&block[off], sblock.fs_bsize - off);
 732         dp = (struct direct *)&block[off];
 733         dp->d_ino = ino;
 734         dp->d_reclen = DIRBLKSIZ;
 735         dp->d_type = DT_REG;
 736         dp->d_namlen = strlen(SUJ_FILE);
 737         bcopy(SUJ_FILE, &dp->d_name, strlen(SUJ_FILE));
 738         dir_clear_block(block, off + DIRBLKSIZ);
 739         if (bwrite(&disk, fsbtodb(&sblock, blk), block, sblock.fs_bsize) <= 0) {
 740                 warn("Failed to write dir block");
 741                 return (-1);
 742         }
 743         return (0);
 744 }
 745
 746 /*
 747  * Extend a directory block in 'blk' by copying it to a full size block
 748  * and inserting the new journal inode into .sujournal.
 749  */
 750 static int
 751 dir_extend(ufs2_daddr_t blk, ufs2_daddr_t nblk, off_t size, ino_t ino)
 752 {
 753         char block[MAXBSIZE];
 754
 755         if (bread(&disk, fsbtodb(&sblock, blk), block,
 756             roundup(size, sblock.fs_fsize)) <= 0) {
 757                 warn("Failed to read dir block");
 758                 return (-1);
 759         }
 760         dir_clear_block(block, size);
 761         if (bwrite(&disk, fsbtodb(&sblock, nblk), block, sblock.fs_bsize)
 762             <= 0) {
 763                 warn("Failed to write dir block");
 764                 return (-1);
 765         }
 766
 767         return (dir_insert(nblk, size, ino));
 768 }
 769
 770 /*
 771  * Insert the journal file into the UFS_ROOTINO directory.  We always extend the
 772  * last frag
 773  */
 774 static int
 775 journal_insertfile(ino_t ino)
 776 {
 777         union dinodep dp;
 778         ufs2_daddr_t nblk;
 779         ufs2_daddr_t blk;
 780         ufs_lbn_t lbn;
 781         int size;
 782         int off;
 783
 784         if (getinode(&disk, &dp, UFS_ROOTINO) != 0) {
 785                 warn("Failed to get root inode: %s", disk.d_error);
 786                 sbdirty();
 787                 return (-1);
 788         }
 789         blk = 0;
 790         size = 0;
 791         nblk = journal_balloc();
 792         if (nblk <= 0)
 793                 return (-1);
 794         /*
 795          * For simplicity sake we aways extend the UFS_ROOTINO into a new
 796          * directory block rather than searching for space and inserting
 797          * into an existing block.  However, if the rootino has frags
 798          * have to free them and extend the block.
 799          */
 800         if (sblock.fs_magic == FS_UFS1_MAGIC) {
 801                 lbn = lblkno(&sblock, dp.dp1->di_size);
 802                 off = blkoff(&sblock, dp.dp1->di_size);
 803                 blk = dp.dp1->di_db[lbn];
 804                 size = sblksize(&sblock, (off_t)dp.dp1->di_size, lbn);
 805         } else {
 806                 lbn = lblkno(&sblock, dp.dp2->di_size);
 807                 off = blkoff(&sblock, dp.dp2->di_size);
 808                 blk = dp.dp2->di_db[lbn];
 809                 size = sblksize(&sblock, (off_t)dp.dp2->di_size, lbn);
 810         }
 811         if (off != 0) {
 812                 if (dir_extend(blk, nblk, off, ino) == -1)
 813                         return (-1);
 814         } else {
 815                 blk = 0;
 816                 if (dir_insert(nblk, 0, ino) == -1)
 817                         return (-1);
 818         }
 819         if (sblock.fs_magic == FS_UFS1_MAGIC) {
 820                 dp.dp1->di_blocks += (sblock.fs_bsize - size) / DEV_BSIZE;
 821                 dp.dp1->di_db[lbn] = nblk;
 822                 dp.dp1->di_size = lblktosize(&sblock, lbn+1);
 823         } else {
 824                 dp.dp2->di_blocks += (sblock.fs_bsize - size) / DEV_BSIZE;
 825                 dp.dp2->di_db[lbn] = nblk;
 826                 dp.dp2->di_size = lblktosize(&sblock, lbn+1);
 827         }
 828         if (putinode(&disk) < 0) {
 829                 warn("Failed to write root inode: %s", disk.d_error);
 830                 return (-1);
 831         }
 832         if (cgwrite(&disk) < 0) {
 833                 warn("Failed to write updated cg");
 834                 sbdirty();
 835                 return (-1);
 836         }
 837         if (blk) {
 838                 if (cgbfree(&disk, blk, size) < 0) {
 839                         warn("Failed to write cg");
 840                         return (-1);
 841                 }
 842         }
 843
 844         return (0);
 845 }
 846
 847 static int
 848 indir_fill(ufs2_daddr_t blk, int level, int *resid)
 849 {
 850         char indirbuf[MAXBSIZE];
 851         ufs1_daddr_t *bap1;
 852         ufs2_daddr_t *bap2;
 853         ufs2_daddr_t nblk;
 854         int ncnt;
 855         int cnt;
 856         int i;
 857
 858         bzero(indirbuf, sizeof(indirbuf));
 859         bap1 = (ufs1_daddr_t *)indirbuf;
 860         bap2 = (void *)bap1;
 861         cnt = 0;
 862         for (i = 0; i < NINDIR(&sblock) && *resid != 0; i++) {
 863                 nblk = journal_balloc();
 864                 if (nblk <= 0)
 865                         return (-1);
 866                 cnt++;
 867                 if (sblock.fs_magic == FS_UFS1_MAGIC)
 868                         *bap1++ = nblk;
 869                 else
 870                         *bap2++ = nblk;
 871                 if (level != 0) {
 872                         ncnt = indir_fill(nblk, level - 1, resid);
 873                         if (ncnt <= 0)
 874                                 return (-1);
 875                         cnt += ncnt;
 876                 } else
 877                         (*resid)--;
 878         }
 879         if (bwrite(&disk, fsbtodb(&sblock, blk), indirbuf,
 880             sblock.fs_bsize) <= 0) {
 881                 warn("Failed to write indirect");
 882                 return (-1);
 883         }
 884         return (cnt);
 885 }
 886
 887 /*
 888  * Clear the flag bits so the journal can be removed.
 889  */
 890 static void
 891 journal_clear(void)
 892 {
 893         union dinodep dp;
 894         ino_t ino;
 895
 896         ino = journal_findfile();
 897         if (ino == (ino_t)-1 || ino == 0) {
 898                 warnx("Journal file does not exist");
 899                 return;
 900         }
 901         printf("Clearing journal flags from inode %ju\n", (uintmax_t)ino);
 902         if (getinode(&disk, &dp, ino) != 0) {
 903                 warn("Failed to get journal inode: %s", disk.d_error);
 904                 return;
 905         }
 906         if (sblock.fs_magic == FS_UFS1_MAGIC)
 907                 dp.dp1->di_flags = 0;
 908         else
 909                 dp.dp2->di_flags = 0;
 910         if (putinode(&disk) < 0) {
 911                 warn("Failed to write journal inode: %s", disk.d_error);
 912                 return;
 913         }
 914 }
 915
 916 static int
 917 journal_alloc(int64_t size)
 918 {
 919         union dinodep dp;
 920         ufs2_daddr_t blk;
 921         struct cg *cgp;
 922         int resid;
 923         ino_t ino;
 924         int blks;
 925         time_t utime;
 926         int i;
 927
 928         cgp = &disk.d_cg;
 929         ino = 0;
 930
 931         /*
 932          * If the journal file exists we can't allocate it.
 933          */
 934         ino = journal_findfile();
 935         if (ino == (ino_t)-1) {
 936                 warnx("journal_findfile() failed.");
 937                 return (-1);
 938         }
 939         if (ino > 0) {
 940                 warnx("Journal file %s already exists, please remove.",
 941                     SUJ_FILE);
 942                 return (-1);
 943         }
 944         /*
 945          * If the user didn't supply a size pick one based on the filesystem
 946          * size constrained with hardcoded MIN and MAX values.  We opt for
 947          * 1/1024th of the filesystem up to MAX but not exceeding one CG and
 948          * not less than the MIN.
 949          */
 950         if (size == 0) {
 951                 size = (sblock.fs_size * sblock.fs_bsize) / 1024;
 952                 if (size / sblock.fs_fsize > sblock.fs_fpg)
 953                         size = sblock.fs_fpg * sblock.fs_fsize;
 954                 size = MAX(SUJ_MIN, size);
 955         }
 956         /* fsck does not support fragments in journal files. */
 957         size = roundup(size, sblock.fs_bsize);
 958         resid = blocks = size / sblock.fs_bsize;
 959         if (sblock.fs_cstotal.cs_nbfree < blocks) {
 960                 warn("Insufficient free space for %jd byte journal", size);
 961                 return (-1);
 962         }
 963         /*
 964          * Find a cg with enough blocks to satisfy the journal
 965          * size.  Presently the journal does not span cgs.
 966          */
 967         while (cgread(&disk) == 1) {
 968                 if (cgp->cg_cs.cs_nifree == 0)
 969                         continue;
 970                 ino = cgialloc(&disk);
 971                 if (ino <= 0)
 972                         break;
 973                 printf("Using inode %ju in cg %d for %jd byte journal\n",
 974                     (uintmax_t)ino, cgp->cg_cgx, size);
 975                 if (getinode(&disk, &dp, ino) != 0) {
 976                         warn("Failed to get allocated inode: %s", disk.d_error);
 977                         sbdirty();
 978                         goto out;
 979                 }
 980                 /*
 981                  * We leave fields unrelated to the number of allocated
 982                  * blocks and size uninitialized.  This causes legacy
 983                  * fsck implementations to clear the inode.
 984                  */
 985                 time(&utime);
 986                 if (sblock.fs_magic == FS_UFS1_MAGIC) {
 987                         bzero(dp.dp1, sizeof(*dp.dp1));
 988                         dp.dp1->di_size = size;
 989                         dp.dp1->di_mode = IFREG | IREAD;
 990                         dp.dp1->di_nlink = 1;
 991                         dp.dp1->di_flags =
 992                             SF_IMMUTABLE | SF_NOUNLINK | UF_NODUMP;
 993                         dp.dp1->di_atime = utime;
 994                         dp.dp1->di_mtime = utime;
 995                         dp.dp1->di_ctime = utime;
 996                 } else {
 997                         bzero(dp.dp2, sizeof(*dp.dp2));
 998                         dp.dp2->di_size = size;
 999                         dp.dp2->di_mode = IFREG | IREAD;
1000                         dp.dp2->di_nlink = 1;
1001                         dp.dp2->di_flags =
1002                             SF_IMMUTABLE | SF_NOUNLINK | UF_NODUMP;
1003                         dp.dp2->di_atime = utime;
1004                         dp.dp2->di_mtime = utime;
1005                         dp.dp2->di_ctime = utime;
1006                         dp.dp2->di_birthtime = utime;
1007                 }
1008                 for (i = 0; i < UFS_NDADDR && resid; i++, resid--) {
1009                         blk = journal_balloc();
1010                         if (blk <= 0)
1011                                 goto out;
1012                         if (sblock.fs_magic == FS_UFS1_MAGIC) {
1013                                 dp.dp1->di_db[i] = blk;
1014                                 dp.dp1->di_blocks++;
1015                         } else {
1016                                 dp.dp2->di_db[i] = blk;
1017                                 dp.dp2->di_blocks++;
1018                         }
1019                 }
1020                 for (i = 0; i < UFS_NIADDR && resid; i++) {
1021                         blk = journal_balloc();
1022                         if (blk <= 0)
1023                                 goto out;
1024                         blks = indir_fill(blk, i, &resid) + 1;
1025                         if (blks <= 0) {
1026                                 sbdirty();
1027                                 goto out;
1028                         }
1029                         if (sblock.fs_magic == FS_UFS1_MAGIC) {
1030                                 dp.dp1->di_ib[i] = blk;
1031                                 dp.dp1->di_blocks += blks;
1032                         } else {
1033                                 dp.dp2->di_ib[i] = blk;
1034                                 dp.dp2->di_blocks += blks;
1035                         }
1036                 }
1037                 if (sblock.fs_magic == FS_UFS1_MAGIC)
1038                         dp.dp1->di_blocks *= sblock.fs_bsize / disk.d_bsize;
1039                 else
1040                         dp.dp2->di_blocks *= sblock.fs_bsize / disk.d_bsize;
1041                 if (putinode(&disk) < 0) {
1042                         warn("Failed to write allocated inode: %s",
1043                             disk.d_error);
1044                         sbdirty();
1045                         return (-1);
1046                 }
1047                 if (cgwrite(&disk) < 0) {
1048                         warn("Failed to write updated cg");
1049                         sbdirty();
1050                         return (-1);
1051                 }
1052                 if (journal_insertfile(ino) < 0) {
1053                         sbdirty();
1054                         return (-1);
1055                 }
1056                 sblock.fs_sujfree = 0;
1057                 return (0);
1058         }
1059         warnx("Insufficient free space for the journal.");
1060 out:
1061         return (-1);
1062 }
1063
1064 static void
1065 usage(void)
1066 {
1067         fprintf(stderr, "%s\n%s\n%s\n%s\n%s\n%s\n",
1068 "usage: tunefs [-A] [-a enable | disable] [-e maxbpg] [-f avgfilesize]",
1069 "              [-J enable | disable] [-j enable | disable] [-k metaspace]",
1070 "              [-L volname] [-l enable | disable] [-m minfree]",
1071 "              [-N enable | disable] [-n enable | disable]",
1072 "              [-o space | time] [-p] [-s avgfpdir] [-t enable | disable]",
1073 "              special | filesystem");
1074         exit(2);
1075 }
1076
1077 static void
1078 printfs(void)
1079 {
1080         warnx("POSIX.1e ACLs: (-a)                                %s",
1081                 (sblock.fs_flags & FS_ACLS)? "enabled" : "disabled");
1082         warnx("NFSv4 ACLs: (-N)                                   %s",
1083                 (sblock.fs_flags & FS_NFS4ACLS)? "enabled" : "disabled");
1084         warnx("MAC multilabel: (-l)                               %s",
1085                 (sblock.fs_flags & FS_MULTILABEL)? "enabled" : "disabled");
1086         warnx("soft updates: (-n)                                 %s",
1087                 (sblock.fs_flags & FS_DOSOFTDEP)? "enabled" : "disabled");
1088         warnx("soft update journaling: (-j)                       %s",
1089                 (sblock.fs_flags & FS_SUJ)? "enabled" : "disabled");
1090         warnx("gjournal: (-J)                                     %s",
1091                 (sblock.fs_flags & FS_GJOURNAL)? "enabled" : "disabled");
1092         warnx("trim: (-t)                                         %s",
1093                 (sblock.fs_flags & FS_TRIM)? "enabled" : "disabled");
1094         warnx("maximum blocks per file in a cylinder group: (-e)  %d",
1095               sblock.fs_maxbpg);
1096         warnx("average file size: (-f)                            %d",
1097               sblock.fs_avgfilesize);
1098         warnx("average number of files in a directory: (-s)       %d",
1099               sblock.fs_avgfpdir);
1100         warnx("minimum percentage of free space: (-m)             %d%%",
1101               sblock.fs_minfree);
1102         warnx("space to hold for metadata blocks: (-k)            %jd",
1103               sblock.fs_metaspace);
1104         warnx("optimization preference: (-o)                      %s",
1105               sblock.fs_optim == FS_OPTSPACE ? "space" : "time");
1106         if (sblock.fs_minfree >= MINFREE &&
1107             sblock.fs_optim == FS_OPTSPACE)
1108                 warnx(OPTWARN, "time", ">=", MINFREE);
1109         if (sblock.fs_minfree < MINFREE &&
1110             sblock.fs_optim == FS_OPTTIME)
1111                 warnx(OPTWARN, "space", "<", MINFREE);
1112         warnx("volume label: (-L)                                 %s",
1113                 sblock.fs_volname);
1114 }