Home | History | Annotate | Line # | Download | only in makefs
makefs.c revision 1.35 
      1 /*	$NetBSD: makefs.c,v 1.35 2012/06/22 06:15:18 sjg 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.35 2012/06/22 06:15:18 sjg 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 
     56 #include "makefs.h"
     57 #include "mtree.h"
     58 #include "cd9660.h"
     59 
     60 /*
     61  * list of supported file systems and dispatch functions
     62  */
     63 typedef struct {
     64 	const char	*type;
     65 	void		(*prepare_options)(fsinfo_t *);
     66 	int		(*parse_options)(const char *, fsinfo_t *);
     67 	void		(*cleanup_options)(fsinfo_t *);
     68 	void		(*make_fs)(const char *, const char *, fsnode *,
     69 				fsinfo_t *);
     70 } fstype_t;
     71 
     72 static fstype_t fstypes[] = {
     73 	{ "ffs", ffs_prep_opts,	ffs_parse_opts,	ffs_cleanup_opts, ffs_makefs },
     74 	{ "cd9660", cd9660_prep_opts, cd9660_parse_opts, cd9660_cleanup_opts,
     75 	  cd9660_makefs},
     76 	{ "chfs", chfs_prep_opts, chfs_parse_opts, chfs_cleanup_opts,
     77 	  chfs_makefs },
     78 	{ "v7fs", v7fs_prep_opts, v7fs_parse_opts, v7fs_cleanup_opts,
     79 	  v7fs_makefs },
     80 	{ .type = NULL	},
     81 };
     82 
     83 u_int		debug;
     84 struct timespec	start_time;
     85 
     86 static	fstype_t *get_fstype(const char *);
     87 static	void	usage(void) __dead;
     88 
     89 int
     90 main(int argc, char *argv[])
     91 {
     92 	struct timeval	 start;
     93 	fstype_t	*fstype;
     94 	fsinfo_t	 fsoptions;
     95 	fsnode		*root;
     96 	int	 	 ch, i, len;
     97 	char		*specfile;
     98 
     99 	setprogname(argv[0]);
    100 
    101 	debug = 0;
    102 	if ((fstype = get_fstype(DEFAULT_FSTYPE)) == NULL)
    103 		errx(1, "Unknown default fs type `%s'.", DEFAULT_FSTYPE);
    104 
    105 		/* set default fsoptions */
    106 	(void)memset(&fsoptions, 0, sizeof(fsoptions));
    107 	fsoptions.fd = -1;
    108 	fsoptions.sectorsize = -1;
    109 
    110 	if (fstype->prepare_options)
    111 		fstype->prepare_options(&fsoptions);
    112 
    113 	specfile = NULL;
    114 	if (gettimeofday(&start, NULL) == -1)
    115 		err(1, "Unable to get system time");
    116 
    117 	start_time.tv_sec = start.tv_sec;
    118 	start_time.tv_nsec = start.tv_usec * 1000;
    119 
    120 	while ((ch = getopt(argc, argv, "B:b:d:f:F:M:m:N:o:s:S:t:xZ")) != -1) {
    121 		switch (ch) {
    122 
    123 		case 'B':
    124 			if (strcmp(optarg, "be") == 0 ||
    125 			    strcmp(optarg, "4321") == 0 ||
    126 			    strcmp(optarg, "big") == 0) {
    127 #if BYTE_ORDER == LITTLE_ENDIAN
    128 				fsoptions.needswap = 1;
    129 #endif
    130 			} else if (strcmp(optarg, "le") == 0 ||
    131 			    strcmp(optarg, "1234") == 0 ||
    132 			    strcmp(optarg, "little") == 0) {
    133 #if BYTE_ORDER == BIG_ENDIAN
    134 				fsoptions.needswap = 1;
    135 #endif
    136 			} else {
    137 				warnx("Invalid endian `%s'.", optarg);
    138 				usage();
    139 			}
    140 			break;
    141 
    142 		case 'b':
    143 			len = strlen(optarg) - 1;
    144 			if (optarg[len] == '%') {
    145 				optarg[len] = '\0';
    146 				fsoptions.freeblockpc =
    147 				    strsuftoll("free block percentage",
    148 					optarg, 0, 99);
    149 			} else {
    150 				fsoptions.freeblocks =
    151 				    strsuftoll("free blocks",
    152 					optarg, 0, LLONG_MAX);
    153 			}
    154 			break;
    155 
    156 		case 'd':
    157 			debug = strtoll(optarg, NULL, 0);
    158 			break;
    159 
    160 		case 'f':
    161 			len = strlen(optarg) - 1;
    162 			if (optarg[len] == '%') {
    163 				optarg[len] = '\0';
    164 				fsoptions.freefilepc =
    165 				    strsuftoll("free file percentage",
    166 					optarg, 0, 99);
    167 			} else {
    168 				fsoptions.freefiles =
    169 				    strsuftoll("free files",
    170 					optarg, 0, LLONG_MAX);
    171 			}
    172 			break;
    173 
    174 		case 'F':
    175 			specfile = optarg;
    176 			break;
    177 
    178 		case 'M':
    179 			fsoptions.minsize =
    180 			    strsuftoll("minimum size", optarg, 1LL, LLONG_MAX);
    181 			break;
    182 
    183 		case 'N':
    184 			if (! setup_getid(optarg))
    185 				errx(1,
    186 			    "Unable to use user and group databases in `%s'",
    187 				    optarg);
    188 			break;
    189 
    190 		case 'm':
    191 			fsoptions.maxsize =
    192 			    strsuftoll("maximum size", optarg, 1LL, LLONG_MAX);
    193 			break;
    194 
    195 		case 'o':
    196 		{
    197 			char *p;
    198 
    199 			while ((p = strsep(&optarg, ",")) != NULL) {
    200 				if (*p == '\0')
    201 					errx(1, "Empty option");
    202 				if (! fstype->parse_options(p, &fsoptions))
    203 					usage();
    204 			}
    205 			break;
    206 		}
    207 
    208 		case 's':
    209 			fsoptions.minsize = fsoptions.maxsize =
    210 			    strsuftoll("size", optarg, 1LL, LLONG_MAX);
    211 			break;
    212 
    213 		case 'S':
    214 			fsoptions.sectorsize =
    215 			    (int)strsuftoll("sector size", optarg,
    216 				1LL, INT_MAX);
    217 			break;
    218 
    219 		case 't':
    220 			/* Check current one and cleanup if necessary. */
    221 			if (fstype->cleanup_options)
    222 				fstype->cleanup_options(&fsoptions);
    223 			fsoptions.fs_specific = NULL;
    224 			if ((fstype = get_fstype(optarg)) == NULL)
    225 				errx(1, "Unknown fs type `%s'.", optarg);
    226 			fstype->prepare_options(&fsoptions);
    227 			break;
    228 
    229 		case 'x':
    230 			fsoptions.onlyspec = 1;
    231 			break;
    232 
    233 		case 'Z':
    234 			fsoptions.sparse = 1;
    235 			break;
    236 
    237 		case '?':
    238 		default:
    239 			usage();
    240 			/* NOTREACHED */
    241 
    242 		}
    243 	}
    244 	if (debug) {
    245 		printf("debug mask: 0x%08x\n", debug);
    246 		printf("start time: %ld.%ld, %s",
    247 		    (long)start_time.tv_sec, (long)start_time.tv_nsec,
    248 		    ctime(&start_time.tv_sec));
    249 	}
    250 	argc -= optind;
    251 	argv += optind;
    252 
    253 	if (argc < 2)
    254 		usage();
    255 
    256 	/* -x must be accompanied by -F */
    257 	if (fsoptions.onlyspec != 0 && specfile == NULL)
    258 		errx(1, "-x requires -F mtree-specfile.");
    259 
    260 				/* walk the tree */
    261 	TIMER_START(start);
    262 	root = walk_dir(argv[1], ".", NULL, NULL);
    263 	TIMER_RESULTS(start, "walk_dir");
    264 
    265 	/* append extra directory */
    266 	for (i = 2; i < argc; i++) {
    267 		struct stat sb;
    268 		if (stat(argv[i], &sb) == -1)
    269 			err(1, "Can't stat `%s'", argv[i]);
    270 		if (!S_ISDIR(sb.st_mode))
    271 			errx(1, "%s: not a directory", argv[i]);
    272 		TIMER_START(start);
    273 		root = walk_dir(argv[i], ".", NULL, root);
    274 		TIMER_RESULTS(start, "walk_dir2");
    275 	}
    276 
    277 	if (specfile) {		/* apply a specfile */
    278 		TIMER_START(start);
    279 		apply_specfile(specfile, argv[1], root, fsoptions.onlyspec);
    280 		TIMER_RESULTS(start, "apply_specfile");
    281 	}
    282 
    283 	if (debug & DEBUG_DUMP_FSNODES) {
    284 		printf("\nparent: %s\n", argv[1]);
    285 		dump_fsnodes(root);
    286 		putchar('\n');
    287 	}
    288 
    289 				/* build the file system */
    290 	TIMER_START(start);
    291 	fstype->make_fs(argv[0], argv[1], root, &fsoptions);
    292 	TIMER_RESULTS(start, "make_fs");
    293 
    294 	free_fsnodes(root);
    295 
    296 	exit(0);
    297 	/* NOTREACHED */
    298 }
    299 
    300 
    301 int
    302 set_option(const option_t *options, const char *var, const char *val)
    303 {
    304 	int	i;
    305 
    306 	for (i = 0; options[i].name != NULL; i++) {
    307 		if (strcmp(options[i].name, var) != 0)
    308 			continue;
    309 		*options[i].value = (int)strsuftoll(options[i].desc, val,
    310 		    options[i].minimum, options[i].maximum);
    311 		return (1);
    312 	}
    313 	warnx("Unknown option `%s'", var);
    314 	return (0);
    315 }
    316 
    317 
    318 static fstype_t *
    319 get_fstype(const char *type)
    320 {
    321 	int i;
    322 
    323 	for (i = 0; fstypes[i].type != NULL; i++)
    324 		if (strcmp(fstypes[i].type, type) == 0)
    325 			return (&fstypes[i]);
    326 	return (NULL);
    327 }
    328 
    329 static void
    330 usage(void)
    331 {
    332 	const char *prog;
    333 
    334 	prog = getprogname();
    335 	fprintf(stderr,
    336 "usage: %s [-xZ] [-B endian] [-b free-blocks] [-d debug-mask]\n"
    337 "\t[-F mtree-specfile] [-f free-files] [-M minimum-size]\n"
    338 "\t[-m maximum-size] [-N userdb-dir] [-o fs-options] [-S sector-size]\n"
    339 "\t[-s image-size] [-t fs-type] image-file directory [extra-directory ...]\n",
    340 	    prog);
    341 	exit(1);
    342 }
    343