-static char *sccsid = "@(#)mkfs.c 1.1 (Berkeley) %G%";
+static char *sccsid = "@(#)mkfs.c 2.6 (Berkeley) %G%";
/*
* make file system for cylinder-group style file systems
*
- * usage: mkfs fs proto
- * or: mkfs size [ nsect ntrak cpg ]
+ * usage: mkfs special size [ nsect ntrak bsize fsize cpg ]
*/
-#define NDIRECT (BSIZE/sizeof(struct direct))
-#define MAXFN 500
+/*
+ * The following constants set the defaults used for the number
+ * of sectors (fs_nsect), and number of tracks (fs_ntrak).
+ */
+#define DFLNSECT 32
+#define DFLNTRAK 16
+
+/*
+ * The following two constants set the default block and fragment sizes.
+ * Both constants must be a power of 2 and meet the following constraints:
+ * MINBSIZE <= DESBLKSIZE <= MAXBSIZE
+ * DEV_BSIZE <= DESFRAGSIZE <= DESBLKSIZE
+ * DESBLKSIZE / DESFRAGSIZE <= 8
+ */
+#define DESBLKSIZE 8192
+#define DESFRAGSIZE 1024
+
+/*
+ * Cylinder groups may have up to MAXCPG cylinders. The actual
+ * number used depends upon how much information can be stored
+ * on a single cylinder. The default is to used 16 cylinders
+ * per group.
+ */
+#define DESCPG 16 /* desired fs_cpg */
+
+/*
+ * MINFREE gives the minimum acceptable percentage of file system
+ * blocks which may be free. If the freelist drops below this level
+ * only the superuser may continue to allocate blocks. This may
+ * be set to 0 if no reserve of free blocks is deemed necessary,
+ * however throughput drops by fifty percent if the file system
+ * is run at between 90% and 100% full; thus the default value of
+ * fs_minfree is 10%.
+ */
+#define MINFREE 10
+
+/*
+ * ROTDELAY gives the minimum number of milliseconds to initiate
+ * another disk transfer on the same cylinder. It is used in
+ * determining the rotationally optimal layout for disk blocks
+ * within a file; the default of fs_rotdelay is 2ms.
+ */
+#define ROTDELAY 2
+
+/*
+ * MAXCONTIG sets the default for the maximum number of blocks
+ * that may be allocated sequentially. Since UNIX drivers are
+ * not capable of scheduling multi-block transfers, this defaults
+ * to 1 (ie no contiguous blocks are allocated).
+ */
+#define MAXCONTIG 1
+
+/*
+ * MAXBLKPG determines the maximum number of data blocks which are
+ * placed in a single cylinder group. This is currently a function
+ * of the block and fragment size of the file system.
+ */
+#define MAXBLKPG(fs) ((fs)->fs_fsize / sizeof(daddr_t))
-#define setbit(a,i) ((a)[(i)/NBBY] |= 1<<((i)%NBBY))
-#define clrbit(a,i) ((a)[(i)/NBBY] &= ~(1<<((i)%NBBY)))
-#define isset(a,i) ((a)[(i)/NBBY] & (1<<((i)%NBBY)))
+/*
+ * Each file system has a number of inodes statically allocated.
+ * We allocate one inode slot per NBPI bytes, expecting this
+ * to be far more than we will ever need.
+ */
+#define NBPI 2048
#ifndef STANDALONE
#include <stdio.h>
#include <a.out.h>
#endif
+#ifndef SIMFS
+#include <sys/param.h>
+#include <sys/inode.h>
+#include <sys/fs.h>
+#else
#include "../h/param.h"
-#include "../h/ino.h"
#include "../h/inode.h"
#include "../h/fs.h"
-#include "../h/dir.h"
-
-time_t utime;
-
-#ifndef STANDALONE
-FILE *fin;
-#else
-int fin;
#endif
+#include <dir.h>
-int fsi;
-int fso;
-char *charp;
-char buf[BSIZE];
-#ifndef STANDALONE
-struct exec head;
-#endif
-char string[50];
+#define UMASK 0755
+#define MAXINOPB (MAXBSIZE / sizeof(struct dinode))
+#define POWEROF2(num) (((num) & ((num) - 1)) == 0)
union {
struct fs fs;
- char pad[BSIZE];
+ char pad[MAXBSIZE];
} fsun;
#define sblock fsun.fs
struct csum *fscs;
union {
struct cg cg;
- char pad[BSIZE];
+ char pad[MAXBSIZE];
} cgun;
#define acg cgun.cg
-#define howmany(x, y) (((x)+((y)-1))/(y))
-#define roundup(x, y) ((((x)+((y)-1))/(y))*(y))
+struct dinode zino[MAXIPG];
char *fsys;
-char *proto;
-int error;
-ino_t ino = ROOTINO - 1;
-long getnum();
+time_t utime;
+int fsi;
+int fso;
daddr_t alloc();
-struct dinode zino[MAXIPG];
-
main(argc, argv)
-char *argv[];
+ int argc;
+ char *argv[];
{
- int f, c;
- long i,n;
+ long cylno, rpos, blk, i, j, inos, fssize, warn = 0;
- argc--, argv++;
#ifndef STANDALONE
+ argc--, argv++;
time(&utime);
- if(argc < 2) {
- printf("usage: mkfs sblock proto/size [ nsect ntrak cpg ]\n");
+ if (argc < 2) {
+ printf("usage: mkfs special size [ nsect ntrak bsize fsize cpg ]\n");
exit(1);
}
fsys = argv[0];
- proto = argv[1];
+ fssize = atoi(argv[1]);
+ fso = creat(fsys, 0666);
+ if(fso < 0) {
+ printf("%s: cannot create\n", fsys);
+ exit(1);
+ }
+ fsi = open(fsys, 0);
+ if(fsi < 0) {
+ printf("%s: cannot open\n", fsys);
+ exit(1);
+ }
#else
{
static char protos[60];
+ char fsbuf[100];
printf("file sys size: ");
gets(protos);
- proto = protos;
- }
-#endif
-#ifdef STANDALONE
- {
- char fsbuf[100];
-
+ fssize = atoi(protos);
do {
printf("file system: ");
gets(fsbuf);
fsi = open(fsbuf, 0);
} while (fso < 0 || fsi < 0);
}
- fin = NULL;
argc = 0;
-#else
- fso = creat(fsys, 0666);
- if(fso < 0) {
- printf("%s: cannot create\n", fsys);
+#endif
+ if (fssize <= 0)
+ printf("preposterous size %d\n", fssize), exit(1);
+ /*
+ * collect and verify the sector and track info
+ */
+ if (argc > 2)
+ sblock.fs_nsect = atoi(argv[2]);
+ else
+ sblock.fs_nsect = DFLNSECT;
+ if (argc > 3)
+ sblock.fs_ntrak = atoi(argv[3]);
+ else
+ sblock.fs_ntrak = DFLNTRAK;
+ if (sblock.fs_ntrak <= 0)
+ printf("preposterous ntrak %d\n", sblock.fs_ntrak), exit(1);
+ if (sblock.fs_nsect <= 0)
+ printf("preposterous nsect %d\n", sblock.fs_nsect), exit(1);
+ sblock.fs_spc = sblock.fs_ntrak * sblock.fs_nsect;
+ /*
+ * collect and verify the block and fragment sizes
+ */
+ if (argc > 4)
+ sblock.fs_bsize = atoi(argv[4]);
+ else
+ sblock.fs_bsize = DESBLKSIZE;
+ if (argc > 5)
+ sblock.fs_fsize = atoi(argv[5]);
+ else
+ sblock.fs_fsize = DESFRAGSIZE;
+ if (!POWEROF2(sblock.fs_bsize)) {
+ printf("block size must be a power of 2, not %d\n",
+ sblock.fs_bsize);
exit(1);
}
- fsi = open(fsys, 0);
- if(fsi < 0) {
- printf("%s: cannot open\n", fsys);
+ if (!POWEROF2(sblock.fs_fsize)) {
+ printf("fragment size must be a power of 2, not %d\n",
+ sblock.fs_fsize);
exit(1);
}
- fin = fopen(proto, "r");
-#endif
-#ifndef STANDALONE
- if (fin != NULL) {
- getstr();
- f = open(string, 0);
- if (f < 0) {
- printf("%s: cannot open init\n", string);
- goto noinit;
- }
- read(f, (char *)&head, sizeof head);
- c = head.a_text + head.a_data;
- if (c > BSIZE)
- printf("%s: too big\n", string);
- else {
- read(f, buf, c);
- wtfs(BBLOCK, BSIZE, buf);
- }
- close(f);
-noinit:
- n = sblock.fs_size = getnum();
- sblock.fs_ntrak = getnum();
- sblock.fs_nsect = getnum();
- sblock.fs_cpg = getnum();
- } else
-#endif
- {
- charp = "d--777 0 0 $ ";
- n = 0;
- for (f=0; c=proto[f]; f++) {
- if (c<'0' || c>'9') {
- printf("%s: cannot open\n", proto);
- exit(1);
- }
- n = n*10 + (c-'0');
+ if (sblock.fs_fsize < DEV_BSIZE) {
+ printf("fragment size %d is too small, minimum is %d\n",
+ sblock.fs_fsize, DEV_BSIZE);
+ exit(1);
+ }
+ if (sblock.fs_bsize < MINBSIZE) {
+ printf("block size %d is too small, minimum is %d\n",
+ sblock.fs_bsize, MINBSIZE);
+ exit(1);
+ }
+ if (sblock.fs_bsize < sblock.fs_fsize) {
+ printf("block size (%d) cannot be smaller than fragment size (%d)\n",
+ sblock.fs_bsize, sblock.fs_fsize);
+ exit(1);
+ }
+ sblock.fs_bmask = ~(sblock.fs_bsize - 1);
+ sblock.fs_fmask = ~(sblock.fs_fsize - 1);
+ for (sblock.fs_bshift = 0, i = sblock.fs_bsize; i > 1; i >>= 1)
+ sblock.fs_bshift++;
+ for (sblock.fs_fshift = 0, i = sblock.fs_fsize; i > 1; i >>= 1)
+ sblock.fs_fshift++;
+ sblock.fs_frag = numfrags(&sblock, sblock.fs_bsize);
+ if (sblock.fs_frag > MAXFRAG) {
+ printf("fragment size %d is too small, minimum with block size %d is %d\n",
+ sblock.fs_fsize, sblock.fs_bsize,
+ sblock.fs_bsize / MAXFRAG);
+ exit(1);
+ }
+ sblock.fs_sblkno =
+ roundup(howmany(BBSIZE + SBSIZE, sblock.fs_fsize), sblock.fs_frag);
+ sblock.fs_cblkno = (daddr_t)(sblock.fs_sblkno +
+ roundup(howmany(SBSIZE, sblock.fs_fsize), sblock.fs_frag));
+ sblock.fs_iblkno = sblock.fs_cblkno + sblock.fs_frag;
+ sblock.fs_cgoffset = roundup(
+ howmany(sblock.fs_nsect, sblock.fs_fsize / DEV_BSIZE),
+ sblock.fs_frag);
+ for (sblock.fs_cgmask = 0xffffffff, i = sblock.fs_ntrak; i > 1; i >>= 1)
+ sblock.fs_cgmask <<= 1;
+ if (!POWEROF2(sblock.fs_ntrak))
+ sblock.fs_cgmask <<= 1;
+ for (sblock.fs_cpc = NSPB(&sblock), i = sblock.fs_spc;
+ sblock.fs_cpc > 1 && (i & 1) == 0;
+ sblock.fs_cpc >>= 1, i >>= 1)
+ /* void */;
+ if (sblock.fs_cpc > MAXCPG) {
+ printf("maximum block size with nsect %d and ntrak %d is %d\n",
+ sblock.fs_nsect, sblock.fs_ntrak,
+ sblock.fs_bsize / (sblock.fs_cpc / MAXCPG));
+ exit(1);
+ }
+ /*
+ * collect and verify the number of cylinders per group
+ */
+ if (argc > 6) {
+ sblock.fs_cpg = atoi(argv[6]);
+ sblock.fs_fpg = (sblock.fs_cpg * sblock.fs_spc) / NSPF(&sblock);
+ } else {
+ sblock.fs_cpg = MAX(sblock.fs_cpc, DESCPG);
+ sblock.fs_fpg = (sblock.fs_cpg * sblock.fs_spc) / NSPF(&sblock);
+ while (sblock.fs_fpg / sblock.fs_frag > MAXBPG(&sblock) &&
+ sblock.fs_cpg > sblock.fs_cpc) {
+ sblock.fs_cpg -= sblock.fs_cpc;
+ sblock.fs_fpg =
+ (sblock.fs_cpg * sblock.fs_spc) / NSPF(&sblock);
}
- sblock.fs_size = n;
- if (argc > 2)
- sblock.fs_nsect = atoi(argv[2]);
- else
- sblock.fs_nsect = 32;
- if (argc > 3)
- sblock.fs_ntrak = atoi(argv[3]);
- else
- sblock.fs_ntrak = 19;
+ }
+ if (sblock.fs_cpg < 1) {
+ printf("cylinder groups must have at least 1 cylinder\n");
+ exit(1);
+ }
+ if (sblock.fs_cpg > MAXCPG) {
+ printf("cylinder groups are limited to %d cylinders\n", MAXCPG);
+ exit(1);
+ }
+ if (sblock.fs_cpg % sblock.fs_cpc != 0) {
+ printf("cylinder groups must have a multiple of %d cylinders\n",
+ sblock.fs_cpc);
+ exit(1);
}
/*
* Now have size for file system and nsect and ntrak.
- * (And, if coming from prototype, cpg).
- * Determine number of cylinders occupied by file system.
+ * Determine number of cylinders and blocks in the file system.
*/
- if (sblock.fs_ntrak <= 0)
- printf("preposterous ntrak %d\n", sblock.fs_ntrak), exit(1);
- if (sblock.fs_nsect <= 0)
- printf("preposterous nsect %d\n", sblock.fs_nsect), exit(1);
- if (sblock.fs_size <= 0)
- printf("preposterous size %d\n", sblock.fs_size), exit(1);
- if (sblock.fs_ntrak * sblock.fs_nsect > MAXBPG * NSPB) {
- printf("cylinder too large (%d sectors)\n",
- sblock.fs_ntrak * sblock.fs_nsect);
- printf("maximum cylinder size: %d sectors\n",
- MAXBPG * NSPB);
+ sblock.fs_size = fssize = dbtofsb(&sblock, fssize);
+ sblock.fs_ncyl = fssize * NSPF(&sblock) / sblock.fs_spc;
+ if (fssize * NSPF(&sblock) > sblock.fs_ncyl * sblock.fs_spc) {
+ sblock.fs_ncyl++;
+ warn = 1;
+ }
+ if (sblock.fs_ncyl < 1) {
+ printf("file systems must have at least one cylinder\n");
exit(1);
}
- sblock.fs_ncyl = n * NSPF / (sblock.fs_nsect * sblock.fs_ntrak);
- if (n * NSPF > sblock.fs_ncyl * sblock.fs_nsect * sblock.fs_ntrak) {
- printf("%d sector(s) in last cylinder unused\n",
- n * NSPF - sblock.fs_ncyl * sblock.fs_nsect * sblock.fs_ntrak);
- sblock.fs_ncyl++;
+ /*
+ * determine feasability/values of rotational layout tables
+ */
+ if (sblock.fs_ntrak == 1) {
+ sblock.fs_cpc = 0;
+ goto next;
+ }
+ if (sblock.fs_spc * sblock.fs_cpc > MAXBPC * NSPB(&sblock) ||
+ sblock.fs_nsect > (1 << NBBY) * NSPB(&sblock)) {
+ printf("%s %s %d %s %d.%s",
+ "Warning: insufficient space in super block for\n",
+ "rotational layout tables with nsect", sblock.fs_nsect,
+ "and ntrak", sblock.fs_ntrak,
+ "\nFile system performance may be impared.\n");
+ sblock.fs_cpc = 0;
+ goto next;
}
- sblock.fs_magic = FS_MAGIC;
+ /*
+ * calculate the available blocks for each rotational position
+ */
+ for (cylno = 0; cylno < MAXCPG; cylno++)
+ for (rpos = 0; rpos < NRPOS; rpos++)
+ sblock.fs_postbl[cylno][rpos] = -1;
+ blk = sblock.fs_spc * sblock.fs_cpc / NSPF(&sblock);
+ for (i = 0; i < blk; i += sblock.fs_frag)
+ /* void */;
+ for (i -= sblock.fs_frag; i >= 0; i -= sblock.fs_frag) {
+ cylno = cbtocylno(&sblock, i);
+ rpos = cbtorpos(&sblock, i);
+ blk = i / sblock.fs_frag;
+ if (sblock.fs_postbl[cylno][rpos] == -1)
+ sblock.fs_rotbl[blk] = 0;
+ else
+ sblock.fs_rotbl[blk] =
+ sblock.fs_postbl[cylno][rpos] - blk;
+ sblock.fs_postbl[cylno][rpos] = blk;
+ }
+next:
/*
* Validate specified/determined cpg.
*/
-#define CGTOOBIG(fs) ((fs).fs_nsect*(fs).fs_ntrak*(fs).fs_cpg/NSPB > MAXBPG)
- if (argc > 4 || fin) {
- if (fin == NULL)
- sblock.fs_cpg = atoi(argv[4]);
- if (CGTOOBIG(sblock)) {
- printf("cylinder group too large (%d blocks); ",
- sblock.fs_cpg * sblock.fs_nsect * sblock.fs_ntrak / NSPB);
- printf("max: %d blocks\n", MAXBPG);
- exit(1);
+ if (sblock.fs_spc > MAXBPG(&sblock) * NSPB(&sblock)) {
+ printf("too many sectors per cylinder (%d sectors)\n",
+ sblock.fs_spc);
+ while(sblock.fs_spc > MAXBPG(&sblock) * NSPB(&sblock)) {
+ sblock.fs_bsize <<= 1;
+ if (sblock.fs_frag < MAXFRAG)
+ sblock.fs_frag <<= 1;
+ else
+ sblock.fs_fsize <<= 1;
}
- if (sblock.fs_cpg > MAXCPG) {
- printf("cylinder groups are limited to %d cylinders\n",
- MAXCPG);
- exit(1);
- }
- } else {
- sblock.fs_cpg = DESCPG;
- while (CGTOOBIG(sblock))
- --sblock.fs_cpg;
+ printf("nsect %d, and ntrak %d, requires block size of %d,\n",
+ sblock.fs_nsect, sblock.fs_ntrak, sblock.fs_bsize);
+ printf("\tand fragment size of %d\n", sblock.fs_fsize);
+ exit(1);
+ }
+ if (sblock.fs_fpg > MAXBPG(&sblock) * sblock.fs_frag) {
+ printf("cylinder group too large (%d cylinders); ",
+ sblock.fs_cpg);
+ printf("max: %d cylinders per group\n",
+ MAXBPG(&sblock) * sblock.fs_frag /
+ (sblock.fs_fpg / sblock.fs_cpg));
+ exit(1);
}
+ sblock.fs_cgsize = fragroundup(&sblock,
+ sizeof(struct cg) + howmany(sblock.fs_fpg, NBBY));
/*
* Compute/validate number of cylinder groups.
*/
sblock.fs_ncg = sblock.fs_ncyl / sblock.fs_cpg;
if (sblock.fs_ncyl % sblock.fs_cpg)
sblock.fs_ncg++;
- if ((sblock.fs_nsect*sblock.fs_ntrak*sblock.fs_cpg) % NSPF) {
+ if ((sblock.fs_spc * sblock.fs_cpg) % NSPF(&sblock)) {
printf("mkfs: nsect %d, ntrak %d, cpg %d is not tolerable\n",
sblock.fs_nsect, sblock.fs_ntrak, sblock.fs_cpg);
printf("as this would would have cyl groups whose size\n");
- printf("is not a multiple of %d; choke!\n", FSIZE);
+ printf("is not a multiple of %d; choke!\n", sblock.fs_fsize);
exit(1);
}
- fscs = (struct csum *)
- calloc(1, roundup(sblock.fs_ncg * sizeof (struct csum), BSIZE));
/*
* Compute number of inode blocks per cylinder group.
* Start with one inode per NBPI bytes; adjust as necessary.
*/
- n = ((n * BSIZE) / NBPI) / INOPB;
- if (n <= 0)
- n = 1;
- if (n > 65500/INOPB)
- n = 65500/INOPB;
- sblock.fs_ipg = ((n / sblock.fs_ncg) + 1) * INOPB;
- if (sblock.fs_ipg < INOPB)
- sblock.fs_ipg = INOPB;
+ i = sblock.fs_iblkno + MAXIPG / INOPF(&sblock);
+ inos = (fssize - sblock.fs_ncg * i) * sblock.fs_fsize /
+ MAX(NBPI, sblock.fs_fsize) / INOPB(&sblock);
+ if (inos <= 0)
+ inos = 1;
+ sblock.fs_ipg = ((inos / sblock.fs_ncg) + 1) * INOPB(&sblock);
if (sblock.fs_ipg > MAXIPG)
sblock.fs_ipg = MAXIPG;
- while (sblock.fs_ipg * sblock.fs_ncyl > 65500)
- sblock.fs_ipg -= INOPB;
- sblock.fs_spc = sblock.fs_ntrak * sblock.fs_nsect;
- sblock.fs_fpg = (sblock.fs_cpg * sblock.fs_spc) / (FSIZE / 512);
- if (cgdmin(0,&sblock) >= sblock.fs_fpg)
+ sblock.fs_dblkno = sblock.fs_iblkno + sblock.fs_ipg / INOPF(&sblock);
+ i = MIN(~sblock.fs_cgmask, sblock.fs_ncg - 1);
+ if (cgdmin(&sblock, i) - cgbase(&sblock, i) >= sblock.fs_fpg) {
printf("inode blocks/cyl group (%d) >= data blocks (%d)\n",
- cgdmin(0,&sblock)/FRAG, sblock.fs_fpg/FRAG), exit(1);
- sblock.fs_nifree = sblock.fs_ipg * sblock.fs_ncg;
- sblock.fs_cgsize = cgsize(&sblock);
- sblock.fs_cssize = cssize(&sblock);
- sblock.fs_sblkno = SBLOCK;
+ cgdmin(&sblock, i) - cgbase(&sblock, i) / sblock.fs_frag,
+ sblock.fs_fpg / sblock.fs_frag);
+ printf("number of cylinders per cylinder group must be increased\n");
+ exit(1);
+ }
+ j = sblock.fs_ncg - 1;
+ if ((i = fssize - j * sblock.fs_fpg) < sblock.fs_fpg &&
+ cgdmin(&sblock, j) - cgbase(&sblock, j) > i) {
+ printf("Warning: inode blocks/cyl group (%d) >= data blocks (%d) in last\n",
+ (cgdmin(&sblock, j) - cgbase(&sblock, j)) / sblock.fs_frag,
+ i / sblock.fs_frag);
+ printf(" cylinder group. This implies %d sector(s) cannot be allocated.\n",
+ i * NSPF(&sblock));
+ sblock.fs_ncg--;
+ sblock.fs_ncyl -= sblock.fs_ncyl % sblock.fs_cpg;
+ sblock.fs_size = fssize = sblock.fs_ncyl * sblock.fs_spc /
+ NSPF(&sblock);
+ warn = 0;
+ }
+ if (warn) {
+ printf("Warning: %d sector(s) in last cylinder unallocated\n",
+ sblock.fs_spc -
+ (fssize * NSPF(&sblock) - (sblock.fs_ncyl - 1)
+ * sblock.fs_spc));
+ }
+ /*
+ * fill in remaining fields of the super block
+ */
+ sblock.fs_csaddr = cgdmin(&sblock, 0);
+ sblock.fs_cssize =
+ fragroundup(&sblock, sblock.fs_ncg * sizeof(struct csum));
+ fscs = (struct csum *)calloc(1, sblock.fs_cssize);
+ sblock.fs_magic = FS_MAGIC;
+ sblock.fs_rotdelay = ROTDELAY;
+ sblock.fs_minfree = MINFREE;
+ sblock.fs_maxcontig = MAXCONTIG;
+ sblock.fs_maxbpg = MAXBLKPG(&sblock);
+ sblock.fs_rps = 60; /* assume disk speed == 60 HZ */
+ sblock.fs_cgrotor = 0;
+ sblock.fs_cstotal.cs_ndir = 0;
+ sblock.fs_cstotal.cs_nbfree = 0;
+ sblock.fs_cstotal.cs_nifree = 0;
+ sblock.fs_cstotal.cs_nffree = 0;
sblock.fs_fmod = 0;
sblock.fs_ronly = 0;
-
/*
- * Dump out information about file system.
+ * Dump out summary information about file system.
*/
printf("%s:\t%d sectors in %d cylinders of %d tracks, %d sectors\n",
- fsys, sblock.fs_size*NSPF, sblock.fs_ncyl, sblock.fs_ntrak, sblock.fs_nsect);
+ fsys, sblock.fs_size * NSPF(&sblock), sblock.fs_ncyl,
+ sblock.fs_ntrak, sblock.fs_nsect);
printf("\t%.1fMb in %d cyl groups (%d c/g, %.2fMb/g, %d i/g)\n",
- (float)sblock.fs_size*FSIZE*1e-6, sblock.fs_ncg, sblock.fs_cpg,
- (float)sblock.fs_fpg*FSIZE*1e-6, sblock.fs_ipg);
-/*
- printf("%7d size (%d blocks)\n", sblock.fs_size, sblock.fs_size/FRAG);
- printf("%7d cylinder groups\n", sblock.fs_ncg);
- printf("%7d cylinder group block size\n", sblock.fs_cgsize);
- printf("%7d tracks\n", sblock.fs_ntrak);
- printf("%7d sectors\n", sblock.fs_nsect);
- printf("%7d sectors per cylinder\n", sblock.fs_spc);
- printf("%7d cylinders\n", sblock.fs_ncyl);
- printf("%7d cylinders per group\n", sblock.fs_cpg);
- printf("%7d blocks per group\n", sblock.fs_fpg/FRAG);
- printf("%7d inodes per group\n", sblock.fs_ipg);
- if (sblock.fs_ncyl % sblock.fs_cpg) {
- printf("%7d cylinders in last group\n",
- i = sblock.fs_ncyl % sblock.fs_cpg);
- printf("%7d blocks in last group\n",
- i * sblock.fs_spc / NSPB);
- }
-*/
+ (float)sblock.fs_size * sblock.fs_fsize * 1e-6, sblock.fs_ncg,
+ sblock.fs_cpg, (float)sblock.fs_fpg * sblock.fs_fsize * 1e-6,
+ sblock.fs_ipg);
/*
* Now build the cylinders group blocks and
- * then print out indices of cylinder groups forwarded
- * past bad blocks or other obstructions.
+ * then print out indices of cylinder groups.
*/
- sblock.fs_nffree = 0;
- sblock.fs_nbfree = 0;
- for (c = 0; c < sblock.fs_ncg; c++)
- initcg(c);
- printf("\tsuper-block backups (for fsck -b#) at %d+k*%d (%d .. %d)\n",
- SBLOCK, sblock.fs_fpg, SBLOCK+sblock.fs_fpg,
- SBLOCK+(sblock.fs_ncg-1)*sblock.fs_fpg);
+ printf("super-block backups (for fsck -b#) at:");
+ for (cylno = 0; cylno < sblock.fs_ncg; cylno++) {
+ initcg(cylno);
+ if (cylno % 10 == 0)
+ printf("\n");
+ printf(" %d,", fsbtodb(&sblock, cgsblock(&sblock, cylno)));
+ }
+ printf("\n%s\n%s\n",
+ "WRITE THESE NUMBERS DOWN!!!",
+ "fsck depends on them to recover this file system.");
/*
- * Now construct the initial file system, and
+ * Now construct the initial file system,
* then write out the super-block.
*/
- cfile((struct inode *)0);
+ fsinit();
sblock.fs_time = utime;
- wtfs(SBLOCK, BSIZE, (char *)&sblock);
- for (i = 0; i < cssize(&sblock); i += BSIZE)
- wtfs(csaddr(&sblock) + i/BSIZE, BSIZE, ((char *)fscs)+i);
- for (c = 0; c < sblock.fs_ncg; c++)
- wtfs(cgsblock(c, &sblock), BSIZE, (char *)&sblock);
+ wtfs(SBLOCK, SBSIZE, (char *)&sblock);
+ for (i = 0; i < sblock.fs_cssize; i += sblock.fs_bsize)
+ wtfs(fsbtodb(&sblock, sblock.fs_csaddr + numfrags(&sblock, i)),
+ sblock.fs_cssize - i < sblock.fs_bsize ?
+ sblock.fs_cssize - i : sblock.fs_bsize,
+ ((char *)fscs) + i);
+ /*
+ * Write out the duplicate super blocks
+ */
+ for (cylno = 0; cylno < sblock.fs_ncg; cylno++)
+ wtfs(fsbtodb(&sblock, cgsblock(&sblock, cylno)),
+ SBSIZE, (char *)&sblock);
#ifndef STANDALONE
- exit(error);
+ exit(0);
#endif
}
/*
* Initialize a cylinder group.
*/
-initcg(c)
- int c;
+initcg(cylno)
+ int cylno;
{
- daddr_t cbase, d, dmin, dmax;
+ daddr_t cbase, d, dlower, dupper, dmax;
long i, j, s;
register struct csum *cs;
* Allow space for super block summary information in first
* cylinder group.
*/
- cbase = cgbase(c,&sblock);
+ cbase = cgbase(&sblock, cylno);
dmax = cbase + sblock.fs_fpg;
if (dmax > sblock.fs_size)
dmax = sblock.fs_size;
- d = cbase;
- cs = fscs+c;
-tryagain:
- for (i = cgdmin(c,&sblock) - FRAG; i >= 0; i -= FRAG)
- if (badblk(d)) {
- d += i + FRAG;
- if (d + sblock.fs_ipg/INOPB >= dmax) {
- printf("bad blocks: cyl grp %d unusable\n", c);
- exit(1);
- }
- goto tryagain;
- }
- cs->cs_ndir = 0;
+ dlower = cgsblock(&sblock, cylno) - cbase;
+ dupper = cgdmin(&sblock, cylno) - cbase;
+ cs = fscs + cylno;
acg.cg_time = utime;
acg.cg_magic = CG_MAGIC;
- acg.cg_cgx = c;
- acg.cg_ncyl = sblock.fs_cpg;
+ acg.cg_cgx = cylno;
+ if (cylno == sblock.fs_ncg - 1)
+ acg.cg_ncyl = sblock.fs_ncyl % sblock.fs_cpg;
+ else
+ acg.cg_ncyl = sblock.fs_cpg;
acg.cg_niblk = sblock.fs_ipg;
acg.cg_ndblk = dmax - cbase;
- acg.cg_ndir = 0;
- acg.cg_nffree = 0;
- acg.cg_nbfree = 0;
- acg.cg_nifree = 0;
+ acg.cg_cs.cs_ndir = 0;
+ acg.cg_cs.cs_nffree = 0;
+ acg.cg_cs.cs_nbfree = 0;
+ acg.cg_cs.cs_nifree = 0;
acg.cg_rotor = 0;
- i = 0;
- d = cgimin(c,&sblock);
- while (i < sblock.fs_ipg) {
- for (j = INOPB; j > 0; j--) {
+ acg.cg_frotor = 0;
+ acg.cg_irotor = 0;
+ for (i = 0; i < sblock.fs_frag; i++) {
+ acg.cg_frsum[i] = 0;
+ }
+ for (i = 0; i < sblock.fs_ipg; ) {
+ for (j = INOPB(&sblock); j > 0; j--) {
clrbit(acg.cg_iused, i);
i++;
}
- acg.cg_nifree += INOPB;
- d++;
+ acg.cg_cs.cs_nifree += INOPB(&sblock);
}
+ if (cylno == 0)
+ for (i = 0; i < ROOTINO; i++) {
+ setbit(acg.cg_iused, i);
+ acg.cg_cs.cs_nifree--;
+ }
while (i < MAXIPG) {
clrbit(acg.cg_iused, i);
i++;
}
- lseek(fso, cgimin(c,&sblock)*FSIZE, 0);
+ lseek(fso, fsbtodb(&sblock, cgimin(&sblock, cylno)) * DEV_BSIZE, 0);
if (write(fso, (char *)zino, sblock.fs_ipg * sizeof (struct dinode)) !=
sblock.fs_ipg * sizeof (struct dinode))
- printf("write error %D\n", tell(fso) / BSIZE);
- for (i = 0; i < MAXCPG; i++)
+ printf("write error %D\n", numfrags(&sblock, tell(fso)));
+ for (i = 0; i < MAXCPG; i++) {
+ acg.cg_btot[i] = 0;
for (j = 0; j < NRPOS; j++)
acg.cg_b[i][j] = 0;
- dmin = cgdmin(c,&sblock) - cbase;
- if (c == 0) {
- dmin += howmany(cssize(&sblock), BSIZE) * FRAG;
- }
- for (d = 0; d < dmin; d += FRAG)
- clrblock(acg.cg_free, d/FRAG);
- while ((d+FRAG) <= dmax - cbase) {
- if (badblk(cbase+d))
- clrblock(acg.cg_free, d/FRAG);
- else {
- setblock(acg.cg_free, d/FRAG);
- acg.cg_nbfree++;
- s = d * NSPF;
- acg.cg_b[s/sblock.fs_spc]
- [s%sblock.fs_nsect*NRPOS/sblock.fs_nsect]++;
- }
- d += FRAG;
- }
- if (d < dmax - cbase)
- if (badblk(d))
- for (; d < dmax - cbase; d++)
- clrbit(acg.cg_free, d);
- else
- for (; d < dmax - cbase; d++) {
- setbit(acg.cg_free, d);
- acg.cg_nffree++;
- }
- for (; d < MAXBPG; d++)
- clrbit(acg.cg_free, d);
- sblock.fs_nffree += acg.cg_nffree;
- sblock.fs_nbfree += acg.cg_nbfree;
- cs->cs_nifree = acg.cg_nifree;
- cs->cs_nbfree = acg.cg_nbfree;
- wtfs(cgtod(c, &sblock), BSIZE, (char *)&acg);
-}
-
-cfile(par)
-struct inode *par;
-{
- struct inode in;
- int dbc, ibc;
- char db[BSIZE];
- daddr_t ib[NINDIR];
- int i, f, c;
-
- /*
- * get mode, uid and gid
- */
-
- getstr();
- in.i_mode = gmode(string[0], "-bcd", IFREG, IFBLK, IFCHR, IFDIR);
- in.i_mode |= gmode(string[1], "-u", 0, ISUID, 0, 0);
- in.i_mode |= gmode(string[2], "-g", 0, ISGID, 0, 0);
- for(i=3; i<6; i++) {
- c = string[i];
- if(c<'0' || c>'7') {
- printf("%c/%s: bad octal mode digit\n", c, string);
- error = 1;
- c = 0;
- }
- in.i_mode |= (c-'0')<<(15-3*i);
}
- in.i_uid = getnum();
- in.i_gid = getnum();
-
- /*
- * general initialization prior to
- * switching on format
- */
-
- ino++;
- in.i_number = ino;
- for(i=0; i<BSIZE; i++)
- db[i] = 0;
- for(i=0; i<NINDIR; i++)
- ib[i] = (daddr_t)0;
- in.i_nlink = 1;
- in.i_size = 0;
- for(i=0; i<NDADDR; i++)
- in.i_un.i_f.i_db[i] = (daddr_t)0;
- for(i=0; i<NIADDR; i++)
- in.i_un.i_f.i_ib[i] = (daddr_t)0;
- if(par == (struct inode *)0) {
- par = ∈
- in.i_nlink--;
- }
- dbc = 0;
- ibc = 0;
- switch(in.i_mode&IFMT) {
-
- case IFREG:
+ if (cylno == 0) {
/*
- * regular file
- * contents is a file name
+ * reserve space for summary info and Boot block
*/
-
- getstr();
- f = open(string, 0);
- if(f < 0) {
- printf("%s: cannot open\n", string);
- error = 1;
- break;
+ dupper += howmany(sblock.fs_cssize, sblock.fs_fsize);
+ for (d = 0; d < dlower; d += sblock.fs_frag)
+ clrblock(&sblock, acg.cg_free, d/sblock.fs_frag);
+ } else {
+ for (d = 0; d < dlower; d += sblock.fs_frag) {
+ setblock(&sblock, acg.cg_free, d/sblock.fs_frag);
+ acg.cg_cs.cs_nbfree++;
+ acg.cg_btot[cbtocylno(&sblock, d)]++;
+ acg.cg_b[cbtocylno(&sblock, d)][cbtorpos(&sblock, d)]++;
}
- while((i=read(f, db, BSIZE)) > 0) {
- in.i_size += i;
- newblk(&dbc, db, &ibc, ib, i);
+ sblock.fs_dsize += dlower;
+ }
+ sblock.fs_dsize += acg.cg_ndblk - dupper;
+ for (; d < dupper; d += sblock.fs_frag)
+ clrblock(&sblock, acg.cg_free, d/sblock.fs_frag);
+ if (d > dupper) {
+ acg.cg_frsum[d - dupper]++;
+ for (i = d - 1; i >= dupper; i--) {
+ setbit(acg.cg_free, i);
+ acg.cg_cs.cs_nffree++;
}
- close(f);
- break;
-
- case IFBLK:
- case IFCHR:
- /*
- * special file
- * content is maj/min types
- */
-
- i = getnum() & 0377;
- f = getnum() & 0377;
- in.i_un.i_d.i_rdev = makedev(i, f);
- break;
-
- case IFDIR:
- /*
- * directory
- * put in extra links
- * call recursively until
- * name of "$" found
- */
-
- par->i_nlink++;
- in.i_nlink++;
- entry(in.i_number, ".", &dbc, db, &ibc, ib);
- entry(par->i_number, "..", &dbc, db, &ibc, ib);
- in.i_size = 2*sizeof(struct direct);
- for(;;) {
- getstr();
- if(string[0]=='$' && string[1]=='\0')
- break;
- if (in.i_size >= FSIZE) {
- printf("can't handle direct of > %d entries\n",
- NDIRECT/FRAG);
- exit(1);
- }
- entry(ino+1, string, &dbc, db, &ibc, ib);
- in.i_size += sizeof(struct direct);
- cfile(&in);
+ }
+ while ((d + sblock.fs_frag) <= dmax - cbase) {
+ setblock(&sblock, acg.cg_free, d/sblock.fs_frag);
+ acg.cg_cs.cs_nbfree++;
+ acg.cg_btot[cbtocylno(&sblock, d)]++;
+ acg.cg_b[cbtocylno(&sblock, d)][cbtorpos(&sblock, d)]++;
+ d += sblock.fs_frag;
+ }
+ if (d < dmax - cbase) {
+ acg.cg_frsum[dmax - cbase - d]++;
+ for (; d < dmax - cbase; d++) {
+ setbit(acg.cg_free, d);
+ acg.cg_cs.cs_nffree++;
}
- break;
+ for (; d % sblock.fs_frag != 0; d++)
+ clrbit(acg.cg_free, d);
}
- if(dbc != 0)
- newblk(&dbc, db, &ibc, ib, roundup(dbc,FSIZE));
- iput(&in, &ibc, ib);
+ for (d /= sblock.fs_frag; d < MAXBPG(&sblock); d ++)
+ clrblock(&sblock, acg.cg_free, d);
+ sblock.fs_cstotal.cs_ndir += acg.cg_cs.cs_ndir;
+ sblock.fs_cstotal.cs_nffree += acg.cg_cs.cs_nffree;
+ sblock.fs_cstotal.cs_nbfree += acg.cg_cs.cs_nbfree;
+ sblock.fs_cstotal.cs_nifree += acg.cg_cs.cs_nifree;
+ *cs = acg.cg_cs;
+ wtfs(fsbtodb(&sblock, cgtod(&sblock, cylno)),
+ sblock.fs_bsize, (char *)&acg);
}
-gmode(c, s, m0, m1, m2, m3)
-char c, *s;
+/*
+ * initialize the file system
+ */
+struct inode node;
+#define PREDEFDIR 3
+struct direct root_dir[] = {
+ { ROOTINO, sizeof(struct direct), 1, "." },
+ { ROOTINO, sizeof(struct direct), 2, ".." },
+ { LOSTFOUNDINO, sizeof(struct direct), 10, "lost+found" },
+};
+struct direct lost_found_dir[] = {
+ { LOSTFOUNDINO, sizeof(struct direct), 1, "." },
+ { ROOTINO, sizeof(struct direct), 2, ".." },
+ { 0, DIRBLKSIZ, 0, 0 },
+};
+char buf[MAXBSIZE];
+
+fsinit()
{
int i;
- for(i=0; s[i]; i++)
- if(c == s[i])
- return((&m0)[i]);
- printf("%c/%s: bad mode\n", c, string);
- error = 1;
- return(0);
+ /*
+ * initialize the node
+ */
+ node.i_atime = utime;
+ node.i_mtime = utime;
+ node.i_ctime = utime;
+ /*
+ * create the lost+found directory
+ */
+ (void)makedir(lost_found_dir, 2);
+ for (i = DIRBLKSIZ; i < sblock.fs_bsize; i += DIRBLKSIZ)
+ bcopy(&lost_found_dir[2], &buf[i], DIRSIZ(&lost_found_dir[2]));
+ node.i_number = LOSTFOUNDINO;
+ node.i_mode = IFDIR | UMASK;
+ node.i_nlink = 2;
+ node.i_size = sblock.fs_bsize;
+ node.i_db[0] = alloc(node.i_size, node.i_mode);
+ wtfs(fsbtodb(&sblock, node.i_db[0]), node.i_size, buf);
+ iput(&node);
+ /*
+ * create the root directory
+ */
+ node.i_number = ROOTINO;
+ node.i_mode = IFDIR | UMASK;
+ node.i_nlink = PREDEFDIR;
+ node.i_size = makedir(root_dir, PREDEFDIR);
+ node.i_db[0] = alloc(sblock.fs_fsize, node.i_mode);
+ wtfs(fsbtodb(&sblock, node.i_db[0]), sblock.fs_fsize, buf);
+ iput(&node);
}
-long
-getnum()
+/*
+ * construct a set of directory entries in "buf".
+ * return size of directory.
+ */
+makedir(protodir, entries)
+ register struct direct *protodir;
+ int entries;
{
- int i, c;
- long n;
-
- getstr();
- n = 0;
- i = 0;
- for(i=0; c=string[i]; i++) {
- if(c<'0' || c>'9') {
- printf("%s: bad number\n", string);
- error = 1;
- return((long)0);
- }
- n = n*10 + (c-'0');
+ char *cp;
+ int i, spcleft;
+
+ spcleft = DIRBLKSIZ;
+ for (cp = buf, i = 0; i < entries - 1; i++) {
+ protodir[i].d_reclen = DIRSIZ(&protodir[i]);
+ bcopy(&protodir[i], cp, protodir[i].d_reclen);
+ cp += protodir[i].d_reclen;
+ spcleft -= protodir[i].d_reclen;
}
- return(n);
+ protodir[i].d_reclen = spcleft;
+ bcopy(&protodir[i], cp, DIRSIZ(&protodir[i]));
+ cp += DIRSIZ(&protodir[i]);
+ return (cp - buf);
}
-getstr()
+/*
+ * allocate a block or frag
+ */
+daddr_t
+alloc(size, mode)
+ int size;
+ int mode;
{
- int i, c;
+ int i, frag;
+ daddr_t d;
-loop:
- switch(c=getch()) {
+ rdfs(fsbtodb(&sblock, cgtod(&sblock, 0)), sblock.fs_cgsize,
+ (char *)&acg);
+ if (acg.cg_magic != CG_MAGIC) {
+ printf("cg 0: bad magic number\n");
+ return (0);
+ }
+ if (acg.cg_cs.cs_nbfree == 0) {
+ printf("first cylinder group ran out of space\n");
+ return (0);
+ }
+ for (d = 0; d < acg.cg_ndblk; d += sblock.fs_frag)
+ if (isblock(&sblock, acg.cg_free, d / sblock.fs_frag))
+ goto goth;
+ printf("internal error: can't find block in cyl 0\n");
+ return (0);
+goth:
+ clrblock(&sblock, acg.cg_free, d / sblock.fs_frag);
+ acg.cg_cs.cs_nbfree--;
+ sblock.fs_cstotal.cs_nbfree--;
+ fscs[0].cs_nbfree--;
+ if (mode & IFDIR) {
+ acg.cg_cs.cs_ndir++;
+ sblock.fs_cstotal.cs_ndir++;
+ fscs[0].cs_ndir++;
+ }
+ acg.cg_btot[cbtocylno(&sblock, d)]--;
+ acg.cg_b[cbtocylno(&sblock, d)][cbtorpos(&sblock, d)]--;
+ if (size != sblock.fs_bsize) {
+ frag = howmany(size, sblock.fs_fsize);
+ fscs[0].cs_nffree += sblock.fs_frag - frag;
+ sblock.fs_cstotal.cs_nffree += sblock.fs_frag - frag;
+ acg.cg_cs.cs_nffree += sblock.fs_frag - frag;
+ acg.cg_frsum[sblock.fs_frag - frag]++;
+ for (i = frag; i < sblock.fs_frag; i++)
+ setbit(acg.cg_free, d + i);
+ }
+ wtfs(fsbtodb(&sblock, cgtod(&sblock, 0)), sblock.fs_cgsize,
+ (char *)&acg);
+ return (d);
+}
- case ' ':
- case '\t':
- case '\n':
- goto loop;
+/*
+ * Allocate an inode on the disk
+ */
+iput(ip)
+ register struct inode *ip;
+{
+ struct dinode buf[MAXINOPB];
+ daddr_t d;
+ int c;
- case '\0':
- printf("EOF\n");
+ c = itog(&sblock, ip->i_number);
+ rdfs(fsbtodb(&sblock, cgtod(&sblock, 0)), sblock.fs_cgsize,
+ (char *)&acg);
+ if (acg.cg_magic != CG_MAGIC) {
+ printf("cg 0: bad magic number\n");
exit(1);
-
- case ':':
- while(getch() != '\n');
- goto loop;
-
}
- i = 0;
-
- do {
- string[i++] = c;
- c = getch();
- } while(c!=' '&&c!='\t'&&c!='\n'&&c!='\0');
- string[i] = '\0';
+ acg.cg_cs.cs_nifree--;
+ setbit(acg.cg_iused, ip->i_number);
+ wtfs(fsbtodb(&sblock, cgtod(&sblock, 0)), sblock.fs_cgsize,
+ (char *)&acg);
+ sblock.fs_cstotal.cs_nifree--;
+ fscs[0].cs_nifree--;
+ if(ip->i_number >= sblock.fs_ipg * sblock.fs_ncg) {
+ printf("fsinit: inode value out of range (%d).\n",
+ ip->i_number);
+ exit(1);
+ }
+ d = fsbtodb(&sblock, itod(&sblock, ip->i_number));
+ rdfs(d, sblock.fs_bsize, buf);
+ buf[itoo(&sblock, ip->i_number)].di_ic = ip->i_ic;
+ wtfs(d, sblock.fs_bsize, buf);
}
+/*
+ * read a block from the file system
+ */
rdfs(bno, size, bf)
-daddr_t bno;
-int size;
-char *bf;
+ daddr_t bno;
+ int size;
+ char *bf;
{
int n;
- lseek(fsi, bno*FSIZE, 0);
+ if (lseek(fsi, bno * DEV_BSIZE, 0) < 0) {
+ printf("seek error: %ld\n", bno);
+ perror("rdfs");
+ exit(1);
+ }
n = read(fsi, bf, size);
if(n != size) {
printf("read error: %ld\n", bno);
+ perror("rdfs");
exit(1);
}
}
+/*
+ * write a block to the file system
+ */
wtfs(bno, size, bf)
-daddr_t bno;
-int size;
-char *bf;
+ daddr_t bno;
+ int size;
+ char *bf;
{
int n;
- lseek(fso, bno*FSIZE, 0);
+ lseek(fso, bno * DEV_BSIZE, 0);
+ if (lseek(fso, bno * DEV_BSIZE, 0) < 0) {
+ printf("seek error: %ld\n", bno);
+ perror("wtfs");
+ exit(1);
+ }
n = write(fso, bf, size);
if(n != size) {
printf("write error: %D\n", bno);
+ perror("wtfs");
exit(1);
}
}
-daddr_t
-alloc(size)
-int size;
-{
- int c, i, s, frag;
- daddr_t d;
-
- c = 0;
- rdfs(cgtod(0,&sblock), sblock.fs_cgsize, (char *)&acg);
- if (acg.cg_nbfree == 0) {
- printf("first cylinder group ran out of space\n");
- return (0);
- }
- for (d = 0; d < acg.cg_ndblk; d += FRAG)
- if (isblock(acg.cg_free, d/FRAG))
- goto goth;
- printf("internal error: can't find block in cyl 0\n");
- return (0);
-goth:
- clrblock(acg.cg_free, d/FRAG);
- acg.cg_nbfree--;
- sblock.fs_nbfree--;
- fscs[0].cs_nbfree--;
- s = d * NSPF;
- acg.cg_b[s/sblock.fs_spc][s%sblock.fs_nsect*NRPOS/sblock.fs_nsect]--;
- if (size != BSIZE) {
- frag = howmany(size, FSIZE);
- acg.cg_nffree += FRAG - frag;
- sblock.fs_nffree += FRAG - frag;
- for (i = frag; i < FRAG; i++)
- setbit(acg.cg_free, d+i);
- }
- wtfs(cgtod(0,&sblock), sblock.fs_cgsize, (char *)&acg);
- return (d);
-}
-
-entry(inum, str, adbc, db, aibc, ib)
-ino_t inum;
-char *str;
-int *adbc, *aibc;
-char *db;
-daddr_t *ib;
+#ifndef STANDALONE
+/*
+ * copy a block
+ */
+bcopy(from, to, size)
+ char *from, *to;
+ int size;
{
- struct direct *dp;
- int i;
-
- dp = (struct direct *)db;
- dp += *adbc;
- (*adbc)++;
- dp->d_ino = inum;
- for(i=0; i<DIRSIZ; i++)
- dp->d_name[i] = 0;
- for(i=0; i<DIRSIZ; i++)
- if((dp->d_name[i] = str[i]) == 0)
- break;
- if(*adbc >= NDIRECT)
- newblk(adbc, db, aibc, ib, BSIZE);
+ asm(" movc3 12(ap),*4(ap),*8(ap)");
}
+#endif
-newblk(adbc, db, aibc, ib, size)
-int *adbc, *aibc;
-char *db;
-daddr_t *ib;
-int size;
+/*
+ * check if a block is available
+ */
+isblock(fs, cp, h)
+ struct fs *fs;
+ unsigned char *cp;
+ int h;
{
- int i;
- daddr_t bno;
-
- bno = alloc(size);
- wtfs(bno, size, db);
- for(i=0; i<size; i++)
- db[i] = 0;
- *adbc = 0;
- ib[*aibc] = bno;
- (*aibc)++;
- if(*aibc >= NINDIR) {
- printf("indirect block full\n");
- error = 1;
- *aibc = 0;
+ unsigned char mask;
+
+ switch (fs->fs_frag) {
+ case 8:
+ return (cp[h] == 0xff);
+ case 4:
+ mask = 0x0f << ((h & 0x1) << 2);
+ return ((cp[h >> 1] & mask) == mask);
+ case 2:
+ mask = 0x03 << ((h & 0x3) << 1);
+ return ((cp[h >> 2] & mask) == mask);
+ case 1:
+ mask = 0x01 << (h & 0x7);
+ return ((cp[h >> 3] & mask) == mask);
+ default:
+#ifdef STANDALONE
+ printf("isblock bad fs_frag %d\n", fs->fs_frag);
+#else
+ fprintf(stderr, "isblock bad fs_frag %d\n", fs->fs_frag);
+#endif
+ return;
}
}
-getch()
+/*
+ * take a block out of the map
+ */
+clrblock(fs, cp, h)
+ struct fs *fs;
+ unsigned char *cp;
+ int h;
{
-
-#ifndef STANDALONE
- if(charp)
-#endif
- return(*charp++);
-#ifndef STANDALONE
- return(getc(fin));
+ switch ((fs)->fs_frag) {
+ case 8:
+ cp[h] = 0;
+ return;
+ case 4:
+ cp[h >> 1] &= ~(0x0f << ((h & 0x1) << 2));
+ return;
+ case 2:
+ cp[h >> 2] &= ~(0x03 << ((h & 0x3) << 1));
+ return;
+ case 1:
+ cp[h >> 3] &= ~(0x01 << (h & 0x7));
+ return;
+ default:
+#ifdef STANDALONE
+ printf("clrblock bad fs_frag %d\n", fs->fs_frag);
+#else
+ fprintf(stderr, "clrblock bad fs_frag %d\n", fs->fs_frag);
#endif
+ return;
+ }
}
-iput(ip, aibc, ib)
-struct inode *ip;
-int *aibc;
-daddr_t *ib;
+/*
+ * put a block into the map
+ */
+setblock(fs, cp, h)
+ struct fs *fs;
+ unsigned char *cp;
+ int h;
{
- struct dinode *dp;
- daddr_t d;
- int i, c = ip->i_number / sblock.fs_ipg;
-
- rdfs(cgtod(c,&sblock), sblock.fs_cgsize, (char *)&acg);
- acg.cg_nifree--;
- setbit(acg.cg_iused, ip->i_number);
- wtfs(cgtod(c,&sblock), sblock.fs_cgsize, (char *)&acg);
- sblock.fs_nifree--;
- fscs[0].cs_nifree--;
- if(ip->i_number >= sblock.fs_ipg) {
- printf("mkfs: cant handle more than one cg of inodes (yet)\n");
- exit(1);
- }
- if(ip->i_number >= sblock.fs_ipg * sblock.fs_ncg) {
- if(error == 0)
- printf("ilist too small\n");
- error = 1;
+ switch (fs->fs_frag) {
+ case 8:
+ cp[h] = 0xff;
+ return;
+ case 4:
+ cp[h >> 1] |= (0x0f << ((h & 0x1) << 2));
+ return;
+ case 2:
+ cp[h >> 2] |= (0x03 << ((h & 0x3) << 1));
+ return;
+ case 1:
+ cp[h >> 3] |= (0x01 << (h & 0x7));
return;
- }
- d = itod(ip->i_number,&sblock);
- rdfs(d, BSIZE, buf);
- dp = (struct dinode *)buf;
- dp += itoo(ip->i_number);
-
- dp->di_mode = ip->i_mode;
- dp->di_nlink = ip->i_nlink;
- dp->di_uid = ip->i_uid;
- dp->di_gid = ip->i_gid;
- dp->di_size = ip->i_size;
- dp->di_atime = utime;
- dp->di_mtime = utime;
- dp->di_ctime = utime;
-
- switch(ip->i_mode&IFMT) {
-
- case IFDIR:
- case IFREG:
- for(i=0; i<*aibc; i++) {
- if(i >= NDADDR)
- break;
- ip->i_un.i_f.i_db[i] = ib[i];
- }
- if(*aibc >= NDADDR) {
- ip->i_un.i_f.i_ib[0] = alloc(BSIZE);
- for(i=0; i<NINDIR-NDADDR; i++) {
- ib[i] = ib[i+NDADDR];
- ib[i+NDADDR] = (daddr_t)0;
- }
- wtfs(ip->i_un.i_f.i_ib[0], (char *)ib);
- }
-
- case IFBLK:
- case IFCHR:
- ltol3(dp->di_addr, ip->i_un.i_f.i_db, NDADDR+NIADDR);
- break;
-
default:
- printf("bad mode %o\n", ip->i_mode);
- exit(1);
+#ifdef STANDALONE
+ printf("setblock bad fs_frag %d\n", fs->fs_frag);
+#else
+ fprintf(stderr, "setblock bad fs_frag %d\n", fs->fs_frag);
+#endif
+ return;
}
- wtfs(d, BSIZE, buf);
-}
-
-badblk(bno)
-daddr_t bno;
-{
-
- return(0);
}