Home | History | Annotate | Line # | Download | only in fsck
fsutil.c revision 1.19.4.1 
      1 /*	$NetBSD: fsutil.c,v 1.19.4.1 2011/06/23 14:18:41 cherry Exp $	*/
      2 
      3 /*
      4  * Copyright (c) 1990, 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 #include <sys/cdefs.h>
     33 #ifndef lint
     34 __RCSID("$NetBSD: fsutil.c,v 1.19.4.1 2011/06/23 14:18:41 cherry Exp $");
     35 #endif /* not lint */
     36 
     37 #include <sys/param.h>
     38 
     39 #include <stdio.h>
     40 #include <string.h>
     41 #include <stdlib.h>
     42 #include <stdarg.h>
     43 #include <errno.h>
     44 #include <fstab.h>
     45 #include <fcntl.h>
     46 #include <unistd.h>
     47 #include <err.h>
     48 
     49 #include <sys/types.h>
     50 #include <sys/stat.h>
     51 
     52 #include "fsutil.h"
     53 #include "exitvalues.h"
     54 
     55 static const char *dev = NULL;
     56 static int hot = 0;
     57 static int preen = 0;
     58 int quiet;
     59 #define F_ERROR	0x80000000
     60 
     61 void
     62 setcdevname(const char *cd, int pr)
     63 {
     64 
     65 	dev = cd;
     66 	preen = pr;
     67 }
     68 
     69 const char *
     70 cdevname(void)
     71 {
     72 
     73 	return dev;
     74 }
     75 
     76 int
     77 hotroot(void)
     78 {
     79 
     80 	return hot;
     81 }
     82 
     83 /*VARARGS*/
     84 void
     85 errexit(const char *fmt, ...)
     86 {
     87 	va_list ap;
     88 
     89 	va_start(ap, fmt);
     90 	(void) vfprintf(stderr, fmt, ap);
     91 	va_end(ap);
     92 	(void)fprintf(stderr, "\n");
     93 	exit(FSCK_EXIT_CHECK_FAILED);
     94 }
     95 
     96 void
     97 vmsg(int fatal, const char *fmt, va_list ap)
     98 {
     99 	int serr = fatal & F_ERROR;
    100 	int serrno = errno;
    101 	fatal &= ~F_ERROR;
    102 
    103 	if (!fatal && preen)
    104 		(void)printf("%s: ", dev);
    105 	if (quiet && !preen) {
    106 		(void)printf("** %s (vmsg)\n", dev);
    107 		quiet = 0;
    108 	}
    109 
    110 	(void) vprintf(fmt, ap);
    111 	if (serr)
    112 		printf(" (%s)", strerror(serrno));
    113 
    114 	if (fatal && preen)
    115 		(void) printf("\n");
    116 
    117 	if (fatal && preen) {
    118 		(void) printf(
    119 		    "%s: UNEXPECTED INCONSISTENCY; RUN %s MANUALLY.\n",
    120 		    dev, getprogname());
    121 		exit(FSCK_EXIT_CHECK_FAILED);
    122 	}
    123 }
    124 
    125 /*VARARGS*/
    126 void
    127 pfatal(const char *fmt, ...)
    128 {
    129 	va_list ap;
    130 
    131 	va_start(ap, fmt);
    132 	vmsg(1, fmt, ap);
    133 	va_end(ap);
    134 }
    135 
    136 /*VARARGS*/
    137 void
    138 pwarn(const char *fmt, ...)
    139 {
    140 	va_list ap;
    141 
    142 	va_start(ap, fmt);
    143 	vmsg(0, fmt, ap);
    144 	va_end(ap);
    145 }
    146 
    147 void
    148 perr(const char *fmt, ...)
    149 {
    150 	va_list ap;
    151 
    152 	va_start(ap, fmt);
    153 	vmsg(1 | F_ERROR, fmt, ap);
    154 	va_end(ap);
    155 }
    156 
    157 void
    158 panic(const char *fmt, ...)
    159 {
    160 	va_list ap;
    161 
    162 	va_start(ap, fmt);
    163 	vmsg(1, fmt, ap);
    164 	va_end(ap);
    165 	exit(FSCK_EXIT_CHECK_FAILED);
    166 }
    167 
    168 const char *
    169 unrawname(const char *name)
    170 {
    171 	static char unrawbuf[MAXPATHLEN];
    172 	const char *dp;
    173 	struct stat stb;
    174 
    175 	if ((dp = strrchr(name, '/')) == 0)
    176 		return (name);
    177 	if (stat(name, &stb) < 0)
    178 		return (name);
    179 	if (!S_ISCHR(stb.st_mode))
    180 		return (name);
    181 	if (dp[1] != 'r')
    182 		return (name);
    183 	(void)snprintf(unrawbuf, sizeof(unrawbuf), "%.*s/%s",
    184 	    (int)(dp - name), name, dp + 2);
    185 	return (unrawbuf);
    186 }
    187 
    188 const char *
    189 rawname(const char *name)
    190 {
    191 	static char rawbuf[MAXPATHLEN];
    192 	const char *dp;
    193 
    194 	if ((dp = strrchr(name, '/')) == 0)
    195 		return (0);
    196 	(void)snprintf(rawbuf, sizeof(rawbuf), "%.*s/r%s",
    197 	    (int)(dp - name), name, dp + 1);
    198 	return (rawbuf);
    199 }
    200 
    201 const char *
    202 blockcheck(const char *origname)
    203 {
    204 	struct stat stslash, stblock, stchar;
    205 	const char *newname, *raw;
    206 	struct fstab *fsp;
    207 	int retried = 0;
    208 
    209 	hot = 0;
    210 	if (stat("/", &stslash) < 0) {
    211 		perr("Can't stat `/'");
    212 		return (origname);
    213 	}
    214 	newname = origname;
    215 retry:
    216 	if (stat(newname, &stblock) < 0) {
    217 		perr("Can't stat `%s'", newname);
    218 		return (origname);
    219 	}
    220 	if (S_ISBLK(stblock.st_mode)) {
    221 		if (stslash.st_dev == stblock.st_rdev)
    222 			hot++;
    223 		raw = rawname(newname);
    224 		if (stat(raw, &stchar) < 0) {
    225 			perr("Can't stat `%s'", raw);
    226 			return (origname);
    227 		}
    228 		if (S_ISCHR(stchar.st_mode)) {
    229 			return (raw);
    230 		} else {
    231 			printf("%s is not a character device\n", raw);
    232 			return (origname);
    233 		}
    234 	} else if (S_ISCHR(stblock.st_mode) && !retried) {
    235 		newname = unrawname(newname);
    236 		retried++;
    237 		goto retry;
    238 	} else if ((fsp = getfsfile(newname)) != 0 && !retried) {
    239 		newname = fsp->fs_spec;
    240 		retried++;
    241 		goto retry;
    242 	}
    243 	/*
    244 	 * Not a block or character device, just return name and
    245 	 * let the user decide whether to use it.
    246 	 */
    247 	return (origname);
    248 }
    249 
    250 const char *
    251 print_mtime(time_t t)
    252 {
    253 	static char b[128];
    254 	char *p = ctime(&t);
    255 	if (p != NULL)
    256 		(void)snprintf(b, sizeof(b), "%12.12s %4.4s ", &p[4], &p[20]);
    257 	else
    258 		(void)snprintf(b, sizeof(b), "%lld ", (long long)t);
    259 	return b;
    260 }
    261 
    262 
    263 void
    264 catch(int n)
    265 {
    266 	if (ckfinish) (*ckfinish)(0);
    267 	_exit(FSCK_EXIT_SIGNALLED);
    268 }
    269 
    270 /*
    271  * When preening, allow a single quit to signal
    272  * a special exit after filesystem checks complete
    273  * so that reboot sequence may be interrupted.
    274  */
    275 void
    276 catchquit(int n)
    277 {
    278 	static const char msg[] =
    279 	    "returning to single-user after filesystem check\n";
    280 	int serrno = errno;
    281 
    282 	(void)write(STDOUT_FILENO, msg, sizeof(msg) - 1);
    283 	returntosingle = 1;
    284 	(void)signal(SIGQUIT, SIG_DFL);
    285 	errno = serrno;
    286 }
    287 
    288 /*
    289  * Ignore a single quit signal; wait and flush just in case.
    290  * Used by child processes in preen.
    291  */
    292 void
    293 voidquit(int n)
    294 {
    295 	int serrno = errno;
    296 
    297 	sleep(1);
    298 	(void)signal(SIGQUIT, SIG_IGN);
    299 	(void)signal(SIGQUIT, SIG_DFL);
    300 	errno = serrno;
    301 }
    302