![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to init.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / b / etc / fsck|
Return to init.c CVS log | Up to [MW Coherent from dump] / coherent / b / etc / fsck |
1.1 root 1: /*
2: * Perform initialization for phases of fsck
3: */
4: #include "fsck.h"
5: #include <mnttab.h>
6: #include <mtab.h>
7:
8: int fsfd; /* file system file descriptor */
9: int writeflg; /* write ok or read-only flag */
10: daddr_t fsize = SUPERI+1; /* file system size in blocks */
11: /* Allows for read of Super Block */
12: int isize; /* First block not in inode list */
13: daddr_t totfree; /* Running total free block count */
14: unsigned ninodes; /* number of inodes */
15: int numfiles; /* number of files in file system */
16:
17: char superb[BSIZE]; /* Super Block */
18: struct filsys *sbp = superb;
19: int sbpfix; /* flag for super block fixes */
20:
21: int offsets[] = /* table of offsets for the levels */
22: { ND, ND+NI, ND+NI+NII, /* of indirection of blocks in the */
23: ND+NI+NII+NIII }; /* inode block list */
24:
25: daddr_t dupblck[DUPTBLSIZE]; /* duplicate referenced blocks */
26: int totdups; /* number of dup blocks so far */
27:
28: /*
29: * A small aside is the fact that the link counter table allocates an
30: * unsigned short if !SMALLMODEL, but is in fact only an unsigned char
31: * if SMALLMODEL. As a result, we cannot currently fsck correctly a
32: * filesystem with any inode having more than 255 links if SMALLMODEL.
33: * The reason for this is that the virtual system is heavily designed
34: * to work with byte sized tables, and that's that for now! Anyway,
35: * everybody has a 386 by now!
36: */
37:
38: #if !SMALLMODEL
39: unsigned short *linkPtr;
40: unsigned char *flagptr, *blockPtr, *dupPtr;
41: #endif
42:
43: init()
44: {
45: int mode;
46: struct stat status;
47: unsigned short stmode;
48:
49: mode = (mdaction == NO) ? 0 : 2;
50:
51: if ( (fsfd = open(fsname, mode)) == (-1) ) {
52: mode = 0;
53: if ( (fsfd = open(fsname, mode)) == (-1) ) {
54: nonfatal("Can't open: %s", fsname);
55: return;
56: }
57: }
58:
59: if (mode == 0) {
60: daction = NO;
61: writeflg = FALSE;
62: } else {
63: daction = mdaction;
64: writeflg = TRUE;
65: }
66:
67: printf("%s: %s\n", fsname, (mode == 0) ? "(NO WRITE)" : "");
68:
69: if ( fstat(fsfd, &status) == (-1) ) {
70: nonfatal("Can't stat: %s", fsname);
71: return;
72: }
73:
74: stmode = status.st_mode & S_IFMT;
75: if ( (stmode != S_IFBLK) && (stmode != S_IFCHR) )
76: switch(query("file is not a block or character device; OK?")){
77: case YES:
78: break;
79: case NO:
80: errflag = TRUE;
81: return;
82: }
83:
84: domount();
85: sbpfix = FALSE;
86: readsuper();
87: checksuper();
88: if ( !errflag )
89: alloctables();
90: }
91:
92: /*
93: * Read in the super block and canonicalize
94: */
95:
96: readsuper()
97: {
98: register int i;
99:
100: bread((daddr_t)SUPERI, superb);
101: sbp = superb;
102:
103: canshort(sbp->s_isize);
104: candaddr(sbp->s_fsize);
105: canshort(sbp->s_nfree);
106: for(i=0; i<NICFREE; i++)
107: candaddr(sbp->s_free[i]);
108: canshort(sbp->s_ninode);
109: for(i=0; i<NICINOD; i++)
110: canino(sbp->s_inode[i]);
111: cantime(sbp->s_time);
112: candaddr(sbp->s_tfree);
113: canino(sbp->s_tinode);
114: canshort(sbp->s_m);
115: canshort(sbp->s_n);
116: canlong(sbp->s_unique);
117:
118: }
119:
120: /*
121: * Check super block for obvious inconsistencies
122: */
123:
124: checksuper()
125: {
126: fsize = sbp->s_fsize;
127: isize = sbp->s_isize;
128: totfree = fsize - isize;
129:
130: if ( (isize<=INODEI) || (isize>=fsize) || (fsize<=INODEI) ) {
131: badsuper("Size check: fsize %U isize %u", fsize, isize);
132: errflag = TRUE;
133: }
134:
135: if ( sbp->s_nfree > NICFREE )
136: badsuper("Too large free block count");
137:
138: if ( sbp->s_ninode > NICINOD )
139: badsuper("Too large free i-node count");
140: }
141:
142: /*
143: * Super Block Error Functions
144: */
145: badsuper(x)
146: {
147: printf("%r\n", &x);
148: printf("fsck: %s: Bad Super Block: %u\n", fsname, SUPERI);
149: }
150:
151: /*
152: * Allocate the necessary buffers for tables
153: */
154: alloctables()
155: {
156: unsigned num, numl;
157:
158: numl = 0;
159: if (!fflag) {
160: ninodes = (unsigned) (isize - INODEI) * INOPB;
161: numl = (unsigned) ninodes;
162: }
163:
164: num = (unsigned) ((fsize+NBPC-1)/NBPC) * sizeof(char);
165: #if SMALLMODEL
166: initV(numl, numl, num, num); /* virtual allocation */
167: #else
168: if (NULL != linkPtr) {
169: free(linkPtr);
170: free(flagPtr);
171: free(blockPtr);
172: free(dupPtr);
173: }
174: linkPtr = calloc(numl, sizeof(unsigned short));
175: flagPtr = calloc(numl, sizeof(unsigned char));
176: blockPtr = calloc(num, sizeof(unsigned char));
177: dupPtr = calloc(num, sizeof(unsigned char));
178: #endif
179: numfiles = /* number of files in the file system */
180: totdups = 0; /* num dup blocks */
181: }
182:
183: /*
184: * domount() checks the files /etc/mnttab and /etc/mtab to find
185: * out where the file system is mounted (if at all). It then
186: * reports where (and when if possible) it was last mounted.
187: */
188: char *mnttab_name = "/etc/mnttab";
189: char *mtab_name = "/etc/mtab";
190: char *bttime_name = "/etc/boottime";
191:
192: domount()
193: {
194: int fd;
195: struct mnttab mnttab;
196: struct mtab mtab;
197: register char *name;
198: struct stat sbuf;
199: time_t boottime;
200: int nothing();
201: char devname[MNTNSIZ+6] = "/dev/";
202:
203: mounted = FALSE;
204: name = fsname; /* strip off all initial */
205: while (*name++ != '\0') ; /* directories in fsname */
206: while ( (*--name != '/') && (name>fsname) ) ;
207: if (*name == '/') name++;
208:
209: if ( stat(bttime_name, &sbuf) == -1 )
210: boottime = (time_t)0;
211: else
212: boottime = sbuf.st_mtime;
213:
214: if ( (fd=open(mnttab_name, 0)) != (-1) ) {
215: while ( read(fd, &mnttab, sizeof(mnttab))==sizeof(mnttab) )
216: if ( mnttab.mt_dev[0] && mnttab.mt_filsys[0] ) {
217: strncpy(&devname[5], mnttab.mt_filsys, MNTNSIZ);
218: devname[MNTNSIZ+5] = '\0';
219: statit(devname, nothing);
220: if (stats.st_rdev != fsysrdev)
221: continue;
222: statit(mnttab.mt_dev, nothing);
223: mounted = (stats.st_dev == fsysrdev);
224: prmnttab(&mnttab, boottime);
225: return;
226: }
227: }
228: if ( (fd=open(mtab_name, 0)) != (-1) ) {
229: while ( read(fd, &mtab, sizeof(mtab))==sizeof(mtab) )
230: if ( mtab.mt_name[0] && mtab.mt_special[0] ) {
231: strncpy(&devname[5], mtab.mt_special, MNAMSIZ);
232: devname[MNAMSIZ+5] = '\0';
233: statit(devname, nothing);
234: if (stats.st_rdev != fsysrdev)
235: continue;
236: statit(mtab.mt_name, nothing);
237: mounted = (stats.st_dev == fsysrdev);
238: prmtab(&mtab);
239: return;
240: }
241: }
242:
243: if (fsysrdev == rootdev)
244: mounted = TRUE;
245: else
246: mounted = FALSE;
247:
248: }
249:
250: prmnttab(ptr, boottime)
251: struct mnttab *ptr;
252: time_t boottime;
253: {
254: if (mounted) {
255: if (boottime < ptr->mt_time)
256: boottime = ptr->mt_time;
257: printf("%s mounted on %.*s as of %s", fsname, MNTNSIZ,
258: ptr->mt_dev, ctime(&boottime));
259: } else
260: printf("%s unmounted. Last mounted on %.*s -- %s",
261: fsname, MNTNSIZ, ptr->mt_dev,
262: ctime(&ptr->mt_time));
263: }
264:
265:
266: prmtab(ptr)
267: struct mtab *ptr;
268: {
269: if (mounted)
270: printf("%s mounted on %.*s\n", fsname, MNAMSIZ, ptr->mt_name);
271: else
272: printf("%s unmounted. Last mounted on %.*s\n", fsname,
273: MNAMSIZ, ptr->mt_name);
274: }
275:
276: nothing()
277: {}
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.