ext4_utils/output_file.c

   1 /*
   2  * Copyright (C) 2010 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 #define _LARGEFILE64_SOURCE
  17
  18 #include <sys/types.h>
  19 #include <sys/stat.h>
  20 #include <sys/types.h>
  21 #include <sys/mman.h>
  22 #include <unistd.h>
  23 #include <fcntl.h>
  24
  25 #include <zlib.h>
  26
  27 #include "ext4_utils.h"
  28 #include "output_file.h"
  29 #include "sparse_format.h"
  30 #include "sparse_crc32.h"
  31
  32 #if defined(__APPLE__) && defined(__MACH__)
  33 #define lseek64 lseek
  34 #define off64_t off_t
  35 #endif
  36
  37 #define SPARSE_HEADER_MAJOR_VER 1
  38 #define SPARSE_HEADER_MINOR_VER 0
  39 #define SPARSE_HEADER_LEN       (sizeof(sparse_header_t))
  40 #define CHUNK_HEADER_LEN (sizeof(chunk_header_t))
  41
  42 struct output_file_ops {
  43         int (*seek)(struct output_file *, off64_t);
  44         int (*write)(struct output_file *, u8 *, int);
  45         void (*close)(struct output_file *);
  46 };
  47
  48 struct output_file {
  49         int fd;
  50         gzFile gz_fd;
  51         int sparse;
  52         u64 cur_out_ptr;
  53         int chunk_cnt;
  54         u32 crc32;
  55         struct output_file_ops *ops;
  56 };
  57
  58 static int file_seek(struct output_file *out, off64_t off)
  59 {
  60         off64_t ret;
  61
  62         ret = lseek64(out->fd, off, SEEK_SET);
  63         if (ret < 0) {
  64                 error_errno("lseek64");
  65                 return -1;
  66         }
  67         return 0;
  68 }
  69
  70 static int file_write(struct output_file *out, u8 *data, int len)
  71 {
  72         int ret;
  73         ret = write(out->fd, data, len);
  74         if (ret < 0) {
  75                 error_errno("write");
  76                 return -1;
  77         } else if (ret < len) {
  78                 error("incomplete write");
  79                 return -1;
  80         }
  81
  82         return 0;
  83 }
  84
  85 static void file_close(struct output_file *out)
  86 {
  87         close(out->fd);
  88 }
  89
  90
  91 static struct output_file_ops file_ops = {
  92         .seek = file_seek,
  93         .write = file_write,
  94         .close = file_close,
  95 };
  96
  97 static int gz_file_seek(struct output_file *out, off64_t off)
  98 {
  99         off64_t ret;
 100
 101         ret = gzseek(out->gz_fd, off, SEEK_SET);
 102         if (ret < 0) {
 103                 error_errno("gzseek");
 104                 return -1;
 105         }
 106         return 0;
 107 }
 108
 109 static int gz_file_write(struct output_file *out, u8 *data, int len)
 110 {
 111         int ret;
 112         ret = gzwrite(out->gz_fd, data, len);
 113         if (ret < 0) {
 114                 error_errno("gzwrite");
 115                 return -1;
 116         } else if (ret < len) {
 117                 error("incomplete gzwrite");
 118                 return -1;
 119         }
 120
 121         return 0;
 122 }
 123
 124 static void gz_file_close(struct output_file *out)
 125 {
 126         gzclose(out->gz_fd);
 127 }
 128
 129 static struct output_file_ops gz_file_ops = {
 130         .seek = gz_file_seek,
 131         .write = gz_file_write,
 132         .close = gz_file_close,
 133 };
 134
 135 static sparse_header_t sparse_header = {
 136         .magic = SPARSE_HEADER_MAGIC,
 137         .major_version = SPARSE_HEADER_MAJOR_VER,
 138         .minor_version = SPARSE_HEADER_MINOR_VER,
 139         .file_hdr_sz = SPARSE_HEADER_LEN,
 140         .chunk_hdr_sz = CHUNK_HEADER_LEN,
 141         .blk_sz = 0,
 142         .total_blks = 0,
 143         .total_chunks = 0,
 144         .image_checksum = 0
 145 };
 146
 147 static u8 *zero_buf;
 148
 149 static int emit_skip_chunk(struct output_file *out, u64 skip_len)
 150 {
 151         chunk_header_t chunk_header;
 152         int ret, chunk;
 153
 154         //DBG printf("skip chunk: 0x%llx bytes\n", skip_len);
 155
 156         if (skip_len % info.block_size) {
 157                 error("don't care size %llu is not a multiple of the block size %u",
 158                                 skip_len, info.block_size);
 159                 return -1;
 160         }
 161
 162         /* We are skipping data, so emit a don't care chunk. */
 163         chunk_header.chunk_type = CHUNK_TYPE_DONT_CARE;
 164         chunk_header.reserved1 = 0;
 165         chunk_header.chunk_sz = skip_len / info.block_size;
 166         chunk_header.total_sz = CHUNK_HEADER_LEN;
 167         ret = out->ops->write(out, (u8 *)&chunk_header, sizeof(chunk_header));
 168         if (ret < 0)
 169                 return -1;
 170
 171         out->cur_out_ptr += skip_len;
 172         out->chunk_cnt++;
 173
 174         /* Compute the CRC for all those zeroes.  Do it block_size bytes at a time. */
 175         while (skip_len) {
 176                 chunk = (skip_len > info.block_size) ? info.block_size : skip_len;
 177                 out->crc32 = sparse_crc32(out->crc32, zero_buf, chunk);
 178                 skip_len -= chunk;
 179         }
 180
 181         return 0;
 182 }
 183
 184 static int write_chunk_raw(struct output_file *out, u64 off, u8 *data, int len)
 185 {
 186         chunk_header_t chunk_header;
 187         int rnd_up_len, zero_len;
 188         int ret;
 189
 190         /* We can assume that all the chunks to be written are in
 191          * ascending order, block-size aligned, and non-overlapping.
 192          * So, if the offset is less than the current output pointer,
 193          * throw an error, and if there is a gap, emit a "don't care"
 194          * chunk.  The first write (of the super block) may not be
 195          * blocksize aligned, so we need to deal with that too.
 196          */
 197         //DBG printf("write chunk: offset 0x%llx, length 0x%x bytes\n", off, len);
 198
 199         if (off < out->cur_out_ptr) {
 200                 error("offset %llu is less than the current output offset %llu",
 201                                 off, out->cur_out_ptr);
 202                 return -1;
 203         }
 204
 205         if (off > out->cur_out_ptr) {
 206                 emit_skip_chunk(out, off - out->cur_out_ptr);
 207         }
 208
 209         if (off % info.block_size) {
 210                 error("write chunk offset %llu is not a multiple of the block size %u",
 211                                 off, info.block_size);
 212                 return -1;
 213         }
 214
 215         if (off != out->cur_out_ptr) {
 216                 error("internal error, offset accounting screwy in write_chunk_raw()");
 217                 return -1;
 218         }
 219
 220         /* Round up the file length to a multiple of the block size */
 221         rnd_up_len = (len + (info.block_size - 1)) & (~(info.block_size -1));
 222         zero_len = rnd_up_len - len;
 223
 224         /* Finally we can safely emit a chunk of data */
 225         chunk_header.chunk_type = CHUNK_TYPE_RAW;
 226         chunk_header.reserved1 = 0;
 227         chunk_header.chunk_sz = rnd_up_len / info.block_size;
 228         chunk_header.total_sz = CHUNK_HEADER_LEN + rnd_up_len;
 229         ret = out->ops->write(out, (u8 *)&chunk_header, sizeof(chunk_header));
 230
 231         if (ret < 0)
 232                 return -1;
 233         ret = out->ops->write(out, data, len);
 234         if (ret < 0)
 235                 return -1;
 236         if (zero_len) {
 237                 ret = out->ops->write(out, zero_buf, zero_len);
 238                 if (ret < 0)
 239                         return -1;
 240         }
 241
 242         out->crc32 = sparse_crc32(out->crc32, data, len);
 243         if (zero_len)
 244                 out->crc32 = sparse_crc32(out->crc32, zero_buf, zero_len);
 245         out->cur_out_ptr += rnd_up_len;
 246         out->chunk_cnt++;
 247
 248         return 0;
 249 }
 250
 251 void close_output_file(struct output_file *out)
 252 {
 253         int ret;
 254
 255         if (out->sparse) {
 256                 /* we need to seek back to the beginning and update the file header */
 257                 sparse_header.total_chunks = out->chunk_cnt;
 258                 sparse_header.image_checksum = out->crc32;
 259
 260                 ret = out->ops->seek(out, 0);
 261                 if (ret < 0)
 262                         error("failure seeking to start of sparse file");
 263
 264                 ret = out->ops->write(out, (u8 *)&sparse_header, sizeof(sparse_header));
 265                 if (ret < 0)
 266                         error("failure updating sparse file header");
 267         }
 268         out->ops->close(out);
 269 }
 270
 271 struct output_file *open_output_file(const char *filename, int gz, int sparse)
 272 {
 273         int ret;
 274         struct output_file *out = malloc(sizeof(struct output_file));
 275         if (!out) {
 276                 error_errno("malloc struct out");
 277                 return NULL;
 278         }
 279         zero_buf = malloc(info.block_size);
 280         if (!zero_buf) {
 281                 error_errno("malloc zero_buf");
 282                 return NULL;
 283         }
 284         memset(zero_buf, '\0', info.block_size);
 285
 286         if (gz) {
 287                 out->ops = &gz_file_ops;
 288                 out->gz_fd = gzopen(filename, "wb9");
 289                 if (!out->gz_fd) {
 290                         error_errno("gzopen");
 291                         free(out);
 292                         return NULL;
 293                 }
 294         } else {
 295                 out->ops = &file_ops;
 296                 out->fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0644);
 297                 if (out->fd < 0) {
 298                         error_errno("open");
 299                         free(out);
 300                         return NULL;
 301                 }
 302         }
 303         out->sparse = sparse;
 304         out->cur_out_ptr = 0ll;
 305         out->chunk_cnt = 0;
 306
 307         /* Initialize the crc32 value */
 308         out->crc32 = 0;
 309
 310         if (out->sparse) {
 311                 /* Write out the file header.  We'll update the unknown fields
 312                  * when we close the file.
 313                  */
 314                 sparse_header.blk_sz = info.block_size,
 315                 sparse_header.total_blks = info.len / info.block_size,
 316                 ret = out->ops->write(out, (u8 *)&sparse_header, sizeof(sparse_header));
 317                 if (ret < 0)
 318                         return NULL;
 319         }
 320
 321         return out;
 322 }
 323
 324 void pad_output_file(struct output_file *out, u64 len)
 325 {
 326         int ret;
 327
 328         if (len > info.len) {
 329                 error("attempted to pad file %llu bytes past end of filesystem",
 330                                 len - info.len);
 331                 return;
 332         }
 333         if (out->sparse) {
 334                 /* We need to emit a DONT_CARE chunk to pad out the file if the
 335                  * cur_out_ptr is not already at the end of the filesystem.
 336                  * We also need to compute the CRC for it.
 337                  */
 338                 if (len < out->cur_out_ptr) {
 339                         error("attempted to pad file %llu bytes less than the current output pointer",
 340                                         out->cur_out_ptr - len);
 341                         return;
 342                 }
 343                 if (len > out->cur_out_ptr) {
 344                         emit_skip_chunk(out, len - out->cur_out_ptr);
 345                 }
 346         } else {
 347                 //KEN TODO: Fixme.  If the filesystem image needs no padding,
 348                 //          this will overwrite the last byte in the file with 0
 349                 //          The answer is to do accounting like the sparse image
 350                 //          code does and know if there is already data there.
 351                 ret = out->ops->seek(out, len - 1);
 352                 if (ret < 0)
 353                         return;
 354
 355                 ret = out->ops->write(out, (u8*)"", 1);
 356                 if (ret < 0)
 357                         return;
 358         }
 359 }
 360
 361 /* Write a contiguous region of data blocks from a memory buffer */
 362 void write_data_block(struct output_file *out, u64 off, u8 *data, int len)
 363 {
 364         int ret;
 365
 366         if (off + len > info.len) {
 367                 error("attempted to write block %llu past end of filesystem",
 368                                 off + len - info.len);
 369                 return;
 370         }
 371
 372         if (out->sparse) {
 373                 write_chunk_raw(out, off, data, len);
 374         } else {
 375                 ret = out->ops->seek(out, off);
 376                 if (ret < 0)
 377                         return;
 378
 379                 ret = out->ops->write(out, data, len);
 380                 if (ret < 0)
 381                         return;
 382         }
 383 }
 384
 385 /* Write a contiguous region of data blocks from a file */
 386 void write_data_file(struct output_file *out, u64 off, const char *file,
 387                      off_t offset, int len)
 388 {
 389         int ret;
 390
 391         if (off + len >= info.len) {
 392                 error("attempted to write block %llu past end of filesystem",
 393                                 off + len - info.len);
 394                 return;
 395         }
 396
 397         int file_fd = open(file, O_RDONLY);
 398         if (file_fd < 0) {
 399                 error_errno("open");
 400                 return;
 401         }
 402
 403         u8 *data = mmap(NULL, len, PROT_READ, MAP_SHARED, file_fd, offset);
 404         if (data == MAP_FAILED) {
 405                 error_errno("mmap");
 406                 close(file_fd);
 407                 return;
 408         }
 409
 410         if (out->sparse) {
 411                 write_chunk_raw(out, off, data, len);
 412         } else {
 413                 ret = out->ops->seek(out, off);
 414                 if (ret < 0)
 415                         goto err;
 416
 417                 ret = out->ops->write(out, data, len);
 418                 if (ret < 0)
 419                         goto err;
 420         }
 421
 422         munmap(data, len);
 423
 424         close(file_fd);
 425
 426 err:
 427         munmap(data, len);
 428         close(file_fd);
 429 }
 430