![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to preen.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / sbin / fsck|
Return to preen.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sbin / fsck |
1.1 root 1: /*
2: * Copyright (c) 1990 The Regents of the University of California.
3: * All rights reserved.
4: *
5: * Redistribution and use in source and binary forms are permitted provided
6: * that: (1) source distributions retain this entire copyright notice and
7: * comment, and (2) distributions including binaries display the following
8: * acknowledgement: ``This product includes software developed by the
9: * University of California, Berkeley and its contributors'' in the
10: * documentation or other materials provided with the distribution and in
11: * all advertising materials mentioning features or use of this software.
12: * Neither the name of the University nor the names of its contributors may
13: * be used to endorse or promote products derived from this software without
14: * specific prior written permission.
15: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
16: * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
17: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
18: */
19:
20: #ifndef lint
21: static char sccsid[] = "@(#)preen.c 5.5 (Berkeley) 7/20/90";
22: #endif /* not lint */
23:
24: #include <sys/param.h>
25: #include <sys/stat.h>
26: #include <sys/wait.h>
27: #include <fstab.h>
28: #include <string.h>
29: #include <stdio.h>
30: #include <stdlib.h>
31: #include <ctype.h>
32:
33: char *rawname(), *unrawname(), *blockcheck();
34:
35: struct part {
36: struct part *next; /* forward link of partitions on disk */
37: char *name; /* device name */
38: char *fsname; /* mounted filesystem name */
39: long auxdata; /* auxillary data for application */
40: } *badlist, **badnext = &badlist;
41:
42: struct disk {
43: char *name; /* disk base name */
44: struct disk *next; /* forward link for list of disks */
45: struct part *part; /* head of list of partitions on disk */
46: int pid; /* If != 0, pid of proc working on */
47: } *disks;
48:
49: int nrun, ndisks;
50: char hotroot;
51:
52: checkfstab(preen, maxrun, docheck, chkit)
53: int preen, maxrun;
54: int (*docheck)(), (*chkit)();
55: {
56: register struct fstab *fsp;
57: register struct disk *dk, *nextdisk;
58: register struct part *pt;
59: int ret, pid, retcode, passno, sumstatus, status;
60: long auxdata;
61: char *name;
62:
63: sumstatus = 0;
64: for (passno = 1; passno <= 2; passno++) {
65: if (setfsent() == 0) {
66: fprintf(stderr, "Can't open checklist file: %s\n",
67: _PATH_FSTAB);
68: return (8);
69: }
70: while ((fsp = getfsent()) != 0) {
71: if ((auxdata = (*docheck)(fsp)) == 0)
72: continue;
73: if (preen == 0 || passno == 1 && fsp->fs_passno == 1) {
74: if (name = blockcheck(fsp->fs_spec)) {
75: if (sumstatus = (*chkit)(name,
76: fsp->fs_file, auxdata))
77: return (sumstatus);
78: } else if (preen)
79: return (8);
80: } else if (passno == 2 && fsp->fs_passno > 1) {
81: if ((name = blockcheck(fsp->fs_spec)) == NULL) {
82: fprintf(stderr, "BAD DISK NAME %s\n",
83: fsp->fs_spec);
84: sumstatus |= 8;
85: continue;
86: }
87: addpart(name, fsp->fs_file, auxdata);
88: }
89: }
90: if (preen == 0)
91: return (0);
92: }
93: if (preen) {
94: if (maxrun == 0)
95: maxrun = ndisks;
96: if (maxrun > ndisks)
97: maxrun = ndisks;
98: nextdisk = disks;
99: for (passno = 0; passno < maxrun; ++passno) {
100: while (ret = startdisk(nextdisk, chkit) && nrun > 0)
101: sleep(10);
102: if (ret)
103: return (ret);
104: nextdisk = nextdisk->next;
105: }
106: while ((pid = wait(&status)) != -1) {
107: for (dk = disks; dk; dk = dk->next)
108: if (dk->pid == pid)
109: break;
110: if (dk == 0) {
111: printf("Unknown pid %d\n", pid);
112: continue;
113: }
114: if (WIFEXITED(status))
115: retcode = WEXITSTATUS(status);
116: else
117: retcode = 0;
118: if (WIFSIGNALED(status)) {
119: printf("%s (%s): EXITED WITH SIGNAL %d\n",
120: dk->part->name, dk->part->fsname,
121: WTERMSIG(status));
122: retcode = 8;
123: }
124: if (retcode != 0) {
125: sumstatus |= retcode;
126: *badnext = dk->part;
127: badnext = &dk->part->next;
128: dk->part = dk->part->next;
129: *badnext = NULL;
130: } else
131: dk->part = dk->part->next;
132: dk->pid = 0;
133: nrun--;
134: if (dk->part == NULL)
135: ndisks--;
136:
137: if (nextdisk == NULL) {
138: if (dk->part) {
139: while (ret = startdisk(dk, chkit) &&
140: nrun > 0)
141: sleep(10);
142: if (ret)
143: return (ret);
144: }
145: } else if (nrun < maxrun && nrun < ndisks) {
146: for ( ;; ) {
147: if ((nextdisk = nextdisk->next) == NULL)
148: nextdisk = disks;
149: if (nextdisk->part != NULL &&
150: nextdisk->pid == 0)
151: break;
152: }
153: while (ret = startdisk(nextdisk, chkit) &&
154: nrun > 0)
155: sleep(10);
156: if (ret)
157: return (ret);
158: }
159: }
160: }
161: if (sumstatus) {
162: if (badlist == 0)
163: return (sumstatus);
164: fprintf(stderr, "THE FOLLOWING FILE SYSTEM%s HAD AN %s\n\t",
165: badlist->next ? "S" : "", "UNEXPECTED INCONSISTENCY:");
166: for (pt = badlist; pt; pt = pt->next)
167: fprintf(stderr, "%s (%s)%s", pt->name, pt->fsname,
168: pt->next ? ", " : "\n");
169: return (sumstatus);
170: }
171: (void)endfsent();
172: return (0);
173: }
174:
175: struct disk *
176: finddisk(name)
177: char *name;
178: {
179: register struct disk *dk, **dkp;
180: register char *p;
181: size_t len;
182:
183: for (p = name + strlen(name) - 1; p >= name; --p)
184: if (isdigit(*p)) {
185: len = p - name + 1;
186: break;
187: }
188: if (p < name)
189: len = strlen(name);
190:
191: for (dk = disks, dkp = &disks; dk; dkp = &dk->next, dk = dk->next) {
192: if (strncmp(dk->name, name, len) == 0 &&
193: dk->name[len] == 0)
194: return (dk);
195: }
196: if ((*dkp = (struct disk *)malloc(sizeof(struct disk))) == NULL) {
197: fprintf(stderr, "out of memory");
198: exit (8);
199: }
200: dk = *dkp;
201: if ((dk->name = malloc(len + 1)) == NULL) {
202: fprintf(stderr, "out of memory");
203: exit (8);
204: }
205: (void)strncpy(dk->name, name, len);
206: dk->name[len] = '\0';
207: dk->part = NULL;
208: dk->next = NULL;
209: dk->pid = 0;
210: ndisks++;
211: return (dk);
212: }
213:
214: addpart(name, fsname, auxdata)
215: char *name, *fsname;
216: long auxdata;
217: {
218: struct disk *dk = finddisk(name);
219: register struct part *pt, **ppt = &dk->part;
220:
221: for (pt = dk->part; pt; ppt = &pt->next, pt = pt->next)
222: if (strcmp(pt->name, name) == 0) {
223: printf("%s in fstab more than once!\n", name);
224: return;
225: }
226: if ((*ppt = (struct part *)malloc(sizeof(struct part))) == NULL) {
227: fprintf(stderr, "out of memory");
228: exit (8);
229: }
230: pt = *ppt;
231: if ((pt->name = malloc(strlen(name) + 1)) == NULL) {
232: fprintf(stderr, "out of memory");
233: exit (8);
234: }
235: (void)strcpy(pt->name, name);
236: if ((pt->fsname = malloc(strlen(fsname) + 1)) == NULL) {
237: fprintf(stderr, "out of memory");
238: exit (8);
239: }
240: (void)strcpy(pt->fsname, fsname);
241: pt->next = NULL;
242: pt->auxdata = auxdata;
243: }
244:
245: startdisk(dk, checkit)
246: register struct disk *dk;
247: int (*checkit)();
248: {
249: register struct part *pt = dk->part;
250:
251: dk->pid = fork();
252: if (dk->pid < 0) {
253: perror("fork");
254: return (8);
255: }
256: if (dk->pid == 0)
257: exit((*checkit)(pt->name, pt->fsname, pt->auxdata));
258: nrun++;
259: return (0);
260: }
261:
262: char *
263: blockcheck(name)
264: char *name;
265: {
266: struct stat stslash, stblock, stchar;
267: char *raw;
268: int retried = 0;
269:
270: hotroot = 0;
271: if (stat("/", &stslash) < 0) {
272: perror("/");
273: printf("Can't stat root\n");
274: return (0);
275: }
276: retry:
277: if (stat(name, &stblock) < 0) {
278: perror(name);
279: printf("Can't stat %s\n", name);
280: return (0);
281: }
282: if ((stblock.st_mode & S_IFMT) == S_IFBLK) {
283: if (stslash.st_dev == stblock.st_rdev)
284: hotroot++;
285: raw = rawname(name);
286: if (stat(raw, &stchar) < 0) {
287: perror(raw);
288: printf("Can't stat %s\n", raw);
289: return (name);
290: }
291: if ((stchar.st_mode & S_IFMT) == S_IFCHR) {
292: return (raw);
293: } else {
294: printf("%s is not a character device\n", raw);
295: return (name);
296: }
297: } else if ((stblock.st_mode & S_IFMT) == S_IFCHR && !retried) {
298: name = unrawname(name);
299: retried++;
300: goto retry;
301: }
302: printf("Can't make sense out of name %s\n", name);
303: return (0);
304: }
305:
306: char *
307: unrawname(name)
308: char *name;
309: {
310: char *dp;
311: struct stat stb;
312:
313: if ((dp = rindex(name, '/')) == 0)
314: return (name);
315: if (stat(name, &stb) < 0)
316: return (name);
317: if ((stb.st_mode & S_IFMT) != S_IFCHR)
318: return (name);
319: if (*(dp + 1) != 'r')
320: return (name);
321: (void)strcpy(dp + 1, dp + 2);
322: return (name);
323: }
324:
325: char *
326: rawname(name)
327: char *name;
328: {
329: static char rawbuf[32];
330: char *dp;
331:
332: if ((dp = rindex(name, '/')) == 0)
333: return (0);
334: *dp = 0;
335: (void)strcpy(rawbuf, name);
336: *dp = '/';
337: (void)strcat(rawbuf, "/r");
338: (void)strcat(rawbuf, dp + 1);
339: return (rawbuf);
340: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.