1/*	$NetBSD: utilities.c,v 1.21 2010/01/07 01:39:56 christos Exp $	*/
2
3/*
4 * Copyright (c) 1980, 1986, 1993
5 *	The Regents of the University of California.  All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 *    notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 *    notice, this list of conditions and the following disclaimer in the
14 *    documentation and/or other materials provided with the distribution.
15 * 3. Neither the name of the University nor the names of its contributors
16 *    may be used to endorse or promote products derived from this software
17 *    without specific prior written permission.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 * SUCH DAMAGE.
30 */
31
32/*
33 * Copyright (c) 1997 Manuel Bouyer.
34 *
35 * Redistribution and use in source and binary forms, with or without
36 * modification, are permitted provided that the following conditions
37 * are met:
38 * 1. Redistributions of source code must retain the above copyright
39 *    notice, this list of conditions and the following disclaimer.
40 * 2. Redistributions in binary form must reproduce the above copyright
41 *    notice, this list of conditions and the following disclaimer in the
42 *    documentation and/or other materials provided with the distribution.
43 *
44 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
45 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
46 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
47 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
48 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
49 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
50 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
51 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
52 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
53 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
54 */
55
56#include <sys/cdefs.h>
57#ifndef lint
58#if 0
59static char sccsid[] = "@(#)utilities.c	8.1 (Berkeley) 6/5/93";
60#else
61__RCSID("$NetBSD: utilities.c,v 1.21 2010/01/07 01:39:56 christos Exp $");
62#endif
63#endif /* not lint */
64
65#include <sys/param.h>
66#include <sys/time.h>
67#include <ufs/ext2fs/ext2fs_dinode.h>
68#include <ufs/ext2fs/ext2fs_dir.h>
69#include <ufs/ext2fs/ext2fs.h>
70#include <ufs/ufs/dinode.h> /* for IFMT & friends */
71#include <stdio.h>
72#include <stdlib.h>
73#include <errno.h>
74#include <string.h>
75#include <ctype.h>
76#include <unistd.h>
77#include <signal.h>
78
79#include "fsutil.h"
80#include "fsck.h"
81#include "extern.h"
82#include "exitvalues.h"
83
84long	diskreads, totalreads;	/* Disk cache statistics */
85
86static void rwerror(const char *, daddr_t);
87
88int
89ftypeok(struct ext2fs_dinode *dp)
90{
91	switch (fs2h16(dp->e2di_mode) & IFMT) {
92
93	case IFDIR:
94	case IFREG:
95	case IFBLK:
96	case IFCHR:
97	case IFLNK:
98	case IFSOCK:
99	case IFIFO:
100		return (1);
101
102	default:
103		if (debug)
104			printf("bad file type 0%o\n", fs2h16(dp->e2di_mode));
105		return (0);
106	}
107}
108
109int
110reply(const char *question)
111{
112	int persevere;
113	char c;
114
115	if (preen)
116		pfatal("INTERNAL ERROR: GOT TO reply()");
117	persevere = !strcmp(question, "CONTINUE");
118	printf("\n");
119	if (!persevere && (nflag || fswritefd < 0)) {
120		printf("%s? no\n\n", question);
121		return (0);
122	}
123	if (yflag || (persevere && nflag)) {
124		printf("%s? yes\n\n", question);
125		return (1);
126	}
127	do	{
128		printf("%s? [yn] ", question);
129		(void) fflush(stdout);
130		c = getc(stdin);
131		while (c != '\n' && getc(stdin) != '\n')
132			if (feof(stdin))
133				return (0);
134	} while (c != 'y' && c != 'Y' && c != 'n' && c != 'N');
135	printf("\n");
136	if (c == 'y' || c == 'Y')
137		return (1);
138	return (0);
139}
140
141/*
142 * Malloc buffers and set up cache.
143 */
144void
145bufinit(void)
146{
147	struct bufarea *bp;
148	long bufcnt, i;
149	char *bufp;
150
151	diskreads = totalreads = 0;
152	pbp = pdirbp = (struct bufarea *)0;
153	bufhead.b_next = bufhead.b_prev = &bufhead;
154	bufcnt = MAXBUFSPACE / sblock.e2fs_bsize;
155	if (bufcnt < MINBUFS)
156		bufcnt = MINBUFS;
157	for (i = 0; i < bufcnt; i++) {
158		bp = malloc(sizeof(struct bufarea));
159		bufp = malloc((size_t)sblock.e2fs_bsize);
160		if (bp == NULL || bufp == NULL) {
161			free(bp);
162			free(bufp);
163			if (i >= MINBUFS)
164				break;
165			errexit("cannot allocate buffer pool");
166		}
167		bp->b_un.b_buf = bufp;
168		bp->b_prev = &bufhead;
169		bp->b_next = bufhead.b_next;
170		bufhead.b_next->b_prev = bp;
171		bufhead.b_next = bp;
172		initbarea(bp);
173	}
174	bufhead.b_size = i;	/* save number of buffers */
175}
176
177/*
178 * Manage a cache of directory blocks.
179 */
180struct bufarea *
181getdatablk(daddr_t blkno, long size)
182{
183	struct bufarea *bp;
184
185	for (bp = bufhead.b_next; bp != &bufhead; bp = bp->b_next)
186		if (bp->b_bno == fsbtodb(&sblock, blkno))
187			goto foundit;
188	for (bp = bufhead.b_prev; bp != &bufhead; bp = bp->b_prev)
189		if ((bp->b_flags & B_INUSE) == 0)
190			break;
191	if (bp == &bufhead)
192		errexit("deadlocked buffer pool");
193	getblk(bp, blkno, size);
194	diskreads++;
195	/* fall through */
196foundit:
197	totalreads++;
198	bp->b_prev->b_next = bp->b_next;
199	bp->b_next->b_prev = bp->b_prev;
200	bp->b_prev = &bufhead;
201	bp->b_next = bufhead.b_next;
202	bufhead.b_next->b_prev = bp;
203	bufhead.b_next = bp;
204	bp->b_flags |= B_INUSE;
205	return (bp);
206}
207
208void
209getblk(struct bufarea *bp, daddr_t blk, long size)
210{
211	daddr_t dblk;
212
213	dblk = fsbtodb(&sblock, blk);
214	if (bp->b_bno != dblk) {
215		flush(fswritefd, bp);
216		bp->b_errs = bread(fsreadfd, bp->b_un.b_buf, dblk, size);
217		bp->b_bno = dblk;
218		bp->b_size = size;
219	}
220}
221
222void
223flush(int fd, struct bufarea *bp)
224{
225	int i;
226
227	if (!bp->b_dirty)
228		return;
229	if (bp->b_errs != 0)
230		pfatal("WRITING %sZERO'ED BLOCK %lld TO DISK\n",
231		    (bp->b_errs == bp->b_size / dev_bsize) ? "" : "PARTIALLY ",
232		    (long long)bp->b_bno);
233	bp->b_dirty = 0;
234	bp->b_errs = 0;
235	bwrite(fd, bp->b_un.b_buf, bp->b_bno, (long)bp->b_size);
236	if (bp != &sblk)
237		return;
238	for (i = 0; i < sblock.e2fs_ngdb; i++) {
239		bwrite(fswritefd, (char *)
240			&sblock.e2fs_gd[i* sblock.e2fs_bsize / sizeof(struct ext2_gd)],
241		    fsbtodb(&sblock, ((sblock.e2fs_bsize>1024)?0:1)+i+1),
242		    sblock.e2fs_bsize);
243	}
244}
245
246static void
247rwerror(const char *mesg, daddr_t blk)
248{
249
250	if (preen == 0)
251		printf("\n");
252	pfatal("CANNOT %s: BLK %lld", mesg, (long long)blk);
253	if (reply("CONTINUE") == 0)
254		errexit("Program terminated");
255}
256
257void
258ckfini(int markclean)
259{
260	struct bufarea *bp, *nbp;
261	int cnt = 0;
262
263	if (fswritefd < 0) {
264		(void)close(fsreadfd);
265		return;
266	}
267	flush(fswritefd, &sblk);
268	if (havesb && sblk.b_bno != SBOFF / dev_bsize &&
269	    !preen && reply("UPDATE STANDARD SUPERBLOCKS")) {
270		sblk.b_bno = SBOFF / dev_bsize;
271		sbdirty();
272		flush(fswritefd, &sblk);
273		copyback_sb(&asblk);
274		asblk.b_dirty = 1;
275		flush(fswritefd, &asblk);
276	}
277	for (bp = bufhead.b_prev; bp && bp != &bufhead; bp = nbp) {
278		cnt++;
279		flush(fswritefd, bp);
280		nbp = bp->b_prev;
281		free(bp->b_un.b_buf);
282		free(bp);
283	}
284	if (bufhead.b_size != cnt)
285		errexit("Panic: lost %d buffers", bufhead.b_size - cnt);
286	pbp = pdirbp = (struct bufarea *)0;
287	if (markclean && (sblock.e2fs.e2fs_state & E2FS_ISCLEAN) == 0) {
288		/*
289		 * Mark the file system as clean, and sync the superblock.
290		 */
291		if (preen)
292			pwarn("MARKING FILE SYSTEM CLEAN\n");
293		else if (!reply("MARK FILE SYSTEM CLEAN"))
294			markclean = 0;
295		if (markclean) {
296			sblock.e2fs.e2fs_state = E2FS_ISCLEAN;
297			sbdirty();
298			flush(fswritefd, &sblk);
299		}
300	}
301	if (debug)
302		printf("cache missed %ld of %ld (%d%%)\n", diskreads,
303		    totalreads, (int)(diskreads * 100 / totalreads));
304	(void)close(fsreadfd);
305	(void)close(fswritefd);
306}
307
308int
309bread(int fd, char *buf, daddr_t blk, long size)
310{
311	char *cp;
312	int i, errs;
313	off_t offset;
314
315	offset = blk;
316	offset *= dev_bsize;
317	if (lseek(fd, offset, 0) < 0)
318		rwerror("SEEK", blk);
319	else if (read(fd, buf, (int)size) == size)
320		return (0);
321	rwerror("READ", blk);
322	if (lseek(fd, offset, 0) < 0)
323		rwerror("SEEK", blk);
324	errs = 0;
325	memset(buf, 0, (size_t)size);
326	printf("THE FOLLOWING DISK SECTORS COULD NOT BE READ:");
327	for (cp = buf, i = 0; i < size; i += secsize, cp += secsize) {
328		if (read(fd, cp, (int)secsize) != secsize) {
329			(void)lseek(fd, offset + i + secsize, 0);
330			if (secsize != dev_bsize && dev_bsize != 1)
331				printf(" %lld (%lld),",
332				    (long long)((blk*dev_bsize + i) / secsize),
333				    (long long)(blk + i / dev_bsize));
334			else
335				printf(" %lld,", (long long)(blk +
336							i / dev_bsize));
337			errs++;
338		}
339	}
340	printf("\n");
341	return (errs);
342}
343
344void
345bwrite(int fd, char *buf, daddr_t blk, long size)
346{
347	int i;
348	char *cp;
349	off_t offset;
350
351	if (fd < 0)
352		return;
353	offset = blk;
354	offset *= dev_bsize;
355	if (lseek(fd, offset, 0) < 0)
356		rwerror("SEEK", blk);
357	else if (write(fd, buf, (int)size) == size) {
358		fsmodified = 1;
359		return;
360	}
361	rwerror("WRITE", blk);
362	if (lseek(fd, offset, 0) < 0)
363		rwerror("SEEK", blk);
364	printf("THE FOLLOWING SECTORS COULD NOT BE WRITTEN:");
365	for (cp = buf, i = 0; i < size; i += dev_bsize, cp += dev_bsize)
366		if (write(fd, cp, (int)dev_bsize) != dev_bsize) {
367			(void)lseek(fd, offset + i + dev_bsize, 0);
368			printf(" %lld,", (long long)(blk + i / dev_bsize));
369		}
370	printf("\n");
371	return;
372}
373
374/*
375 * allocate a data block
376 */
377int
378allocblk(void)
379{
380	int i;
381
382	for (i = 0; i < maxfsblock - 1; i++) {
383		if (testbmap(i))
384				continue;
385		setbmap(i);
386		n_blks++;
387		return (i);
388	}
389	return (0);
390}
391
392/*
393 * Free a previously allocated block
394 */
395void
396freeblk(daddr_t blkno)
397{
398	struct inodesc idesc;
399
400	idesc.id_blkno = blkno;
401	idesc.id_numfrags = 1;
402	(void)pass4check(&idesc);
403}
404
405/*
406 * Find a pathname
407 */
408void
409getpathname(char *namebuf, size_t namebuflen, ino_t curdir, ino_t ino)
410{
411	int len;
412	char *cp;
413	struct inodesc idesc;
414	static int busy = 0;
415
416	if (curdir == ino && ino == EXT2_ROOTINO) {
417		(void)strlcpy(namebuf, "/", namebuflen);
418		return;
419	}
420	if (busy ||
421	    (statemap[curdir] != DSTATE && statemap[curdir] != DFOUND)) {
422		(void)strlcpy(namebuf, "?", namebuflen);
423		return;
424	}
425	busy = 1;
426	memset(&idesc, 0, sizeof(struct inodesc));
427	idesc.id_type = DATA;
428	idesc.id_fix = IGNORE;
429	cp = &namebuf[MAXPATHLEN - 1];
430	*cp = '\0';
431	if (curdir != ino) {
432		idesc.id_parent = curdir;
433		goto namelookup;
434	}
435	while (ino != EXT2_ROOTINO) {
436		idesc.id_number = ino;
437		idesc.id_func = findino;
438		idesc.id_name = "..";
439		if ((ckinode(ginode(ino), &idesc) & FOUND) == 0)
440			break;
441	namelookup:
442		idesc.id_number = idesc.id_parent;
443		idesc.id_parent = ino;
444		idesc.id_func = findname;
445		idesc.id_name = namebuf;
446		if ((ckinode(ginode(idesc.id_number), &idesc)&FOUND) == 0)
447			break;
448		len = strlen(namebuf);
449		cp -= len;
450		memcpy(cp, namebuf, (size_t)len);
451		*--cp = '/';
452		if (cp < &namebuf[EXT2FS_MAXNAMLEN])
453			break;
454		ino = idesc.id_number;
455	}
456	busy = 0;
457	if (ino != EXT2_ROOTINO)
458		*--cp = '?';
459	memcpy(namebuf, cp, (size_t)(&namebuf[MAXPATHLEN] - cp));
460}
461
462/*
463 * determine whether an inode should be fixed.
464 */
465int
466dofix(struct inodesc *idesc, const char *msg)
467{
468
469	switch (idesc->id_fix) {
470
471	case DONTKNOW:
472		if (idesc->id_type == DATA)
473			direrror(idesc->id_number, msg);
474		else
475			pwarn("%s", msg);
476		if (preen) {
477			printf(" (SALVAGED)\n");
478			idesc->id_fix = FIX;
479			return (ALTERED);
480		}
481		if (reply("SALVAGE") == 0) {
482			idesc->id_fix = NOFIX;
483			return (0);
484		}
485		idesc->id_fix = FIX;
486		return (ALTERED);
487
488	case FIX:
489		return (ALTERED);
490
491	case NOFIX:
492	case IGNORE:
493		return (0);
494
495	default:
496		errexit("UNKNOWN INODESC FIX MODE %d", idesc->id_fix);
497	}
498	/* NOTREACHED */
499}
500