sbin/fsck/utilities.c

   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
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. Neither the name of the University nor the names of its contributors
  14  *    may be used to endorse or promote products derived from this software
  15  *    without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  *
  29  * @(#)utilities.c      8.6 (Berkeley) 5/19/95
  30  * $FreeBSD: src/sbin/fsck/utilities.c,v 1.11.2.3 2001/01/23 23:11:07 iedowse Exp $
  31  */
  32
  33 #include <sys/param.h>
  34
  35 #include <vfs/ufs/dinode.h>
  36 #include <vfs/ufs/dir.h>
  37 #include <vfs/ufs/fs.h>
  38
  39 #include <err.h>
  40 #include <string.h>
  41
  42 #include "fsck.h"
  43
  44 long    diskreads, totalreads;  /* Disk cache statistics */
  45
  46 static void rwerror(char *mesg, ufs_daddr_t blk);
  47
  48 int
  49 ftypeok(struct ufs1_dinode *dp)
  50 {
  51         switch (dp->di_mode & IFMT) {
  52
  53         case IFDIR:
  54         case IFREG:
  55         case IFBLK:
  56         case IFCHR:
  57         case IFLNK:
  58         case IFSOCK:
  59         case IFIFO:
  60                 return (1);
  61
  62         default:
  63                 if (debug)
  64                         printf("bad file type 0%o\n", dp->di_mode);
  65                 return (0);
  66         }
  67 }
  68
  69 int
  70 reply(char *question)
  71 {
  72         int persevere;
  73         char c;
  74
  75         if (preen)
  76                 pfatal("INTERNAL ERROR: GOT TO reply()");
  77         persevere = !strcmp(question, "CONTINUE");
  78         printf("\n");
  79         if (!persevere && (nflag || fswritefd < 0)) {
  80                 printf("%s? no\n\n", question);
  81                 resolved = 0;
  82                 return (0);
  83         }
  84         if (yflag || (persevere && nflag)) {
  85                 printf("%s? yes\n\n", question);
  86                 return (1);
  87         }
  88         do      {
  89                 printf("%s? [yn] ", question);
  90                 fflush(stdout);
  91                 c = getc(stdin);
  92                 while (c != '\n' && getc(stdin) != '\n') {
  93                         if (feof(stdin)) {
  94                                 resolved = 0;
  95                                 return (0);
  96                         }
  97                 }
  98         } while (c != 'y' && c != 'Y' && c != 'n' && c != 'N');
  99         printf("\n");
 100         if (c == 'y' || c == 'Y')
 101                 return (1);
 102         resolved = 0;
 103         return (0);
 104 }
 105
 106 /*
 107  * Look up state information for an inode.
 108  */
 109 struct inostat *
 110 inoinfo(ufs1_ino_t inum)
 111 {
 112         static struct inostat unallocated = { USTATE, 0, 0 };
 113         struct inostatlist *ilp;
 114         int iloff;
 115
 116         if (inum > maxino)
 117                 errx(EEXIT, "inoinfo: inumber %d out of range", inum);
 118         ilp = &inostathead[inum / sblock.fs_ipg];
 119         iloff = inum % sblock.fs_ipg;
 120         if (iloff >= ilp->il_numalloced)
 121                 return (&unallocated);
 122         return (&ilp->il_stat[iloff]);
 123 }
 124
 125 /*
 126  * Malloc buffers and set up cache.
 127  */
 128 void
 129 bufinit(void)
 130 {
 131         struct bufarea *bp;
 132         long bufcnt, i;
 133         char *bufp;
 134
 135         pbp = pdirbp = NULL;
 136         bufp = malloc((unsigned int)sblock.fs_bsize);
 137         if (bufp == NULL)
 138                 errx(EEXIT, "cannot allocate buffer pool");
 139         cgblk.b_un.b_buf = bufp;
 140         initbarea(&cgblk);
 141         bufhead.b_next = bufhead.b_prev = &bufhead;
 142         bufcnt = MAXBUFSPACE / sblock.fs_bsize;
 143         if (bufcnt < MINBUFS)
 144                 bufcnt = MINBUFS;
 145         for (i = 0; i < bufcnt; i++) {
 146                 bp = (struct bufarea *)malloc(sizeof(struct bufarea));
 147                 bufp = malloc((unsigned int)sblock.fs_bsize);
 148                 if (bp == NULL || bufp == NULL) {
 149                         if (i >= MINBUFS)
 150                                 break;
 151                         errx(EEXIT, "cannot allocate buffer pool");
 152                 }
 153                 bp->b_un.b_buf = bufp;
 154                 bp->b_prev = &bufhead;
 155                 bp->b_next = bufhead.b_next;
 156                 bufhead.b_next->b_prev = bp;
 157                 bufhead.b_next = bp;
 158                 initbarea(bp);
 159         }
 160         bufhead.b_size = i;     /* save number of buffers */
 161 }
 162
 163 /*
 164  * Manage a cache of directory blocks.
 165  */
 166 struct bufarea *
 167 getdatablk(ufs_daddr_t blkno, long size)
 168 {
 169         struct bufarea *bp;
 170
 171         for (bp = bufhead.b_next; bp != &bufhead; bp = bp->b_next)
 172                 if (bp->b_bno == fsbtodb(&sblock, blkno))
 173                         goto foundit;
 174         for (bp = bufhead.b_prev; bp != &bufhead; bp = bp->b_prev)
 175                 if ((bp->b_flags & B_INUSE) == 0)
 176                         break;
 177         if (bp == &bufhead)
 178                 errx(EEXIT, "deadlocked buffer pool");
 179         getblk(bp, blkno, size);
 180         /* fall through */
 181 foundit:
 182         totalreads++;
 183         bp->b_prev->b_next = bp->b_next;
 184         bp->b_next->b_prev = bp->b_prev;
 185         bp->b_prev = &bufhead;
 186         bp->b_next = bufhead.b_next;
 187         bufhead.b_next->b_prev = bp;
 188         bufhead.b_next = bp;
 189         bp->b_flags |= B_INUSE;
 190         return (bp);
 191 }
 192
 193 void
 194 getblk(struct bufarea *bp, ufs_daddr_t blk, long size)
 195 {
 196         ufs_daddr_t dblk;
 197
 198         dblk = fsbtodb(&sblock, blk);
 199         if (bp->b_bno != dblk) {
 200                 flush(fswritefd, bp);
 201                 diskreads++;
 202                 bp->b_errs = bread(fsreadfd, bp->b_un.b_buf, dblk, size);
 203                 bp->b_bno = dblk;
 204                 bp->b_size = size;
 205         }
 206 }
 207
 208 void
 209 flush(int fd, struct bufarea *bp)
 210 {
 211         int i, j;
 212
 213         if (!bp->b_dirty)
 214                 return;
 215         if (bp->b_errs != 0)
 216                 pfatal("WRITING %sZERO'ED BLOCK %d TO DISK\n",
 217                     (bp->b_errs == bp->b_size / dev_bsize) ? "" : "PARTIALLY ",
 218                     bp->b_bno);
 219         bp->b_dirty = 0;
 220         bp->b_errs = 0;
 221         bwrite(fd, bp->b_un.b_buf, bp->b_bno, (long)bp->b_size);
 222         if (bp != &sblk)
 223                 return;
 224         for (i = 0, j = 0; i < sblock.fs_cssize; i += sblock.fs_bsize, j++) {
 225                 bwrite(fswritefd, (char *)sblock.fs_csp + i,
 226                     fsbtodb(&sblock, sblock.fs_csaddr + j * sblock.fs_frag),
 227                     sblock.fs_cssize - i < sblock.fs_bsize ?
 228                     sblock.fs_cssize - i : sblock.fs_bsize);
 229         }
 230 }
 231
 232 static void
 233 rwerror(char *mesg, ufs_daddr_t blk)
 234 {
 235
 236         if (preen == 0)
 237                 printf("\n");
 238         pfatal("CANNOT %s: BLK %d", mesg, blk);
 239         if (reply("CONTINUE") == 0)
 240                 exit(EEXIT);
 241 }
 242
 243 void
 244 ckfini(int markclean)
 245 {
 246         struct bufarea *bp, *nbp;
 247         int ofsmodified, cnt = 0;
 248
 249         if (fswritefd < 0) {
 250                 close(fsreadfd);
 251                 return;
 252         }
 253         flush(fswritefd, &sblk);
 254         if (havesb && sblk.b_bno != SBOFF / dev_bsize &&
 255             !preen && reply("UPDATE STANDARD SUPERBLOCK")) {
 256                 sblk.b_bno = SBOFF / dev_bsize;
 257                 sbdirty();
 258                 flush(fswritefd, &sblk);
 259         }
 260         flush(fswritefd, &cgblk);
 261         free(cgblk.b_un.b_buf);
 262         for (bp = bufhead.b_prev; bp && bp != &bufhead; bp = nbp) {
 263                 cnt++;
 264                 flush(fswritefd, bp);
 265                 nbp = bp->b_prev;
 266                 free(bp->b_un.b_buf);
 267                 free((char *)bp);
 268         }
 269         if (bufhead.b_size != cnt)
 270                 errx(EEXIT, "panic: lost %d buffers", bufhead.b_size - cnt);
 271         pbp = pdirbp = NULL;
 272         if (sblock.fs_clean != markclean) {
 273                 sblock.fs_clean = markclean;
 274                 sbdirty();
 275                 ofsmodified = fsmodified;
 276                 flush(fswritefd, &sblk);
 277                 fsmodified = ofsmodified;
 278                 if (!preen) {
 279                         printf("\n***** FILE SYSTEM MARKED %s *****\n",
 280                             markclean ? "CLEAN" : "DIRTY");
 281                         if (!markclean)
 282                                 rerun = 1;
 283                 }
 284         } else if (!preen && !markclean) {
 285                 printf("\n***** FILE SYSTEM STILL DIRTY *****\n");
 286                 rerun = 1;
 287         }
 288         if (debug)
 289                 printf("cache missed %ld of %ld (%d%%)\n", diskreads,
 290                     totalreads, (int)(diskreads * 100 / totalreads));
 291         close(fsreadfd);
 292         close(fswritefd);
 293 }
 294
 295 int
 296 bread(int fd, char *buf, ufs_daddr_t blk, long size)
 297 {
 298         char *cp;
 299         int i, errs;
 300         off_t offset;
 301
 302         offset = blk;
 303         offset *= dev_bsize;
 304         if (lseek(fd, offset, 0) < 0)
 305                 rwerror("SEEK", blk);
 306         else if (read(fd, buf, (int)size) == size)
 307                 return (0);
 308         rwerror("READ", blk);
 309         if (lseek(fd, offset, 0) < 0)
 310                 rwerror("SEEK", blk);
 311         errs = 0;
 312         memset(buf, 0, (size_t)size);
 313         printf("THE FOLLOWING DISK SECTORS COULD NOT BE READ:");
 314         for (cp = buf, i = 0; i < size; i += secsize, cp += secsize) {
 315                 if (read(fd, cp, (int)secsize) != secsize) {
 316                         lseek(fd, offset + i + secsize, 0);
 317                         if (secsize != dev_bsize && dev_bsize != 1)
 318                                 printf(" %ld (%ld),",
 319                                     (blk * dev_bsize + i) / secsize,
 320                                     blk + i / dev_bsize);
 321                         else
 322                                 printf(" %ld,", blk + i / dev_bsize);
 323                         errs++;
 324                 }
 325         }
 326         printf("\n");
 327         if (errs)
 328                 resolved = 0;
 329         return (errs);
 330 }
 331
 332 void
 333 bwrite(int fd, char *buf, ufs_daddr_t blk, long size)
 334 {
 335         int i;
 336         char *cp;
 337         off_t offset;
 338
 339         if (fd < 0)
 340                 return;
 341         offset = blk;
 342         offset *= dev_bsize;
 343         if (lseek(fd, offset, 0) < 0)
 344                 rwerror("SEEK", blk);
 345         else if (write(fd, buf, (int)size) == size) {
 346                 fsmodified = 1;
 347                 return;
 348         }
 349         resolved = 0;
 350         rwerror("WRITE", blk);
 351         if (lseek(fd, offset, 0) < 0)
 352                 rwerror("SEEK", blk);
 353         printf("THE FOLLOWING SECTORS COULD NOT BE WRITTEN:");
 354         for (cp = buf, i = 0; i < size; i += dev_bsize, cp += dev_bsize)
 355                 if (write(fd, cp, (int)dev_bsize) != dev_bsize) {
 356                         lseek(fd, offset + i + dev_bsize, 0);
 357                         printf(" %ld,", blk + i / dev_bsize);
 358                 }
 359         printf("\n");
 360         return;
 361 }
 362
 363 /*
 364  * allocate a data block with the specified number of fragments
 365  */
 366 ufs_daddr_t
 367 allocblk(long frags)
 368 {
 369         int i, j, k, cg, baseblk;
 370         struct cg *cgp = &cgrp;
 371
 372         if (frags <= 0 || frags > sblock.fs_frag)
 373                 return (0);
 374         for (i = 0; i < maxfsblock - sblock.fs_frag; i += sblock.fs_frag) {
 375                 for (j = 0; j <= sblock.fs_frag - frags; j++) {
 376                         if (testbmap(i + j))
 377                                 continue;
 378                         for (k = 1; k < frags; k++)
 379                                 if (testbmap(i + j + k))
 380                                         break;
 381                         if (k < frags) {
 382                                 j += k;
 383                                 continue;
 384                         }
 385                         cg = dtog(&sblock, i + j);
 386                         getblk(&cgblk, cgtod(&sblock, cg), sblock.fs_cgsize);
 387                         if (!cg_chkmagic(cgp))
 388                                 pfatal("CG %d: BAD MAGIC NUMBER\n", cg);
 389                         baseblk = dtogd(&sblock, i + j);
 390                         for (k = 0; k < frags; k++) {
 391                                 setbmap(i + j + k);
 392                                 clrbit(cg_blksfree(cgp), baseblk + k);
 393                         }
 394                         n_blks += frags;
 395                         if (frags == sblock.fs_frag)
 396                                 cgp->cg_cs.cs_nbfree--;
 397                         else
 398                                 cgp->cg_cs.cs_nffree -= frags;
 399                         cgdirty();
 400                         return (i + j);
 401                 }
 402         }
 403         return (0);
 404 }
 405
 406 /*
 407  * Free a previously allocated block
 408  */
 409 void
 410 freeblk(ufs_daddr_t blkno, long frags)
 411 {
 412         struct inodesc idesc;
 413
 414         idesc.id_blkno = blkno;
 415         idesc.id_numfrags = frags;
 416         pass4check(&idesc);
 417 }
 418
 419 /*
 420  * Find a pathname
 421  */
 422 void
 423 getpathname(char *namebuf, ufs1_ino_t curdir, ufs1_ino_t ino)
 424 {
 425         int len;
 426         char *cp;
 427         struct inodesc idesc;
 428         static int busy = 0;
 429
 430         if (curdir == ino && ino == ROOTINO) {
 431                 strcpy(namebuf, "/");
 432                 return;
 433         }
 434         if (busy ||
 435             (inoinfo(curdir)->ino_state != DSTATE &&
 436              inoinfo(curdir)->ino_state != DFOUND)) {
 437                 strcpy(namebuf, "?");
 438                 return;
 439         }
 440         busy = 1;
 441         memset(&idesc, 0, sizeof(struct inodesc));
 442         idesc.id_type = DATA;
 443         idesc.id_fix = IGNORE;
 444         cp = &namebuf[MAXPATHLEN - 1];
 445         *cp = '\0';
 446         if (curdir != ino) {
 447                 idesc.id_parent = curdir;
 448                 goto namelookup;
 449         }
 450         while (ino != ROOTINO) {
 451                 idesc.id_number = ino;
 452                 idesc.id_func = findino;
 453                 idesc.id_name = "..";
 454                 if ((ckinode(ginode(ino), &idesc) & FOUND) == 0)
 455                         break;
 456         namelookup:
 457                 idesc.id_number = idesc.id_parent;
 458                 idesc.id_parent = ino;
 459                 idesc.id_func = findname;
 460                 idesc.id_name = namebuf;
 461                 if ((ckinode(ginode(idesc.id_number), &idesc)&FOUND) == 0)
 462                         break;
 463                 len = strlen(namebuf);
 464                 cp -= len;
 465                 memmove(cp, namebuf, (size_t)len);
 466                 *--cp = '/';
 467                 if (cp < &namebuf[MAXNAMLEN])
 468                         break;
 469                 ino = idesc.id_number;
 470         }
 471         busy = 0;
 472         if (ino != ROOTINO)
 473                 *--cp = '?';
 474         memmove(namebuf, cp, (size_t)(&namebuf[MAXPATHLEN] - cp));
 475 }
 476
 477 /* ARGSUSED */
 478 void
 479 catch(int sig)
 480 {
 481         if (!doinglevel2)
 482                 ckfini(0);
 483         exit(12);
 484 }
 485
 486 /*
 487  * When preening, allow a single quit to signal
 488  * a special exit after filesystem checks complete
 489  * so that reboot sequence may be interrupted.
 490  */
 491 /* ARGSUSED */
 492 void
 493 catchquit(int sig)
 494 {
 495         printf("returning to single-user after filesystem check\n");
 496         returntosingle = 1;
 497         signal(SIGQUIT, SIG_DFL);
 498 }
 499
 500 /*
 501  * Ignore a single quit signal; wait and flush just in case.
 502  * Used by child processes in preen.
 503  */
 504 /* ARGSUSED */
 505 void
 506 voidquit(int sig)
 507 {
 508
 509         sleep(1);
 510         signal(SIGQUIT, SIG_IGN);
 511         signal(SIGQUIT, SIG_DFL);
 512 }
 513
 514 /* ARGSUSED */
 515 void
 516 infohandler(int sig)
 517 {
 518         got_siginfo = 1;
 519 }
 520
 521 /*
 522  * determine whether an inode should be fixed.
 523  */
 524 int
 525 dofix(struct inodesc *idesc, char *msg)
 526 {
 527
 528         switch (idesc->id_fix) {
 529
 530         case DONTKNOW:
 531                 if (idesc->id_type == DATA)
 532                         direrror(idesc->id_number, msg);
 533                 else
 534                         pwarn("%s", msg);
 535                 if (preen) {
 536                         printf(" (SALVAGED)\n");
 537                         idesc->id_fix = FIX;
 538                         return (ALTERED);
 539                 }
 540                 if (reply("SALVAGE") == 0) {
 541                         idesc->id_fix = NOFIX;
 542                         return (0);
 543                 }
 544                 idesc->id_fix = FIX;
 545                 return (ALTERED);
 546
 547         case FIX:
 548                 return (ALTERED);
 549
 550         case NOFIX:
 551         case IGNORE:
 552                 return (0);
 553
 554         default:
 555                 errx(EEXIT, "UNKNOWN INODESC FIX MODE %d", idesc->id_fix);
 556         }
 557         /* NOTREACHED */
 558         return (0);
 559 }
 560
 561 #include <stdarg.h>
 562
 563 /*
 564  * An unexpected inconsistency occured.
 565  * Die if preening or filesystem is running with soft dependency protocol,
 566  * otherwise just print message and continue.
 567  */
 568 void
 569 pfatal(const char *fmt, ...)
 570 {
 571         va_list ap;
 572         va_start(ap, fmt);
 573         if (!preen) {
 574                 vfprintf(stderr, fmt, ap);
 575                 va_end(ap);
 576                 if (usedsoftdep)
 577                         fprintf(stderr,
 578                             "\nUNEXPECTED SOFT UPDATE INCONSISTENCY\n");
 579                 return;
 580         }
 581         if (cdevname == NULL)
 582                 cdevname = "fsck";
 583         fprintf(stderr, "%s: ", cdevname);
 584         vfprintf(stderr, fmt, ap);
 585         fprintf(stderr,
 586             "\n%s: UNEXPECTED%sINCONSISTENCY; RUN fsck MANUALLY.\n",
 587             cdevname, usedsoftdep ? " SOFT UPDATE " : " ");
 588         ckfini(0);
 589         exit(EEXIT);
 590 }
 591
 592 /*
 593  * Pwarn just prints a message when not preening or running soft dependency
 594  * protocol, or a warning (preceded by filename) when preening.
 595  */
 596 void
 597 pwarn(const char *fmt, ...)
 598 {
 599         va_list ap;
 600         va_start(ap, fmt);
 601         if (preen)
 602                 fprintf(stderr, "%s: ", cdevname);
 603         vfprintf(stderr, fmt, ap);
 604         va_end(ap);
 605 }
 606
 607 /*
 608  * Stub for routines from kernel.
 609  */
 610 void
 611 panic(const char *fmt, ...)
 612 {
 613         va_list ap;
 614
 615         va_start(ap, fmt);
 616         pfatal("INTERNAL INCONSISTENCY:");
 617         vfprintf(stderr, fmt, ap);
 618         va_end(ap);
 619         exit(EEXIT);
 620 }