[unix-history] / usr / src / cmd / mkfs.c

/*
 * Make a file system prototype.
 * usage: mkfs filsys proto/size [ m n ]
 */
#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>
#endif
#include <sys/param.h>
#include <sys/ino.h>
#include <sys/inode.h>
#include <sys/filsys.h>
#include <sys/fblk.h>
#include <sys/dir.h>
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;
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];

		printf("file sys size: ");
		gets(protos);
		proto = protos;
	}
#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;
		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);
}
Commit	Line	Data
8dbf4a5b KT	1	/*
	2	* Make a file system prototype.
	3	* usage: mkfs filsys proto/size [ m n ]
	4	*/
	5	#define NIPB (BSIZE/sizeof(struct dinode))
	6	#define NINDIR (BSIZE/sizeof(daddr_t))
	7	#define NDIRECT (BSIZE/sizeof(struct direct))
	8	#define LADDR 10
	9	#define MAXFN 500
	10	#define itoo(x) (int)((x+15)&07)
	11	#ifndef STANDALONE
	12	#include <stdio.h>
	13	#include <a.out.h>
	14	#endif
	15	#include <sys/param.h>
	16	#include <sys/ino.h>
	17	#include <sys/inode.h>
	18	#include <sys/filsys.h>
	19	#include <sys/fblk.h>
	20	#include <sys/dir.h>
	21	time_t utime;
	22	#ifndef STANDALONE
	23	FILE *fin;
	24	#else
	25	int fin;
	26	#endif
	27	int fsi;
	28	int fso;
	29	char *charp;
	30	char buf[BSIZE];
	31	union {
	32	struct fblk fb;
	33	char pad1[BSIZE];
	34	} fbuf;
	35	#ifndef STANDALONE
	36	struct exec head;
	37	#endif
	38	char string[50];
	39	union {
	40	struct filsys fs;
	41	char pad2[BSIZE];
	42	} filsys;
	43	char *fsys;
	44	char *proto;
	45	int f_n = MAXFN;
	46	int f_m = 3;
	47	int error;
	48	ino_t ino;
	49	long getnum();
	50	daddr_t alloc();
	51
	52	main(argc, argv)
	53	char *argv[];
	54	{
	55	int f, c;
	56	long n;
	57
	58	#ifndef STANDALONE
	59	time(&utime);
	60	if(argc < 3) {
	61	printf("usage: mkfs filsys proto/size [ m n ]\n");
	62	exit(1);
	63	}
	64	fsys = argv[1];
65	proto = argv[2];
66	#else
67	{
68	static char protos[60];
69
70	printf("file sys size: ");
71	gets(protos);
72	proto = protos;
73	}
74	#endif
75	#ifdef STANDALONE
76	{
77	char fsbuf[100];
78
79	do {
80	printf("file system: ");
81	gets(fsbuf);
82	fso = open(fsbuf, 1);
83	fsi = open(fsbuf, 0);
84	} while (fso < 0 \|\| fsi < 0);
85	}
86	fin = NULL;
87	argc = 0;
88	#else
89	fso = creat(fsys, 0666);
90	if(fso < 0) {
91	printf("%s: cannot create\n", fsys);
92	exit(1);
93	}
94	fsi = open(fsys, 0);
95	if(fsi < 0) {
96	printf("%s: cannot open\n", fsys);
97	exit(1);
98	}
99	fin = fopen(proto, "r");
100	#endif
101	if(fin == NULL) {
102	n = 0;
103	for(f=0; c=proto[f]; f++) {
104	if(c<'0' \|\| c>'9') {
105	printf("%s: cannot open\n", proto);
106	exit(1);
107	}
108	n = n*10 + (c-'0');
109	}
110	filsys.s_fsize = n;
111	n = n/25;
112	if(n <= 0)
113	n = 1;
114	if(n > 65500/NIPB)
115	n = 65500/NIPB;
116	filsys.s_isize = n + 2;
117	printf("isize = %D\n", n*NIPB);
118	charp = "d--777 0 0 $ ";
119	goto f3;
120	}
121
122	#ifndef STANDALONE
123	/*
124	* get name of boot load program
125	* and read onto block 0
126	*/
127
128	getstr();
129	f = open(string, 0);
130	if(f < 0) {
131	printf("%s: cannot open init\n", string);
132	goto f2;
133	}
134	read(f, (char *)&head, sizeof head);
135	if(head.a_magic != A_MAGIC1) {
136	printf("%s: bad format\n", string);
137	goto f1;
138	}
139	c = head.a_text + head.a_data;
140	if(c > BSIZE) {
141	printf("%s: too big\n", string);
142	goto f1;
143	}
144	read(f, buf, c);
145	wtfs((long)0, buf);
146
147	f1:
148	close(f);
149
150	/*
151	* get total disk size
152	* and inode block size
153	*/
154
155	f2:
156	filsys.s_fsize = getnum();
157	n = getnum();
158	n /= NIPB;
159	filsys.s_isize = n + 3;
160
161	#endif
162	f3:
163	if(argc >= 5) {
164	f_m = atoi(argv[3]);
165	f_n = atoi(argv[4]);
166	if(f_n <= 0 \|\| f_n >= MAXFN)
167	f_n = MAXFN;
168	if(f_m <= 0 \|\| f_m > f_n)
169	f_m = 3;
170	}
171	filsys.s_m = f_m;
172	filsys.s_n = f_n;
173	printf("m/n = %d %d\n", f_m, f_n);
174	if(filsys.s_isize >= filsys.s_fsize) {
175	printf("%ld/%ld: bad ratio\n", filsys.s_fsize, filsys.s_isize-2);
176	exit(1);
177	}
178	filsys.s_tfree = 0;
179	filsys.s_tinode = 0;
180	for(c=0; c<BSIZE; c++)
181	buf[c] = 0;
182	for(n=2; n!=filsys.s_isize; n++) {
183	wtfs(n, buf);
184	filsys.s_tinode += NIPB;
185	}
186	ino = 0;
187
188	bflist();
189
190	cfile((struct inode *)0);
191
192	filsys.s_time = utime;
193	wtfs((long)1, (char *)&filsys);
194	exit(error);
195	}
196
197	cfile(par)
198	struct inode *par;
199	{
200	struct inode in;
201	int dbc, ibc;
202	char db[BSIZE];
203	daddr_t ib[NINDIR];
204	int i, f, c;
205
206	/*
207	* get mode, uid and gid
208	*/
209
210	getstr();
211	in.i_mode = gmode(string[0], "-bcd", IFREG, IFBLK, IFCHR, IFDIR);
212	in.i_mode \|= gmode(string[1], "-u", 0, ISUID, 0, 0);
213	in.i_mode \|= gmode(string[2], "-g", 0, ISGID, 0, 0);
214	for(i=3; i<6; i++) {
215	c = string[i];
216	if(c<'0' \|\| c>'7') {
217	printf("%c/%s: bad octal mode digit\n", c, string);
218	error = 1;
219	c = 0;
220	}
221	in.i_mode \|= (c-'0')<<(15-3*i);
222	}
223	in.i_uid = getnum();
224	in.i_gid = getnum();
225
226	/*
227	* general initialization prior to
228	* switching on format
229	*/
230
231	ino++;
232	in.i_number = ino;
233	for(i=0; i<BSIZE; i++)
234	db[i] = 0;
235	for(i=0; i<NINDIR; i++)
236	ib[i] = (daddr_t)0;
237	in.i_nlink = 1;
238	in.i_size = 0;
239	for(i=0; i<NADDR; i++)
240	in.i_un.i_addr[i] = (daddr_t)0;
241	if(par == (struct inode *)0) {
242	par = &in;
243	in.i_nlink--;
244	}
245	dbc = 0;
246	ibc = 0;
247	switch(in.i_mode&IFMT) {
248
249	case IFREG:
250	/*
251	* regular file
252	* contents is a file name
253	*/
254
255	getstr();
256	f = open(string, 0);
257	if(f < 0) {
258	printf("%s: cannot open\n", string);
259	error = 1;
260	break;
261	}
262	while((i=read(f, db, BSIZE)) > 0) {
263	in.i_size += i;
264	newblk(&dbc, db, &ibc, ib);
265	}
266	close(f);
267	break;
268
269	case IFBLK:
270	case IFCHR:
271	/*
272	* special file
273	* content is maj/min types
274	*/
275
276	i = getnum() & 0377;
277	f = getnum() & 0377;
278	in.i_un.i_addr[0] = (i<<8) \| f;
279	break;
280
281	case IFDIR:
282	/*
283	* directory
284	* put in extra links
285	* call recursively until
286	* name of "$" found
287	*/
288
289	par->i_nlink++;
290	in.i_nlink++;
291	entry(in.i_number, ".", &dbc, db, &ibc, ib);
292	entry(par->i_number, "..", &dbc, db, &ibc, ib);
293	in.i_size = 2*sizeof(struct direct);
294	for(;;) {
295	getstr();
296	if(string[0]=='$' && string[1]=='\0')
297	break;
298	entry(ino+1, string, &dbc, db, &ibc, ib);
299	in.i_size += sizeof(struct direct);
300	cfile(&in);
301	}
302	break;
303	}
304	if(dbc != 0)
305	newblk(&dbc, db, &ibc, ib);
306	iput(&in, &ibc, ib);
307	}
308
309	gmode(c, s, m0, m1, m2, m3)
310	char c, *s;
311	{
312	int i;
313
314	for(i=0; s[i]; i++)
315	if(c == s[i])
316	return((&m0)[i]);
317	printf("%c/%s: bad mode\n", c, string);
318	error = 1;
319	return(0);
320	}
321
322	long
323	getnum()
324	{
325	int i, c;
326	long n;
327
328	getstr();
329	n = 0;
330	i = 0;
331	for(i=0; c=string[i]; i++) {
332	if(c<'0' \|\| c>'9') {
333	printf("%s: bad number\n", string);
334	error = 1;
335	return((long)0);
336	}
337	n = n*10 + (c-'0');
338	}
339	return(n);
340	}
341
342	getstr()
343	{
344	int i, c;
345
346	loop:
347	switch(c=getch()) {
348
349	case ' ':
350	case '\t':
351	case '\n':
352	goto loop;
353
354	case '\0':
355	printf("EOF\n");
356	exit(1);
357
358	case ':':
359	while(getch() != '\n');
360	goto loop;
361
362	}
363	i = 0;
364
365	do {
366	string[i++] = c;
367	c = getch();
368	} while(c!=' '&&c!='\t'&&c!='\n'&&c!='\0');
369	string[i] = '\0';
370	}
371
372	rdfs(bno, bf)
373	daddr_t bno;
374	char *bf;
375	{
376	int n;
377
378	lseek(fsi, bno*BSIZE, 0);
379	n = read(fsi, bf, BSIZE);
380	if(n != BSIZE) {
381	printf("read error: %ld\n", bno);
382	exit(1);
383	}
384	}
385
386	wtfs(bno, bf)
387	daddr_t bno;
388	char *bf;
389	{
390	int n;
391
392	lseek(fso, bno*BSIZE, 0);
393	n = write(fso, bf, BSIZE);
394	if(n != BSIZE) {
395	printf("write error: %D\n", bno);
396	exit(1);
397	}
398	}
399
400	daddr_t
401	alloc()
402	{
403	int i;
404	daddr_t bno;
405
406	filsys.s_tfree--;
407	bno = filsys.s_free[--filsys.s_nfree];
408	if(bno == 0) {
409	printf("out of free space\n");
410	exit(1);
411	}
412	if(filsys.s_nfree <= 0) {
413	rdfs(bno, (char *)&fbuf);
414	filsys.s_nfree = fbuf.df_nfree;
415	for(i=0; i<NICFREE; i++)
416	filsys.s_free[i] = fbuf.df_free[i];
417	}
418	return(bno);
419	}
420
421	bfree(bno)
422	daddr_t bno;
423	{
424	int i;
425
426	filsys.s_tfree++;
427	if(filsys.s_nfree >= NICFREE) {
428	fbuf.df_nfree = filsys.s_nfree;
429	for(i=0; i<NICFREE; i++)
430	fbuf.df_free[i] = filsys.s_free[i];
431	wtfs(bno, (char *)&fbuf);
432	filsys.s_nfree = 0;
433	}
434	filsys.s_free[filsys.s_nfree++] = bno;
435	}
436
437	entry(inum, str, adbc, db, aibc, ib)
438	ino_t inum;
439	char *str;
440	int adbc, aibc;
441	char *db;
442	daddr_t *ib;
443	{
444	struct direct *dp;
445	int i;
446
447	dp = (struct direct *)db;
448	dp += *adbc;
449	(*adbc)++;
450	dp->d_ino = inum;
451	for(i=0; i<DIRSIZ; i++)
452	dp->d_name[i] = 0;
453	for(i=0; i<DIRSIZ; i++)
454	if((dp->d_name[i] = str[i]) == 0)
455	break;
456	if(*adbc >= NDIRECT)
457	newblk(adbc, db, aibc, ib);
458	}
459
460	newblk(adbc, db, aibc, ib)
461	int adbc, aibc;
462	char *db;
463	daddr_t *ib;
464	{
465	int i;
466	daddr_t bno;
467
468	bno = alloc();
469	wtfs(bno, db);
470	for(i=0; i<BSIZE; i++)
471	db[i] = 0;
472	*adbc = 0;
473	ib[*aibc] = bno;
474	(*aibc)++;
475	if(*aibc >= NINDIR) {
476	printf("indirect block full\n");
477	error = 1;
478	*aibc = 0;
479	}
480	}
481
482	getch()
483	{
484
485	#ifndef STANDALONE
486	if(charp)
487	#endif
488	return(*charp++);
489	#ifndef STANDALONE
490	return(getc(fin));
491	#endif
492	}
493
494	bflist()
495	{
496	struct inode in;
497	daddr_t ib[NINDIR];
498	int ibc;
499	char flg[MAXFN];
500	int adr[MAXFN];
501	int i, j;
502	daddr_t f, d;
503
504	for(i=0; i<f_n; i++)
505	flg[i] = 0;
506	i = 0;
507	for(j=0; j<f_n; j++) {
508	while(flg[i])
509	i = (i+1)%f_n;
510	adr[j] = i+1;
511	flg[i]++;
512	i = (i+f_m)%f_n;
513	}
514
515	ino++;
516	in.i_number = ino;
517	in.i_mode = IFREG;
518	in.i_uid = 0;
519	in.i_gid = 0;
520	in.i_nlink = 0;
521	in.i_size = 0;
522	for(i=0; i<NADDR; i++)
523	in.i_un.i_addr[i] = (daddr_t)0;
524
525	for(i=0; i<NINDIR; i++)
526	ib[i] = (daddr_t)0;
527	ibc = 0;
528	bfree((daddr_t)0);
529	d = filsys.s_fsize-1;
530	while(d%f_n)
531	d++;
532	for(; d > 0; d -= f_n)
533	for(i=0; i<f_n; i++) {
534	f = d - adr[i];
535	if(f < filsys.s_fsize && f >= filsys.s_isize)
536	if(badblk(f)) {
537	if(ibc >= NINDIR) {
538	printf("too many bad blocks\n");
539	error = 1;
540	ibc = 0;
541	}
542	ib[ibc] = f;
543	ibc++;
544	} else
545	bfree(f);
546	}
547	iput(&in, &ibc, ib);
548	}
549
550	iput(ip, aibc, ib)
551	struct inode *ip;
552	int *aibc;
553	daddr_t *ib;
554	{
555	struct dinode *dp;
556	daddr_t d;
557	int i;
558
559	filsys.s_tinode--;
560	d = itod(ip->i_number);
561	if(d >= filsys.s_isize) {
562	if(error == 0)
563	printf("ilist too small\n");
564	error = 1;
565	return;
566	}
567	rdfs(d, buf);
568	dp = (struct dinode *)buf;
569	dp += itoo(ip->i_number);
570
571	dp->di_mode = ip->i_mode;
572	dp->di_nlink = ip->i_nlink;
573	dp->di_uid = ip->i_uid;
574	dp->di_gid = ip->i_gid;
575	dp->di_size = ip->i_size;
576	dp->di_atime = utime;
577	dp->di_mtime = utime;
578	dp->di_ctime = utime;
579
580	switch(ip->i_mode&IFMT) {
581
582	case IFDIR:
583	case IFREG:
584	for(i=0; i<*aibc; i++) {
585	if(i >= LADDR)
586	break;
587	ip->i_un.i_addr[i] = ib[i];
588	}
589	if(*aibc >= LADDR) {
590	ip->i_un.i_addr[LADDR] = alloc();
591	for(i=0; i<NINDIR-LADDR; i++) {
592	ib[i] = ib[i+LADDR];
593	ib[i+LADDR] = (daddr_t)0;
594	}
595	wtfs(ip->i_un.i_addr[LADDR], (char *)ib);
596	}
597
598	case IFBLK:
599	case IFCHR:
600	ltol3(dp->di_addr, ip->i_un.i_addr, NADDR);
601	break;
602
603	default:
604	printf("bad mode %o\n", ip->i_mode);
605	exit(1);
606	}
607	wtfs(d, buf);
608	}
609
610	badblk(bno)
611	daddr_t bno;
612	{
613
614	return(0);
615	}