1 /*
2 * Copyright (c) 1998, 2010, Oracle and/or its affiliates. All rights reserved.
3 */
4
5 /* Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T */
6 /* All Rights Reserved */
7
8 /*
9 * Copyright (c) 1980, 1986, 1990 The Regents of the University of California.
10 * All rights reserved.
11 *
12 * Redistribution and use in source and binary forms are permitted
13 * provided that: (1) source distributions retain this entire copyright
14 * notice and comment, and (2) distributions including binaries display
15 * the following acknowledgement: ``This product includes software
16 * developed by the University of California, Berkeley and its contributors''
17 * in the documentation or other materials provided with the distribution
18 * and in all advertising materials mentioning features or use of this
19 * software. Neither the name of the University nor the names of its
20 * contributors may be used to endorse or promote products derived
21 * from this software without specific prior written permission.
22 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
23 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
24 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
25 */
26
27 #include <stdio.h>
28 #include <fcntl.h>
29 #include <errno.h>
30 #include <unistd.h>
31 #include <stdlib.h>
32 #include <stdarg.h>
33 #include <fcntl.h>
34 #include <string.h>
35 #include <strings.h>
36 #include <ctype.h>
37 #include <malloc.h>
38 #include <signal.h>
39 #include <sys/param.h>
40 #include <sys/types.h>
41 #include <sys/mntent.h>
42 #include <sys/filio.h>
43 #include <sys/vnode.h>
44 #include <sys/mnttab.h>
45 #include <sys/types.h>
46 #include <sys/stat.h>
47 #include <sys/vfstab.h>
48 #include <sys/sysmacros.h>
49 #include <sys/fs/udf_volume.h>
50 #include "fsck.h"
51 #include <sys/lockfs.h>
52 #include <locale.h>
53
54 extern int32_t verifytag(struct tag *, uint32_t, struct tag *, int);
55 extern char *tagerrs[];
56 extern void maketag(struct tag *, struct tag *);
57 extern char *hasvfsopt(struct vfstab *, char *);
58 static struct bufarea *getdatablk(daddr_t, long);
59 static struct bufarea *getblk(struct bufarea *, daddr_t, long);
60
61 void flush(int32_t, struct bufarea *);
62 int32_t bread(int32_t, char *, daddr_t, long);
63 void bwrite(int, char *, daddr_t, long);
64 static int32_t getaline(FILE *, char *, int32_t);
65 void errexit(char *, ...) __NORETURN;
66 static long diskreads, totalreads; /* Disk cache statistics */
67 offset_t llseek();
68 extern unsigned int largefile_count;
69
70 /*
71 * An unexpected inconsistency occured.
72 * Die if preening, otherwise just print message and continue.
73 */
74 /* VARARGS1 */
75 void
pfatal(char * fmt,...)76 pfatal(char *fmt, ...)
77 {
78 va_list args;
79 va_start(args, fmt);
80 if (preen) {
81 (void) printf("%s: ", devname);
82 (void) vprintf(fmt, args);
83 (void) printf("\n");
84 (void) printf(
85 gettext("%s: UNEXPECTED INCONSISTENCY; RUN fsck "
86 "MANUALLY.\n"), devname);
87 va_end(args);
88 exit(36);
89 }
90 (void) vprintf(fmt, args);
91 va_end(args);
92 }
93
94 /*
95 * Pwarn just prints a message when not preening,
96 * or a warning (preceded by filename) when preening.
97 */
98 /* VARARGS1 */
99 void
pwarn(char * fmt,...)100 pwarn(char *fmt, ...)
101 {
102 va_list args;
103 va_start(args, fmt);
104 if (preen)
105 (void) printf("%s: ", devname);
106 (void) vprintf(fmt, args);
107 va_end(args);
108 }
109
110
111 /* VARARGS1 */
112 void
errexit(char * fmt,...)113 errexit(char *fmt, ...)
114 {
115 va_list args;
116 va_start(args, fmt);
117 (void) vprintf(fmt, args);
118 va_end(args);
119 exit(39);
120 }
121
122 void
markbusy(daddr_t block,long count)123 markbusy(daddr_t block, long count)
124 {
125 register int i;
126
127 count = roundup(count, secsize) / secsize;
128 for (i = 0; i < count; i++, block++) {
129 if ((unsigned)block > part_len) {
130 pwarn(gettext("Block %lx out of range\n"), block);
131 break;
132 }
133 if (testbusy(block))
134 pwarn(gettext("Dup block %lx\n"), block);
135 else {
136 n_blks++;
137 setbusy(block);
138 }
139 }
140 }
141
142 void
printfree()143 printfree()
144 {
145 int i, startfree, endfree;
146
147 startfree = -1;
148 for (i = 0; i < part_len; i++) {
149 if (!testbusy(i)) {
150 if (startfree <= 0)
151 startfree = i;
152 endfree = i;
153 } else if (startfree >= 0) {
154 (void) printf("free: %x-%x\n", startfree, endfree - 1);
155 startfree = -1;
156 }
157 }
158 if (startfree >= 0) {
159 (void) printf("free: %x-%x\n", startfree, endfree);
160 }
161 }
162
163 struct bufarea *
getfilentry(uint32_t block,int len)164 getfilentry(uint32_t block, int len)
165 {
166 struct bufarea *bp;
167 struct file_entry *fp;
168 int err;
169
170 if (len > fsbsize) {
171 (void) printf(gettext("File entry at %x is too long "
172 "(%d bytes)\n"), block, len);
173 len = fsbsize;
174 }
175 bp = getdatablk((daddr_t)(block + part_start), fsbsize);
176 if (bp->b_errs) {
177 bp->b_flags &= ~B_INUSE;
178 return (NULL);
179 }
180 /* LINTED */
181 fp = (struct file_entry *)bp->b_un.b_buf;
182 err = verifytag(&fp->fe_tag, block, &fp->fe_tag, UD_FILE_ENTRY);
183 if (err) {
184 (void) printf(gettext("Tag error %s or bad file entry, "
185 "tag=%d\n"), tagerrs[err], fp->fe_tag.tag_id);
186 bp->b_flags &= ~B_INUSE;
187 return (NULL);
188 }
189 return (bp);
190 }
191
192 void
putfilentry(struct bufarea * bp)193 putfilentry(struct bufarea *bp)
194 {
195 struct file_entry *fp;
196
197 /* LINTED */
198 fp = (struct file_entry *)bp->b_un.b_buf;
199 maketag(&fp->fe_tag, &fp->fe_tag);
200 }
201
202
203 int32_t
reply(char * question)204 reply(char *question)
205 {
206 char line[80];
207
208 if (preen)
209 pfatal(gettext("INTERNAL ERROR: GOT TO reply()"));
210 (void) printf("\n%s? ", question);
211 if (nflag || fswritefd < 0) {
212 (void) printf(gettext(" no\n\n"));
213 iscorrupt = 1; /* known to be corrupt */
214 return (0);
215 }
216 if (yflag) {
217 (void) printf(gettext(" yes\n\n"));
218 return (1);
219 }
220 if (getaline(stdin, line, sizeof (line)) == EOF)
221 errexit("\n");
222 (void) printf("\n");
223 if (line[0] == 'y' || line[0] == 'Y')
224 return (1);
225 else {
226 iscorrupt = 1; /* known to be corrupt */
227 return (0);
228 }
229 }
230
231 int32_t
getaline(FILE * fp,char * loc,int32_t maxlen)232 getaline(FILE *fp, char *loc, int32_t maxlen)
233 {
234 int n;
235 register char *p, *lastloc;
236
237 p = loc;
238 lastloc = &p[maxlen-1];
239 while ((n = getc(fp)) != '\n') {
240 if (n == EOF)
241 return (EOF);
242 if (!isspace(n) && p < lastloc)
243 *p++ = n;
244 }
245 *p = 0;
246 return (p - loc);
247 }
248 /*
249 * Malloc buffers and set up cache.
250 */
251 void
bufinit()252 bufinit()
253 {
254 register struct bufarea *bp;
255 long bufcnt, i;
256 char *bufp;
257
258 bufp = malloc((unsigned int)fsbsize);
259 if (bufp == 0)
260 errexit(gettext("cannot allocate buffer pool\n"));
261 bufhead.b_next = bufhead.b_prev = &bufhead;
262 bufcnt = MAXBUFSPACE / fsbsize;
263 if (bufcnt < MINBUFS)
264 bufcnt = MINBUFS;
265 for (i = 0; i < bufcnt; i++) {
266 bp = (struct bufarea *)malloc(sizeof (struct bufarea));
267 bufp = malloc((unsigned int)fsbsize);
268 if (bp == NULL || bufp == NULL) {
269 if (i >= MINBUFS)
270 break;
271 errexit(gettext("cannot allocate buffer pool\n"));
272 }
273 bp->b_un.b_buf = bufp;
274 bp->b_prev = &bufhead;
275 bp->b_next = bufhead.b_next;
276 bufhead.b_next->b_prev = bp;
277 bufhead.b_next = bp;
278 initbarea(bp);
279 }
280 bufhead.b_size = i; /* save number of buffers */
281 pbp = pdirbp = NULL;
282 }
283
284 /*
285 * Manage a cache of directory blocks.
286 */
287 static struct bufarea *
getdatablk(daddr_t blkno,long size)288 getdatablk(daddr_t blkno, long size)
289 {
290 register struct bufarea *bp;
291
292 for (bp = bufhead.b_next; bp != &bufhead; bp = bp->b_next)
293 if (bp->b_bno == fsbtodb(blkno))
294 goto foundit;
295 for (bp = bufhead.b_prev; bp != &bufhead; bp = bp->b_prev)
296 if ((bp->b_flags & B_INUSE) == 0)
297 break;
298 if (bp == &bufhead)
299 errexit(gettext("deadlocked buffer pool\n"));
300 (void) getblk(bp, blkno, size);
301 /* fall through */
302 foundit:
303 totalreads++;
304 bp->b_prev->b_next = bp->b_next;
305 bp->b_next->b_prev = bp->b_prev;
306 bp->b_prev = &bufhead;
307 bp->b_next = bufhead.b_next;
308 bufhead.b_next->b_prev = bp;
309 bufhead.b_next = bp;
310 bp->b_flags |= B_INUSE;
311 return (bp);
312 }
313
314 static struct bufarea *
getblk(struct bufarea * bp,daddr_t blk,long size)315 getblk(struct bufarea *bp, daddr_t blk, long size)
316 {
317 daddr_t dblk;
318
319 dblk = fsbtodb(blk);
320 if (bp->b_bno == dblk)
321 return (bp);
322 flush(fswritefd, bp);
323 diskreads++;
324 bp->b_errs = bread(fsreadfd, bp->b_un.b_buf, dblk, size);
325 bp->b_bno = dblk;
326 bp->b_size = size;
327 return (bp);
328 }
329
330 void
flush(int32_t fd,struct bufarea * bp)331 flush(int32_t fd, struct bufarea *bp)
332 {
333 if (!bp->b_dirty)
334 return;
335 if (bp->b_errs != 0)
336 pfatal(gettext("WRITING ZERO'ED BLOCK %d TO DISK\n"),
337 bp->b_bno);
338 bp->b_dirty = 0;
339 bp->b_errs = 0;
340 bwrite(fd, bp->b_un.b_buf, bp->b_bno, (long)bp->b_size);
341 }
342
343 static void
rwerror(char * mesg,daddr_t blk)344 rwerror(char *mesg, daddr_t blk)
345 {
346
347 if (preen == 0)
348 (void) printf("\n");
349 pfatal(gettext("CANNOT %s: BLK %ld"), mesg, blk);
350 if (reply(gettext("CONTINUE")) == 0)
351 errexit(gettext("Program terminated\n"));
352 }
353
354 void
ckfini()355 ckfini()
356 {
357 struct bufarea *bp, *nbp;
358 int cnt = 0;
359
360 for (bp = bufhead.b_prev; bp && bp != &bufhead; bp = nbp) {
361 cnt++;
362 flush(fswritefd, bp);
363 nbp = bp->b_prev;
364 free(bp->b_un.b_buf);
365 free((char *)bp);
366 }
367 pbp = pdirbp = NULL;
368 if (bufhead.b_size != cnt)
369 errexit(gettext("Panic: lost %d buffers\n"),
370 bufhead.b_size - cnt);
371 if (debug)
372 (void) printf("cache missed %ld of %ld (%ld%%)\n",
373 diskreads, totalreads,
374 totalreads ? diskreads * 100 / totalreads : 0);
375 (void) close(fsreadfd);
376 (void) close(fswritefd);
377 }
378
379 int32_t
bread(int fd,char * buf,daddr_t blk,long size)380 bread(int fd, char *buf, daddr_t blk, long size)
381 {
382 char *cp;
383 int i, errs;
384 offset_t offset = ldbtob(blk);
385 offset_t addr;
386
387 if (llseek(fd, offset, 0) < 0)
388 rwerror(gettext("SEEK"), blk);
389 else if (read(fd, buf, (int)size) == size)
390 return (0);
391 rwerror(gettext("READ"), blk);
392 if (llseek(fd, offset, 0) < 0)
393 rwerror(gettext("SEEK"), blk);
394 errs = 0;
395 bzero(buf, (int)size);
396 pwarn(gettext("THE FOLLOWING SECTORS COULD NOT BE READ:"));
397 for (cp = buf, i = 0; i < btodb(size); i++, cp += DEV_BSIZE) {
398 addr = ldbtob(blk + i);
399 if (llseek(fd, addr, SEEK_CUR) < 0 ||
400 read(fd, cp, (int)secsize) < 0) {
401 (void) printf(" %ld", blk + i);
402 errs++;
403 }
404 }
405 (void) printf("\n");
406 return (errs);
407 }
408
409 void
bwrite(int fd,char * buf,daddr_t blk,long size)410 bwrite(int fd, char *buf, daddr_t blk, long size)
411 {
412 int i, n;
413 char *cp;
414 offset_t offset = ldbtob(blk);
415 offset_t addr;
416
417 if (fd < 0)
418 return;
419 if (llseek(fd, offset, 0) < 0)
420 rwerror(gettext("SEEK"), blk);
421 else if (write(fd, buf, (int)size) == size) {
422 fsmodified = 1;
423 return;
424 }
425 rwerror(gettext("WRITE"), blk);
426 if (llseek(fd, offset, 0) < 0)
427 rwerror(gettext("SEEK"), blk);
428 pwarn(gettext("THE FOLLOWING SECTORS COULD NOT BE WRITTEN:"));
429 for (cp = buf, i = 0; i < btodb(size); i++, cp += DEV_BSIZE) {
430 n = 0;
431 addr = ldbtob(blk + i);
432 if (llseek(fd, addr, SEEK_CUR) < 0 ||
433 (n = write(fd, cp, DEV_BSIZE)) < 0) {
434 (void) printf(" %ld", blk + i);
435 } else if (n > 0) {
436 fsmodified = 1;
437 }
438
439 }
440 (void) printf("\n");
441 }
442
443 void
catch()444 catch()
445 {
446 ckfini();
447 exit(37);
448 }
449
450 /*
451 * When preening, allow a single quit to signal
452 * a special exit after filesystem checks complete
453 * so that reboot sequence may be interrupted.
454 */
455 void
catchquit()456 catchquit()
457 {
458 extern int returntosingle;
459
460 (void) printf(gettext("returning to single-user after filesystem "
461 "check\n"));
462 returntosingle = 1;
463 (void) signal(SIGQUIT, SIG_DFL);
464 }
465
466 /*
467 * determine whether an inode should be fixed.
468 */
469 /* ARGSUSED1 */
470 int32_t
dofix(struct inodesc * idesc,char * msg)471 dofix(struct inodesc *idesc, char *msg)
472 {
473
474 switch (idesc->id_fix) {
475
476 case DONTKNOW:
477 pwarn(msg);
478 if (preen) {
479 (void) printf(gettext(" (SALVAGED)\n"));
480 idesc->id_fix = FIX;
481 return (ALTERED);
482 }
483 if (reply(gettext("SALVAGE")) == 0) {
484 idesc->id_fix = NOFIX;
485 return (0);
486 }
487 idesc->id_fix = FIX;
488 return (ALTERED);
489
490 case FIX:
491 return (ALTERED);
492
493 case NOFIX:
494 return (0);
495
496 default:
497 errexit(gettext("UNKNOWN INODESC FIX MODE %d\n"),
498 idesc->id_fix);
499 }
500 /* NOTREACHED */
501 }
502
503 /*
504 * Check to see if unraw version of name is already mounted.
505 * Since we do not believe /etc/mnttab, we stat the mount point
506 * to see if it is really looks mounted.
507 */
508 int
mounted(char * name)509 mounted(char *name)
510 {
511 int found = 0;
512 struct mnttab mnt;
513 FILE *mnttab;
514 struct stat device_stat, mount_stat;
515 char *blkname, *unrawname();
516 int err;
517
518 mnttab = fopen(MNTTAB, "r");
519 if (mnttab == NULL) {
520 (void) printf(gettext("can't open %s\n"), MNTTAB);
521 return (0);
522 }
523 blkname = unrawname(name);
524 while ((getmntent(mnttab, &mnt)) == NULL) {
525 if (strcmp(mnt.mnt_fstype, MNTTYPE_UDFS) != 0) {
526 continue;
527 }
528 if (strcmp(blkname, mnt.mnt_special) == 0) {
529 err = stat(mnt.mnt_mountp, &mount_stat);
530 err |= stat(mnt.mnt_special, &device_stat);
531 if (err < 0)
532 continue;
533 if (device_stat.st_rdev == mount_stat.st_dev) {
534 (void) strncpy(mnt.mnt_mountp, mountpoint,
535 sizeof (mountpoint));
536 if (hasmntopt(&mnt, MNTOPT_RO) != 0)
537 found = 2; /* mounted as RO */
538 else
539 found = 1; /* mounted as R/W */
540 }
541 break;
542 }
543 }
544 (void) fclose(mnttab);
545 return (found);
546 }
547
548 /*
549 * Check to see if name corresponds to an entry in vfstab, and that the entry
550 * does not have option ro.
551 */
552 int
writable(char * name)553 writable(char *name)
554 {
555 int rw = 1;
556 struct vfstab vfsbuf;
557 FILE *vfstab;
558 char *blkname, *unrawname();
559
560 vfstab = fopen(VFSTAB, "r");
561 if (vfstab == NULL) {
562 (void) printf(gettext("can't open %s\n"), VFSTAB);
563 return (1);
564 }
565 blkname = unrawname(name);
566 if ((getvfsspec(vfstab, &vfsbuf, blkname) == 0) &&
567 (vfsbuf.vfs_fstype != NULL) &&
568 (strcmp(vfsbuf.vfs_fstype, MNTTYPE_UDFS) == 0) &&
569 (hasvfsopt(&vfsbuf, MNTOPT_RO))) {
570 rw = 0;
571 }
572 (void) fclose(vfstab);
573 return (rw);
574 }
575
576 /*
577 * print out clean info
578 */
579 void
printclean()580 printclean()
581 {
582 char *s;
583
584 switch (lvintp->lvid_int_type) {
585
586 case LVI_CLOSE:
587 s = gettext("clean");
588 break;
589
590 case LVI_OPEN:
591 s = gettext("active");
592 break;
593
594 default:
595 s = gettext("unknown");
596 }
597
598 if (preen)
599 pwarn(gettext("is %s.\n"), s);
600 else
601 (void) printf("** %s is %s.\n", devname, s);
602 }
603