Deleted Added
sdiff udiff text old ( 96707 ) new ( 98542 )
full compact
tunefs.c (96707) tunefs.c (98542)
1/*
2 * Copyright (c) 1983, 1993
3 * The Regents of the University of California. All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright

--- 28 unchanged lines hidden (view full) ---

37 The Regents of the University of California. All rights reserved.\n";
38#endif /* not lint */
39
40#ifndef lint
41#if 0
42static char sccsid[] = "@(#)tunefs.c 8.2 (Berkeley) 4/19/94";
43#endif
44static const char rcsid[] =
1/*
2 * Copyright (c) 1983, 1993
3 * The Regents of the University of California. All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright

--- 28 unchanged lines hidden (view full) ---

37 The Regents of the University of California. All rights reserved.\n";
38#endif /* not lint */
39
40#ifndef lint
41#if 0
42static char sccsid[] = "@(#)tunefs.c 8.2 (Berkeley) 4/19/94";
43#endif
44static const char rcsid[] =
45 "$FreeBSD: head/sbin/tunefs/tunefs.c 96707 2002-05-16 04:10:46Z trhodes $";
45 "$FreeBSD: head/sbin/tunefs/tunefs.c 98542 2002-06-21 06:18:05Z mckusick $";
46#endif /* not lint */
47
48/*
49 * tunefs: change layout parameters to an existing filesystem.
50 */
51#include <sys/param.h>
52#include <sys/mount.h>
53#include <sys/disklabel.h>
54#include <sys/stat.h>
55
46#endif /* not lint */
47
48/*
49 * tunefs: change layout parameters to an existing filesystem.
50 */
51#include <sys/param.h>
52#include <sys/mount.h>
53#include <sys/disklabel.h>
54#include <sys/stat.h>
55
56#include <ufs/ffs/fs.h>
57#include <ufs/ufs/ufsmount.h>
56#include <ufs/ufs/ufsmount.h>
57#include <ufs/ufs/dinode.h>
58#include <ufs/ffs/fs.h>
58
59#include <err.h>
60#include <fcntl.h>
61#include <fstab.h>
62#include <paths.h>
63#include <stdio.h>
64#include <stdlib.h>
65#include <string.h>

--- 6 unchanged lines hidden (view full) ---

72 struct fs sb;
73 char pad[MAXBSIZE];
74} sbun;
75#define sblock sbun.sb
76
77int fi;
78long dev_bsize = 1;
79
59
60#include <err.h>
61#include <fcntl.h>
62#include <fstab.h>
63#include <paths.h>
64#include <stdio.h>
65#include <stdlib.h>
66#include <string.h>

--- 6 unchanged lines hidden (view full) ---

