installer_ext4.c

   1 /* commands/sysloader/installer/installer.c
   2  *
   3  * Copyright 2008, The Android Open Source Project
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18 #define LOG_TAG "installer"
  19
  20 #include <sys/types.h>
  21 #include <errno.h>
  22 #include <fcntl.h>
  23 #include <stdint.h>
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <unistd.h>
  28 #include <sys/mount.h>
  29 #include <sys/stat.h>
  30 #include <sys/wait.h>
  31
  32
  33 #include <cutils/config_utils.h>
  34 #include <cutils/log.h>
  35
  36 #include "diskconfig/diskconfig.h"
  37 #include "installer.h"
  38
  39 #define MKE2FS_BIN     "/system/bin/mke2fs"
  40 #define E2FSCK_BIN     "/system/bin/e2fsck"
  41 #define TUNE2FS_BIN    "/system/bin/tune2fs"
  42 #define RESIZE2FS_BIN  "/system/bin/resize2fs"
  43
  44 static int
  45 usage(void)
  46 {
  47     fprintf(stderr, "Usage: %s\n", LOG_TAG);
  48     fprintf(stderr, "\t-c <path> - Path to installer conf file "
  49                     "(/system/etc/installer.conf)\n");
  50     fprintf(stderr, "\t-l <path> - Path to device disk layout conf file "
  51                     "(/system/etc/disk_layout.conf)\n");
  52     fprintf(stderr, "\t-h        - This help message\n");
  53     fprintf(stderr, "\t-d        - Dump the compiled in partition info.\n");
  54     fprintf(stderr, "\t-p <path> - Path to device that should be mounted"
  55                     " to /data.\n");
  56     fprintf(stderr, "\t-t        - Test mode. Don't write anything to disk.\n");
  57     return 1;
  58 }
  59
  60 static cnode *
  61 read_conf_file(const char *fn)
  62 {
  63     cnode *root = config_node("", "");
  64     config_load_file(root, fn);
  65
  66     if (root->first_child == NULL) {
  67         LOGE("Could not read config file %s", fn);
  68         return NULL;
  69     }
  70
  71     return root;
  72 }
  73
  74 static int
  75 exec_cmd(const char *cmd, ...) /* const char *arg, ...) */
  76 {
  77     va_list ap;
  78     int size = 0;
  79     char *str;
  80     char *outbuf;
  81     int rv;
  82
  83     /* compute the size for the command buffer */
  84     size = strlen(cmd) + 1;
  85     va_start(ap, cmd);
  86     while ((str = va_arg(ap, char *))) {
  87         size += strlen(str) + 1;  /* need room for the space separator */
  88     }
  89     va_end(ap);
  90
  91     if (!(outbuf = malloc(size + 1))) {
  92         LOGE("Can't allocate memory to exec cmd");
  93         return -1;
  94     }
  95
  96     /* this is a bit inefficient, but is trivial, and works */
  97     strcpy(outbuf, cmd);
  98     va_start(ap, cmd);
  99     while ((str = va_arg(ap, char *))) {
 100         strcat(outbuf, " ");
 101         strcat(outbuf, str);
 102     }
 103     va_end(ap);
 104
 105     LOGI("Executing: %s", outbuf);
 106     rv = system(outbuf);
 107     free(outbuf);
 108     if (rv < 0) {
 109         LOGI("Error while trying to execute '%s'", cmd);
 110         return -1;
 111     }
 112     rv = WEXITSTATUS(rv);
 113     LOGI("Done executing %s (%d)", outbuf, rv);
 114     return rv;
 115 }
 116
 117
 118 static int
 119 do_fsck(const char *dst, int force)
 120 {
 121     int rv;
 122     const char *opts = force ? "-fy" : "-y";
 123
 124
 125     LOGI("Running e2fsck... (force=%d) This MAY take a while.", force);
 126     if ((rv = exec_cmd(E2FSCK_BIN, "-C 0", opts, dst, NULL)) < 0)
 127         return 1;
 128     if (rv >= 4) {
 129         LOGE("Error while running e2fsck: %d", rv);
 130         return 1;
 131     }
 132     sync();
 133     LOGI("e2fsck succeeded (exit code: %d)", rv);
 134
 135     return 0;
 136 }
 137
 138 static int
 139 process_ext2_image(const char *dst, const char *src, uint32_t flags, int test)
 140 {
 141     int rv;
 142
 143     /* First, write the image to disk. */
 144     if (write_raw_image(dst, src, 0, test))
 145         return 1;
 146
 147     if (test)
 148         return 0;
 149
 150     /* Next, let's e2fsck the fs to make sure it got written ok, and
 151      * everything is peachy */
 152     if (do_fsck(dst, 1))
 153         return 1;
 154
 155     /* set the mount count to 1 so that 1st mount on boot doesn't complain */
 156     if ((rv = exec_cmd(TUNE2FS_BIN, "-C", "1", dst, NULL)) < 0)
 157         return 1;
 158     if (rv) {
 159         LOGE("Error while running tune2fs: %d", rv);
 160         return 1;
 161     }
 162
 163     /* If the user requested that we resize, let's do it now */
 164     if (flags & INSTALL_FLAG_RESIZE) {
 165         if ((rv = exec_cmd(RESIZE2FS_BIN, "-F", dst, NULL)) < 0)
 166             return 1;
 167         if (rv) {
 168             LOGE("Error while running resize2fs: %d", rv);
 169             return 1;
 170         }
 171         sync();
 172         if (do_fsck(dst, 0))
 173             return 1;
 174     }
 175
 176     /* make this an ext3 fs? */
 177     if (flags & INSTALL_FLAG_ADDJOURNAL) {
 178         if ((rv = exec_cmd(TUNE2FS_BIN, "-j", dst, NULL)) < 0)
 179             return 1;
 180         if (rv) {
 181             LOGE("Error while running tune2fs: %d", rv);
 182             return 1;
 183         }
 184         sync();
 185         if (do_fsck(dst, 0))
 186             return 1;
 187     }
 188
 189     return 0;
 190 }
 191
 192
 193 /* TODO: PLEASE break up this function into several functions that just
 194  * do what they need with the image node. Many of them will end up
 195  * looking at same strings, but it will be sooo much cleaner */
 196 static int
 197 process_image_node(cnode *img, struct disk_info *dinfo, int test)
 198 {
 199     struct part_info *pinfo = NULL;
 200     loff_t offset = (loff_t)-1;
 201     const char *filename = NULL;
 202     char *dest_part = NULL;
 203     const char *tmp;
 204     uint32_t flags = 0;
 205     uint8_t type = 0;
 206     int rv;
 207     int func_ret = 1;
 208
 209     filename = config_str(img, "filename", NULL);
 210
 211     /* process the 'offset' image parameter */
 212     if ((tmp = config_str(img, "offset", NULL)) != NULL)
 213         offset = strtoull(tmp, NULL, 0);
 214
 215     /* process the 'partition' image parameter */
 216     if ((tmp = config_str(img, "partition", NULL)) != NULL) {
 217         if (offset != (loff_t)-1) {
 218             LOGE("Cannot specify the partition name AND an offset for %s",
 219                  img->name);
 220             goto fail;
 221         }
 222
 223         if (!(pinfo = find_part(dinfo, tmp))) {
 224             LOGE("Cannot find partition %s while processing %s",
 225                  tmp, img->name);
 226             goto fail;
 227         }
 228
 229         if (!(dest_part = find_part_device(dinfo, pinfo->name))) {
 230             LOGE("Could not get the device name for partition %s while"
 231                  " processing image %s", pinfo->name, img->name);
 232             goto fail;
 233         }
 234         offset = pinfo->start_lba * dinfo->sect_size;
 235     }
 236
 237     /* process the 'mkfs' parameter */
 238     if ((tmp = config_str(img, "mkfs", NULL)) != NULL) {
 239         char *journal_opts;
 240         char vol_lbl[16]; /* ext2/3 has a 16-char volume label */
 241
 242         if (!pinfo) {
 243             LOGE("Target partition required for mkfs for '%s'", img->name);
 244             goto fail;
 245         } else if (filename) {
 246             LOGE("Providing filename and mkfs parameters is meaningless");
 247             goto fail;
 248         }
 249
 250         if (!strcmp(tmp, "ext4"))
 251             journal_opts = "";
 252         else if (!strcmp(tmp, "ext2"))
 253             journal_opts = "";
 254         else if (!strcmp(tmp, "ext3"))
 255             journal_opts = "-j";
 256         else {
 257             LOGE("Unknown filesystem type for mkfs: %s", tmp);
 258             goto fail;
 259         }
 260
 261         /* put the partition name as the volume label */
 262         strncpy(vol_lbl, pinfo->name, sizeof(vol_lbl));
 263
 264         /* since everything checked out, lets make the fs, and return since
 265          * we don't need to do anything else */
 266         rv = exec_cmd(MKE2FS_BIN, "-L", vol_lbl, journal_opts, dest_part, NULL);
 267         if (rv < 0)
 268             goto fail;
 269         else if (rv > 0) {
 270             LOGE("Error while running mke2fs: %d", rv);
 271             goto fail;
 272         }
 273         sync();
 274         if (do_fsck(dest_part, 0))
 275             goto fail;
 276         goto done;
 277     }
 278
 279     /* since we didn't mkfs above, all the rest of the options assume
 280      * there's a filename involved */
 281     if (!filename) {
 282         LOGE("Filename is required for image %s", img->name);
 283         goto fail;
 284     }
 285
 286     /* process the 'flags' image parameter */
 287     if ((tmp = config_str(img, "flags", NULL)) != NULL) {
 288         char *flagstr, *flagstr_orig;
 289
 290         if (!(flagstr = flagstr_orig = strdup(tmp))) {
 291             LOGE("Cannot allocate memory for dup'd flags string");
 292             goto fail;
 293         }
 294         while ((tmp = strsep(&flagstr, ","))) {
 295             if (!strcmp(tmp, "resize"))
 296                 flags |= INSTALL_FLAG_RESIZE;
 297             else if (!strcmp(tmp, "addjournal"))
 298                 flags |= INSTALL_FLAG_ADDJOURNAL;
 299             else {
 300                 LOGE("Unknown flag '%s' for image %s", tmp, img->name);
 301                 free(flagstr_orig);
 302                 goto fail;
 303             }
 304         }
 305         free(flagstr_orig);
 306     }
 307
 308     /* process the 'type' image parameter */
 309     if (!(tmp = config_str(img, "type", NULL))) {
 310         LOGE("Type is required for image %s", img->name);
 311         goto fail;
 312     } else if (!strcmp(tmp, "raw")) {
 313         type = INSTALL_IMAGE_RAW;
 314     } else if (!strcmp(tmp, "ext2")) {
 315         type = INSTALL_IMAGE_EXT2;
 316     } else if (!strcmp(tmp, "ext3")) {
 317         type = INSTALL_IMAGE_EXT3;
 318     } else if (!strcmp(tmp, "ext4")) {
 319         type = INSTALL_IMAGE_EXT4;
 320     } else {
 321         LOGE("Unknown image type '%s' for image %s", tmp, img->name);
 322         goto fail;
 323     }
 324
 325     /* at this point we MUST either have a partition in 'pinfo' or a raw
 326      * 'offset', otherwise quit */
 327     if (!pinfo && (offset == (loff_t)-1)) {
 328         LOGE("Offset to write into the disk is unknown for %s", img->name);
 329         goto fail;
 330     }
 331
 332     if (!pinfo && (type != INSTALL_IMAGE_RAW)) {
 333         LOGE("Only raw images can specify direct offset on the disk. Please"
 334              " specify the target partition name instead. (%s)", img->name);
 335         goto fail;
 336     }
 337
 338     switch(type) {
 339         case INSTALL_IMAGE_RAW:
 340             if (write_raw_image(dinfo->device, filename, offset, test))
 341                 goto fail;
 342             break;
 343
 344         case INSTALL_IMAGE_EXT3:
 345             /* makes the error checking in the imager function easier */
 346             if (flags & INSTALL_FLAG_ADDJOURNAL) {
 347                 LOGW("addjournal flag is meaningless for ext3 images");
 348                 flags &= ~INSTALL_FLAG_ADDJOURNAL;
 349             }
 350             /* ...fall through... */
 351
 352         case INSTALL_IMAGE_EXT4:
 353             /* fallthru */
 354
 355         case INSTALL_IMAGE_EXT2:
 356             if (process_ext2_image(dest_part, filename, flags, test))
 357                 goto fail;
 358             break;
 359
 360         default:
 361             LOGE("Unknown image type: %d", type);
 362             goto fail;
 363     }
 364
 365 done:
 366     func_ret = 0;
 367
 368 fail:
 369     if (dest_part)
 370         free(dest_part);
 371     return func_ret;
 372 }
 373
 374 int
 375 main(int argc, char *argv[])
 376 {
 377     char *disk_conf_file = "/system/etc/disk_layout.conf";
 378     char *inst_conf_file = "/system/etc/installer.conf";
 379     char *inst_data_dir = "/data";
 380     char *inst_data_dev = NULL;
 381     char *data_fstype = "ext4";
 382     cnode *config;
 383     cnode *images;
 384     cnode *img;
 385     int cnt = 0;
 386     struct disk_info *device_disk_info;
 387     int dump = 0;
 388     int test = 0;
 389     int x;
 390
 391     while ((x = getopt (argc, argv, "thdc:l:p:")) != EOF) {
 392         switch (x) {
 393             case 'h':
 394                 return usage();
 395             case 'c':
 396                 inst_conf_file = optarg;
 397                 break;
 398             case 'l':
 399                 disk_conf_file = optarg;
 400                 break;
 401             case 't':
 402                 test = 1;
 403                 break;
 404             case 'p':
 405                 inst_data_dev = optarg;
 406                 break;
 407             case 'd':
 408                 dump = 1;
 409                 break;
 410             default:
 411                 fprintf(stderr, "Unknown argument: %c\n", (char)optopt);
 412                 return usage();
 413         }
 414     }
 415
 416     /* If the user asked us to wait for data device, wait for it to appear,
 417      * and then mount it onto /data */
 418     if (inst_data_dev && !dump) {
 419         struct stat filestat;
 420
 421         LOGI("Waiting for device: %s", inst_data_dev);
 422         while (stat(inst_data_dev, &filestat))
 423             sleep(1);
 424         LOGI("Device %s ready", inst_data_dev);
 425         if (mount(inst_data_dev, inst_data_dir, data_fstype, MS_RDONLY, NULL)) {
 426             LOGE("Could not mount %s on %s as %s", inst_data_dev, inst_data_dir,
 427                  data_fstype);
 428             return 1;
 429         }
 430     }
 431
 432     /* Read and process the disk configuration */
 433     if (!(device_disk_info = load_diskconfig(disk_conf_file, NULL))) {
 434         LOGE("Errors encountered while loading disk conf file %s",
 435              disk_conf_file);
 436         return 1;
 437     }
 438
 439     if (process_disk_config(device_disk_info)) {
 440         LOGE("Errors encountered while processing disk config from %s",
 441              disk_conf_file);
 442         return 1;
 443     }
 444
 445     /* Was all of this for educational purposes? If so, quit. */
 446     if (dump) {
 447         dump_disk_config(device_disk_info);
 448         return 0;
 449     }
 450
 451     /* This doesnt do anything but load the config file */
 452     if (!(config = read_conf_file(inst_conf_file)))
 453         return 1;
 454
 455     /* First, partition the drive */
 456     if (apply_disk_config(device_disk_info, test))
 457         return 1;
 458
 459     /* Now process the installer config file and write the images to disk */
 460     if (!(images = config_find(config, "images"))) {
 461         LOGE("Invalid configuration file %s. Missing 'images' section",
 462              inst_conf_file);
 463         return 1;
 464     }
 465
 466     for (img = images->first_child; img; img = img->next) {
 467         if (process_image_node(img, device_disk_info, test)) {
 468             LOGE("Unable to write data to partition. Try running 'installer' again.");
 469             return 1;
 470         }
 471         ++cnt;
 472     }
 473
 474     /*
 475      * We have to do the apply() twice. We must do it once before the image
 476      * writes to layout the disk partitions so that we can write images to
 477      * them. We then do the apply() again in case one of the images
 478      * replaced the MBR with a new bootloader, and thus messed with
 479      * partition table.
 480      */
 481     if (apply_disk_config(device_disk_info, test))
 482         return 1;
 483
 484     LOGI("Done processing installer config. Configured %d images", cnt);
 485     LOGI("Type 'reboot' or reset to run new image");
 486     return 0;
 487 }