contrib/android/ext2simg.c

   1 /*
   2  * Copyright (C) 2016 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <libgen.h>
  18 #include <unistd.h>
  19 #include <sys/types.h>
  20 #include <sys/stat.h>
  21 #include <fcntl.h>
  22 #include <ext2fs/ext2fs.h>
  23 #include <et/com_err.h>
  24 #include <sparse/sparse.h>
  25
  26 struct {
  27         int     crc;
  28         int     sparse;
  29         int     gzip;
  30         char    *in_file;
  31         char    *out_file;
  32         bool    overwrite_input;
  33 } params = {
  34         .crc        = 0,
  35         .sparse     = 1,
  36         .gzip       = 0,
  37 };
  38
  39 #define ext2fs_fatal(Retval, Format, ...) \
  40         do { \
  41                 com_err("error", Retval, Format, __VA_ARGS__); \
  42                 exit(EXIT_FAILURE); \
  43         } while(0)
  44
  45 #define sparse_fatal(Format) \
  46         do { \
  47                 fprintf(stderr, "sparse: "Format); \
  48                 exit(EXIT_FAILURE); \
  49         } while(0)
  50
  51 static void usage(char *path)
  52 {
  53         char *progname = basename(path);
  54
  55         fprintf(stderr, "%s [ options ] <image or block device> <output image>\n"
  56                         "  -c include CRC block\n"
  57                         "  -z gzip output\n"
  58                         "  -S don't use sparse output format\n", progname);
  59 }
  60
  61 static struct buf_item {
  62         struct buf_item     *next;
  63         void                *buf[0];
  64 } *buf_list;
  65
  66 static void add_chunk(ext2_filsys fs, struct sparse_file *s, blk_t chunk_start, blk_t chunk_end)
  67 {
  68         int retval;
  69         unsigned int nb_blk = chunk_end - chunk_start;
  70         size_t len = nb_blk * fs->blocksize;
  71         int64_t offset = (int64_t)chunk_start * (int64_t)fs->blocksize;
  72
  73         if (params.overwrite_input == false) {
  74                 if (sparse_file_add_file(s, params.in_file, offset, len, chunk_start) < 0)
  75                         sparse_fatal("adding data to the sparse file");
  76         } else {
  77                 /*
  78                  * The input file will be overwritten, make a copy of
  79                  * the blocks
  80                  */
  81                 struct buf_item *bi = calloc(1, sizeof(struct buf_item) + len);
  82                 if (buf_list == NULL)
  83                         buf_list = bi;
  84                 else {
  85                         bi->next = buf_list;
  86                         buf_list = bi;
  87                 }
  88
  89                 retval = io_channel_read_blk64(fs->io, chunk_start, nb_blk, bi->buf);
  90                 if (retval < 0)
  91                         ext2fs_fatal(retval, "reading block %u - %u", chunk_start, chunk_end);
  92
  93                 if (sparse_file_add_data(s, bi->buf, len, chunk_start) < 0)
  94                         sparse_fatal("adding data to the sparse file");
  95         }
  96 }
  97
  98 static void free_chunks(void)
  99 {
 100         struct buf_item *bi;
 101
 102         while (buf_list) {
 103                 bi = buf_list->next;
 104                 free(buf_list);
 105                 buf_list = bi;
 106         }
 107 }
 108
 109 static struct sparse_file *ext_to_sparse(const char *in_file)
 110 {
 111         errcode_t retval;
 112         ext2_filsys fs;
 113         struct sparse_file *s;
 114         int64_t chunk_start = -1;
 115         blk_t first_blk, last_blk, nb_blk, cur_blk;
 116
 117         retval = ext2fs_open(in_file, 0, 0, 0, unix_io_manager, &fs);
 118         if (retval)
 119                 ext2fs_fatal(retval, "while reading %s", in_file);
 120
 121         retval = ext2fs_read_block_bitmap(fs);
 122         if (retval)
 123                 ext2fs_fatal(retval, "while reading block bitmap of %s", in_file);
 124
 125         first_blk = ext2fs_get_block_bitmap_start2(fs->block_map);
 126         last_blk = ext2fs_get_block_bitmap_end2(fs->block_map);
 127         nb_blk = last_blk - first_blk + 1;
 128
 129         s = sparse_file_new(fs->blocksize, (uint64_t)fs->blocksize * (uint64_t)nb_blk);
 130         if (!s)
 131                 sparse_fatal("creating sparse file");
 132
 133         /*
 134          * The sparse format encodes the size of a chunk (and its header) in a
 135          * 32-bit unsigned integer (UINT32_MAX)
 136          * When writing the chunk, the library uses a single call to write().
 137          * Linux's implementation of the 'write' syscall does not allow transfers
 138          * larger than INT32_MAX (32-bit _and_ 64-bit systems).
 139          * Make sure we do not create chunks larger than this limit.
 140          */
 141         int64_t max_blk_per_chunk = (INT32_MAX - 12) / fs->blocksize;
 142
 143         /* Iter on the blocks to merge contiguous chunk */
 144         for (cur_blk = first_blk; cur_blk <= last_blk; ++cur_blk) {
 145                 if (ext2fs_test_block_bitmap2(fs->block_map, cur_blk)) {
 146                         if (chunk_start == -1) {
 147                                 chunk_start = cur_blk;
 148                         } else if (cur_blk - chunk_start + 1 == max_blk_per_chunk) {
 149                                 add_chunk(fs, s, chunk_start, cur_blk);
 150                                 chunk_start = -1;
 151                         }
 152                 } else if (chunk_start != -1) {
 153                         add_chunk(fs, s, chunk_start, cur_blk);
 154                         chunk_start = -1;
 155                 }
 156         }
 157         if (chunk_start != -1)
 158                 add_chunk(fs, s, chunk_start, cur_blk - 1);
 159
 160         ext2fs_free(fs);
 161         return s;
 162 }
 163
 164 static bool same_file(const char *in, const char *out)
 165 {
 166         struct stat st1, st2;
 167
 168         if (access(out, F_OK) == -1)
 169                 return false;
 170
 171         if (lstat(in, &st1) == -1)
 172                 ext2fs_fatal(errno, "stat %s\n", in);
 173         if (lstat(out, &st2) == -1)
 174                 ext2fs_fatal(errno, "stat %s\n", out);
 175         return st1.st_ino == st2.st_ino;
 176 }
 177
 178 int main(int argc, char *argv[])
 179 {
 180         int opt;
 181         int out_fd;
 182         struct sparse_file *s;
 183
 184         while ((opt = getopt(argc, argv, "czS")) != -1) {
 185                 switch(opt) {
 186                 case 'c':
 187                         params.crc = 1;
 188                         break;
 189                 case 'z':
 190                         params.gzip = 1;
 191                         break;
 192                 case 'S':
 193                         params.sparse = 0;
 194                         break;
 195                 default:
 196                         usage(argv[0]);
 197                         exit(EXIT_FAILURE);
 198                 }
 199         }
 200         if (optind + 1 >= argc) {
 201                 usage(argv[0]);
 202                 exit(EXIT_FAILURE);
 203         }
 204         params.in_file = strdup(argv[optind++]);
 205         params.out_file = strdup(argv[optind]);
 206         params.overwrite_input = same_file(params.in_file, params.out_file);
 207
 208         s = ext_to_sparse(params.in_file);
 209
 210         out_fd = open(params.out_file, O_WRONLY | O_CREAT | O_TRUNC, 0664);
 211         if (out_fd == -1)
 212                 ext2fs_fatal(errno, "opening %s\n", params.out_file);
 213         if (sparse_file_write(s, out_fd, params.gzip, params.sparse, params.crc) < 0)
 214                 sparse_fatal("writing sparse file");
 215
 216         sparse_file_destroy(s);
 217
 218         free(params.in_file);
 219         free(params.out_file);
 220         free_chunks();
 221         close(out_fd);
 222
 223         return 0;
 224 }