libfstools/snapshot.c

   1 /*
   2  * Copyright (C) 2014 John Crispin <blogic@openwrt.org>
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU Lesser General Public License version 2.1
   6  * as published by the Free Software Foundation
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  */
  13
  14 #include <sys/stat.h>
  15 #include <sys/stat.h>
  16 #include <sys/types.h>
  17 #include <sys/ioctl.h>
  18 #include <sys/mount.h>
  19 #include <mtd/mtd-user.h>
  20
  21 #include <glob.h>
  22 #include <fcntl.h>
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <libgen.h>
  26 #include <unistd.h>
  27 #include <string.h>
  28
  29 #include <libubox/list.h>
  30 #include <libubox/blob.h>
  31 #include <libubox/md5.h>
  32
  33 #include "../fs-state.h"
  34 #include "volume.h"
  35
  36 #define PATH_MAX        256
  37 #define OWRT            0x4f575254
  38 #define DATA            0x44415441
  39 #define CONF            0x434f4e46
  40
  41 struct file_header {
  42         uint32_t magic;
  43         uint32_t type;
  44         uint32_t seq;
  45         uint32_t length;
  46         uint32_t md5[4];
  47 };
  48
  49 static inline int
  50 is_config(struct file_header *h)
  51 {
  52         return ((h->magic == OWRT) && (h->type == CONF));
  53 }
  54
  55 static inline int
  56 valid_file_size(int fs)
  57 {
  58         if ((fs > 8 * 1024 * 1204) || (fs <= 0))
  59                 return -1;
  60
  61         return 0;
  62 }
  63
  64 static void
  65 hdr_to_be32(struct file_header *hdr)
  66 {
  67         uint32_t *h = (uint32_t *) hdr;
  68         int i;
  69
  70         for (i = 0; i < sizeof(struct file_header) / sizeof(uint32_t); i++)
  71                 h[i] = cpu_to_be32(h[i]);
  72 }
  73
  74 static void
  75 be32_to_hdr(struct file_header *hdr)
  76 {
  77         uint32_t *h = (uint32_t *) hdr;
  78         int i;
  79
  80         for (i = 0; i < sizeof(struct file_header) / sizeof(uint32_t); i++)
  81                 h[i] = be32_to_cpu(h[i]);
  82 }
  83
  84 static int
  85 pad_file_size(struct volume *v, int size)
  86 {
  87         int mod;
  88
  89         size += sizeof(struct file_header);
  90         mod = size % v->block_size;
  91         if (mod) {
  92                 size -= mod;
  93                 size += v->block_size;
  94         }
  95
  96         return size;
  97 }
  98
  99 static int
 100 verify_file_hash(char *file, uint32_t *hash)
 101 {
 102         uint32_t md5[4];
 103
 104         if (md5sum(file, md5)) {
 105                 fprintf(stderr, "failed to generate md5 sum\n");
 106                 return -1;
 107         }
 108
 109         if (memcmp(md5, hash, sizeof(md5))) {
 110                 fprintf(stderr, "failed to verify hash of %s.\n", file);
 111                 return -1;
 112         }
 113
 114         return 0;
 115 }
 116
 117 static int
 118 snapshot_next_free(struct volume *v, uint32_t *seq)
 119 {
 120         struct file_header hdr = { 0 };
 121         int block = 0;
 122
 123         *seq = rand();
 124
 125         do {
 126                 if (volume_read(v, &hdr, block * v->block_size, sizeof(struct file_header))) {
 127                         fprintf(stderr, "scanning for next free block failed\n");
 128                         return 0;
 129                 }
 130
 131                 be32_to_hdr(&hdr);
 132
 133                 if (hdr.magic != OWRT)
 134                         break;
 135
 136                 if (hdr.type == DATA && !valid_file_size(hdr.length)) {
 137                         if (*seq + 1 != hdr.seq && block)
 138                                 return block;
 139                         *seq = hdr.seq;
 140                         block += pad_file_size(v, hdr.length) / v->block_size;
 141                 }
 142         } while (hdr.type == DATA);
 143
 144         return block;
 145 }
 146
 147 static int
 148 config_find(struct volume *v, struct file_header *conf, struct file_header *sentinel)
 149 {
 150         uint32_t seq;
 151         int i, next = snapshot_next_free(v, &seq);
 152
 153         conf->magic = sentinel->magic = 0;
 154
 155         if (!volume_read(v, conf, next, sizeof(*conf)))
 156                 be32_to_hdr(conf);
 157
 158         for (i = (v->size / v->block_size) - 1; i > 0; i--) {
 159                 if (volume_read(v, sentinel,  i * v->block_size, sizeof(*sentinel))) {
 160                         fprintf(stderr, "failed to read header\n");
 161                         return -1;
 162                 }
 163                 be32_to_hdr(sentinel);
 164
 165                 if (sentinel->magic == OWRT && sentinel->type == CONF && !valid_file_size(sentinel->length)) {
 166                         if (next == i)
 167                                 return -1;
 168                         return i;
 169                 }
 170         }
 171
 172         return -1;
 173 }
 174
 175 static int
 176 snapshot_info(void)
 177 {
 178         struct volume *v = volume_find("rootfs_data");
 179         struct file_header hdr = { 0 }, conf;
 180         int block = 0;
 181
 182         if (!v)
 183                 return -1;
 184
 185         fprintf(stderr, "sectors:\t%llu, block_size:\t%dK\n", v->size / v->block_size, v->block_size / 1024);
 186         do {
 187                 if (volume_read(v, &hdr, block * v->block_size, sizeof(struct file_header))) {
 188                         fprintf(stderr, "scanning for next free block failed\n");
 189                         return 0;
 190                 }
 191
 192                 be32_to_hdr(&hdr);
 193
 194                 if (hdr.magic != OWRT)
 195                         break;
 196
 197                 if (hdr.type == DATA)
 198                         fprintf(stderr, "block %d:\tsnapshot entry, size: %d, sectors: %d, sequence: %d\n", block,  hdr.length, pad_file_size(v, hdr.length) / v->block_size, hdr.seq);
 199                 else if (hdr.type == CONF)
 200                         fprintf(stderr, "block %d:\tvolatile entry, size: %d, sectors: %d, sequence: %d\n", block,  hdr.length, pad_file_size(v, hdr.length) / v->block_size, hdr.seq);
 201
 202                 if (hdr.type == DATA && !valid_file_size(hdr.length))
 203                         block += pad_file_size(v, hdr.length) / v->block_size;
 204         } while (hdr.type == DATA);
 205         block = config_find(v, &conf, &hdr);
 206         if (block > 0)
 207                 fprintf(stderr, "block %d:\tsentinel entry, size: %d, sectors: %d, sequence: %d\n", block, hdr.length, pad_file_size(v, hdr.length) / v->block_size, hdr.seq);
 208
 209         return 0;
 210 }
 211
 212 static int
 213 snapshot_write_file(struct volume *v, int block, char *file, uint32_t seq, uint32_t type)
 214 {
 215         uint32_t md5[4] = { 0 };
 216         struct file_header hdr;
 217         struct stat s;
 218         char buffer[256];
 219         int in = 0, len, offset;
 220         int ret = -1;
 221
 222         if (stat(file, &s) || md5sum(file, md5)) {
 223                 fprintf(stderr, "stat failed on %s\n", file);
 224                 goto out;
 225         }
 226
 227         if ((block * v->block_size) + pad_file_size(v, s.st_size) > v->size) {
 228                 fprintf(stderr, "upgrade is too big for the flash\n");
 229                 goto out;
 230         }
 231         volume_erase(v, block * v->block_size, pad_file_size(v, s.st_size));
 232         volume_erase(v, block * v->block_size + pad_file_size(v, s.st_size), v->block_size);
 233
 234         hdr.length = s.st_size;
 235         hdr.magic = OWRT;
 236         hdr.type = type;
 237         hdr.seq = seq;
 238         memcpy(hdr.md5, md5, sizeof(md5));
 239         hdr_to_be32(&hdr);
 240
 241         if (volume_write(v, &hdr, block * v->block_size, sizeof(struct file_header))) {
 242                 fprintf(stderr, "failed to write header\n");
 243                 goto out;
 244         }
 245
 246         in = open(file, O_RDONLY);
 247         if (in < 1) {
 248                 fprintf(stderr, "failed to open %s\n", file);
 249                 goto out;
 250         }
 251
 252         offset = (block * v->block_size) + sizeof(struct file_header);
 253
 254         while ((len = read(in, buffer, sizeof(buffer))) > 0) {
 255                 if (volume_write(v, buffer, offset, len) < 0)
 256                         goto out;
 257                 offset += len;
 258         }
 259
 260         ret = 0;
 261
 262 out:
 263         if (in > 0)
 264                 close(in);
 265
 266         return ret;
 267 }
 268
 269 static int
 270 snapshot_read_file(struct volume *v, int block, char *file, uint32_t type)
 271 {
 272         struct file_header hdr;
 273         char buffer[256];
 274         int out, offset = 0;
 275
 276         if (volume_read(v, &hdr, block * v->block_size, sizeof(struct file_header))) {
 277                 fprintf(stderr, "failed to read header\n");
 278                 return -1;
 279         }
 280         be32_to_hdr(&hdr);
 281
 282         if (hdr.magic != OWRT)
 283                 return -1;
 284
 285         if (hdr.type != type)
 286                 return -1;
 287
 288         if (valid_file_size(hdr.length))
 289                 return -1;
 290
 291         out = open(file, O_WRONLY | O_CREAT, 0700);
 292         if (!out) {
 293                 fprintf(stderr, "failed to open %s\n", file);
 294                 return -1;
 295         }
 296
 297         while (hdr.length > 0) {
 298                 int len = sizeof(buffer);
 299
 300                 if (hdr.length < len)
 301                         len = hdr.length;
 302
 303                 if ((volume_read(v, buffer, offset, len) != len) || (write(out, buffer, len) != len))
 304                         return -1;
 305
 306                 offset += len;
 307                 hdr.length -= len;
 308         }
 309
 310         close(out);
 311
 312         if (verify_file_hash(file, hdr.md5)) {
 313                 fprintf(stderr, "md5 verification failed\n");
 314                 unlink(file);
 315                 return 0;
 316         }
 317
 318         block += pad_file_size(v, hdr.length) / v->block_size;
 319
 320         return block;
 321 }
 322
 323 static int
 324 sentinel_write(struct volume *v, uint32_t _seq)
 325 {
 326         int ret, block;
 327         struct stat s;
 328         uint32_t seq;
 329
 330         if (stat("/tmp/config.tar.gz", &s)) {
 331                 fprintf(stderr, "failed to stat /tmp/config.tar.gz\n");
 332                 return -1;
 333         }
 334
 335         snapshot_next_free(v, &seq);
 336         if (_seq)
 337                 seq = _seq;
 338         block = v->size / v->block_size;
 339         block -= pad_file_size(v, s.st_size) / v->block_size;
 340         if (block < 0)
 341                 block = 0;
 342
 343         ret = snapshot_write_file(v, block, "/tmp/config.tar.gz", seq, CONF);
 344         if (ret)
 345                 fprintf(stderr, "failed to write sentinel\n");
 346         else
 347                 fprintf(stderr, "wrote /tmp/config.tar.gz sentinel\n");
 348         return ret;
 349 }
 350
 351 static int
 352 volatile_write(struct volume *v, uint32_t _seq)
 353 {
 354         int block, ret;
 355         uint32_t seq;
 356
 357         block = snapshot_next_free(v, &seq);
 358         if (_seq)
 359                 seq = _seq;
 360         if (block < 0)
 361                 block = 0;
 362
 363         ret = snapshot_write_file(v, block, "/tmp/config.tar.gz", seq, CONF);
 364         if (ret)
 365                 fprintf(stderr, "failed to write /tmp/config.tar.gz\n");
 366         else
 367                 fprintf(stderr, "wrote /tmp/config.tar.gz\n");
 368         return ret;
 369 }
 370
 371 static int
 372 config_write(int argc, char **argv)
 373 {
 374         struct volume *v = volume_find("rootfs_data");
 375         int ret;
 376
 377         if (!v)
 378                 return -1;
 379
 380         ret = volatile_write(v, 0);
 381         if (!ret)
 382                 ret = sentinel_write(v, 0);
 383
 384         return ret;
 385 }
 386
 387 static int
 388 config_read(int argc, char **argv)
 389 {
 390         struct volume *v = volume_find("rootfs_data");
 391         struct file_header conf, sentinel;
 392         int next, block, ret = 0;
 393         uint32_t seq;
 394
 395         if (!v)
 396                 return -1;
 397
 398         block = config_find(v, &conf, &sentinel);
 399         next = snapshot_next_free(v, &seq);
 400         if (is_config(&conf) && conf.seq == seq)
 401                 block = next;
 402         else if (!is_config(&sentinel) || sentinel.seq != seq)
 403                 return -1;
 404
 405         unlink("/tmp/config.tar.gz");
 406         ret = snapshot_read_file(v, block, "/tmp/config.tar.gz", CONF);
 407
 408         if (ret < 1)
 409                 fprintf(stderr, "failed to read /tmp/config.tar.gz\n");
 410
 411         return ret;
 412 }
 413
 414 static int
 415 snapshot_write(int argc, char **argv)
 416 {
 417         struct volume *v = volume_find("rootfs_data");
 418         int block, ret;
 419         uint32_t seq;
 420
 421         if (!v)
 422                 return -1;
 423
 424         block = snapshot_next_free(v, &seq);
 425         if (block < 0)
 426                 block = 0;
 427
 428         ret = snapshot_write_file(v, block, "/tmp/snapshot.tar.gz", seq + 1, DATA);
 429         if (ret)
 430                 fprintf(stderr, "failed to write /tmp/snapshot.tar.gz\n");
 431         else
 432                 fprintf(stderr, "wrote /tmp/snapshot.tar.gz\n");
 433
 434         return ret;
 435 }
 436
 437 static int
 438 snapshot_mark(int argc, char **argv)
 439 {
 440         __be32 owrt = cpu_to_be32(OWRT);
 441         struct volume *v;
 442         size_t sz;
 443         int fd;
 444
 445         fprintf(stderr, "This will remove all snapshot data stored on the system. Are you sure? [N/y]\n");
 446         if (getchar() != 'y')
 447                 return -1;
 448
 449         v = volume_find("rootfs_data");
 450         if (!v) {
 451                 fprintf(stderr, "no rootfs_data was found\n");
 452                 return -1;
 453         }
 454
 455         fd = open(v->blk, O_WRONLY);
 456         fprintf(stderr, "%s - marking with 0x%08x\n", v->blk, owrt);
 457         if (fd < 0) {
 458                 fprintf(stderr, "opening %s failed\n", v->blk);
 459                 return -1;
 460         }
 461
 462         sz = write(fd, &owrt, sizeof(owrt));
 463         close(fd);
 464
 465         if (sz != 1) {
 466                 fprintf(stderr, "writing %s failed: %s\n", v->blk, strerror(errno));
 467                 return -1;
 468         }
 469
 470         return 0;
 471 }
 472
 473 static int
 474 snapshot_read(int argc, char **argv)
 475 {
 476         struct volume *v = volume_find("rootfs_data");;
 477         int block = 0, ret = 0;
 478         char file[64];
 479
 480         if (!v)
 481                 return -1;
 482
 483         if (argc > 1) {
 484                 block = atoi(argv[1]);
 485                 if (block >= (v->size / v->block_size)) {
 486                         fprintf(stderr, "invalid block %d > %llu\n", block, v->size / v->block_size);
 487                         goto out;
 488                 }
 489                 snprintf(file, sizeof(file), "/tmp/snapshot/block%d.tar.gz", block);
 490
 491                 ret = snapshot_read_file(v, block, file, DATA);
 492                 goto out;
 493         }
 494
 495         do {
 496                 snprintf(file, sizeof(file), "/tmp/snapshot/block%d.tar.gz", block);
 497                 block = snapshot_read_file(v, block, file, DATA);
 498         } while (block > 0);
 499
 500 out:
 501         return ret;
 502 }
 503
 504 static int
 505 snapshot_sync(void)
 506 {
 507         struct volume *v = volume_find("rootfs_data");
 508         struct file_header sentinel, conf;
 509         int next, block = 0;
 510         uint32_t seq;
 511
 512         if (!v)
 513                 return -1;
 514
 515         next = snapshot_next_free(v, &seq);
 516         block = config_find(v, &conf, &sentinel);
 517         if (is_config(&conf) && conf.seq != seq) {
 518                 conf.magic = 0;
 519                 volume_erase(v, next * v->block_size, 2 * v->block_size);
 520         }
 521
 522         if (is_config(&sentinel) && (sentinel.seq != seq)) {
 523                 sentinel.magic = 0;
 524                 volume_erase(v, block * v->block_size, v->block_size);
 525         }
 526
 527         if (!is_config(&conf) && !is_config(&sentinel)) {
 528         //      fprintf(stderr, "no config found\n");
 529         } else if (((is_config(&conf) && is_config(&sentinel)) &&
 530                                 (memcmp(conf.md5, sentinel.md5, sizeof(conf.md5)) || (conf.seq != sentinel.seq))) ||
 531                         (is_config(&conf) && !is_config(&sentinel))) {
 532                 uint32_t seq;
 533                 int next = snapshot_next_free(v, &seq);
 534                 int ret = snapshot_read_file(v, next, "/tmp/config.tar.gz", CONF);
 535                 if (ret > 0) {
 536                         if (sentinel_write(v, conf.seq))
 537                                 fprintf(stderr, "failed to write sentinel data");
 538                 }
 539         } else if (!is_config(&conf) && is_config(&sentinel) && next) {
 540                 int ret = snapshot_read_file(v, block, "/tmp/config.tar.gz", CONF);
 541                 if (ret > 0)
 542                         if (volatile_write(v, sentinel.seq))
 543                                 fprintf(stderr, "failed to write sentinel data");
 544         } else
 545                 fprintf(stderr, "config in sync\n");
 546
 547         unlink("/tmp/config.tar.gz");
 548
 549         return 0;
 550 }
 551
 552 static int
 553 _ramoverlay(char *rom, char *overlay)
 554 {
 555         mount("tmpfs", overlay, "tmpfs", MS_NOATIME, "mode=0755");
 556         return fopivot(overlay, rom);
 557 }
 558
 559 static int
 560 snapshot_mount(void)
 561 {
 562         snapshot_sync();
 563         setenv("SNAPSHOT", "magic", 1);
 564         _ramoverlay("/rom", "/overlay");
 565         system("/sbin/snapshot unpack");
 566         foreachdir("/overlay/", handle_whiteout);
 567         mkdir("/volatile", 0700);
 568         _ramoverlay("/rom", "/volatile");
 569         mount_move("/rom/volatile", "/volatile", "");
 570         mount_move("/rom/rom", "/rom", "");
 571         system("/sbin/snapshot config_unpack");
 572         foreachdir("/volatile/", handle_whiteout);
 573         unsetenv("SNAPSHOT");
 574         return -1;
 575 }
 576
 577 static struct backend_handler snapshot_handlers[] = {
 578 {
 579         .name = "config_read",
 580         .cli = config_read,
 581 }, {
 582         .name = "config_write",
 583         .cli = config_write,
 584 }, {
 585         .name = "read",
 586         .cli = snapshot_read,
 587 }, {
 588         .name = "write",
 589         .cli = snapshot_write,
 590 }, {
 591         .name = "mark",
 592         .cli = snapshot_mark,
 593 }};
 594
 595 static struct backend snapshot_backend = {
 596         .name = "snapshot",
 597         .num_handlers = ARRAY_SIZE(snapshot_handlers),
 598         .handlers = snapshot_handlers,
 599         .mount = snapshot_mount,
 600         .info = snapshot_info,
 601 };
 602 BACKEND(snapshot_backend);