V7M/src/cmd/mkfs.c
/*
* Make a file system prototype.
* usage: mkfs filsys proto/size [ m n ]
*
* Modified for use with unix/v7m 2.0 .
* The files /sys/sas/mkfs.c and /usr/src/cmd/mkfs.c
* are identical, the make distribution process
* requires two copies of mkfs.c .
*
* Fred Canter 8/19/81
*/
#define NIPB (BSIZE/sizeof(struct dinode))
#define NINDIR (BSIZE/sizeof(daddr_t))
#define NDIRECT (BSIZE/sizeof(struct direct))
#define LADDR 10
#define MAXFN 500
#define itoo(x) (int)((x+15)&07)
#ifndef STANDALONE
#include <stdio.h>
#include <a.out.h>
#include <sys/param.h>
#include <sys/ino.h>
#include <sys/inode.h>
#include <sys/filsys.h>
#include <sys/fblk.h>
#include <sys/dir.h>
#else
#include "../h/param.h"
#include "../h/ino.h"
#include "../h/inode.h"
#include "../h/filsys.h"
#include "../h/fblk.h"
#include "../h/dir.h"
#endif
time_t utime;
#ifndef STANDALONE
FILE *fin;
#else
int fin;
#endif
int fsi;
int fso;
char *charp;
char buf[BSIZE];
union {
struct fblk fb;
char pad1[BSIZE];
} fbuf;
#ifndef STANDALONE
struct exec head;
#endif
char string[50];
union {
struct filsys fs;
char pad2[BSIZE];
} filsys;
char *fsys;
char *proto;
char *mstrg;
char *nstrg;
int f_n = MAXFN;
int f_m = 3;
int error;
ino_t ino;
long getnum();
daddr_t alloc();
main(argc, argv)
char *argv[];
{
int f, c;
long n;
#ifndef STANDALONE
time(&utime);
if(argc < 3) {
printf("usage: mkfs filsys proto/size [ m n ]\n");
exit(1);
}
fsys = argv[1];
proto = argv[2];
#else
{
static char protos[60];
static char mstrg[60];
static char nstrg[60];
printf("file sys size: ");
gets(protos);
proto = protos;
printf("interleave factor: ");
gets(mstrg);
f_m = atoi(mstrg);
printf("blocks per cylinder: ");
gets(nstrg);
f_n = atoi(nstrg);
if(f_n <= 0 || f_n >= MAXFN)
f_n = MAXFN;
if(f_m <= 0 || f_m > f_n)
f_m = 3;
}
#endif
#ifdef STANDALONE
{
char fsbuf[100];
do {
printf("file system: ");
gets(fsbuf);
fso = open(fsbuf, 1);
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);
exit(1);
}
fsi = open(fsys, 0);
if(fsi < 0) {
printf("%s: cannot open\n", fsys);
exit(1);
}
fin = fopen(proto, "r");
#endif
if(fin == NULL) {
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');
}
filsys.s_fsize = n;
n = n/25;
if(n <= 0)
n = 1;
if(n > 65500/NIPB)
n = 65500/NIPB;
filsys.s_isize = n + 2;
printf("isize = %D\n", n*NIPB);
charp = "d--777 0 0 $ ";
goto f3;
}
#ifndef STANDALONE
/*
* get name of boot load program
* and read onto block 0
*/
getstr();
f = open(string, 0);
if(f < 0) {
printf("%s: cannot open init\n", string);
goto f2;
}
read(f, (char *)&head, sizeof head);
if(head.a_magic != A_MAGIC1) {
printf("%s: bad format\n", string);
goto f1;
}
c = head.a_text + head.a_data;
if(c > BSIZE) {
printf("%s: too big\n", string);
goto f1;
}
read(f, buf, c);
wtfs((long)0, buf);
f1:
close(f);
/*
* get total disk size
* and inode block size
*/
f2:
filsys.s_fsize = getnum();
n = getnum();
n /= NIPB;
filsys.s_isize = n + 3;
#endif
f3:
if(argc >= 5) {
f_m = atoi(argv[3]);
f_n = atoi(argv[4]);
if(f_n <= 0 || f_n >= MAXFN)
f_n = MAXFN;
if(f_m <= 0 || f_m > f_n)
f_m = 3;
}
filsys.s_m = f_m;
filsys.s_n = f_n;
printf("m/n = %d %d\n", f_m, f_n);
if(filsys.s_isize >= filsys.s_fsize) {
printf("%ld/%ld: bad ratio\n", filsys.s_fsize, filsys.s_isize-2);
exit(1);
}
filsys.s_tfree = 0;
filsys.s_tinode = 0;
for(c=0; c<BSIZE; c++)
buf[c] = 0;
for(n=2; n!=filsys.s_isize; n++) {
wtfs(n, buf);
filsys.s_tinode += NIPB;
}
ino = 0;
bflist();
cfile((struct inode *)0);
filsys.s_time = utime;
wtfs((long)1, (char *)&filsys);
exit(error);
}
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<NADDR; i++)
in.i_un.i_addr[i] = (daddr_t)0;
if(par == (struct inode *)0) {
par = ∈
in.i_nlink--;
}
dbc = 0;
ibc = 0;
switch(in.i_mode&IFMT) {
case IFREG:
/*
* regular file
* contents is a file name
*/
getstr();
f = open(string, 0);
if(f < 0) {
printf("%s: cannot open\n", string);
error = 1;
break;
}
while((i=read(f, db, BSIZE)) > 0) {
in.i_size += i;
newblk(&dbc, db, &ibc, ib);
}
close(f);
break;
case IFBLK:
case IFCHR:
/*
* special file
* content is maj/min types
*/
i = getnum() & 0377;
f = getnum() & 0377;
in.i_un.i_addr[0] = (i<<8) | 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;
entry(ino+1, string, &dbc, db, &ibc, ib);
in.i_size += sizeof(struct direct);
cfile(&in);
}
break;
}
if(dbc != 0)
newblk(&dbc, db, &ibc, ib);
iput(&in, &ibc, ib);
}
gmode(c, s, m0, m1, m2, m3)
char c, *s;
{
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);
}
long
getnum()
{
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');
}
return(n);
}
getstr()
{
int i, c;
loop:
switch(c=getch()) {
case ' ':
case '\t':
case '\n':
goto loop;
case '\0':
printf("EOF\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';
}
rdfs(bno, bf)
daddr_t bno;
char *bf;
{
int n;
lseek(fsi, bno*BSIZE, 0);
n = read(fsi, bf, BSIZE);
if(n != BSIZE) {
printf("read error: %ld\n", bno);
exit(1);
}
}
wtfs(bno, bf)
daddr_t bno;
char *bf;
{
int n;
lseek(fso, bno*BSIZE, 0);
n = write(fso, bf, BSIZE);
if(n != BSIZE) {
printf("write error: %D\n", bno);
exit(1);
}
}
daddr_t
alloc()
{
int i;
daddr_t bno;
filsys.s_tfree--;
bno = filsys.s_free[--filsys.s_nfree];
if(bno == 0) {
printf("out of free space\n");
exit(1);
}
if(filsys.s_nfree <= 0) {
rdfs(bno, (char *)&fbuf);
filsys.s_nfree = fbuf.df_nfree;
for(i=0; i<NICFREE; i++)
filsys.s_free[i] = fbuf.df_free[i];
}
return(bno);
}
bfree(bno)
daddr_t bno;
{
int i;
filsys.s_tfree++;
if(filsys.s_nfree >= NICFREE) {
fbuf.df_nfree = filsys.s_nfree;
for(i=0; i<NICFREE; i++)
fbuf.df_free[i] = filsys.s_free[i];
wtfs(bno, (char *)&fbuf);
filsys.s_nfree = 0;
}
filsys.s_free[filsys.s_nfree++] = bno;
}
entry(inum, str, adbc, db, aibc, ib)
ino_t inum;
char *str;
int *adbc, *aibc;
char *db;
daddr_t *ib;
{
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);
}
newblk(adbc, db, aibc, ib)
int *adbc, *aibc;
char *db;
daddr_t *ib;
{
int i;
daddr_t bno;
bno = alloc();
wtfs(bno, db);
for(i=0; i<BSIZE; i++)
db[i] = 0;
*adbc = 0;
ib[*aibc] = bno;
(*aibc)++;
if(*aibc >= NINDIR) {
printf("indirect block full\n");
error = 1;
*aibc = 0;
}
}
getch()
{
#ifndef STANDALONE
if(charp)
#endif
return(*charp++);
#ifndef STANDALONE
return(getc(fin));
#endif
}
bflist()
{
struct inode in;
daddr_t ib[NINDIR];
int ibc;
char flg[MAXFN];
int adr[MAXFN];
int i, j;
daddr_t f, d;
for(i=0; i<f_n; i++)
flg[i] = 0;
i = 0;
for(j=0; j<f_n; j++) {
while(flg[i])
i = (i+1)%f_n;
adr[j] = i+1;
flg[i]++;
i = (i+f_m)%f_n;
}
ino++;
in.i_number = ino;
in.i_mode = IFREG;
in.i_uid = 0;
in.i_gid = 0;
in.i_nlink = 0;
in.i_size = 0;
for(i=0; i<NADDR; i++)
in.i_un.i_addr[i] = (daddr_t)0;
for(i=0; i<NINDIR; i++)
ib[i] = (daddr_t)0;
ibc = 0;
bfree((daddr_t)0);
d = filsys.s_fsize-1;
while(d%f_n)
d++;
for(; d > 0; d -= f_n)
for(i=0; i<f_n; i++) {
f = d - adr[i];
if(f < filsys.s_fsize && f >= filsys.s_isize)
if(badblk(f)) {
if(ibc >= NINDIR) {
printf("too many bad blocks\n");
error = 1;
ibc = 0;
}
ib[ibc] = f;
ibc++;
} else
bfree(f);
}
iput(&in, &ibc, ib);
}
iput(ip, aibc, ib)
struct inode *ip;
int *aibc;
daddr_t *ib;
{
struct dinode *dp;
daddr_t d;
int i;
filsys.s_tinode--;
d = itod(ip->i_number);
if(d >= filsys.s_isize) {
if(error == 0)
printf("ilist too small\n");
error = 1;
return;
}
rdfs(d, 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 >= LADDR)
break;
ip->i_un.i_addr[i] = ib[i];
}
if(*aibc >= LADDR) {
ip->i_un.i_addr[LADDR] = alloc();
for(i=0; i<NINDIR-LADDR; i++) {
ib[i] = ib[i+LADDR];
ib[i+LADDR] = (daddr_t)0;
}
wtfs(ip->i_un.i_addr[LADDR], (char *)ib);
}
case IFBLK:
case IFCHR:
ltol3(dp->di_addr, ip->i_un.i_addr, NADDR);
break;
default:
printf("bad mode %o\n", ip->i_mode);
exit(1);
}
wtfs(d, buf);
}
badblk(bno)
daddr_t bno;
{
return(0);
}