BSD 4_1c_2 release

[unix-history] / usr / src / etc / tunefs.c

#ifndef lint
static  char *sccsid = "@(#)tunefs.c    4.2 (Berkeley) 2/26/83";
#endif lint

/*
* tunefs: change layout parameters to an existing file system.
*/

#include <stdio.h>
#include <sys/param.h>
#include <sys/stat.h>
#include <sys/fs.h>
#include <sys/inode.h>

union {
       struct  fs sb;
       char pad[MAXBSIZE];
} sbun;
#define sblock sbun.sb

int fi;

main(argc, argv)
       int argc;
       char *argv[];
{
       char *cp, *special, *name;
       struct stat st;
       int i;
       int Aflag = 0;
       char device[MAXPATHLEN];
       extern char *sprintf();

       argc--, argv++; 
       if (argc < 2)
               goto usage;
       special = argv[argc - 1];
again:
       if (stat(special, &st) < 0) {
               if (*special != '/') {
                       if (*special == 'r')
                               special++;
                       special = sprintf(device, "/dev/%s", special);
                       goto again;
               }
               fprintf(stderr, "tunefs: "); perror(special);
               exit(1);
       }
       if ((st.st_mode & S_IFMT) != S_IFBLK &&
           (st.st_mode & S_IFMT) != S_IFCHR)
               fatal("%s: not a block or character device", special);
       getsb(&sblock, special);
       for (; argc > 0 && argv[0][0] == '-'; argc--, argv++) {
               for (cp = &argv[0][1]; *cp; cp++)
                       switch (*cp) {

                       case 'A':
                               Aflag++;
                               continue;

                       case 'a':
                               name = "maximum contiguous block count";
                               if (argc < 1)
                                       fatal("-a: missing %s", name);
                               argc--, argv++;
                               i = atoi(*argv);
                               if (i < 1)
                                       fatal("%s: %s must be >= 1",
                                               *argv, name);
                               fprintf(stdout, "%s changes from %d to %d\n",
                                       name, sblock.fs_maxcontig, i);
                               sblock.fs_maxcontig = i;
                               continue;

                       case 'd':
                               name =
                                  "rotational delay between contiguous blocks";
                               if (argc < 1)
                                       fatal("-d: missing %s", name);
                               argc--, argv++;
                               i = atoi(*argv);
                               if (i < 0)
                                       fatal("%s: bad %s", *argv, name);
                               fprintf(stdout,
                                       "%s changes from %dms to %dms\n",
                                       name, sblock.fs_rotdelay, i);
                               sblock.fs_rotdelay = i;
                               continue;

                       case 'e':
                               name =
                                 "maximum blocks per file in a cylinder group";
                               if (argc < 1)
                                       fatal("-e: missing %s", name);
                               argc--, argv++;
                               i = atoi(*argv);
                               if (i < 1)
                                       fatal("%s: %s must be >= 1",
                                               *argv, name);
                               fprintf(stdout, "%s changes from %d to %d\n",
                                       name, sblock.fs_maxbpg, i);
                               sblock.fs_maxbpg = i;
                               continue;

                       case 'm':
                               name = "minimum percentage of free space";
                               if (argc < 1)
                                       fatal("-m: missing %s", name);
                               argc--, argv++;
                               i = atoi(*argv);
                               if (i < 0 || i > 99)
                                       fatal("%s: bad %s", *argv, name);
                               fprintf(stdout,
                                       "%s changes from %d%% to %d%%\n",
                                       name, sblock.fs_minfree, i);
                               sblock.fs_minfree = i;
                               continue;

                       default:
                               fatal("-%c: unknown flag", *cp);
                       }
       }
       if (argc != 1)
               goto usage;
       bwrite(SBLOCK, (char *)&sblock, SBSIZE);
       if (Aflag)
               for (i = 0; i < sblock.fs_ncg; i++)
                       bwrite(fsbtodb(&sblock, cgsblock(&sblock, i)),
                           (char *)&sblock, SBSIZE);
       close(fi);
       exit(0);
usage:
       fprintf(stderr, "Usage: tunefs tuneup-options special-device\n");
       fprintf(stderr, "where tuneup-options are:\n");
       fprintf(stderr, "\t-a maximum contigouous blocks\n");
       fprintf(stderr, "\t-d rotational delay between contiguous blocks\n");
       fprintf(stderr, "\t-e maximum blocks per file in a cylinder group\n");
       fprintf(stderr, "\t-m minimum percentage of free space\n");
       exit(2);
}

getsb(fs, file)
       register struct fs *fs;
       char *file;
{

       fi = open(file, 2);
       if (fi < 0) {
               fprintf(stderr, "cannot open");
               perror(file);
               exit(3);
       }
       if (bread(SBLOCK, (char *)fs, SBSIZE)) {
               fprintf(stderr, "bad super block");
               perror(file);
               exit(4);
       }
       if (fs->fs_magic != FS_MAGIC) {
               fprintf(stderr, "%s: bad magic number\n", file);
               exit(5);
       }
}

bwrite(blk, buf, size)
       char *buf;
       daddr_t blk;
       register size;
{
       if (lseek(fi, blk * DEV_BSIZE, 0) < 0) {
               perror("FS SEEK");
               exit(6);
       }
       if (write(fi, buf, size) != size) {
               perror("FS WRITE");
               exit(7);
       }
}

bread(bno, buf, cnt)
       daddr_t bno;
       char *buf;
{
       register i;

       if (lseek(fi, bno * DEV_BSIZE, 0) < 0)
               return(1);
       if ((i = read(fi, buf, cnt)) != cnt) {
               for(i=0; i<sblock.fs_bsize; i++)
                       buf[i] = 0;
               return (1);
       }
       return (0);
}

/* VARARGS1 */
fatal(fmt, arg1, arg2)
       char *fmt, *arg1, *arg2;
{

       fprintf(stderr, "tunefs: ");
       fprintf(stderr, fmt, arg1, arg2);
       putc('\n', stderr);
       exit(10);
}