Home | History | Annotate | Line # | Download | only in makefs
makefs.c revision 1.50 
      1 /*	$NetBSD: makefs.c,v 1.50 2013/08/05 14:41:57 reinoud Exp $	*/
      2 
      3 /*
      4  * Copyright (c) 2001-2003 Wasabi Systems, Inc.
      5  * All rights reserved.
      6  *
      7  * Written by Luke Mewburn for Wasabi Systems, Inc.
      8  *
      9  * Redistribution and use in source and binary forms, with or without
     10  * modification, are permitted provided that the following conditions
     11  * are met:
     12  * 1. Redistributions of source code must retain the above copyright
     13  *    notice, this list of conditions and the following disclaimer.
     14  * 2. Redistributions in binary form must reproduce the above copyright
     15  *    notice, this list of conditions and the following disclaimer in the
     16  *    documentation and/or other materials provided with the distribution.
     17  * 3. All advertising materials mentioning features or use of this software
     18  *    must display the following acknowledgement:
     19  *      This product includes software developed for the NetBSD Project by
     20  *      Wasabi Systems, Inc.
     21  * 4. The name of Wasabi Systems, Inc. may not be used to endorse
     22  *    or promote products derived from this software without specific prior
     23  *    written permission.
     24  *
     25  * THIS SOFTWARE IS PROVIDED BY WASABI SYSTEMS, INC. ``AS IS'' AND
     26  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     27  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     28  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL WASABI SYSTEMS, INC
     29  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     30  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     31  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     32  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     33  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     34  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     35  * POSSIBILITY OF SUCH DAMAGE.
     36  */
     37 
     38 #if HAVE_NBTOOL_CONFIG_H
     39 #include "nbtool_config.h"
     40 #endif
     41 
     42 #include <sys/cdefs.h>
     43 #if defined(__RCSID) && !defined(__lint)
     44 __RCSID("$NetBSD: makefs.c,v 1.50 2013/08/05 14:41:57 reinoud Exp $");
     45 #endif	/* !__lint */
     46 
     47 #include <assert.h>
     48 #include <ctype.h>
     49 #include <errno.h>
     50 #include <limits.h>
     51 #include <stdio.h>
     52 #include <stdlib.h>
     53 #include <string.h>
     54 #include <unistd.h>
     55 #include <stdbool.h>
     56 #include <util.h>
     57 
     58 #include "makefs.h"
     59 #include "mtree.h"
     60 #include "cd9660.h"
     61 
     62 /*
     63  * list of supported file systems and dispatch functions
     64  */
     65 typedef struct {
     66 	const char	*type;
     67 	void		(*prepare_options)(fsinfo_t *);
     68 	int		(*parse_options)(const char *, fsinfo_t *);
     69 	void		(*cleanup_options)(fsinfo_t *);
     70 	void		(*make_fs)(const char *, const char *, fsnode *,
     71 				fsinfo_t *);
     72 } fstype_t;
     73 
     74 static fstype_t fstypes[] = {
     75 #define ENTRY(name) { \
     76 	# name, name ## _prep_opts, name ## _parse_opts, \
     77 	name ## _cleanup_opts, name ## _makefs  \
     78 }
     79 	ENTRY(ffs),
     80 	ENTRY(cd9660),
     81 	ENTRY(chfs),
     82 	ENTRY(v7fs),
     83 	ENTRY(msdos),
     84 	ENTRY(udf),
     85 	{ .type = NULL	},
     86 };
     87 
     88 u_int		debug;
     89 struct timespec	start_time;
     90 
     91 static	fstype_t *get_fstype(const char *);
     92 static	void	usage(fstype_t *, fsinfo_t *) __dead;
     93 
     94 int
     95 main(int argc, char *argv[])
     96 {
     97 	struct timeval	 start;
     98 	fstype_t	*fstype;
     99 	fsinfo_t	 fsoptions;
    100 	fsnode		*root;
    101 	int	 	 ch, i, len;
    102 	char		*specfile;
    103 
    104 	setprogname(argv[0]);
    105 
    106 	debug = 0;
    107 	if ((fstype = get_fstype(DEFAULT_FSTYPE)) == NULL)
    108 		errx(1, "Unknown default fs type `%s'.", DEFAULT_FSTYPE);
    109 
    110 		/* set default fsoptions */
    111 	(void)memset(&fsoptions, 0, sizeof(fsoptions));
    112 	fsoptions.fd = -1;
    113 	fsoptions.sectorsize = -1;
    114 
    115 	if (fstype->prepare_options)
    116 		fstype->prepare_options(&fsoptions);
    117 
    118 	specfile = NULL;
    119 	if (gettimeofday(&start, NULL) == -1)
    120 		err(1, "Unable to get system time");
    121 
    122 	start_time.tv_sec = start.tv_sec;
    123 	start_time.tv_nsec = start.tv_usec * 1000;
    124 
    125 	while ((ch = getopt(argc, argv, "B:b:d:f:F:M:m:N:O:o:rs:S:t:xZ")) != -1) {
    126 		switch (ch) {
    127 
    128 		case 'B':
    129 			if (strcmp(optarg, "be") == 0 ||
    130 			    strcmp(optarg, "4321") == 0 ||
    131 			    strcmp(optarg, "big") == 0) {
    132 #if BYTE_ORDER == LITTLE_ENDIAN
    133 				fsoptions.needswap = 1;
    134 #endif
    135 			} else if (strcmp(optarg, "le") == 0 ||
    136 			    strcmp(optarg, "1234") == 0 ||
    137 			    strcmp(optarg, "little") == 0) {
    138 #if BYTE_ORDER == BIG_ENDIAN
    139 				fsoptions.needswap = 1;
    140 #endif
    141 			} else {
    142 				warnx("Invalid endian `%s'.", optarg);
    143 				usage(fstype, &fsoptions);
    144 			}
    145 			break;
    146 
    147 		case 'b':
    148 			len = strlen(optarg) - 1;
    149 			if (optarg[len] == '%') {
    150 				optarg[len] = '\0';
    151 				fsoptions.freeblockpc =
    152 				    strsuftoll("free block percentage",
    153 					optarg, 0, 99);
    154 			} else {
    155 				fsoptions.freeblocks =
    156 				    strsuftoll("free blocks",
    157 					optarg, 0, LLONG_MAX);
    158 			}
    159 			break;
    160 
    161 		case 'd':
    162 			debug = strtoll(optarg, NULL, 0);
    163 			break;
    164 
    165 		case 'f':
    166 			len = strlen(optarg) - 1;
    167 			if (optarg[len] == '%') {
    168 				optarg[len] = '\0';
    169 				fsoptions.freefilepc =
    170 				    strsuftoll("free file percentage",
    171 					optarg, 0, 99);
    172 			} else {
    173 				fsoptions.freefiles =
    174 				    strsuftoll("free files",
    175 					optarg, 0, LLONG_MAX);
    176 			}
    177 			break;
    178 
    179 		case 'F':
    180 			specfile = optarg;
    181 			break;
    182 
    183 		case 'M':
    184 			fsoptions.minsize =
    185 			    strsuftoll("minimum size", optarg, 1LL, LLONG_MAX);
    186 			break;
    187 
    188 		case 'N':
    189 			if (! setup_getid(optarg))
    190 				errx(1,
    191 			    "Unable to use user and group databases in `%s'",
    192 				    optarg);
    193 			break;
    194 
    195 		case 'm':
    196 			fsoptions.maxsize =
    197 			    strsuftoll("maximum size", optarg, 1LL, LLONG_MAX);
    198 			break;
    199 
    200 		case 'O':
    201 			fsoptions.offset =
    202 			    strsuftoll("offset", optarg, 0LL, LLONG_MAX);
    203 			break;
    204 
    205 		case 'o':
    206 		{
    207 			char *p;
    208 
    209 			while ((p = strsep(&optarg, ",")) != NULL) {
    210 				if (*p == '\0')
    211 					errx(1, "Empty option");
    212 				if (! fstype->parse_options(p, &fsoptions))
    213 					usage(fstype, &fsoptions);
    214 			}
    215 			break;
    216 		}
    217 
    218 		case 'r':
    219 			fsoptions.replace = 1;
    220 			break;
    221 
    222 		case 's':
    223 			fsoptions.minsize = fsoptions.maxsize =
    224 			    strsuftoll("size", optarg, 1LL, LLONG_MAX);
    225 			break;
    226 
    227 		case 'S':
    228 			fsoptions.sectorsize =
    229 			    (int)strsuftoll("sector size", optarg,
    230 				1LL, INT_MAX);
    231 			break;
    232 
    233 		case 't':
    234 			/* Check current one and cleanup if necessary. */
    235 			if (fstype->cleanup_options)
    236 				fstype->cleanup_options(&fsoptions);
    237 			fsoptions.fs_specific = NULL;
    238 			if ((fstype = get_fstype(optarg)) == NULL)
    239 				errx(1, "Unknown fs type `%s'.", optarg);
    240 			fstype->prepare_options(&fsoptions);
    241 			break;
    242 
    243 		case 'x':
    244 			fsoptions.onlyspec = 1;
    245 			break;
    246 
    247 		case 'Z':
    248 			fsoptions.sparse = 1;
    249 			break;
    250 
    251 		case '?':
    252 		default:
    253 			usage(fstype, &fsoptions);
    254 			/* NOTREACHED */
    255 
    256 		}
    257 	}
    258 	if (debug) {
    259 		printf("debug mask: 0x%08x\n", debug);
    260 		printf("start time: %ld.%ld, %s",
    261 		    (long)start_time.tv_sec, (long)start_time.tv_nsec,
    262 		    ctime(&start_time.tv_sec));
    263 	}
    264 	argc -= optind;
    265 	argv += optind;
    266 
    267 	if (argc < 2)
    268 		usage(fstype, &fsoptions);
    269 
    270 	/* -x must be accompanied by -F */
    271 	if (fsoptions.onlyspec != 0 && specfile == NULL)
    272 		errx(1, "-x requires -F mtree-specfile.");
    273 
    274 				/* walk the tree */
    275 	TIMER_START(start);
    276 	root = walk_dir(argv[1], ".", NULL, NULL, fsoptions.replace);
    277 	TIMER_RESULTS(start, "walk_dir");
    278 
    279 	/* append extra directory */
    280 	for (i = 2; i < argc; i++) {
    281 		struct stat sb;
    282 		if (stat(argv[i], &sb) == -1)
    283 			err(1, "Can't stat `%s'", argv[i]);
    284 		if (!S_ISDIR(sb.st_mode))
    285 			errx(1, "%s: not a directory", argv[i]);
    286 		TIMER_START(start);
    287 		root = walk_dir(argv[i], ".", NULL, root, fsoptions.replace);
    288 		TIMER_RESULTS(start, "walk_dir2");
    289 	}
    290 
    291 	if (specfile) {		/* apply a specfile */
    292 		TIMER_START(start);
    293 		apply_specfile(specfile, argv[1], root, fsoptions.onlyspec);
    294 		TIMER_RESULTS(start, "apply_specfile");
    295 	}
    296 
    297 	if (debug & DEBUG_DUMP_FSNODES) {
    298 		printf("\nparent: %s\n", argv[1]);
    299 		dump_fsnodes(root);
    300 		putchar('\n');
    301 	}
    302 
    303 				/* build the file system */
    304 	TIMER_START(start);
    305 	fstype->make_fs(argv[0], argv[1], root, &fsoptions);
    306 	TIMER_RESULTS(start, "make_fs");
    307 
    308 	free_fsnodes(root);
    309 
    310 	exit(0);
    311 	/* NOTREACHED */
    312 }
    313 
    314 int
    315 set_option(const option_t *options, const char *option, char *buf, size_t len)
    316 {
    317 	char *var, *val;
    318 	int retval;
    319 
    320 	assert(option != NULL);
    321 
    322 	var = estrdup(option);
    323 	for (val = var; *val; val++)
    324 		if (*val == '=') {
    325 			*val++ = '\0';
    326 			break;
    327 		}
    328 	retval = set_option_var(options, var, val, buf, len);
    329 	free(var);
    330 	return retval;
    331 }
    332 
    333 int
    334 set_option_var(const option_t *options, const char *var, const char *val,
    335     char *buf, size_t len)
    336 {
    337 	char *s;
    338 	size_t i;
    339 
    340 #define NUM(type) \
    341 	if (!*val) { \
    342 		*(type *)options[i].value = 1; \
    343 		break; \
    344 	} \
    345 	*(type *)options[i].value = (type)strsuftoll(options[i].desc, val, \
    346 	    options[i].minimum, options[i].maximum); break
    347 
    348 	for (i = 0; options[i].name != NULL; i++) {
    349 		if (var[1] == '\0') {
    350 			if (options[i].letter != var[0])
    351 				continue;
    352 		} else if (strcmp(options[i].name, var) != 0)
    353 			continue;
    354 		switch (options[i].type) {
    355 		case OPT_BOOL:
    356 			*(bool *)options[i].value = 1;
    357 			break;
    358 		case OPT_STRARRAY:
    359 			strlcpy((void *)options[i].value, val, (size_t)
    360 			    options[i].maximum);
    361 			break;
    362 		case OPT_STRPTR:
    363 			s = estrdup(val);
    364 			*(char **)options[i].value = s;
    365 			break;
    366 		case OPT_STRBUF:
    367 			if (buf == NULL)
    368 				abort();
    369 			strlcpy(buf, val, len);
    370 			break;
    371 		case OPT_INT64:
    372 			NUM(uint64_t);
    373 		case OPT_INT32:
    374 			NUM(uint32_t);
    375 		case OPT_INT16:
    376 			NUM(uint16_t);
    377 		case OPT_INT8:
    378 			NUM(uint8_t);
    379 		default:
    380 			warnx("Unknown type %d in option %s", options[i].type,
    381 			    val);
    382 			return 0;
    383 		}
    384 		return i;
    385 	}
    386 	warnx("Unknown option `%s'", var);
    387 	return -1;
    388 }
    389 
    390 
    391 static fstype_t *
    392 get_fstype(const char *type)
    393 {
    394 	int i;
    395 
    396 	for (i = 0; fstypes[i].type != NULL; i++)
    397 		if (strcmp(fstypes[i].type, type) == 0)
    398 			return (&fstypes[i]);
    399 	return (NULL);
    400 }
    401 
    402 option_t *
    403 copy_opts(const option_t *o)
    404 {
    405 	size_t i;
    406 	for (i = 0; o[i].name; i++)
    407 		continue;
    408 	i++;
    409 	return memcpy(ecalloc(i, sizeof(*o)), o, i * sizeof(*o));
    410 }
    411 
    412 static void
    413 usage(fstype_t *fstype, fsinfo_t *fsoptions)
    414 {
    415 	const char *prog;
    416 
    417 	prog = getprogname();
    418 	fprintf(stderr,
    419 "Usage: %s [-rxZ] [-B endian] [-b free-blocks] [-d debug-mask]\n"
    420 "\t[-F mtree-specfile] [-f free-files] [-M minimum-size] [-m maximum-size]\n"
    421 "\t[-N userdb-dir] [-O offset] [-o fs-options] [-S sector-size]\n"
    422 "\t[-s image-size] [-t fs-type] image-file directory [extra-directory ...]\n",
    423 	    prog);
    424 
    425 	if (fstype) {
    426 		size_t i;
    427 		option_t *o = fsoptions->fs_options;
    428 
    429 		fprintf(stderr, "\n%s specific options:\n", fstype->type);
    430 		for (i = 0; o[i].name != NULL; i++)
    431 			fprintf(stderr, "\t%c%c%20.20s\t%s\n",
    432 			    o[i].letter ? o[i].letter : ' ',
    433 			    o[i].letter ? ',' : ' ',
    434 			    o[i].name, o[i].desc);
    435 	}
    436 	exit(1);
    437 }
    438