verity/fec/image.cpp

   1 /*
   2  * Copyright (C) 2015 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 #undef NDEBUG
  18 #define _LARGEFILE64_SOURCE
  19
  20 extern "C" {
  21     #include <fec.h>
  22 }
  23
  24 #include <assert.h>
  25 #include <android-base/file.h>
  26 #include <errno.h>
  27 #include <fcntl.h>
  28 #include <getopt.h>
  29 #include <openssl/sha.h>
  30 #include <pthread.h>
  31 #include <stdbool.h>
  32 #include <stdlib.h>
  33 #include <string.h>
  34 #include <sys/ioctl.h>
  35 #include <sys/mman.h>
  36 #ifndef IMAGE_NO_SPARSE
  37 #include <sparse/sparse.h>
  38 #endif
  39 #include "image.h"
  40
  41 #if defined(__linux__)
  42     #include <linux/fs.h>
  43 #elif defined(__APPLE__)
  44     #include <sys/disk.h>
  45     #define BLKGETSIZE64 DKIOCGETBLOCKCOUNT
  46     #define O_LARGEFILE 0
  47 #endif
  48
  49 void image_init(image *ctx)
  50 {
  51     memset(ctx, 0, sizeof(*ctx));
  52 }
  53
  54 static void mmap_image_free(image *ctx)
  55 {
  56     if (ctx->input) {
  57         munmap(ctx->input, (size_t)ctx->inp_size);
  58         close(ctx->inp_fd);
  59     }
  60
  61     if (ctx->fec_mmap_addr) {
  62         munmap(ctx->fec_mmap_addr, FEC_BLOCKSIZE + ctx->fec_size);
  63         close(ctx->fec_fd);
  64     }
  65
  66     if (!ctx->inplace && ctx->output) {
  67         delete[] ctx->output;
  68     }
  69 }
  70
  71 static void file_image_free(image *ctx)
  72 {
  73     assert(ctx->input == ctx->output);
  74
  75     if (ctx->input) {
  76         delete[] ctx->input;
  77     }
  78
  79     if (ctx->fec) {
  80         delete[] ctx->fec;
  81     }
  82 }
  83
  84 void image_free(image *ctx)
  85 {
  86     if (ctx->mmap) {
  87         mmap_image_free(ctx);
  88     } else {
  89         file_image_free(ctx);
  90     }
  91
  92     image_init(ctx);
  93 }
  94
  95 static uint64_t get_size(int fd)
  96 {
  97     struct stat st;
  98
  99     if (fstat(fd, &st) == -1) {
 100         FATAL("failed to fstat: %s\n", strerror(errno));
 101     }
 102
 103     uint64_t size = 0;
 104
 105     if (S_ISBLK(st.st_mode)) {
 106         if (ioctl(fd, BLKGETSIZE64, &size) == -1) {
 107             FATAL("failed to ioctl(BLKGETSIZE64): %s\n", strerror(errno));
 108         }
 109     } else if (S_ISREG(st.st_mode)) {
 110         size = st.st_size;
 111     } else {
 112         FATAL("unknown file mode: %d\n", (int)st.st_mode);
 113     }
 114
 115     return size;
 116 }
 117
 118 static void calculate_rounds(uint64_t size, image *ctx)
 119 {
 120     if (!size) {
 121         FATAL("empty file?\n");
 122     } else if (size % FEC_BLOCKSIZE) {
 123         FATAL("file size %" PRIu64 " is not a multiple of %u bytes\n",
 124             size, FEC_BLOCKSIZE);
 125     }
 126
 127     ctx->inp_size = size;
 128     ctx->blocks = fec_div_round_up(ctx->inp_size, FEC_BLOCKSIZE);
 129     ctx->rounds = fec_div_round_up(ctx->blocks, ctx->rs_n);
 130 }
 131
 132 static void mmap_image_load(const std::vector<int>& fds, image *ctx,
 133         bool output_needed)
 134 {
 135     if (fds.size() != 1) {
 136         FATAL("multiple input files not supported with mmap\n");
 137     }
 138
 139     int fd = fds.front();
 140
 141     calculate_rounds(get_size(fd), ctx);
 142
 143     /* check that we can memory map the file; on 32-bit platforms we are
 144        limited to encoding at most 4 GiB files */
 145     if (ctx->inp_size > SIZE_MAX) {
 146         FATAL("cannot mmap %" PRIu64 " bytes\n", ctx->inp_size);
 147     }
 148
 149     if (ctx->verbose) {
 150         INFO("memory mapping '%s' (size %" PRIu64 ")\n", ctx->fec_filename,
 151             ctx->inp_size);
 152     }
 153
 154     int flags = PROT_READ;
 155
 156     if (ctx->inplace) {
 157         flags |= PROT_WRITE;
 158     }
 159
 160     void *p = mmap(NULL, (size_t)ctx->inp_size, flags, MAP_SHARED, fd, 0);
 161
 162     if (p == MAP_FAILED) {
 163         FATAL("failed to mmap '%s' (size %" PRIu64 "): %s\n",
 164             ctx->fec_filename, ctx->inp_size, strerror(errno));
 165     }
 166
 167     ctx->inp_fd = fd;
 168     ctx->input = (uint8_t *)p;
 169
 170     if (ctx->inplace) {
 171         ctx->output = ctx->input;
 172     } else if (output_needed) {
 173         if (ctx->verbose) {
 174             INFO("allocating %" PRIu64 " bytes of memory\n", ctx->inp_size);
 175         }
 176
 177         ctx->output = new uint8_t[ctx->inp_size];
 178
 179         if (!ctx->output) {
 180                 FATAL("failed to allocate memory\n");
 181         }
 182
 183         memcpy(ctx->output, ctx->input, ctx->inp_size);
 184     }
 185
 186     /* fd is closed in mmap_image_free */
 187 }
 188
 189 #ifndef IMAGE_NO_SPARSE
 190 static int process_chunk(void *priv, const void *data, int len)
 191 {
 192     image *ctx = (image *)priv;
 193     assert(len % FEC_BLOCKSIZE == 0);
 194
 195     if (data) {
 196         memcpy(&ctx->input[ctx->pos], data, len);
 197     }
 198
 199     ctx->pos += len;
 200     return 0;
 201 }
 202 #endif
 203
 204 static void file_image_load(const std::vector<int>& fds, image *ctx)
 205 {
 206     uint64_t size = 0;
 207 #ifndef IMAGE_NO_SPARSE
 208     std::vector<struct sparse_file *> files;
 209 #endif
 210
 211     for (auto fd : fds) {
 212         uint64_t len = 0;
 213
 214 #ifdef IMAGE_NO_SPARSE
 215         if (ctx->sparse) {
 216             FATAL("sparse files not supported\n");
 217         }
 218
 219         len = get_size(fd);
 220 #else
 221         struct sparse_file *file;
 222
 223         if (ctx->sparse) {
 224             file = sparse_file_import(fd, false, false);
 225         } else {
 226             file = sparse_file_import_auto(fd, false, ctx->verbose);
 227         }
 228
 229         if (!file) {
 230             FATAL("failed to read file %s\n", ctx->fec_filename);
 231         }
 232
 233         len = sparse_file_len(file, false, false);
 234         files.push_back(file);
 235 #endif /* IMAGE_NO_SPARSE */
 236
 237         size += len;
 238     }
 239
 240     calculate_rounds(size, ctx);
 241
 242     if (ctx->verbose) {
 243         INFO("allocating %" PRIu64 " bytes of memory\n", ctx->inp_size);
 244     }
 245
 246     ctx->input = new uint8_t[ctx->inp_size];
 247
 248     if (!ctx->input) {
 249         FATAL("failed to allocate memory\n");
 250     }
 251
 252     memset(ctx->input, 0, ctx->inp_size);
 253     ctx->output = ctx->input;
 254     ctx->pos = 0;
 255
 256 #ifdef IMAGE_NO_SPARSE
 257     for (auto fd : fds) {
 258         uint64_t len = get_size(fd);
 259
 260         if (!android::base::ReadFully(fd, &ctx->input[ctx->pos], len)) {
 261             FATAL("failed to read: %s\n", strerror(errno));
 262         }
 263
 264         ctx->pos += len;
 265         close(fd);
 266     }
 267 #else
 268     for (auto file : files) {
 269         sparse_file_callback(file, false, false, process_chunk, ctx);
 270         sparse_file_destroy(file);
 271     }
 272
 273     for (auto fd : fds) {
 274         close(fd);
 275     }
 276 #endif
 277 }
 278
 279 bool image_load(const std::vector<std::string>& filenames, image *ctx,
 280         bool output_needed)
 281 {
 282     assert(ctx->roots > 0 && ctx->roots < FEC_RSM);
 283     ctx->rs_n = FEC_RSM - ctx->roots;
 284
 285     int flags = O_RDONLY;
 286
 287     if (ctx->inplace) {
 288         flags = O_RDWR;
 289     }
 290
 291     std::vector<int> fds;
 292
 293     for (auto fn : filenames) {
 294         int fd = TEMP_FAILURE_RETRY(open(fn.c_str(), flags | O_LARGEFILE));
 295
 296         if (fd < 0) {
 297             FATAL("failed to open file '%s': %s\n", fn.c_str(), strerror(errno));
 298         }
 299
 300         fds.push_back(fd);
 301     }
 302
 303     if (ctx->mmap) {
 304         mmap_image_load(fds, ctx, output_needed);
 305     } else {
 306         file_image_load(fds, ctx);
 307     }
 308
 309     return true;
 310 }
 311
 312 bool image_save(const std::string& filename, image *ctx)
 313 {
 314     if (ctx->inplace && ctx->mmap) {
 315         return true; /* nothing to do */
 316     }
 317
 318     /* TODO: support saving as a sparse file */
 319     int fd = TEMP_FAILURE_RETRY(open(filename.c_str(),
 320                 O_WRONLY | O_CREAT | O_TRUNC, 0666));
 321
 322     if (fd < 0) {
 323         FATAL("failed to open file '%s: %s'\n", filename.c_str(),
 324             strerror(errno));
 325     }
 326
 327     if (!android::base::WriteFully(fd, ctx->output, ctx->inp_size)) {
 328         FATAL("failed to write to output: %s\n", strerror(errno));
 329     }
 330
 331     close(fd);
 332     return true;
 333 }
 334
 335 static void mmap_image_ecc_new(image *ctx)
 336 {
 337     if (ctx->verbose) {
 338         INFO("mmaping '%s' (size %u)\n", ctx->fec_filename, ctx->fec_size);
 339     }
 340
 341     int fd = TEMP_FAILURE_RETRY(open(ctx->fec_filename,
 342                 O_RDWR | O_CREAT, 0666));
 343
 344     if (fd < 0) {
 345         FATAL("failed to open file '%s': %s\n", ctx->fec_filename,
 346             strerror(errno));
 347     }
 348
 349     assert(sizeof(fec_header) <= FEC_BLOCKSIZE);
 350     size_t fec_size = FEC_BLOCKSIZE + ctx->fec_size;
 351
 352     if (ftruncate(fd, fec_size) == -1) {
 353         FATAL("failed to ftruncate file '%s': %s\n", ctx->fec_filename,
 354             strerror(errno));
 355     }
 356
 357     if (ctx->verbose) {
 358         INFO("memory mapping '%s' (size %zu)\n", ctx->fec_filename, fec_size);
 359     }
 360
 361     void *p = mmap(NULL, fec_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
 362
 363     if (p == MAP_FAILED) {
 364         FATAL("failed to mmap '%s' (size %zu): %s\n", ctx->fec_filename,
 365             fec_size, strerror(errno));
 366     }
 367
 368     ctx->fec_fd = fd;
 369     ctx->fec_mmap_addr = (uint8_t *)p;
 370     ctx->fec = ctx->fec_mmap_addr;
 371 }
 372
 373 static void file_image_ecc_new(image *ctx)
 374 {
 375     if (ctx->verbose) {
 376         INFO("allocating %u bytes of memory\n", ctx->fec_size);
 377     }
 378
 379     ctx->fec = new uint8_t[ctx->fec_size];
 380
 381     if (!ctx->fec) {
 382         FATAL("failed to allocate %u bytes\n", ctx->fec_size);
 383     }
 384 }
 385
 386 bool image_ecc_new(const std::string& filename, image *ctx)
 387 {
 388     assert(ctx->rounds > 0); /* image_load should be called first */
 389
 390     ctx->fec_filename = filename.c_str();
 391     ctx->fec_size = ctx->rounds * ctx->roots * FEC_BLOCKSIZE;
 392
 393     if (ctx->mmap) {
 394         mmap_image_ecc_new(ctx);
 395     } else {
 396         file_image_ecc_new(ctx);
 397     }
 398
 399     return true;
 400 }
 401
 402 bool image_ecc_load(const std::string& filename, image *ctx)
 403 {
 404     int fd = TEMP_FAILURE_RETRY(open(filename.c_str(), O_RDONLY));
 405
 406     if (fd < 0) {
 407         FATAL("failed to open file '%s': %s\n", filename.c_str(),
 408             strerror(errno));
 409     }
 410
 411     if (lseek64(fd, -FEC_BLOCKSIZE, SEEK_END) < 0) {
 412         FATAL("failed to seek to header in '%s': %s\n", filename.c_str(),
 413             strerror(errno));
 414     }
 415
 416     assert(sizeof(fec_header) <= FEC_BLOCKSIZE);
 417
 418     uint8_t header[FEC_BLOCKSIZE];
 419     fec_header *p = (fec_header *)header;
 420
 421     if (!android::base::ReadFully(fd, header, sizeof(header))) {
 422         FATAL("failed to read %zd bytes from '%s': %s\n", sizeof(header),
 423             filename.c_str(), strerror(errno));
 424     }
 425
 426     if (p->magic != FEC_MAGIC) {
 427         FATAL("invalid magic in '%s': %08x\n", filename.c_str(), p->magic);
 428     }
 429
 430     if (p->version != FEC_VERSION) {
 431         FATAL("unsupported version in '%s': %u\n", filename.c_str(),
 432             p->version);
 433     }
 434
 435     if (p->size != sizeof(fec_header)) {
 436         FATAL("unexpected header size in '%s': %u\n", filename.c_str(),
 437             p->size);
 438     }
 439
 440     if (p->roots == 0 || p->roots >= FEC_RSM) {
 441         FATAL("invalid roots in '%s': %u\n", filename.c_str(), p->roots);
 442     }
 443
 444     if (p->fec_size % p->roots || p->fec_size % FEC_BLOCKSIZE) {
 445         FATAL("invalid length in '%s': %u\n", filename.c_str(), p->fec_size);
 446     }
 447
 448     ctx->roots = (int)p->roots;
 449     ctx->rs_n = FEC_RSM - ctx->roots;
 450
 451     calculate_rounds(p->inp_size, ctx);
 452
 453     if (!image_ecc_new(filename, ctx)) {
 454         FATAL("failed to allocate ecc\n");
 455     }
 456
 457     if (p->fec_size != ctx->fec_size) {
 458         FATAL("inconsistent header in '%s'\n", filename.c_str());
 459     }
 460
 461     if (lseek64(fd, 0, SEEK_SET) < 0) {
 462         FATAL("failed to rewind '%s': %s", filename.c_str(), strerror(errno));
 463     }
 464
 465     if (!ctx->mmap && !android::base::ReadFully(fd, ctx->fec, ctx->fec_size)) {
 466         FATAL("failed to read %u bytes from '%s': %s\n", ctx->fec_size,
 467             filename.c_str(), strerror(errno));
 468     }
 469
 470     close(fd);
 471
 472     uint8_t hash[SHA256_DIGEST_LENGTH];
 473     SHA256(ctx->fec, ctx->fec_size, hash);
 474
 475     if (memcmp(hash, p->hash, SHA256_DIGEST_LENGTH) != 0) {
 476         FATAL("invalid ecc data\n");
 477     }
 478
 479     return true;
 480 }
 481
 482 bool image_ecc_save(image *ctx)
 483 {
 484     assert(sizeof(fec_header) <= FEC_BLOCKSIZE);
 485
 486     uint8_t header[FEC_BLOCKSIZE];
 487     uint8_t *p = header;
 488
 489     if (ctx->mmap) {
 490         p = (uint8_t *)&ctx->fec_mmap_addr[ctx->fec_size];
 491     }
 492
 493     memset(p, 0, FEC_BLOCKSIZE);
 494
 495     fec_header *f = (fec_header *)p;
 496
 497     f->magic = FEC_MAGIC;
 498     f->version = FEC_VERSION;
 499     f->size = sizeof(fec_header);
 500     f->roots = ctx->roots;
 501     f->fec_size = ctx->fec_size;
 502     f->inp_size = ctx->inp_size;
 503
 504     SHA256(ctx->fec, ctx->fec_size, f->hash);
 505
 506     /* store a copy of the fec_header at the end of the header block */
 507     memcpy(&p[sizeof(header) - sizeof(fec_header)], p, sizeof(fec_header));
 508
 509     if (!ctx->mmap) {
 510         assert(ctx->fec_filename);
 511
 512         int fd = TEMP_FAILURE_RETRY(open(ctx->fec_filename,
 513                     O_WRONLY | O_CREAT | O_TRUNC, 0666));
 514
 515         if (fd < 0) {
 516             FATAL("failed to open file '%s': %s\n", ctx->fec_filename,
 517                 strerror(errno));
 518         }
 519
 520         if (!android::base::WriteFully(fd, ctx->fec, ctx->fec_size) ||
 521             !android::base::WriteFully(fd, header, sizeof(header))) {
 522             FATAL("failed to write to output: %s\n", strerror(errno));
 523         }
 524
 525         close(fd);
 526     }
 527
 528     return true;
 529 }
 530
 531 static void * process(void *cookie)
 532 {
 533     image_proc_ctx *ctx = (image_proc_ctx *)cookie;
 534     ctx->func(ctx);
 535     return NULL;
 536 }
 537
 538 bool image_process(image_proc_func func, image *ctx)
 539 {
 540     int threads = ctx->threads;
 541
 542     if (threads < IMAGE_MIN_THREADS) {
 543         threads = sysconf(_SC_NPROCESSORS_ONLN);
 544
 545         if (threads < IMAGE_MIN_THREADS) {
 546             threads = IMAGE_MIN_THREADS;
 547         }
 548     }
 549
 550     assert(ctx->rounds > 0);
 551
 552     if ((uint64_t)threads > ctx->rounds) {
 553         threads = (int)ctx->rounds;
 554     }
 555     if (threads > IMAGE_MAX_THREADS) {
 556         threads = IMAGE_MAX_THREADS;
 557     }
 558
 559     if (ctx->verbose) {
 560         INFO("starting %d threads to compute RS(255, %d)\n", threads,
 561             ctx->rs_n);
 562     }
 563
 564     pthread_t pthreads[threads];
 565     image_proc_ctx args[threads];
 566
 567     uint64_t current = 0;
 568     uint64_t end = ctx->rounds * ctx->rs_n * FEC_BLOCKSIZE;
 569     uint64_t rs_blocks_per_thread =
 570         fec_div_round_up(ctx->rounds * FEC_BLOCKSIZE, threads);
 571
 572     if (ctx->verbose) {
 573         INFO("computing %" PRIu64 " codes per thread\n", rs_blocks_per_thread);
 574     }
 575
 576     for (int i = 0; i < threads; ++i) {
 577         args[i].func = func;
 578         args[i].id = i;
 579         args[i].ctx = ctx;
 580         args[i].rv = 0;
 581         args[i].fec_pos = current * ctx->roots;
 582         args[i].start = current * ctx->rs_n;
 583         args[i].end = (current + rs_blocks_per_thread) * ctx->rs_n;
 584
 585         args[i].rs = init_rs_char(FEC_PARAMS(ctx->roots));
 586
 587         if (!args[i].rs) {
 588             FATAL("failed to initialize encoder for thread %d\n", i);
 589         }
 590
 591         if (args[i].end > end) {
 592             args[i].end = end;
 593         } else if (i == threads && args[i].end + rs_blocks_per_thread *
 594                                         ctx->rs_n > end) {
 595             args[i].end = end;
 596         }
 597
 598         if (ctx->verbose) {
 599             INFO("thread %d: [%" PRIu64 ", %" PRIu64 ")\n",
 600                 i, args[i].start, args[i].end);
 601         }
 602
 603         assert(args[i].start < args[i].end);
 604         assert((args[i].end - args[i].start) % ctx->rs_n == 0);
 605
 606         if (pthread_create(&pthreads[i], NULL, process, &args[i]) != 0) {
 607             FATAL("failed to create thread %d\n", i);
 608         }
 609
 610         current += rs_blocks_per_thread;
 611     }
 612
 613     ctx->rv = 0;
 614
 615     for (int i = 0; i < threads; ++i) {
 616         if (pthread_join(pthreads[i], NULL) != 0) {
 617             FATAL("failed to join thread %d: %s\n", i, strerror(errno));
 618         }
 619
 620         ctx->rv += args[i].rv;
 621
 622         if (args[i].rs) {
 623             free_rs_char(args[i].rs);
 624             args[i].rs = NULL;
 625         }
 626     }
 627
 628     return true;
 629 }