73 struct fs sb;
74 char pad[MAXBSIZE];
75} sbun;
76#define sblock sbun.sb
77
78int fi;
79long dev_bsize = 1;
80
80void bwrite(daddr_t, const char *, int);
81int bread(daddr_t, char *, int);
81void bwrite(ufs2_daddr_t, const char *, int);
82int bread(ufs2_daddr_t, char *, int);
82void getsb(struct fs *, const char *);
83void putsb(struct fs *, const char *, int);
84void usage(void);
85void printfs(void);
86
87int
88main(argc, argv)
89 int argc;
90 char *argv[];
91{
92 char *special;
93 const char *name;
94 struct stat st;
95 int Aflag = 0, active = 0;
83void getsb(struct fs *, const char *);
84void putsb(struct fs *, const char *, int);
85void usage(void);
86void printfs(void);
87
88int
89main(argc, argv)
90 int argc;
91 char *argv[];
92{
93 char *special;
94 const char *name;
95 struct stat st;
96 int Aflag = 0, active = 0;
96 int aflag = 0, dflag = 0, eflag = 0, fflag = 0, mflag = 0;
97 int aflag = 0, eflag = 0, fflag = 0, mflag = 0;
97 int nflag = 0, oflag = 0, pflag = 0, sflag = 0;
98 int nflag = 0, oflag = 0, pflag = 0, sflag = 0;
98 int avalue = 0, dvalue = 0, evalue = 0, fvalue = 0;
99 int avalue = 0, evalue = 0, fvalue = 0;
99 int mvalue = 0, ovalue = 0, svalue = 0;
100 char *nvalue = NULL;
101 struct fstab *fs;
102 const char *chg[2];
103 char device[MAXPATHLEN];
104 struct ufs_args args;
105 struct statfs stfs;
106 int found_arg, ch;
107
108 if (argc < 3)
109 usage();
110 found_arg = 0; /* at least one arg is required */
100 int mvalue = 0, ovalue = 0, svalue = 0;
101 char *nvalue = NULL;
102 struct fstab *fs;
103 const char *chg[2];
104 char device[MAXPATHLEN];
105 struct ufs_args args;
106 struct statfs stfs;
107 int found_arg, ch;
108
109 if (argc < 3)
110 usage();
111 found_arg = 0; /* at least one arg is required */
111 while ((ch = getopt(argc, argv, "Aa:d:e:f:m:n:o:ps:")) != -1)
112 while ((ch = getopt(argc, argv, "Aa:e:f:m:n:o:ps:")) != -1)
112 switch (ch) {
113 case 'A':
114 found_arg = 1;
115 Aflag++;
116 break;
117 case 'a':
118 found_arg = 1;
119 name = "maximum contiguous block count";
120 avalue = atoi(optarg);
121 if (avalue < 1)
122 errx(10, "%s must be >= 1 (was %s)", name, optarg);
123 aflag = 1;
124 break;
113 switch (ch) {
114 case 'A':
115 found_arg = 1;
116 Aflag++;
117 break;
118 case 'a':
119 found_arg = 1;
120 name = "maximum contiguous block count";
121 avalue = atoi(optarg);
122 if (avalue < 1)
123 errx(10, "%s must be >= 1 (was %s)", name, optarg);
124 aflag = 1;
125 break;
125 case 'd':
126 found_arg = 1;
127 name = "rotational delay between contiguous blocks";
128 dvalue = atoi(optarg);
129 dflag = 1;
130 break;
131 case 'e':
132 found_arg = 1;
133 name = "maximum blocks per file in a cylinder group";
134 evalue = atoi(optarg);
135 if (evalue < 1)
136 errx(10, "%s must be >= 1 (was %s)", name, optarg);
137 eflag = 1;
138 break;

--- 93 unchanged lines hidden (view full) ---

232 warnx("%s remains unchanged as %d", name, avalue);
233 }
234 else {
235 warnx("%s changes from %d to %d",
236 name, sblock.fs_maxcontig, avalue);
237 sblock.fs_maxcontig = avalue;
238 }
239 }
126 case 'e':
127 found_arg = 1;
128 name = "maximum blocks per file in a cylinder group";
129 evalue = atoi(optarg);
130 if (evalue < 1)
131 errx(10, "%s must be >= 1 (was %s)", name, optarg);
132 eflag = 1;
133 break;

--- 93 unchanged lines hidden (view full) ---

227 warnx("%s remains unchanged as %d", name, avalue);
228 }
229 else {
230 warnx("%s changes from %d to %d",
231 name, sblock.fs_maxcontig, avalue);
232 sblock.fs_maxcontig = avalue;
233 }
234 }
240 if (dflag) {
241 name = "rotational delay between contiguous blocks";
242 if (sblock.fs_rotdelay == dvalue) {
243 warnx("%s remains unchanged as %dms", name, dvalue);
244 }
245 else {
246 warnx("%s changes from %dms to %dms",
247 name, sblock.fs_rotdelay, dvalue);
248 sblock.fs_rotdelay = dvalue;
249 }
250 }
251 if (eflag) {
252 name = "maximum blocks per file in a cylinder group";
253 if (sblock.fs_maxbpg == evalue) {
254 warnx("%s remains unchanged as %d", name, evalue);
255 }
256 else {
257 warnx("%s changes from %d to %d",
258 name, sblock.fs_maxbpg, evalue);

--- 94 unchanged lines hidden (view full) ---

353{
354 fprintf(stderr, "%s\n%s\n%s\n",
355"usage: tunefs [-A] [-a maxcontig] [-d rotdelay] [-e maxbpg] [-f avgfilesize]",
356" [-m minfree] [-p] [-n enable | disable] [-o space | time]",
357" [-s filesperdir] special | filesystem");
358 exit(2);
359}
360
235 if (eflag) {
236 name = "maximum blocks per file in a cylinder group";
237 if (sblock.fs_maxbpg == evalue) {
238 warnx("%s remains unchanged as %d", name, evalue);
239 }
240 else {
241 warnx("%s changes from %d to %d",
242 name, sblock.fs_maxbpg, evalue);

--- 94 unchanged lines hidden (view full) ---

337{
338 fprintf(stderr, "%s\n%s\n%s\n",
339"usage: tunefs [-A] [-a maxcontig] [-d rotdelay] [-e maxbpg] [-f avgfilesize]",
340" [-m minfree] [-p] [-n enable | disable] [-o space | time]",
341" [-s filesperdir] special | filesystem");
342 exit(2);
343}
344
345/*
346 * Possible superblock locations ordered from most to least likely.
347 */
348static int sblock_try[] = SBLOCKSEARCH;
349static ufs2_daddr_t sblockloc;
350
361void
362getsb(fs, file)
363 struct fs *fs;
364 const char *file;
365{
351void
352getsb(fs, file)
353 struct fs *fs;
354 const char *file;
355{
356 int i;
366
367 fi = open(file, O_RDONLY);
368 if (fi < 0)
369 err(3, "cannot open %s", file);
357
358 fi = open(file, O_RDONLY);
359 if (fi < 0)
360 err(3, "cannot open %s", file);
370 if (bread((daddr_t)SBOFF, (char *)fs, SBSIZE))
371 err(4, "%s: bad super block", file);
372 if (fs->fs_magic != FS_MAGIC)
373 errx(5, "%s: bad magic number", file);
361 for (i = 0; sblock_try[i] != -1; i++) {
362 if (bread(sblock_try[i], (char *)fs, SBLOCKSIZE))
363 err(4, "%s: bad super block", file);
364 if ((fs->fs_magic == FS_UFS1_MAGIC ||
365 (fs->fs_magic == FS_UFS2_MAGIC &&
366 fs->fs_sblockloc == numfrags(fs, sblock_try[i]))) &&
367 fs->fs_bsize <= MAXBSIZE &&
368 fs->fs_bsize >= sizeof(struct fs))
369 break;
370 }
371 if (sblock_try[i] == -1)
372 err(5, "Cannot find filesystem superblock");
374 dev_bsize = fs->fs_fsize / fsbtodb(fs, 1);
373 dev_bsize = fs->fs_fsize / fsbtodb(fs, 1);
374 sblockloc = sblock_try[i] / dev_bsize;
375}
376
377void
378putsb(fs, file, all)
379 struct fs *fs;
380 const char *file;
381 int all;
382{

--- 4 unchanged lines hidden (view full) ---

387 * descriptor as an interlock to prevent the device from
388 * being mounted while we are switching mode.
389 */
390 i = fi;
391 fi = open(file, O_RDWR);
392 close(i);
393 if (fi < 0)
394 err(3, "cannot open %s", file);
375}
376
377void
378putsb(fs, file, all)
379 struct fs *fs;
380 const char *file;
381 int all;
382{

--- 4 unchanged lines hidden (view full) ---

387 * descriptor as an interlock to prevent the device from
388 * being mounted while we are switching mode.
389 */
390 i = fi;
391 fi = open(file, O_RDWR);
392 close(i);
393 if (fi < 0)
394 err(3, "cannot open %s", file);
395 bwrite((daddr_t)SBOFF / dev_bsize, (const char *)fs, SBSIZE);
395 bwrite(sblockloc, (const char *)fs, SBLOCKSIZE);
396 if (all)
397 for (i = 0; i < fs->fs_ncg; i++)
398 bwrite(fsbtodb(fs, cgsblock(fs, i)),
396 if (all)
397 for (i = 0; i < fs->fs_ncg; i++)
398 bwrite(fsbtodb(fs, cgsblock(fs, i)),
399 (const char *)fs, SBSIZE);
399 (const char *)fs, SBLOCKSIZE);
400 close(fi);
401}
402
403void
404printfs()
405{
406 warnx("soft updates: (-n) %s",
407 (sblock.fs_flags & FS_DOSOFTDEP)? "enabled" : "disabled");
408 warnx("maximum contiguous block count: (-a) %d",
409 sblock.fs_maxcontig);
400 close(fi);
401}
402
403void
404printfs()
405{
406 warnx("soft updates: (-n) %s",
407 (sblock.fs_flags & FS_DOSOFTDEP)? "enabled" : "disabled");
408 warnx("maximum contiguous block count: (-a) %d",
409 sblock.fs_maxcontig);
410 warnx("rotational delay between contiguous blocks: (-d) %d ms",
411 sblock.fs_rotdelay);
412 warnx("maximum blocks per file in a cylinder group: (-e) %d",
413 sblock.fs_maxbpg);
414 warnx("average file size: (-f) %d",
415 sblock.fs_avgfilesize);
416 warnx("average number of files in a directory: (-s) %d",
417 sblock.fs_avgfpdir);
418 warnx("minimum percentage of free space: (-m) %d%%",
419 sblock.fs_minfree);

--- 4 unchanged lines hidden (view full) ---

424 warnx(OPTWARN, "time", ">=", MINFREE);
425 if (sblock.fs_minfree < MINFREE &&
426 sblock.fs_optim == FS_OPTTIME)
427 warnx(OPTWARN, "space", "<", MINFREE);
428}
429
430void
431bwrite(blk, buf, size)
410 warnx("maximum blocks per file in a cylinder group: (-e) %d",
411 sblock.fs_maxbpg);
412 warnx("average file size: (-f) %d",
413 sblock.fs_avgfilesize);
414 warnx("average number of files in a directory: (-s) %d",
415 sblock.fs_avgfpdir);
416 warnx("minimum percentage of free space: (-m) %d%%",
417 sblock.fs_minfree);

--- 4 unchanged lines hidden (view full) ---

422 warnx(OPTWARN, "time", ">=", MINFREE);
423 if (sblock.fs_minfree < MINFREE &&
424 sblock.fs_optim == FS_OPTTIME)
425 warnx(OPTWARN, "space", "<", MINFREE);
426}
427
428void
429bwrite(blk, buf, size)
432 daddr_t blk;
430 ufs2_daddr_t blk;
433 const char *buf;
434 int size;
435{
436
437 if (lseek(fi, (off_t)blk * dev_bsize, SEEK_SET) < 0)
438 err(6, "FS SEEK");
439 if (write(fi, buf, size) != size)
440 err(7, "FS WRITE");
441}
442
443int
444bread(bno, buf, cnt)
431 const char *buf;
432 int size;
433{
434
435 if (lseek(fi, (off_t)blk * dev_bsize, SEEK_SET) < 0)
436 err(6, "FS SEEK");
437 if (write(fi, buf, size) != size)
438 err(7, "FS WRITE");
439}
440
441int
442bread(bno, buf, cnt)
445 daddr_t bno;
443 ufs2_daddr_t bno;
446 char *buf;
447 int cnt;
448{
449 int i;
450
451 if (lseek(fi, (off_t)bno * dev_bsize, SEEK_SET) < 0)
452 return(1);
453 if ((i = read(fi, buf, cnt)) != cnt) {
454 for(i=0; i<sblock.fs_bsize; i++)
455 buf[i] = 0;
456 return (1);
457 }
458 return (0);
459}
444 char *buf;
445 int cnt;
446{
447 int i;
448
449 if (lseek(fi, (off_t)bno * dev_bsize, SEEK_SET) < 0)
450 return(1);
451 if ((i = read(fi, buf, cnt)) != cnt) {
452 for(i=0; i<sblock.fs_bsize; i++)
453 buf[i] = 0;
454 return (1);
455 }
456 return (0);
457}