helper/ext2.c

   1 /* febootstrap-supermin-helper reimplementation in C.
   2  * Copyright (C) 2009-2010 Red Hat Inc.
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17  */
  18
  19 #include <config.h>
  20
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <fcntl.h>
  25 #include <unistd.h>
  26 #include <errno.h>
  27 #include <limits.h>
  28 #include <sys/stat.h>
  29 #include <assert.h>
  30
  31 #include "error.h"
  32 #include "fts_.h"
  33 #include "xvasprintf.h"
  34
  35 #include "helper.h"
  36 #include "ext2internal.h"
  37
  38 ext2_filsys fs;
  39
  40 /* The ext2 image that we build always has a fixed size, and we 'hope'
  41  * that the files fit in (otherwise we'll get an error).  Note that
  42  * the file is sparsely allocated.
  43  *
  44  * The downside of allocating a very large initial disk is that the
  45  * fixed overhead of ext2 is larger (since ext2 calculates it based on
  46  * the size of the disk).  For a 1GB disk the overhead is
  47  * approximately 16MB.
  48  *
  49  * In future, make this configurable, or determine it from the input
  50  * files (XXX).
  51  */
  52 #define APPLIANCE_SIZE (1024*1024*1024)
  53
  54 static void
  55 ext2_start (const char *hostcpu, const char *appliance,
  56             const char *modpath, const char *initrd)
  57 {
  58   initialize_ext2_error_table ();
  59
  60   /* Make the initrd. */
  61   ext2_make_initrd (modpath, initrd);
  62
  63   /* Make the appliance sparse image. */
  64   int fd = open (appliance, O_WRONLY | O_CREAT | O_TRUNC | O_NOCTTY, 0644);
  65   if (fd == -1)
  66     error (EXIT_FAILURE, errno, "open: %s", appliance);
  67
  68   if (lseek (fd, APPLIANCE_SIZE - 1, SEEK_SET) == -1)
  69     error (EXIT_FAILURE, errno, "lseek");
  70
  71   char c = 0;
  72   if (write (fd, &c, 1) != 1)
  73     error (EXIT_FAILURE, errno, "write");
  74
  75   if (close (fd) == -1)
  76     error (EXIT_FAILURE, errno, "close");
  77
  78   /* Run mke2fs on the file.
  79    * XXX Quoting, but this string doesn't come from an untrusted source.
  80    */
  81   char *cmd = xasprintf ("%s -t ext2 -F%s '%s'",
  82                          MKE2FS,
  83                          verbose >= 2 ? "" : "q",
  84                          appliance);
  85   int r = system (cmd);
  86   if (r == -1 || WEXITSTATUS (r) != 0)
  87     error (EXIT_FAILURE, 0, "%s: failed", cmd);
  88   free (cmd);
  89
  90   if (verbose)
  91     print_timestamped_message ("finished mke2fs");
  92
  93   /* Open the filesystem. */
  94   errcode_t err =
  95     ext2fs_open (appliance, EXT2_FLAG_RW, 0, 0, unix_io_manager, &fs);
  96   if (err != 0)
  97     error (EXIT_FAILURE, 0, "ext2fs_open: %s", error_message (err));
  98
  99   /* Bitmaps are not loaded by default, so load them.  ext2fs_close will
 100    * write out any changes.
 101    */
 102   err = ext2fs_read_bitmaps (fs);
 103   if (err != 0)
 104     error (EXIT_FAILURE, 0, "ext2fs_read_bitmaps: %s", error_message (err));
 105 }
 106
 107 static void
 108 ext2_end (void)
 109 {
 110   /* Write out changes and close. */
 111   errcode_t err = ext2fs_close (fs);
 112   if (err != 0)
 113     error (EXIT_FAILURE, 0, "ext2fs_close: %s", error_message (err));
 114 }
 115
 116 void
 117 ext2_mkdir (ext2_ino_t dir_ino, const char *dirname, const char *basename,
 118             mode_t mode, uid_t uid, gid_t gid,
 119             time_t ctime, time_t atime, time_t mtime)
 120 {
 121   errcode_t err;
 122
 123   mode = LINUX_S_IFDIR | (mode & 0777);
 124
 125   /* Does the directory exist?  This is legitimate: we just skip
 126    * this case.
 127    */
 128   ext2_ino_t ino;
 129   err = ext2fs_namei (fs, EXT2_ROOT_INO, dir_ino, basename, &ino);
 130   if (err == 0)
 131     return; /* skip */
 132
 133   /* Otherwise, create it. */
 134   err = ext2fs_new_inode (fs, dir_ino, mode, 0, &ino);
 135   if (err != 0)
 136     error (EXIT_FAILURE, 0, "ext2fs_new_inode: %s", error_message (err));
 137
 138  try_again:
 139   err = ext2fs_mkdir (fs, dir_ino, ino, basename);
 140   if (err != 0) {
 141     /* See: http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=217892 */
 142     if (err == EXT2_ET_DIR_NO_SPACE) {
 143       err = ext2fs_expand_dir (fs, dir_ino);
 144       if (err)
 145         error (EXIT_FAILURE, 0, "ext2fs_expand_dir: %s/%s: %s",
 146                dirname, basename, error_message (err));
 147       goto try_again;
 148     } else
 149       error (EXIT_FAILURE, 0, "ext2fs_mkdir: %s/%s: %s",
 150              dirname, basename, error_message (err));
 151   }
 152
 153   /* Copy the final permissions, UID etc. to the inode. */
 154   struct ext2_inode inode;
 155   err = ext2fs_read_inode (fs, ino, &inode);
 156   if (err != 0)
 157     error (EXIT_FAILURE, 0, "ext2fs_read_inode: %s", error_message (err));
 158   inode.i_mode = mode;
 159   inode.i_uid = uid;
 160   inode.i_gid = gid;
 161   inode.i_ctime = ctime;
 162   inode.i_atime = atime;
 163   inode.i_mtime = mtime;
 164   err = ext2fs_write_inode (fs, ino, &inode);
 165   if (err != 0)
 166     error (EXIT_FAILURE, 0, "ext2fs_write_inode: %s", error_message (err));
 167 }
 168
 169 void
 170 ext2_empty_inode (ext2_ino_t dir_ino, const char *dirname, const char *basename,
 171                   mode_t mode, uid_t uid, gid_t gid,
 172                   time_t ctime, time_t atime, time_t mtime,
 173                   int major, int minor, int dir_ft, ext2_ino_t *ino_ret)
 174 {
 175   errcode_t err;
 176   struct ext2_inode inode;
 177   ext2_ino_t ino;
 178
 179   err = ext2fs_new_inode (fs, dir_ino, mode, 0, &ino);
 180   if (err != 0)
 181     error (EXIT_FAILURE, 0, "ext2fs_new_inode: %s", error_message (err));
 182
 183   memset (&inode, 0, sizeof inode);
 184   inode.i_mode = mode;
 185   inode.i_uid = uid;
 186   inode.i_gid = gid;
 187   inode.i_blocks = 0;
 188   inode.i_links_count = 1;
 189   inode.i_ctime = ctime;
 190   inode.i_atime = atime;
 191   inode.i_mtime = mtime;
 192   inode.i_size = 0;
 193   inode.i_block[0] = (minor & 0xff) | (major << 8) | ((minor & ~0xff) << 12);
 194
 195   err = ext2fs_write_new_inode (fs, ino, &inode);
 196   if (err != 0)
 197     error (EXIT_FAILURE, 0, "ext2fs_write_inode: %s", error_message (err));
 198
 199   ext2_link (dir_ino, basename, ino, dir_ft);
 200
 201   ext2fs_inode_alloc_stats2 (fs, ino, 1, 0);
 202
 203   if (ino_ret)
 204     *ino_ret = ino;
 205 }
 206
 207 /* You must create the file first with ext2_empty_inode. */
 208 void
 209 ext2_write_file (ext2_ino_t ino, const char *buf, size_t size)
 210 {
 211   errcode_t err;
 212   ext2_file_t file;
 213   err = ext2fs_file_open2 (fs, ino, NULL, EXT2_FILE_WRITE, &file);
 214   if (err != 0)
 215     error (EXIT_FAILURE, 0, "ext2fs_file_open2: %s", error_message (err));
 216
 217   /* ext2fs_file_write cannot deal with partial writes.  You have
 218    * to write the entire file in a single call.
 219    */
 220   unsigned int written;
 221   err = ext2fs_file_write (file, buf, size, &written);
 222   if (err != 0)
 223     error (EXIT_FAILURE, 0, "ext2fs_file_write: %s", error_message (err));
 224   if ((size_t) written != size)
 225     error (EXIT_FAILURE, 0,
 226            "ext2fs_file_write: size = %zu != written = %u\n",
 227            size, written);
 228
 229   err = ext2fs_file_flush (file);
 230   if (err != 0)
 231     error (EXIT_FAILURE, 0, "ext2fs_file_flush: %s", error_message (err));
 232   err = ext2fs_file_close (file);
 233   if (err != 0)
 234     error (EXIT_FAILURE, 0, "ext2fs_file_close: %s", error_message (err));
 235
 236   /* Update the true size in the inode. */
 237   struct ext2_inode inode;
 238   err = ext2fs_read_inode (fs, ino, &inode);
 239   if (err != 0)
 240     error (EXIT_FAILURE, 0, "ext2fs_read_inode: %s", error_message (err));
 241   inode.i_size = size;
 242   err = ext2fs_write_inode (fs, ino, &inode);
 243   if (err != 0)
 244     error (EXIT_FAILURE, 0, "ext2fs_write_inode: %s", error_message (err));
 245 }
 246
 247 /* This is just a wrapper around ext2fs_link which calls
 248  * ext2fs_expand_dir as necessary if the directory fills up.  See
 249  * definition of expand_dir in the sources of debugfs.
 250  */
 251 void
 252 ext2_link (ext2_ino_t dir_ino, const char *basename, ext2_ino_t ino, int dir_ft)
 253 {
 254   errcode_t err;
 255
 256  again:
 257   err = ext2fs_link (fs, dir_ino, basename, ino, dir_ft);
 258
 259   if (err == EXT2_ET_DIR_NO_SPACE) {
 260     err = ext2fs_expand_dir (fs, dir_ino);
 261     if (err != 0)
 262       error (EXIT_FAILURE, 0, "ext2_link: ext2fs_expand_dir: %s: %s",
 263              basename, error_message (err));
 264     goto again;
 265   }
 266
 267   if (err != 0)
 268     error (EXIT_FAILURE, 0, "ext2fs_link: %s: %s",
 269              basename, error_message (err));
 270 }
 271
 272 static int
 273 release_block (ext2_filsys fs, blk_t *blocknr,
 274                 int blockcnt, void *private)
 275 {
 276   blk_t block;
 277
 278   block = *blocknr;
 279   ext2fs_block_alloc_stats (fs, block, -1);
 280   return 0;
 281 }
 282
 283 /* unlink or rmdir path, if it exists. */
 284 void
 285 ext2_clean_path (ext2_ino_t dir_ino,
 286                  const char *dirname, const char *basename,
 287                  int isdir)
 288 {
 289   errcode_t err;
 290
 291   ext2_ino_t ino;
 292   err = ext2fs_lookup (fs, dir_ino, basename, strlen (basename),
 293                        NULL, &ino);
 294   if (err == EXT2_ET_FILE_NOT_FOUND)
 295     return;
 296
 297   if (!isdir) {
 298     struct ext2_inode inode;
 299     err = ext2fs_read_inode (fs, ino, &inode);
 300     if (err != 0)
 301       error (EXIT_FAILURE, 0, "ext2fs_read_inode: %s", error_message (err));
 302     inode.i_links_count--;
 303     err = ext2fs_write_inode (fs, ino, &inode);
 304     if (err != 0)
 305       error (EXIT_FAILURE, 0, "ext2fs_write_inode: %s", error_message (err));
 306
 307     err = ext2fs_unlink (fs, dir_ino, basename, 0, 0);
 308     if (err != 0)
 309       error (EXIT_FAILURE, 0, "ext2fs_unlink_inode: %s", error_message (err));
 310
 311     if (inode.i_links_count == 0) {
 312       inode.i_dtime = time (NULL);
 313       err = ext2fs_write_inode (fs, ino, &inode);
 314       if (err != 0)
 315         error (EXIT_FAILURE, 0, "ext2fs_write_inode: %s", error_message (err));
 316
 317       if (ext2fs_inode_has_valid_blocks (&inode)) {
 318         int flags = 0;
 319         /* From the docs: "BLOCK_FLAG_READ_ONLY is a promise by the
 320          * caller that it will not modify returned block number."
 321          * RHEL 5 does not have this flag, so just omit it if it is
 322          * not defined.
 323          */
 324 #ifdef BLOCK_FLAG_READ_ONLY
 325         flags |= BLOCK_FLAG_READ_ONLY;
 326 #endif
 327         ext2fs_block_iterate (fs, ino, flags, NULL,
 328                               release_block, NULL);
 329       }
 330
 331       ext2fs_inode_alloc_stats2 (fs, ino, -1, isdir);
 332     }
 333   }
 334   /* else it's a directory, what to do? XXX */
 335 }
 336
 337 /* Read in the whole file into memory.  Check the size is still 'size'. */
 338 static char *
 339 read_whole_file (const char *filename, size_t size)
 340 {
 341   char *buf = malloc (size);
 342   if (buf == NULL)
 343     error (EXIT_FAILURE, errno, "malloc");
 344
 345   int fd = open (filename, O_RDONLY);
 346   if (fd == -1)
 347     error (EXIT_FAILURE, errno, "open: %s", filename);
 348
 349   size_t n = 0;
 350   char *p = buf;
 351
 352   while (n < size) {
 353     ssize_t r = read (fd, p, size - n);
 354     if (r == -1)
 355       error (EXIT_FAILURE, errno, "read: %s", filename);
 356     if (r == 0)
 357       error (EXIT_FAILURE, 0,
 358              "error: file has changed size unexpectedly: %s", filename);
 359     n += r;
 360     p += r;
 361   }
 362
 363   if (close (fd) == -1)
 364     error (EXIT_FAILURE, errno, "close: %s", filename);
 365
 366   return buf;
 367 }
 368
 369 /* Add a file (or directory etc) from the host. */
 370 static void
 371 ext2_file_stat (const char *orig_filename, const struct stat *statbuf)
 372 {
 373   errcode_t err;
 374
 375   if (verbose >= 2)
 376     fprintf (stderr, "ext2_file_stat %s 0%o\n",
 377              orig_filename, statbuf->st_mode);
 378
 379   /* Sanity check the path.  These rules are always true for the paths
 380    * passed to us here from the appliance layer.  The assertions just
 381    * verify that the rules haven't changed.
 382    */
 383   size_t n = strlen (orig_filename);
 384   assert (n <= PATH_MAX);
 385   assert (n > 0);
 386   assert (orig_filename[0] == '/'); /* always absolute path */
 387   assert (n == 1 || orig_filename[n-1] != '/'); /* no trailing slash */
 388
 389   /* Don't make the root directory, it always exists.  This simplifies
 390    * the code that follows.
 391    */
 392   if (n == 1) return;
 393
 394   const char *dirname, *basename;
 395   const char *p = strrchr (orig_filename, '/');
 396   ext2_ino_t dir_ino;
 397   if (orig_filename == p) {     /* "/foo" */
 398     dirname = "/";
 399     basename = orig_filename+1;
 400     dir_ino = EXT2_ROOT_INO;
 401   } else {                      /* "/foo/bar" */
 402     dirname = strndup (orig_filename, p-orig_filename);
 403     basename = p+1;
 404
 405     /* Look up the parent directory. */
 406     err = ext2fs_namei (fs, EXT2_ROOT_INO, EXT2_ROOT_INO, dirname, &dir_ino);
 407     if (err != 0)
 408       error (EXIT_FAILURE, 0, "ext2: parent directory not found: %s: %s",
 409              dirname, error_message (err));
 410   }
 411
 412   ext2_clean_path (dir_ino, dirname, basename, S_ISDIR (statbuf->st_mode));
 413
 414   int dir_ft;
 415
 416   /* Create regular file. */
 417   if (S_ISREG (statbuf->st_mode)) {
 418     /* XXX Hard links get duplicated here. */
 419     ext2_ino_t ino;
 420     ext2_empty_inode (dir_ino, dirname, basename,
 421                       statbuf->st_mode, statbuf->st_uid, statbuf->st_gid,
 422                       statbuf->st_ctime, statbuf->st_atime, statbuf->st_mtime,
 423                       0, 0, EXT2_FT_REG_FILE, &ino);
 424
 425     if (statbuf->st_size > 0) {
 426       char *buf = read_whole_file (orig_filename, statbuf->st_size);
 427       ext2_write_file (ino, buf, statbuf->st_size);
 428       free (buf);
 429     }
 430   }
 431   /* Create a symlink. */
 432   else if (S_ISLNK (statbuf->st_mode)) {
 433     ext2_ino_t ino;
 434     ext2_empty_inode (dir_ino, dirname, basename,
 435                       statbuf->st_mode, statbuf->st_uid, statbuf->st_gid,
 436                       statbuf->st_ctime, statbuf->st_atime, statbuf->st_mtime,
 437                       0, 0, EXT2_FT_SYMLINK, &ino);
 438
 439     char buf[PATH_MAX+1];
 440     ssize_t r = readlink (orig_filename, buf, sizeof buf);
 441     if (r == -1)
 442       error (EXIT_FAILURE, errno, "readlink: %s", orig_filename);
 443     ext2_write_file (ino, buf, r);
 444   }
 445   /* Create directory. */
 446   else if (S_ISDIR (statbuf->st_mode))
 447     ext2_mkdir (dir_ino, dirname, basename,
 448                 statbuf->st_mode, statbuf->st_uid, statbuf->st_gid,
 449                 statbuf->st_ctime, statbuf->st_atime, statbuf->st_mtime);
 450   /* Create a special file. */
 451   else if (S_ISBLK (statbuf->st_mode)) {
 452     dir_ft = EXT2_FT_BLKDEV;
 453     goto make_special;
 454   }
 455   else if (S_ISCHR (statbuf->st_mode)) {
 456     dir_ft = EXT2_FT_CHRDEV;
 457     goto make_special;
 458   } else if (S_ISFIFO (statbuf->st_mode)) {
 459     dir_ft = EXT2_FT_FIFO;
 460     goto make_special;
 461   } else if (S_ISSOCK (statbuf->st_mode)) {
 462     dir_ft = EXT2_FT_SOCK;
 463   make_special:
 464     ext2_empty_inode (dir_ino, dirname, basename,
 465                       statbuf->st_mode, statbuf->st_uid, statbuf->st_gid,
 466                       statbuf->st_ctime, statbuf->st_atime, statbuf->st_mtime,
 467                       major (statbuf->st_rdev), minor (statbuf->st_rdev),
 468                       dir_ft, NULL);
 469   }
 470 }
 471
 472 static void
 473 ext2_file (const char *filename)
 474 {
 475   struct stat statbuf;
 476
 477   if (lstat (filename, &statbuf) == -1)
 478     error (EXIT_FAILURE, errno, "lstat: %s", filename);
 479   ext2_file_stat (filename, &statbuf);
 480 }
 481
 482 /* In theory this could be optimized to avoid a namei lookup, but
 483  * it probably wouldn't make much difference.
 484  */
 485 static void
 486 ext2_fts_entry (FTSENT *entry)
 487 {
 488   if (entry->fts_info & FTS_NS || entry->fts_info & FTS_NSOK)
 489     ext2_file (entry->fts_path);
 490   else
 491     ext2_file_stat (entry->fts_path, entry->fts_statp);
 492 }
 493
 494 struct writer ext2_writer = {
 495   .wr_start = ext2_start,
 496   .wr_end = ext2_end,
 497   .wr_file = ext2_file,
 498   .wr_file_stat = ext2_file_stat,
 499   .wr_fts_entry = ext2_fts_entry,
 500   .wr_cpio_file = ext2_cpio_file,
 501 };