![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mkfs.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / chuck|
Return to mkfs.c CVS log | Up to [Research Unix] / researchv10no / cmd / chuck |
1.1 root 1: #include "fs.h"
2:
3: /* always bit-mapped. only question is how many blocks of inodes */
4: mknew()
5: { int n;
6: if(pblk < 4)
7: fatal("%d blocks is too few\n", pblk);
8: fd = open(file, 2);
9: inopb = bsize/sizeof(struct dinode);
10: fblk = (pblk-2)/(1+inopb);
11: ninode = (fblk-2)*inopb;
12: if(ninode > 65536) { /* temporary, I hope FIX */
13: fblk = 65536/inopb + 2;
14: }
15: else if(ninode <= 0)
16: fblk = 3;
17: ninode = (fblk-2)*inopb;
18: if(fblk + BITMAP*8*sizeof(long) < pblk)
19: lblk = pblk - (pblk + 8*bsize - 1)/(8*bsize);
20: else
21: lblk = pblk;
22: pmesg("%d blocks, %d inodes, fblk %d, lblk %d (%d data blocks)\n",
23: pblk, ninode, fblk, lblk, lblk-fblk);
24: /* we could give the sucker a chance to adjust this */
25: if(qry("is this ok? (yq)\n") != 'y')
26: fatal("too bad, quitting\n");
27: n = pblk - lblk + fblk; /* inodes plus bit maps */
28: buf = (char *) malloc(bsize * n);
29: memset(buf, 0, bsize * n);
30: newsuper();
31: sblk.U.B.S_valid = 1;
32: newroot();
33: newbits();
34: writeem();
35: exit(0);
36: }
37:
38: newsuper()
39: { int i;
40: long *p;
41: sblk.s_isize = fblk;
42: sblk.s_fsize = pblk;
43: sblk.s_tinode = ninode - 1;
44: for(i = 0; i < NICINOD; i++) {
45: if(i+3 >= ninode) /* maybe >? */
46: break;
47: sblk.s_inode[i] = i+3;
48: }
49: sblk.s_ninode = i;
50: sblk.s_time = time(0);
51: sblk.s_tfree = lblk-fblk-1;
52: if(pblk > lblk)
53: return;
54: p = sblk.U.B.S_bfree;
55: for(i = 0; i < (lblk-fblk)/(8*sizeof(long)); i++)
56: p[i] = ~0;
57: /* and the (possible) last bunch */
58: for(i = i*8*sizeof(long) + fblk; i < lblk; i++)
59: setfree(p, i-fblk);
60: /* fblk is used by the root */
61: *p &= ~1;
62: }
63:
64: setfree(p, n)
65: long *p;
66: { int j, k;
67: j = n/(8*sizeof(int));
68: k = n%(8*sizeof(int));
69: p[j] |= (1 << k);
70: }
71:
72: /* the root goes in inode 2, and in block fblk */
73: newroot()
74: { struct dinode *p = (struct dinode *) (buf + 2*bsize);
75: struct direct *d = (struct direct *) (buf + bsize);
76: p++; /* root is inode 2 */
77: p->di_mode = IFDIR | (~umask(0) & 0777); /* sets umask */
78: p->di_nlink = 2;
79: p->di_uid = getuid();
80: p->di_gid = getgid();
81: p->di_size = 32; /* temporary, I hope FIX */
82: p->di_atime = p->di_mtime = p->di_ctime = time(0);
83: ltol3(p->di_addr, &fblk, 1);
84: d->d_ino = 2;
85: strcpy(d->d_name, ".");
86: d++;
87: d->d_ino = 2;
88: strcpy(d->d_name, "..");
89: }
90:
91: newbits()
92: { int i;
93: long *p;
94: if(pblk <= lblk)
95: return;
96: p = (long *)(buf + fblk*bsize);
97: for(i = fblk+1; i % (8*sizeof(int)); i++)
98: setfree(p, i);
99: for(; i+8*sizeof(int) < lblk; i += 8*sizeof(int))
100: p[i/(8*sizeof(int))] = ~0;
101: for(; i < lblk; i++)
102: setfree(p, i);
103: /* sblk.U.N.S_flag = 1; /* bit map blocks */
104: /* sblk.U.N.S_bsize = 4096*8;*/
105: }
106: writeem()
107: {
108: fd = open(file, 2);
109: if(fd < 0)
110: fatal("can't write\n");
111: if(bwrite(pblk-1, buf, 1))
112: fatal("can't write last block (%d)\n", pblk-1);
113: if(pblk > lblk)
114: if(bwrite(lblk, buf+fblk*bsize, pblk-lblk))
115: fatal("couldn't write bit maps\n");
116: if(bwrite(fblk, buf+bsize, 1))
117: fatal("couldn't write root dir\n");
118: if(bwrite(2, buf+2*bsize, fblk-2))
119: fatal("couldn't write inodes\n");
120: if(bwrite(1, (char *)&sblk, 1))
121: fatal("couldn't write superblock\n");
122: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.