usr.sbin/makefs/makefs.c

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