Deleted Added
sdiff udiff text old ( 18286 ) new ( 23675 )
full compact
1/*
2 * Copyright (c) 1980, 1986, 1993
3 * The Regents of the University of California. All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright

--- 18 unchanged lines hidden (view full) ---

27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31 * SUCH DAMAGE.
32 */
33
34#ifndef lint
35static const char sccsid[] = "@(#)utilities.c 8.1 (Berkeley) 6/5/93";
35static const char sccsid[] = "@(#)utilities.c 8.6 (Berkeley) 5/19/95";
36#endif /* not lint */
37
38#include <sys/param.h>
39#include <sys/time.h>
40
41#include <ufs/ufs/dinode.h>
42#include <ufs/ufs/dir.h>
43#include <ufs/ffs/fs.h>
44#include <stdio.h>
45#include <stdlib.h>
46#include <unistd.h>
47#include <stdarg.h>
48#include <string.h>
49#include <ctype.h>
50#include <err.h>
51
52#include "fsck.h"
53
54long diskreads, totalreads; /* Disk cache statistics */
55
52static void rwerror __P((char *mesg, daddr_t blk));
56static void rwerror __P((char *mesg, ufs_daddr_t blk));
57
58int
59ftypeok(dp)
60 struct dinode *dp;
61{
62 switch (dp->di_mode & IFMT) {
63
64 case IFDIR:

--- 53 unchanged lines hidden (view full) ---

118{
119 register struct bufarea *bp;
120 long bufcnt, i;
121 char *bufp;
122
123 pbp = pdirbp = (struct bufarea *)0;
124 bufp = malloc((unsigned int)sblock.fs_bsize);
125 if (bufp == 0)
122 errexit("cannot allocate buffer pool\n");
126 errx(EEXIT, "cannot allocate buffer pool");
127 cgblk.b_un.b_buf = bufp;
128 initbarea(&cgblk);
129 bufhead.b_next = bufhead.b_prev = &bufhead;
130 bufcnt = MAXBUFSPACE / sblock.fs_bsize;
131 if (bufcnt < MINBUFS)
132 bufcnt = MINBUFS;
133 for (i = 0; i < bufcnt; i++) {
134 bp = (struct bufarea *)malloc(sizeof(struct bufarea));
135 bufp = malloc((unsigned int)sblock.fs_bsize);
136 if (bp == NULL || bufp == NULL) {
137 if (i >= MINBUFS)
138 break;
135 errexit("cannot allocate buffer pool\n");
139 errx(EEXIT, "cannot allocate buffer pool");
140 }
141 bp->b_un.b_buf = bufp;
142 bp->b_prev = &bufhead;
143 bp->b_next = bufhead.b_next;
144 bufhead.b_next->b_prev = bp;
145 bufhead.b_next = bp;
146 initbarea(bp);
147 }
148 bufhead.b_size = i; /* save number of buffers */
149}
150
151/*
152 * Manage a cache of directory blocks.
153 */
154struct bufarea *
155getdatablk(blkno, size)
152 daddr_t blkno;
156 ufs_daddr_t blkno;
157 long size;
158{
159 register struct bufarea *bp;
160
161 for (bp = bufhead.b_next; bp != &bufhead; bp = bp->b_next)
162 if (bp->b_bno == fsbtodb(&sblock, blkno))
163 goto foundit;
164 for (bp = bufhead.b_prev; bp != &bufhead; bp = bp->b_prev)
165 if ((bp->b_flags & B_INUSE) == 0)
166 break;
167 if (bp == &bufhead)
164 errexit("deadlocked buffer pool\n");
168 errx(EEXIT, "deadlocked buffer pool");
169 getblk(bp, blkno, size);
170 /* fall through */
171foundit:
172 totalreads++;
173 bp->b_prev->b_next = bp->b_next;
174 bp->b_next->b_prev = bp->b_prev;
175 bp->b_prev = &bufhead;
176 bp->b_next = bufhead.b_next;
177 bufhead.b_next->b_prev = bp;
178 bufhead.b_next = bp;
179 bp->b_flags |= B_INUSE;
180 return (bp);
181}
182
183void
184getblk(bp, blk, size)
185 register struct bufarea *bp;
182 daddr_t blk;
186 ufs_daddr_t blk;
187 long size;
188{
185 daddr_t dblk;
189 ufs_daddr_t dblk;
190
191 dblk = fsbtodb(&sblock, blk);
192 if (bp->b_bno != dblk) {
193 flush(fswritefd, bp);
194 diskreads++;
195 bp->b_errs = bread(fsreadfd, bp->b_un.b_buf, dblk, size);
196 bp->b_bno = dblk;
197 bp->b_size = size;

--- 21 unchanged lines hidden (view full) ---

219 for (i = 0, j = 0; i < sblock.fs_cssize; i += sblock.fs_bsize, j++) {
220 bwrite(fswritefd, (char *)sblock.fs_csp[j],
221 fsbtodb(&sblock, sblock.fs_csaddr + j * sblock.fs_frag),
222 sblock.fs_cssize - i < sblock.fs_bsize ?
223 sblock.fs_cssize - i : sblock.fs_bsize);
224 }
225}
226
223void
227static void
228rwerror(mesg, blk)
229 char *mesg;
226 daddr_t blk;
230 ufs_daddr_t blk;
231{
232
233 if (preen == 0)
234 printf("\n");
235 pfatal("CANNOT %s: BLK %ld", mesg, blk);
236 if (reply("CONTINUE") == 0)
233 errexit("Program terminated\n");
237 exit(EEXIT);
238}
239
240void
237ckfini()
241ckfini(markclean)
242 int markclean;
243{
244 register struct bufarea *bp, *nbp;
240 int cnt = 0;
245 int ofsmodified, cnt = 0;
246
247 if (fswritefd < 0) {
248 (void)close(fsreadfd);
249 return;
250 }
251 flush(fswritefd, &sblk);
252 if (havesb && sblk.b_bno != SBOFF / dev_bsize &&
253 !preen && reply("UPDATE STANDARD SUPERBLOCK")) {

--- 6 unchanged lines hidden (view full) ---

260 for (bp = bufhead.b_prev; bp && bp != &bufhead; bp = nbp) {
261 cnt++;
262 flush(fswritefd, bp);
263 nbp = bp->b_prev;
264 free(bp->b_un.b_buf);
265 free((char *)bp);
266 }
267 if (bufhead.b_size != cnt)
263 errexit("Panic: lost %d buffers\n", bufhead.b_size - cnt);
268 errx(EEXIT, "Panic: lost %d buffers", bufhead.b_size - cnt);
269 pbp = pdirbp = (struct bufarea *)0;
270 if (markclean && sblock.fs_clean == 0) {
271 sblock.fs_clean = 1;
272 sbdirty();
273 ofsmodified = fsmodified;
274 flush(fswritefd, &sblk);
275 fsmodified = ofsmodified;
276 if (!preen)
277 printf("\n***** FILE SYSTEM MARKED CLEAN *****\n");
278 }
279 if (debug)
280 printf("cache missed %ld of %ld (%d%%)\n", diskreads,
281 totalreads, (int)(diskreads * 100 / totalreads));
282 (void)close(fsreadfd);
283 (void)close(fswritefd);
284}
285
286int
287bread(fd, buf, blk, size)
288 int fd;
289 char *buf;
276 daddr_t blk;
290 ufs_daddr_t blk;
291 long size;
292{
293 char *cp;
294 int i, errs;
295 off_t offset;
296
297 offset = blk;
298 offset *= dev_bsize;
299 if (lseek(fd, offset, 0) < 0)
300 rwerror("SEEK", blk);
301 else if (read(fd, buf, (int)size) == size)
302 return (0);
303 rwerror("READ", blk);
304 if (lseek(fd, offset, 0) < 0)
305 rwerror("SEEK", blk);
306 errs = 0;
293 bzero(buf, (size_t)size);
307 memset(buf, 0, (size_t)size);
308 printf("THE FOLLOWING DISK SECTORS COULD NOT BE READ:");
309 for (cp = buf, i = 0; i < size; i += secsize, cp += secsize) {
310 if (read(fd, cp, (int)secsize) != secsize) {
311 (void)lseek(fd, offset + i + secsize, 0);
312 if (secsize != dev_bsize && dev_bsize != 1)
313 printf(" %ld (%ld),",
314 (blk * dev_bsize + i) / secsize,
315 blk + i / dev_bsize);

--- 5 unchanged lines hidden (view full) ---

321 printf("\n");
322 return (errs);
323}
324
325void
326bwrite(fd, buf, blk, size)
327 int fd;
328 char *buf;
315 daddr_t blk;
329 ufs_daddr_t blk;
330 long size;
331{
332 int i;
333 char *cp;
334 off_t offset;
335
336 if (fd < 0)
337 return;

--- 16 unchanged lines hidden (view full) ---

354 }
355 printf("\n");
356 return;
357}
358
359/*
360 * allocate a data block with the specified number of fragments
361 */
348int
362ufs_daddr_t
363allocblk(frags)
364 long frags;
365{
366 register int i, j, k;
367
368 if (frags <= 0 || frags > sblock.fs_frag)
369 return (0);
370 for (i = 0; i < maxfsblock - sblock.fs_frag; i += sblock.fs_frag) {

--- 16 unchanged lines hidden (view full) ---

387 return (0);
388}
389
390/*
391 * Free a previously allocated block
392 */
393void
394freeblk(blkno, frags)
381 daddr_t blkno;
395 ufs_daddr_t blkno;
396 long frags;
397{
398 struct inodesc idesc;
399
400 idesc.id_blkno = blkno;
401 idesc.id_numfrags = frags;
402 (void)pass4check(&idesc);
403}

--- 16 unchanged lines hidden (view full) ---

420 return;
421 }
422 if (busy ||
423 (statemap[curdir] != DSTATE && statemap[curdir] != DFOUND)) {
424 (void)strcpy(namebuf, "?");
425 return;
426 }
427 busy = 1;
414 bzero((char *)&idesc, sizeof(struct inodesc));
428 memset(&idesc, 0, sizeof(struct inodesc));
429 idesc.id_type = DATA;
430 idesc.id_fix = IGNORE;
431 cp = &namebuf[MAXPATHLEN - 1];
432 *cp = '\0';
433 if (curdir != ino) {
434 idesc.id_parent = curdir;
435 goto namelookup;
436 }

--- 7 unchanged lines hidden (view full) ---

444 idesc.id_number = idesc.id_parent;
445 idesc.id_parent = ino;
446 idesc.id_func = findname;
447 idesc.id_name = namebuf;
448 if ((ckinode(ginode(idesc.id_number), &idesc)&FOUND) == 0)
449 break;
450 len = strlen(namebuf);
451 cp -= len;
438 bcopy(namebuf, cp, (size_t)len);
452 memmove(cp, namebuf, (size_t)len);
453 *--cp = '/';
454 if (cp < &namebuf[MAXNAMLEN])
455 break;
456 ino = idesc.id_number;
457 }
458 busy = 0;
459 if (ino != ROOTINO)
460 *--cp = '?';
447 bcopy(cp, namebuf, (size_t)(&namebuf[MAXPATHLEN] - cp));
461 memmove(namebuf, cp, (size_t)(&namebuf[MAXPATHLEN] - cp));
462}
463
464void
451catch(x)
452 int x;
465catch(sig)
466 int sig;
467{
468 if (!doinglevel2)
455 ckfini();
469 ckfini(0);
470 exit(12);
471}
472
473/*
474 * When preening, allow a single quit to signal
475 * a special exit after filesystem checks complete
476 * so that reboot sequence may be interrupted.
477 */
478void
465catchquit(x)
466 int x;
479catchquit(sig)
480 int sig;
481{
482 printf("returning to single-user after filesystem check\n");
483 returntosingle = 1;
484 (void)signal(SIGQUIT, SIG_DFL);
485}
486
487/*
488 * Ignore a single quit signal; wait and flush just in case.
489 * Used by child processes in preen.
490 */
491void
478voidquit(x)
479 int x;
492voidquit(sig)
493 int sig;
494{
495
496 sleep(1);
497 (void)signal(SIGQUIT, SIG_IGN);
498 (void)signal(SIGQUIT, SIG_DFL);
499}
500
501/*

--- 27 unchanged lines hidden (view full) ---

529 case FIX:
530 return (ALTERED);
531
532 case NOFIX:
533 case IGNORE:
534 return (0);
535
536 default:
523 errexit("UNKNOWN INODESC FIX MODE %d\n", idesc->id_fix);
524 return (0);
537 errx(EEXIT, "UNKNOWN INODESC FIX MODE %d", idesc->id_fix);
538 }
539 /* NOTREACHED */
540 return (0);
541}
542
529/* VARARGS1 */
530void
531errexit(const char *s1, ...)
532{
533 va_list ap;
534 va_start(ap,s1);
535 vfprintf(stdout, s1, ap);
536 va_end(ap);
537 exit(8);
538}
543#if __STDC__
544#include <stdarg.h>
545#else
546#include <varargs.h>
547#endif
548
549/*
550 * An unexpected inconsistency occured.
551 * Die if preening, otherwise just print message and continue.
552 */
544/* VARARGS1 */
553void
546pfatal(const char *s, ...)
554#if __STDC__
555pfatal(const char *fmt, ...)
556#else
557pfatal(fmt, va_alist)
558 char *fmt;
559 va_dcl
560#endif
561{
548
562 va_list ap;
550 va_start(ap,s);
551 if (preen) {
552 printf("%s: ", cdevname);
553 vfprintf(stdout, s, ap);
554 printf("\n");
555 printf("%s: UNEXPECTED INCONSISTENCY; RUN fsck MANUALLY.\n",
556 cdevname);
557 exit(8);
563#if __STDC__
564 va_start(ap, fmt);
565#else
566 va_start(ap);
567#endif
568 if (!preen) {
569 (void)vfprintf(stderr, fmt, ap);
570 va_end(ap);
571 return;
572 }
559 vfprintf(stdout, s, ap);
560 va_end(ap);
573 (void)fprintf(stderr, "%s: ", cdevname);
574 (void)vfprintf(stderr, fmt, ap);
575 (void)fprintf(stderr,
576 "\n%s: UNEXPECTED INCONSISTENCY; RUN fsck MANUALLY.\n",
577 cdevname);
578 exit(EEXIT);
579}
580
581/*
582 * Pwarn just prints a message when not preening,
583 * or a warning (preceded by filename) when preening.
584 */
567/* VARARGS1 */
585void
569pwarn(const char *s, ...)
586#if __STDC__
587pwarn(const char *fmt, ...)
588#else
589pwarn(fmt, va_alist)
590 char *fmt;
591 va_dcl
592#endif
593{
594 va_list ap;
572 va_start(ap,s);
595#if __STDC__
596 va_start(ap, fmt);
597#else
598 va_start(ap);
599#endif
600 if (preen)
574 printf("%s: ", cdevname);
575 vfprintf(stdout, s, ap);
601 (void)fprintf(stderr, "%s: ", cdevname);
602 (void)vfprintf(stderr, fmt, ap);
603 va_end(ap);
604}
605
579#ifndef lint
606/*
607 * Stub for routines from kernel.
608 */
609void
584#ifdef __STDC__
610#if __STDC__
611panic(const char *fmt, ...)
612#else
613panic(fmt, va_alist)
614 char *fmt;
615 va_dcl
616#endif
617{
591
618 va_list ap;
619#if __STDC__
620 va_start(ap, fmt);
621#else
622 va_start(ap);
623#endif
624 pfatal("INTERNAL INCONSISTENCY:");
593 errexit(fmt);
625 (void)vfprintf(stderr, fmt, ap);
626 va_end(ap);
627 exit(EEXIT);
628}
595#endif