obsolete-buildroot/sources/cramfs.patch

   1 --- cramfs-1.1.orig/cramfsck.c  2002-02-22 17:00:42.000000000 -0700
   2 +++ cramfs-1.1/cramfsck.c       2002-12-21 01:25:17.000000000 -0700
   3 @@ -51,10 +51,11 @@
   4  #include <utime.h>
   5  #include <sys/ioctl.h>
   6  #define _LINUX_STRING_H_
   7 -#include <linux/fs.h>
   8 -#include <linux/cramfs_fs.h>
   9 +#include "linux/cramfs_fs.h"
  10  #include <zlib.h>
  11
  12 +#define BLKGETSIZE     _IO(0x12,96) /* return device size /512 (long *arg) */
  13 +
  14  /* Exit codes used by fsck-type programs */
  15  #define FSCK_OK          0     /* No errors */
  16  #define FSCK_NONDESTRUCT 1     /* File system errors corrected */
  17 @@ -75,7 +76,7 @@
  18  static int opt_verbose = 0;    /* 1 = verbose (-v), 2+ = very verbose (-vv) */
  19  #ifdef INCLUDE_FS_TESTS
  20  static int opt_extract = 0;            /* extract cramfs (-x) */
  21 -static char *extract_dir = "root";     /* extraction directory (-x) */
  22 +static char *extract_dir = "/";        /* extraction directory (-x) */
  23  static uid_t euid;                     /* effective UID */
  24
  25  /* (cramfs_super + start) <= start_dir < end_dir <= start_data <= end_data */
  26 @@ -155,7 +156,7 @@
  27         }
  28
  29         if (*length < sizeof(struct cramfs_super)) {
  30 -               die(FSCK_UNCORRECTED, 0, "file length too short");
  31 +               die(FSCK_UNCORRECTED, 0, "filesystem smaller than a cramfs superblock!");
  32         }
  33
  34         /* find superblock */
  35 @@ -190,7 +191,8 @@
  36                         die(FSCK_UNCORRECTED, 0, "zero file count");
  37                 }
  38                 if (*length < super.size) {
  39 -                       die(FSCK_UNCORRECTED, 0, "file length too short");
  40 +                       die(FSCK_UNCORRECTED, 0, "file length too short, %lu is smaller than %lu",
  41 +                               *length, super.size);
  42                 }
  43                 else if (*length > super.size) {
  44                         fprintf(stderr, "warning: file extends past end of filesystem\n");
  45 @@ -267,11 +269,11 @@
  46  #ifdef INCLUDE_FS_TESTS
  47  static void print_node(char type, struct cramfs_inode *i, char *name)
  48  {
  49 -       char info[10];
  50 +       char info[11];
  51
  52         if (S_ISCHR(i->mode) || (S_ISBLK(i->mode))) {
  53                 /* major/minor numbers can be as high as 2^12 or 4096 */
  54 -               snprintf(info, 10, "%4d,%4d", major(i->size), minor(i->size));
  55 +               snprintf(info, 11, "%4d,%4d", major(i->size), minor(i->size));
  56         }
  57         else {
  58                 /* size be as high as 2^24 or 16777216 */
  59 @@ -445,8 +447,10 @@
  60         }
  61         /* TODO: Do we need to check end_dir for empty case? */
  62         memcpy(newpath, path, pathlen);
  63 -       newpath[pathlen] = '/';
  64 -       pathlen++;
  65 +       if (pathlen > 1) {
  66 +           newpath[pathlen] = '/';
  67 +           pathlen++;
  68 +       }
  69         if (opt_verbose) {
  70                 print_node('d', i, path);
  71         }
  72 --- cramfs-1.1.orig/device_table.txt    1969-12-31 17:00:00.000000000 -0700
  73 +++ cramfs-1.1/device_table.txt 2003-01-01 05:13:44.000000000 -0700
  74 @@ -0,0 +1,129 @@
  75 +# When building a target filesystem, it is desirable to not have to
  76 +# become root and then run 'mknod' a thousand times.  Using a device
  77 +# table you can create device nodes and directories "on the fly".
  78 +#
  79 +# This is a sample device table file for use with mkcramfs.  You can
  80 +# do all sorts of interesting things with a device table file.  For
  81 +# example, if you want to adjust the permissions on a particular file
  82 +# you can just add an entry like:
  83 +#   /sbin/foobar       f       2755    0       0       -       -       -       -       -
  84 +# and (assuming the file /sbin/foobar exists) it will be made setuid
  85 +# root (regardless of what its permissions are on the host filesystem.
  86 +# Furthermore, you can use a single table entry to create a many device
  87 +# minors.  For example, if I wanted to create /dev/hda and /dev/hda[0-15]
  88 +# I could just use the following two table entries:
  89 +#   /dev/hda   b       640     0       0       3       0       0       0       -
  90 +#   /dev/hda   b       640     0       0       3       1       1       1       15
  91 +#
  92 +# Device table entries take the form of:
  93 +# <name>    <type>     <mode>  <uid>   <gid>   <major> <minor> <start> <inc>   <count>
  94 +# where name is the file name,  type can be one of:
  95 +#      f       A regular file
  96 +#      d       Directory
  97 +#      c       Character special device file
  98 +#      b       Block special device file
  99 +#      p       Fifo (named pipe)
 100 +# uid is the user id for the target file, gid is the group id for the
 101 +# target file.  The rest of the entries (major, minor, etc) apply only
 102 +# to device special files.
 103 +
 104 +# Have fun
 105 +# -Erik Andersen <andersen@codepoet.org>
 106 +#
 107 +
 108 +#<name>                <type>  <mode>  <uid>   <gid>   <major> <minor> <start> <inc>   <count>
 109 +/dev           d       755     0       0       -       -       -       -       -
 110 +/dev/mem       c       640     0       0       1       1       0       0       -
 111 +/dev/kmem      c       640     0       0       1       2       0       0       -
 112 +/dev/null      c       640     0       0       1       3       0       0       -
 113 +/dev/zero      c       640     0       0       1       5       0       0       -
 114 +/dev/random    c       640     0       0       1       8       0       0       -
 115 +/dev/urandom   c       640     0       0       1       9       0       0       -
 116 +/dev/tty       c       666     0       0       5       0       0       0       -
 117 +/dev/tty       c       666     0       0       4       0       0       1       6
 118 +/dev/console   c       640     0       0       5       1       0       0       -
 119 +/dev/ram       b       640     0       0       1       1       0       0       -
 120 +/dev/ram       b       640     0       0       1       0       0       1       4
 121 +/dev/loop      b       640     0       0       7       0       0       1       2
 122 +/dev/ptmx      c       666     0       0       5       2       0       0       -
 123 +#/dev/ttyS     c       640     0       0       4       64      0       1       4
 124 +#/dev/psaux    c       640     0       0       10      1       0       0       -
 125 +#/dev/rtc      c       640     0       0       10      135     0       0       -
 126 +
 127 +# Adjust permissions on some normal files
 128 +#/etc/shadow   f       600     0       0       -       -       -       -       -
 129 +#/bin/tinylogin        f       4755    0       0       -       -       -       -       -
 130 +
 131 +# User-mode Linux stuff
 132 +/dev/ubda      b       640     0       0       98      0       0       0       -
 133 +/dev/ubda      b       640     0       0       98      1       1       1       15
 134 +
 135 +# IDE Devices
 136 +/dev/hda       b       640     0       0       3       0       0       0       -
 137 +/dev/hda       b       640     0       0       3       1       1       1       15
 138 +/dev/hdb       b       640     0       0       3       64      0       0       -
 139 +/dev/hdb       b       640     0       0       3       65      1       1       15
 140 +#/dev/hdc      b       640     0       0       22      0       0       0       -
 141 +#/dev/hdc      b       640     0       0       22      1       1       1       15
 142 +#/dev/hdd      b       640     0       0       22      64      0       0       -
 143 +#/dev/hdd      b       640     0       0       22      65      1       1       15
 144 +#/dev/hde      b       640     0       0       33      0       0       0       -
 145 +#/dev/hde      b       640     0       0       33      1       1       1       15
 146 +#/dev/hdf      b       640     0       0       33      64      0       0       -
 147 +#/dev/hdf      b       640     0       0       33      65      1       1       15
 148 +#/dev/hdg      b       640     0       0       34      0       0       0       -
 149 +#/dev/hdg      b       640     0       0       34      1       1       1       15
 150 +#/dev/hdh      b       640     0       0       34      64      0       0       -
 151 +#/dev/hdh      b       640     0       0       34      65      1       1       15
 152 +
 153 +# SCSI Devices
 154 +#/dev/sda      b       640     0       0       8       0       0       0       -
 155 +#/dev/sda      b       640     0       0       8       1       1       1       15
 156 +#/dev/sdb      b       640     0       0       8       16      0       0       -
 157 +#/dev/sdb      b       640     0       0       8       17      1       1       15
 158 +#/dev/sdc      b       640     0       0       8       32      0       0       -
 159 +#/dev/sdc      b       640     0       0       8       33      1       1       15
 160 +#/dev/sdd      b       640     0       0       8       48      0       0       -
 161 +#/dev/sdd      b       640     0       0       8       49      1       1       15
 162 +#/dev/sde      b       640     0       0       8       64      0       0       -
 163 +#/dev/sde      b       640     0       0       8       65      1       1       15
 164 +#/dev/sdf      b       640     0       0       8       80      0       0       -
 165 +#/dev/sdf      b       640     0       0       8       81      1       1       15
 166 +#/dev/sdg      b       640     0       0       8       96      0       0       -
 167 +#/dev/sdg      b       640     0       0       8       97      1       1       15
 168 +#/dev/sdh      b       640     0       0       8       112     0       0       -
 169 +#/dev/sdh      b       640     0       0       8       113     1       1       15
 170 +#/dev/sg               c       640     0       0       21      0       0       1       15
 171 +#/dev/scd      b       640     0       0       11      0       0       1       15
 172 +#/dev/st               c       640     0       0       9       0       0       1       8
 173 +#/dev/nst      c       640     0       0       9       128     0       1       8
 174 +#/dev/st       c       640     0       0       9       32      1       1       4
 175 +#/dev/st       c       640     0       0       9       64      1       1       4
 176 +#/dev/st       c       640     0       0       9       96      1       1       4
 177 +
 178 +# Floppy disk devices
 179 +#/dev/fd               b       640     0       0       2       0       0       1       2
 180 +#/dev/fd0d360  b       640     0       0       2       4       0       0       -
 181 +#/dev/fd1d360  b       640     0       0       2       5       0       0       -
 182 +#/dev/fd0h1200 b       640     0       0       2       8       0       0       -
 183 +#/dev/fd1h1200 b       640     0       0       2       9       0       0       -
 184 +#/dev/fd0u1440 b       640     0       0       2       28      0       0       -
 185 +#/dev/fd1u1440 b       640     0       0       2       29      0       0       -
 186 +#/dev/fd0u2880 b       640     0       0       2       32      0       0       -
 187 +#/dev/fd1u2880 b       640     0       0       2       33      0       0       -
 188 +
 189 +# All the proprietary cdrom devices in the world
 190 +#/dev/aztcd    b       640     0       0       29      0       0       0       -
 191 +#/dev/bpcd     b       640     0       0       41      0       0       0       -
 192 +#/dev/capi20   c       640     0       0       68      0       0       1       2
 193 +#/dev/cdu31a   b       640     0       0       15      0       0       0       -
 194 +#/dev/cdu535   b       640     0       0       24      0       0       0       -
 195 +#/dev/cm206cd  b       640     0       0       32      0       0       0       -
 196 +#/dev/sjcd     b       640     0       0       18      0       0       0       -
 197 +#/dev/sonycd   b       640     0       0       15      0       0       0       -
 198 +#/dev/gscd     b       640     0       0       16      0       0       0       -
 199 +#/dev/sbpcd    b       640     0       0       25      0       0       0       -
 200 +#/dev/sbpcd    b       640     0       0       25      0       0       1       4
 201 +#/dev/mcd      b       640     0       0       23      0       0       0       -
 202 +#/dev/optcd    b       640     0       0       17      0       0       0       -
 203 +
 204 --- cramfs-1.1.orig/mkcramfs.c  2002-02-20 01:03:32.000000000 -0700
 205 +++ cramfs-1.1/mkcramfs.c       2002-12-21 01:25:17.000000000 -0700
 206 @@ -1,3 +1,4 @@
 207 +/* vi: set sw=8 ts=8: */
 208  /*
 209   * mkcramfs - make a cramfs file system
 210   *
 211 @@ -16,12 +17,21 @@
 212   * You should have received a copy of the GNU General Public License
 213   * along with this program; if not, write to the Free Software
 214   * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 215 + *
 216 + * Added device table support (code taken from mkfs.jffs2.c, credit to
 217 + * Erik Andersen <andersen@codepoet.org>) as well as an option to squash
 218 + * permissions. - Russ Dill <Russ.Dill@asu.edu> September 2002
 219 + *
 220 + * Reworked, cleaned up, and updated for cramfs-1.1, December 2002
 221 + *  - Erik Andersen <andersen@codepoet.org>
 222 + *
 223   */
 224
 225  /*
 226   * If you change the disk format of cramfs, please update fs/cramfs/README.
 227   */
 228
 229 +#define _GNU_SOURCE
 230  #include <sys/types.h>
 231  #include <stdio.h>
 232  #include <sys/stat.h>
 233 @@ -33,8 +43,15 @@
 234  #include <errno.h>
 235  #include <string.h>
 236  #include <stdarg.h>
 237 +#include <libgen.h>
 238 +#include <ctype.h>
 239 +#include <assert.h>
 240 +#include <getopt.h>
 241  #include <linux/cramfs_fs.h>
 242  #include <zlib.h>
 243 +#ifdef DMALLOC
 244 +#include <dmalloc.h>
 245 +#endif
 246
 247  /* Exit codes used by mkfs-type programs */
 248  #define MKFS_OK          0     /* No errors */
 249 @@ -71,11 +88,17 @@
 250                   + (1 << CRAMFS_SIZE_WIDTH) - 1 /* filesize */ \
 251                   + (1 << CRAMFS_SIZE_WIDTH) * 4 / PAGE_CACHE_SIZE /* block pointers */ )
 252
 253 +
 254 +/* The kernel assumes PAGE_CACHE_SIZE as block size. */
 255 +#define PAGE_CACHE_SIZE (4096)
 256 +
 257 +
 258  static const char *progname = "mkcramfs";
 259  static unsigned int blksize = PAGE_CACHE_SIZE;
 260  static long total_blocks = 0, total_nodes = 1; /* pre-count the root node */
 261  static int image_length = 0;
 262
 263 +
 264  /*
 265   * If opt_holes is set, then mkcramfs can create explicit holes in the
 266   * data, which saves 26 bytes per hole (which is a lot smaller a
 267 @@ -91,10 +114,12 @@
 268  static int opt_holes = 0;
 269  static int opt_pad = 0;
 270  static int opt_verbose = 0;
 271 +static int opt_squash = 0;
 272  static char *opt_image = NULL;
 273  static char *opt_name = NULL;
 274
 275  static int warn_dev, warn_gid, warn_namelen, warn_skip, warn_size, warn_uid;
 276 +static const char *const memory_exhausted = "memory exhausted";
 277
 278  /* In-core version of inode / directory entry. */
 279  struct entry {
 280 @@ -123,7 +148,7 @@
 281  {
 282         FILE *stream = status ? stderr : stdout;
 283
 284 -       fprintf(stream, "usage: %s [-h] [-e edition] [-i file] [-n name] dirname outfile\n"
 285 +       fprintf(stream, "usage: %s [-h] [-e edition] [-i file] [-n name] [-D file] dirname outfile\n"
 286                 " -h         print this help\n"
 287                 " -E         make all warnings errors (non-zero exit status)\n"
 288                 " -e edition set edition number (part of fsid)\n"
 289 @@ -133,39 +158,157 @@
 290                 " -s         sort directory entries (old option, ignored)\n"
 291                 " -v         be more verbose\n"
 292                 " -z         make explicit holes (requires >= 2.3.39)\n"
 293 -               " dirname    root of the directory tree to be compressed\n"
 294 +               " -D         Use the named FILE as a device table file\n"
 295 +               " -q         squash permissions (make everything owned by root)\n"
 296 +               " dirname    root of the filesystem to be compressed\n"
 297                 " outfile    output file\n", progname, PAD_SIZE);
 298
 299         exit(status);
 300  }
 301
 302 -static void die(int status, int syserr, const char *fmt, ...)
 303 +static void verror_msg(const char *s, va_list p)
 304 +{
 305 +       fflush(stdout);
 306 +       fprintf(stderr, "mkcramfs: ");
 307 +       vfprintf(stderr, s, p);
 308 +}
 309 +
 310 +static void vperror_msg(const char *s, va_list p)
 311 +{
 312 +       int err = errno;
 313 +
 314 +       if (s == 0)
 315 +               s = "";
 316 +       verror_msg(s, p);
 317 +       if (*s)
 318 +               s = ": ";
 319 +       fprintf(stderr, "%s%s\n", s, strerror(err));
 320 +}
 321 +
 322 +static void perror_msg(const char *s, ...)
 323 +{
 324 +       va_list p;
 325 +
 326 +       va_start(p, s);
 327 +       vperror_msg(s, p);
 328 +       va_end(p);
 329 +}
 330 +
 331 +static void error_msg_and_die(const char *s, ...)
 332 +{
 333 +       va_list p;
 334 +
 335 +       va_start(p, s);
 336 +       verror_msg(s, p);
 337 +       va_end(p);
 338 +       putc('\n', stderr);
 339 +       exit(MKFS_ERROR);
 340 +}
 341 +
 342 +static void perror_msg_and_die(const char *s, ...)
 343 +{
 344 +       va_list p;
 345 +
 346 +       va_start(p, s);
 347 +       vperror_msg(s, p);
 348 +       va_end(p);
 349 +       exit(MKFS_ERROR);
 350 +}
 351 +#ifndef DMALLOC
 352 +extern char *xstrdup(const char *s)
 353 +{
 354 +       char *t;
 355 +
 356 +       if (s == NULL)
 357 +               return NULL;
 358 +       t = strdup(s);
 359 +       if (t == NULL)
 360 +               error_msg_and_die(memory_exhausted);
 361 +       return t;
 362 +}
 363 +
 364 +extern void *xmalloc(size_t size)
 365 +{
 366 +       void *ptr = malloc(size);
 367 +
 368 +       if (ptr == NULL && size != 0)
 369 +               error_msg_and_die(memory_exhausted);
 370 +       return ptr;
 371 +}
 372 +
 373 +extern void *xcalloc(size_t nmemb, size_t size)
 374 +{
 375 +       void *ptr = calloc(nmemb, size);
 376 +
 377 +       if (ptr == NULL && nmemb != 0 && size != 0)
 378 +               error_msg_and_die(memory_exhausted);
 379 +       return ptr;
 380 +}
 381 +
 382 +extern void *xrealloc(void *ptr, size_t size)
 383 +{
 384 +       ptr = realloc(ptr, size);
 385 +       if (ptr == NULL && size != 0)
 386 +               error_msg_and_die(memory_exhausted);
 387 +       return ptr;
 388 +}
 389 +#endif
 390 +
 391 +static FILE *xfopen(const char *path, const char *mode)
 392  {
 393 -       va_list arg_ptr;
 394 -       int save = errno;
 395 +       FILE *fp;
 396 +
 397 +       if ((fp = fopen(path, mode)) == NULL)
 398 +               perror_msg_and_die("%s", path);
 399 +       return fp;
 400 +}
 401
 402 -       fflush(0);
 403 -       va_start(arg_ptr, fmt);
 404 -       fprintf(stderr, "%s: ", progname);
 405 -       vfprintf(stderr, fmt, arg_ptr);
 406 -       if (syserr) {
 407 -               fprintf(stderr, ": %s", strerror(save));
 408 +extern int xopen(const char *pathname, int flags, mode_t mode)
 409 +{
 410 +       int ret;
 411 +
 412 +       if (flags & O_CREAT)
 413 +               ret = open(pathname, flags, mode);
 414 +       else
 415 +               ret = open(pathname, flags);
 416 +       if (ret == -1) {
 417 +               perror_msg_and_die("%s", pathname);
 418         }
 419 -       fprintf(stderr, "\n");
 420 -       va_end(arg_ptr);
 421 -       exit(status);
 422 +       return ret;
 423  }
 424
 425 +extern char *xreadlink(const char *path)
 426 +{
 427 +       static const int GROWBY = 80; /* how large we will grow strings by */
 428 +
 429 +       char *buf = NULL;
 430 +       int bufsize = 0, readsize = 0;
 431 +
 432 +       do {
 433 +               buf = xrealloc(buf, bufsize += GROWBY);
 434 +               readsize = readlink(path, buf, bufsize); /* 1st try */
 435 +               if (readsize == -1) {
 436 +                   perror_msg("%s:%s", progname, path);
 437 +                   return NULL;
 438 +               }
 439 +       }
 440 +       while (bufsize < readsize + 1);
 441 +
 442 +       buf[readsize] = '\0';
 443 +
 444 +       return buf;
 445 +}
 446 +
 447  static void map_entry(struct entry *entry)
 448  {
 449         if (entry->path) {
 450                 entry->fd = open(entry->path, O_RDONLY);
 451                 if (entry->fd < 0) {
 452 -                       die(MKFS_ERROR, 1, "open failed: %s", entry->path);
 453 +                       error_msg_and_die("open failed: %s", entry->path);
 454                 }
 455                 entry->uncompressed = mmap(NULL, entry->size, PROT_READ, MAP_PRIVATE, entry->fd, 0);
 456                 if (entry->uncompressed == MAP_FAILED) {
 457 -                       die(MKFS_ERROR, 1, "mmap failed: %s", entry->path);
 458 +                       error_msg_and_die("mmap failed: %s", entry->path);
 459                 }
 460         }
 461  }
 462 @@ -174,8 +317,9 @@
 463  {
 464         if (entry->path) {
 465                 if (munmap(entry->uncompressed, entry->size) < 0) {
 466 -                       die(MKFS_ERROR, 1, "munmap failed: %s", entry->path);
 467 +                       error_msg_and_die("munmap failed: %s", entry->path);
 468                 }
 469 +               entry->uncompressed=NULL;
 470                 close(entry->fd);
 471         }
 472  }
 473 @@ -204,7 +348,8 @@
 474                 find_identical_file(orig->next, newfile));
 475  }
 476
 477 -static void eliminate_doubles(struct entry *root, struct entry *orig) {
 478 +static void eliminate_doubles(struct entry *root, struct entry *orig)
 479 +{
 480         if (orig) {
 481                 if (orig->size && (orig->path || orig->uncompressed))
 482                         find_identical_file(root, orig);
 483 @@ -232,10 +377,7 @@
 484
 485         /* Set up the path. */
 486         /* TODO: Reuse the parent's buffer to save memcpy'ing and duplication. */
 487 -       path = malloc(len + 1 + MAX_INPUT_NAMELEN + 1);
 488 -       if (!path) {
 489 -               die(MKFS_ERROR, 1, "malloc failed");
 490 -       }
 491 +       path = xmalloc(len + 1 + MAX_INPUT_NAMELEN + 1);
 492         memcpy(path, name, len);
 493         endpath = path + len;
 494         *endpath = '/';
 495 @@ -245,7 +387,7 @@
 496         dircount = scandir(name, &dirlist, 0, cramsort);
 497
 498         if (dircount < 0) {
 499 -               die(MKFS_ERROR, 1, "scandir failed: %s", name);
 500 +               error_msg_and_die("scandir failed: %s", name);
 501         }
 502
 503         /* process directory */
 504 @@ -269,25 +411,20 @@
 505                 }
 506                 namelen = strlen(dirent->d_name);
 507                 if (namelen > MAX_INPUT_NAMELEN) {
 508 -                       die(MKFS_ERROR, 0,
 509 -                               "very long (%u bytes) filename found: %s\n"
 510 -                               "please increase MAX_INPUT_NAMELEN in mkcramfs.c and recompile",
 511 +                       error_msg_and_die(
 512 +                               "Very long (%u bytes) filename `%s' found.\n"
 513 +                               " Please increase MAX_INPUT_NAMELEN in mkcramfs.c and recompile.  Exiting.\n",
 514                                 namelen, dirent->d_name);
 515                 }
 516                 memcpy(endpath, dirent->d_name, namelen + 1);
 517
 518                 if (lstat(path, &st) < 0) {
 519 +                       perror(endpath);
 520                         warn_skip = 1;
 521                         continue;
 522                 }
 523 -               entry = calloc(1, sizeof(struct entry));
 524 -               if (!entry) {
 525 -                       die(MKFS_ERROR, 1, "calloc failed");
 526 -               }
 527 -               entry->name = strdup(dirent->d_name);
 528 -               if (!entry->name) {
 529 -                       die(MKFS_ERROR, 1, "strdup failed");
 530 -               }
 531 +               entry = xcalloc(1, sizeof(struct entry));
 532 +               entry->name = xstrdup(dirent->d_name);
 533                 /* truncate multi-byte UTF-8 filenames on character boundary */
 534                 if (namelen > CRAMFS_MAXPATHLEN) {
 535                         namelen = CRAMFS_MAXPATHLEN;
 536 @@ -297,24 +434,25 @@
 537                                 namelen--;
 538                                 /* are we reasonably certain it was UTF-8 ? */
 539                                 if (entry->name[namelen] < 0x80 || !namelen) {
 540 -                                       die(MKFS_ERROR, 0, "cannot truncate filenames not encoded in UTF-8");
 541 +                                       error_msg_and_die("cannot truncate filenames not encoded in UTF-8");
 542                                 }
 543                         }
 544                         entry->name[namelen] = '\0';
 545                 }
 546                 entry->mode = st.st_mode;
 547                 entry->size = st.st_size;
 548 -               entry->uid = st.st_uid;
 549 +               entry->uid = opt_squash ? 0 : st.st_uid;
 550                 if (entry->uid >= 1 << CRAMFS_UID_WIDTH)
 551                         warn_uid = 1;
 552 -               entry->gid = st.st_gid;
 553 -               if (entry->gid >= 1 << CRAMFS_GID_WIDTH)
 554 +               entry->gid = opt_squash ? 0 : st.st_gid;
 555 +               if (entry->gid >= 1 << CRAMFS_GID_WIDTH) {
 556                         /* TODO: We ought to replace with a default
 557                            gid instead of truncating; otherwise there
 558                            are security problems.  Maybe mode should
 559                            be &= ~070.  Same goes for uid once Linux
 560                            supports >16-bit uids. */
 561                         warn_gid = 1;
 562 +               }
 563                 size = sizeof(struct cramfs_inode) + ((namelen + 3) & ~3);
 564                 *fslen_ub += size;
 565                 if (S_ISDIR(st.st_mode)) {
 566 @@ -325,21 +463,15 @@
 567                                         warn_skip = 1;
 568                                         continue;
 569                                 }
 570 -                               entry->path = strdup(path);
 571 -                               if (!entry->path) {
 572 -                                       die(MKFS_ERROR, 1, "strdup failed");
 573 -                               }
 574 +                               entry->path = xstrdup(path);
 575                                 if ((entry->size >= 1 << CRAMFS_SIZE_WIDTH)) {
 576                                         warn_size = 1;
 577                                         entry->size = (1 << CRAMFS_SIZE_WIDTH) - 1;
 578                                 }
 579                         }
 580                 } else if (S_ISLNK(st.st_mode)) {
 581 -                       entry->uncompressed = malloc(entry->size);
 582 +                       entry->uncompressed = xreadlink(path);
 583                         if (!entry->uncompressed) {
 584 -                               die(MKFS_ERROR, 1, "malloc failed");
 585 -                       }
 586 -                       if (readlink(path, entry->uncompressed, entry->size) < 0) {
 587                                 warn_skip = 1;
 588                                 continue;
 589                         }
 590 @@ -351,7 +483,7 @@
 591                         if (entry->size & -(1<<CRAMFS_SIZE_WIDTH))
 592                                 warn_dev = 1;
 593                 } else {
 594 -                       die(MKFS_ERROR, 0, "bogus file type: %s", entry->name);
 595 +                       error_msg_and_die("bogus file type: %s", entry->name);
 596                 }
 597
 598                 if (S_ISREG(st.st_mode) || S_ISLNK(st.st_mode)) {
 599 @@ -378,7 +510,9 @@
 600         struct cramfs_super *super = (struct cramfs_super *) base;
 601         unsigned int offset = sizeof(struct cramfs_super) + image_length;
 602
 603 -       offset += opt_pad;      /* 0 if no padding */
 604 +       if (opt_pad) {
 605 +               offset += opt_pad;      /* 0 if no padding */
 606 +       }
 607
 608         super->magic = CRAMFS_MAGIC;
 609         super->flags = CRAMFS_FLAG_FSID_VERSION_2 | CRAMFS_FLAG_SORTED_DIRS;
 610 @@ -414,10 +548,10 @@
 611         struct cramfs_inode *inode = (struct cramfs_inode *) (base + entry->dir_offset);
 612
 613         if ((offset & 3) != 0) {
 614 -               die(MKFS_ERROR, 0, "illegal offset of %lu bytes", offset);
 615 +               error_msg_and_die("illegal offset of %lu bytes", offset);
 616         }
 617         if (offset >= (1 << (2 + CRAMFS_OFFSET_WIDTH))) {
 618 -               die(MKFS_ERROR, 0, "filesystem too big");
 619 +               error_msg_and_die("filesystem too big");
 620         }
 621         inode->offset = (offset >> 2);
 622  }
 623 @@ -429,7 +563,7 @@
 624   */
 625  static void print_node(struct entry *e)
 626  {
 627 -       char info[10];
 628 +       char info[12];
 629         char type = '?';
 630
 631         if (S_ISREG(e->mode)) type = 'f';
 632 @@ -442,11 +576,11 @@
 633
 634         if (S_ISCHR(e->mode) || (S_ISBLK(e->mode))) {
 635                 /* major/minor numbers can be as high as 2^12 or 4096 */
 636 -               snprintf(info, 10, "%4d,%4d", major(e->size), minor(e->size));
 637 +               snprintf(info, 11, "%4d,%4d", major(e->size), minor(e->size));
 638         }
 639         else {
 640                 /* size be as high as 2^24 or 16777216 */
 641 -               snprintf(info, 10, "%9d", e->size);
 642 +               snprintf(info, 11, "%9d", e->size);
 643         }
 644
 645         printf("%c %04o %s %5d:%-3d %s\n",
 646 @@ -462,17 +596,9 @@
 647  {
 648         int stack_entries = 0;
 649         int stack_size = 64;
 650 -       struct entry **entry_stack;
 651 -
 652 -       entry_stack = malloc(stack_size * sizeof(struct entry *));
 653 -       if (!entry_stack) {
 654 -               die(MKFS_ERROR, 1, "malloc failed");
 655 -       }
 656 -
 657 -       if (opt_verbose) {
 658 -               printf("root:\n");
 659 -       }
 660 +       struct entry **entry_stack = NULL;
 661
 662 +       entry_stack = xmalloc(stack_size * sizeof(struct entry *));
 663         for (;;) {
 664                 int dir_start = stack_entries;
 665                 while (entry) {
 666 @@ -506,10 +632,7 @@
 667                         if (entry->child) {
 668                                 if (stack_entries >= stack_size) {
 669                                         stack_size *= 2;
 670 -                                       entry_stack = realloc(entry_stack, stack_size * sizeof(struct entry *));
 671 -                                       if (!entry_stack) {
 672 -                                               die(MKFS_ERROR, 1, "realloc failed");
 673 -                                       }
 674 +                                       entry_stack = xrealloc(entry_stack, stack_size * sizeof(struct entry *));
 675                                 }
 676                                 entry_stack[stack_entries] = entry;
 677                                 stack_entries++;
 678 @@ -543,7 +666,7 @@
 679
 680                 set_data_offset(entry, base, offset);
 681                 if (opt_verbose) {
 682 -                       printf("%s:\n", entry->name);
 683 +                   printf("'%s':\n", entry->name);
 684                 }
 685                 entry = entry->child;
 686         }
 687 @@ -553,16 +676,21 @@
 688
 689  static int is_zero(char const *begin, unsigned len)
 690  {
 691 -       /* Returns non-zero iff the first LEN bytes from BEGIN are all NULs. */
 692 -       return (len-- == 0 ||
 693 -               (begin[0] == '\0' &&
 694 -                (len-- == 0 ||
 695 -                 (begin[1] == '\0' &&
 696 -                  (len-- == 0 ||
 697 -                   (begin[2] == '\0' &&
 698 -                    (len-- == 0 ||
 699 -                     (begin[3] == '\0' &&
 700 -                      memcmp(begin, begin + 4, len) == 0))))))));
 701 +       if (opt_holes)
 702 +               /* Returns non-zero iff the first LEN bytes from BEGIN are
 703 +                  all NULs. */
 704 +               return (len-- == 0 ||
 705 +                       (begin[0] == '\0' &&
 706 +                        (len-- == 0 ||
 707 +                         (begin[1] == '\0' &&
 708 +                          (len-- == 0 ||
 709 +                           (begin[2] == '\0' &&
 710 +                            (len-- == 0 ||
 711 +                             (begin[3] == '\0' &&
 712 +                              memcmp(begin, begin + 4, len) == 0))))))));
 713 +       else
 714 +               /* Never create holes. */
 715 +               return 0;
 716  }
 717
 718  /*
 719 @@ -575,37 +703,34 @@
 720   * Note that size > 0, as a zero-sized file wouldn't ever
 721   * have gotten here in the first place.
 722   */
 723 -static unsigned int do_compress(char *base, unsigned int offset, char const *name, char *uncompressed, unsigned int size)
 724 +static unsigned int do_compress(char *base, unsigned int offset, struct entry *entry)
 725  {
 726 +       unsigned int size = entry->size;
 727         unsigned long original_size = size;
 728         unsigned long original_offset = offset;
 729         unsigned long new_size;
 730         unsigned long blocks = (size - 1) / blksize + 1;
 731         unsigned long curr = offset + 4 * blocks;
 732         int change;
 733 +       char *uncompressed = entry->uncompressed;
 734
 735 -       total_blocks += blocks;
 736 +       total_blocks += blocks;
 737
 738         do {
 739                 unsigned long len = 2 * blksize;
 740                 unsigned int input = size;
 741 -               int err;
 742 -
 743                 if (input > blksize)
 744                         input = blksize;
 745                 size -= input;
 746 -               if (!(opt_holes && is_zero (uncompressed, input))) {
 747 -                       err = compress2(base + curr, &len, uncompressed, input, Z_BEST_COMPRESSION);
 748 -                       if (err != Z_OK) {
 749 -                               die(MKFS_ERROR, 0, "compression error: %s", zError(err));
 750 -                       }
 751 +               if (!is_zero (uncompressed, input)) {
 752 +                       compress(base + curr, &len, uncompressed, input);
 753                         curr += len;
 754                 }
 755                 uncompressed += input;
 756
 757                 if (len > blksize*2) {
 758                         /* (I don't think this can happen with zlib.) */
 759 -                       die(MKFS_ERROR, 0, "AIEEE: block \"compressed\" to > 2*blocklength (%ld)", len);
 760 +                       error_msg_and_die("AIEEE: block \"compressed\" to > 2*blocklength (%ld)\n", len);
 761                 }
 762
 763                 *(u32 *) (base + offset) = curr;
 764 @@ -618,10 +743,12 @@
 765            st_blocks * 512.  But if you say that then perhaps
 766            administrative data should also be included in both. */
 767         change = new_size - original_size;
 768 -       if (opt_verbose > 1) {
 769 -               printf("%6.2f%% (%+d bytes)\t%s\n",
 770 -                      (change * 100) / (double) original_size, change, name);
 771 +#if 0
 772 +       if (opt_verbose) {
 773 +           printf("%6.2f%% (%+d bytes)\t%s\n",
 774 +                   (change * 100) / (double) original_size, change, entry->name);
 775         }
 776 +#endif
 777
 778         return curr;
 779  }
 780 @@ -644,7 +771,7 @@
 781                                 set_data_offset(entry, base, offset);
 782                                 entry->offset = offset;
 783                                 map_entry(entry);
 784 -                               offset = do_compress(base, offset, entry->name, entry->uncompressed, entry->size);
 785 +                               offset = do_compress(base, offset, entry);
 786                                 unmap_entry(entry);
 787                         }
 788                 }
 789 @@ -660,13 +787,10 @@
 790         int fd;
 791         char *buf;
 792
 793 -       fd = open(file, O_RDONLY);
 794 -       if (fd < 0) {
 795 -               die(MKFS_ERROR, 1, "open failed: %s", file);
 796 -       }
 797 +       fd = xopen(file, O_RDONLY, 0);
 798         buf = mmap(NULL, image_length, PROT_READ, MAP_PRIVATE, fd, 0);
 799         if (buf == MAP_FAILED) {
 800 -               die(MKFS_ERROR, 1, "mmap failed");
 801 +               error_msg_and_die("mmap failed");
 802         }
 803         memcpy(base + offset, buf, image_length);
 804         munmap(buf, image_length);
 805 @@ -679,6 +803,328 @@
 806         return (offset + image_length);
 807  }
 808
 809 +static struct entry *find_filesystem_entry(struct entry *dir, char *name, mode_t type)
 810 +{
 811 +       struct entry *e = dir;
 812 +
 813 +       if (S_ISDIR(dir->mode)) {
 814 +               e = dir->child;
 815 +       }
 816 +       while (e) {
 817 +               /* Only bother to do the expensive strcmp on matching file types */
 818 +               if (type == (e->mode & S_IFMT) && e->name) {
 819 +                       if (S_ISDIR(e->mode)) {
 820 +                               int len = strlen(e->name);
 821 +
 822 +                               /* Check if we are a parent of the correct path */
 823 +                               if (strncmp(e->name, name, len) == 0) {
 824 +                                       /* Is this an _exact_ match? */
 825 +                                       if (strcmp(name, e->name) == 0) {
 826 +                                               return (e);
 827 +                                       }
 828 +                                       /* Looks like we found a parent of the correct path */
 829 +                                       if (name[len] == '/') {
 830 +                                               if (e->child) {
 831 +                                                       return (find_filesystem_entry (e, name + len + 1, type));
 832 +                                               } else {
 833 +                                                       return NULL;
 834 +                                               }
 835 +                                       }
 836 +                               }
 837 +                       } else {
 838 +                               if (strcmp(name, e->name) == 0) {
 839 +                                       return (e);
 840 +                               }
 841 +                       }
 842 +               }
 843 +               e = e->next;
 844 +       }
 845 +       return (NULL);
 846 +}
 847 +
 848 +void modify_entry(char *full_path, unsigned long uid, unsigned long gid,
 849 +       unsigned long mode, unsigned long rdev, struct entry *root, loff_t *fslen_ub)
 850 +{
 851 +       char *name, *path, *full;
 852 +       struct entry *curr, *parent, *entry, *prev;
 853 +
 854 +       full = xstrdup(full_path);
 855 +       path = xstrdup(dirname(full));
 856 +       name = full_path + strlen(path) + 1;
 857 +       free(full);
 858 +       if (strcmp(path, "/") == 0) {
 859 +               parent = root;
 860 +               name = full_path + 1;
 861 +       } else {
 862 +               if (!(parent = find_filesystem_entry(root, path+1, S_IFDIR)))
 863 +                       error_msg_and_die("%s/%s: could not find parent\n", path, name);
 864 +       }
 865 +       if ((entry = find_filesystem_entry(parent, name, (mode & S_IFMT)))) {
 866 +               /* its there, just modify permissions */
 867 +               entry->mode = mode;
 868 +               entry->uid = uid;
 869 +               entry->gid = gid;
 870 +       } else { /* make a new entry */
 871 +
 872 +               /* code partially replicated from parse_directory() */
 873 +               size_t namelen;
 874 +               if (S_ISREG(mode)) {
 875 +                       error_msg_and_die("%s: regular file from device_table file must exist on disk!", full_path);
 876 +               }
 877 +
 878 +               namelen = strlen(name);
 879 +               if (namelen > MAX_INPUT_NAMELEN) {
 880 +                       error_msg_and_die(
 881 +                               "Very long (%u bytes) filename `%s' found.\n"
 882 +                               " Please increase MAX_INPUT_NAMELEN in mkcramfs.c and recompile.  Exiting.\n",
 883 +                               namelen, name);
 884 +               }
 885 +               entry = xcalloc(1, sizeof(struct entry));
 886 +               entry->name = xstrdup(name);
 887 +               /* truncate multi-byte UTF-8 filenames on character boundary */
 888 +               if (namelen > CRAMFS_MAXPATHLEN) {
 889 +                       namelen = CRAMFS_MAXPATHLEN;
 890 +                       warn_namelen = 1;
 891 +                       /* the first lost byte must not be a trail byte */
 892 +                       while ((entry->name[namelen] & 0xc0) == 0x80) {
 893 +                               namelen--;
 894 +                               /* are we reasonably certain it was UTF-8 ? */
 895 +                               if (entry->name[namelen] < 0x80 || !namelen) {
 896 +                                       error_msg_and_die("cannot truncate filenames not encoded in UTF-8");
 897 +                               }
 898 +                       }
 899 +                       entry->name[namelen] = '\0';
 900 +               }
 901 +               entry->mode = mode;
 902 +               entry->uid = uid;
 903 +               entry->gid = gid;
 904 +               entry->size = 0;
 905 +               if (S_ISBLK(mode) || S_ISCHR(mode)) {
 906 +                       entry->size = rdev;
 907 +                       if (entry->size & -(1<<CRAMFS_SIZE_WIDTH))
 908 +                               warn_dev = 1;
 909 +               }
 910 +
 911 +               /* ok, now we have to backup and correct the size of all the entries above us */
 912 +               *fslen_ub += sizeof(struct cramfs_inode) + ((namelen + 3) & ~3);
 913 +               parent->size += sizeof(struct cramfs_inode) + ((namelen + 3) & ~3);
 914 +
 915 +               /* alright, time to link us in */
 916 +               curr = parent->child;
 917 +               prev = NULL;
 918 +               while (curr && strcmp(name, curr->name) > 0) {
 919 +                       prev = curr;
 920 +                       curr = curr->next;
 921 +               }
 922 +               if (!prev) parent->child = entry;
 923 +               else prev->next = entry;
 924 +               entry->next = curr;
 925 +               entry->child = NULL;
 926 +       }
 927 +       if (entry->uid >= 1 << CRAMFS_UID_WIDTH)
 928 +               warn_uid = 1;
 929 +       if (entry->gid >= 1 << CRAMFS_GID_WIDTH) {
 930 +               /* TODO: We ought to replace with a default
 931 +                  gid instead of truncating; otherwise there
 932 +                  are security problems.  Maybe mode should
 933 +                  be &= ~070.  Same goes for uid once Linux
 934 +                  supports >16-bit uids. */
 935 +               warn_gid = 1;
 936 +       }
 937 +       free(path);
 938 +}
 939 +
 940 +/* the GNU C library has a wonderful scanf("%as", string) which will
 941 + allocate the string with the right size, good to avoid buffer overruns.
 942 + the following macros use it if available or use a hacky workaround...
 943 + */
 944 +
 945 +#ifdef __GNUC__
 946 +#define SCANF_PREFIX "a"
 947 +#define SCANF_STRING(s) (&s)
 948 +#define GETCWD_SIZE 0
 949 +#else
 950 +#define SCANF_PREFIX "511"
 951 +#define SCANF_STRING(s) (s = xmalloc(512))
 952 +#define GETCWD_SIZE -1
 953 +inline int snprintf(char *str, size_t n, const char *fmt, ...)
 954 +{
 955 +       int ret;
 956 +       va_list ap;
 957 +
 958 +       va_start(ap, fmt);
 959 +       ret = vsprintf(str, fmt, ap);
 960 +       va_end(ap);
 961 +       return ret;
 962 +}
 963 +#endif
 964 +
 965 +/*  device table entries take the form of:
 966 +    <path>     <type> <mode>   <uid>   <gid>   <major> <minor> <start> <inc>   <count>
 967 +    /dev/mem     c    640       0       0         1       1       0     0         -
 968 +
 969 +    type can be one of:
 970 +       f       A regular file
 971 +       d       Directory
 972 +       c       Character special device file
 973 +       b       Block special device file
 974 +       p       Fifo (named pipe)
 975 +
 976 +    I don't bother with symlinks (permissions are irrelevant), hard
 977 +    links (special cases of regular files), or sockets (why bother).
 978 +
 979 +    Regular files must exist in the target root directory.  If a char,
 980 +    block, fifo, or directory does not exist, it will be created.
 981 +*/
 982 +
 983 +static int interpret_table_entry(char *line, struct entry *root, loff_t *fslen_ub)
 984 +{
 985 +       char type, *name = NULL;
 986 +       unsigned long mode = 0755, uid = 0, gid = 0, major = 0, minor = 0;
 987 +       unsigned long start = 0, increment = 1, count = 0;
 988 +
 989 +       if (sscanf (line, "%" SCANF_PREFIX "s %c %lo %lu %lu %lu %lu %lu %lu %lu",
 990 +                SCANF_STRING(name), &type, &mode, &uid, &gid, &major, &minor,
 991 +                &start, &increment, &count) < 0)
 992 +       {
 993 +               return 1;
 994 +       }
 995 +
 996 +       if (!strcmp(name, "/")) {
 997 +               error_msg_and_die("Device table entries require absolute paths");
 998 +       }
 999 +
1000 +       switch (type) {
1001 +       case 'd':
1002 +               mode |= S_IFDIR;
1003 +               modify_entry(name, uid, gid, mode, 0, root, fslen_ub);
1004 +               break;
1005 +       case 'f':
1006 +               mode |= S_IFREG;
1007 +               modify_entry(name, uid, gid, mode, 0, root, fslen_ub);
1008 +               break;
1009 +       case 'p':
1010 +               mode |= S_IFIFO;
1011 +               modify_entry(name, uid, gid, mode, 0, root, fslen_ub);
1012 +               break;
1013 +       case 'c':
1014 +       case 'b':
1015 +               mode |= (type == 'c') ? S_IFCHR : S_IFBLK;
1016 +               if (count > 0) {
1017 +                       char *buf;
1018 +                       unsigned long i;
1019 +                       dev_t rdev;
1020 +
1021 +                       for (i = start; i < count; i++) {
1022 +                               asprintf(&buf, "%s%lu", name, i);
1023 +                               rdev = makedev(major, minor + (i * increment - start));
1024 +                               modify_entry(buf, uid, gid, mode, rdev, root, fslen_ub);
1025 +                               free(buf);
1026 +                       }
1027 +               } else {
1028 +                       dev_t rdev = makedev(major, minor);
1029 +                       modify_entry(name, uid, gid, mode, rdev, root, fslen_ub);
1030 +               }
1031 +               break;
1032 +       default:
1033 +               error_msg_and_die("Unsupported file type");
1034 +       }
1035 +       free(name);
1036 +       return 0;
1037 +}
1038 +
1039 +static int parse_device_table(FILE *file, struct entry *root, loff_t *fslen_ub)
1040 +{
1041 +       char *line;
1042 +       int status = 0;
1043 +       size_t length = 0;
1044 +
1045 +       /* Turn off squash, since we must ensure that values
1046 +        * entered via the device table are not squashed */
1047 +       opt_squash = 0;
1048 +
1049 +       /* Looks ok so far.  The general plan now is to read in one
1050 +        * line at a time, check for leading comment delimiters ('#'),
1051 +        * then try and parse the line as a device table.  If we fail
1052 +        * to parse things, try and help the poor fool to fix their
1053 +        * device table with a useful error msg... */
1054 +       line = NULL;
1055 +       while (getline(&line, &length, file) != -1) {
1056 +               /* First trim off any whitespace */
1057 +               int len = strlen(line);
1058 +
1059 +               /* trim trailing whitespace */
1060 +               while (len > 0 && isspace(line[len - 1]))
1061 +                       line[--len] = '\0';
1062 +               /* trim leading whitespace */
1063 +               memmove(line, &line[strspn(line, " \n\r\t\v")], len);
1064 +
1065 +               /* How long are we after trimming? */
1066 +               len = strlen(line);
1067 +
1068 +               /* If this is NOT a comment line, try to interpret it */
1069 +               if (len && *line != '#') {
1070 +                       if (interpret_table_entry(line, root, fslen_ub))
1071 +                               status = 1;
1072 +               }
1073 +
1074 +               free(line);
1075 +               line = NULL;
1076 +       }
1077 +       free(line);
1078 +       fclose(file);
1079 +
1080 +       return status;
1081 +}
1082 +
1083 +void traverse(struct entry *entry, int depth)
1084 +{
1085 +       struct entry *curr = entry;
1086 +       int i;
1087 +
1088 +       while (curr) {
1089 +               for (i = 0; i < depth; i++) putchar(' ');
1090 +               printf("%s: size=%d mode=%d same=%p\n",
1091 +                       (curr->name)? (char*)curr->name : "/",
1092 +                       curr->size, curr->mode, curr->same);
1093 +               if (curr->child) traverse(curr->child, depth + 4);
1094 +               curr = curr->next;
1095 +       }
1096 +}
1097 +
1098 +static void free_filesystem_entry(struct entry *dir)
1099 +{
1100 +       struct entry *e = dir, *last;
1101 +
1102 +       if (S_ISDIR(dir->mode)) {
1103 +               e = dir->child;
1104 +       }
1105 +       while (e) {
1106 +               if (e->name)
1107 +                       free(e->name);
1108 +               if (e->path)
1109 +                       free(e->path);
1110 +               if (e->uncompressed)
1111 +                       free(e->uncompressed);
1112 +               last = e;
1113 +               if (e->child) {
1114 +                       free_filesystem_entry(e);
1115 +               }
1116 +               e = e->next;
1117 +               free(last);
1118 +       }
1119 +}
1120 +
1121 +
1122 +/*
1123 + * Usage:
1124 + *
1125 + *      mkcramfs directory-name outfile
1126 + *
1127 + * where "directory-name" is simply the root of the directory
1128 + * tree that we want to generate a compressed filesystem out
1129 + * of.
1130 + */
1131  int main(int argc, char **argv)
1132  {
1133         struct stat st;         /* used twice... */
1134 @@ -692,6 +1138,7 @@
1135         u32 crc;
1136         int c;                  /* for getopt */
1137         char *ep;               /* for strtoul */
1138 +       FILE *devtable = NULL;
1139
1140         total_blocks = 0;
1141
1142 @@ -699,7 +1146,7 @@
1143                 progname = argv[0];
1144
1145         /* command line options */
1146 -       while ((c = getopt(argc, argv, "hEe:i:n:psvz")) != EOF) {
1147 +       while ((c = getopt(argc, argv, "hEe:i:n:psvzD:q")) != EOF) {
1148                 switch (c) {
1149                 case 'h':
1150                         usage(MKFS_OK);
1151 @@ -715,7 +1162,7 @@
1152                 case 'i':
1153                         opt_image = optarg;
1154                         if (lstat(opt_image, &st) < 0) {
1155 -                               die(MKFS_ERROR, 1, "lstat failed: %s", opt_image);
1156 +                               error_msg_and_die("lstat failed: %s", opt_image);
1157                         }
1158                         image_length = st.st_size; /* may be padded later */
1159                         fslen_ub += (image_length + 3); /* 3 is for padding */
1160 @@ -736,6 +1183,16 @@
1161                 case 'z':
1162                         opt_holes = 1;
1163                         break;
1164 +               case 'q':
1165 +                       opt_squash = 1;
1166 +                       break;
1167 +               case 'D':
1168 +                       devtable = xfopen(optarg, "r");
1169 +                       if (fstat(fileno(devtable), &st) < 0)
1170 +                               perror_msg_and_die(optarg);
1171 +                       if (st.st_size < 10)
1172 +                               error_msg_and_die("%s: not a proper device table file\n", optarg);
1173 +                       break;
1174                 }
1175         }
1176
1177 @@ -745,25 +1202,23 @@
1178         outfile = argv[optind + 1];
1179
1180         if (stat(dirname, &st) < 0) {
1181 -               die(MKFS_USAGE, 1, "stat failed: %s", dirname);
1182 -       }
1183 -       fd = open(outfile, O_WRONLY | O_CREAT | O_TRUNC, 0666);
1184 -       if (fd < 0) {
1185 -               die(MKFS_USAGE, 1, "open failed: %s", outfile);
1186 +               error_msg_and_die("stat failed: %s", dirname);
1187         }
1188 +       fd = xopen(outfile, O_WRONLY | O_CREAT | O_TRUNC, 0666);
1189
1190 -       root_entry = calloc(1, sizeof(struct entry));
1191 -       if (!root_entry) {
1192 -               die(MKFS_ERROR, 1, "calloc failed");
1193 -       }
1194 +       root_entry = xcalloc(1, sizeof(struct entry));
1195         root_entry->mode = st.st_mode;
1196         root_entry->uid = st.st_uid;
1197         root_entry->gid = st.st_gid;
1198
1199         root_entry->size = parse_directory(root_entry, dirname, &root_entry->child, &fslen_ub);
1200
1201 +       if (devtable) {
1202 +               parse_device_table(devtable, root_entry, &fslen_ub);
1203 +       }
1204 +
1205         /* always allocate a multiple of blksize bytes because that's
1206 -          what we're going to write later on */
1207 +           what we're going to write later on */
1208         fslen_ub = ((fslen_ub - 1) | (blksize - 1)) + 1;
1209
1210         if (fslen_ub > MAXFSLEN) {
1211 @@ -790,7 +1245,7 @@
1212         rom_image = mmap(NULL, fslen_ub?fslen_ub:1, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
1213
1214         if (rom_image == MAP_FAILED) {
1215 -               die(MKFS_ERROR, 1, "mmap failed");
1216 +               error_msg_and_die("mmap failed");
1217         }
1218
1219         /* Skip the first opt_pad bytes for boot loader code */
1220 @@ -807,6 +1262,7 @@
1221         }
1222
1223         offset = write_directory_structure(root_entry->child, rom_image, offset);
1224 +       if (opt_verbose)
1225         printf("Directory data: %d bytes\n", offset);
1226
1227         offset = write_data(root_entry, rom_image, offset);
1228 @@ -814,30 +1270,38 @@
1229         /* We always write a multiple of blksize bytes, so that
1230            losetup works. */
1231         offset = ((offset - 1) | (blksize - 1)) + 1;
1232 +       if (opt_verbose)
1233         printf("Everything: %d kilobytes\n", offset >> 10);
1234
1235         /* Write the superblock now that we can fill in all of the fields. */
1236         write_superblock(root_entry, rom_image+opt_pad, offset);
1237 +       if (opt_verbose)
1238         printf("Super block: %d bytes\n", sizeof(struct cramfs_super));
1239
1240         /* Put the checksum in. */
1241         crc = crc32(0L, Z_NULL, 0);
1242         crc = crc32(crc, (rom_image+opt_pad), (offset-opt_pad));
1243         ((struct cramfs_super *) (rom_image+opt_pad))->fsid.crc = crc;
1244 +       if (opt_verbose)
1245         printf("CRC: %x\n", crc);
1246
1247         /* Check to make sure we allocated enough space. */
1248         if (fslen_ub < offset) {
1249 -               die(MKFS_ERROR, 0, "not enough space allocated for ROM image (%Ld allocated, %d used)", fslen_ub, offset);
1250 +               error_msg_and_die("not enough space allocated for ROM "
1251 +                       "image (%Ld allocated, %d used)", fslen_ub, offset);
1252         }
1253
1254         written = write(fd, rom_image, offset);
1255         if (written < 0) {
1256 -               die(MKFS_ERROR, 1, "write failed");
1257 +               error_msg_and_die("write failed");
1258         }
1259         if (offset != written) {
1260 -               die(MKFS_ERROR, 0, "ROM image write failed (wrote %d of %d bytes)", written, offset);
1261 +               error_msg_and_die("ROM image write failed (wrote %d of %d bytes)", written, offset);
1262         }
1263 +
1264 +       /* Free up memory */
1265 +       free_filesystem_entry(root_entry);
1266 +       free(root_entry);
1267
1268         /* (These warnings used to come at the start, but they scroll off the
1269            screen too quickly.) */