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