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 "libfstools/libfstools.h"
  34 #include "libfstools/volume.h"
  35 #include "libfstools/snapshot.h"
  36
  37 static int
  38 config_write(int argc, char **argv)
  39 {
  40         struct volume *v = volume_find("rootfs_data");
  41         int ret;
  42
  43         if (!v)
  44                 return -1;
  45
  46         ret = volatile_write(v, 0);
  47         if (!ret)
  48                 ret = sentinel_write(v, 0);
  49
  50         return ret;
  51 }
  52
  53 static int
  54 config_read(int argc, char **argv)
  55 {
  56         struct volume *v = volume_find("rootfs_data");
  57         struct file_header conf, sentinel;
  58         int next, block, ret = 0;
  59         uint32_t seq;
  60
  61         if (!v)
  62                 return -1;
  63
  64         block = config_find(v, &conf, &sentinel);
  65         next = snapshot_next_free(v, &seq);
  66         if (is_config(&conf) && conf.seq == seq)
  67                 block = next;
  68         else if (!is_config(&sentinel) || sentinel.seq != seq)
  69                 return -1;
  70
  71         unlink("/tmp/config.tar.gz");
  72         ret = snapshot_read_file(v, block, "/tmp/config.tar.gz", CONF);
  73
  74         if (ret < 1)
  75                 fprintf(stderr, "failed to read /tmp/config.tar.gz\n");
  76
  77         return ret;
  78 }
  79
  80 static int
  81 snapshot_write(int argc, char **argv)
  82 {
  83         struct volume *v = volume_find("rootfs_data");
  84         int block, ret;
  85         uint32_t seq;
  86
  87         if (!v)
  88                 return -1;
  89
  90         block = snapshot_next_free(v, &seq);
  91         if (block < 0)
  92                 block = 0;
  93
  94         ret = snapshot_write_file(v, block, "/tmp/snapshot.tar.gz", seq + 1, DATA);
  95         if (ret)
  96                 fprintf(stderr, "failed to write /tmp/snapshot.tar.gz\n");
  97         else
  98                 fprintf(stderr, "wrote /tmp/snapshot.tar.gz\n");
  99
 100         return ret;
 101 }
 102
 103 static int
 104 snapshot_mark(int argc, char **argv)
 105 {
 106         __be32 owrt = cpu_to_be32(OWRT);
 107         struct volume *v;
 108         size_t sz;
 109         int fd;
 110
 111         fprintf(stderr, "This will remove all snapshot data stored on the system. Are you sure? [N/y]\n");
 112         if (getchar() != 'y')
 113                 return -1;
 114
 115         v = volume_find("rootfs_data");
 116         if (!v) {
 117                 fprintf(stderr, "no rootfs_data was found\n");
 118                 return -1;
 119         }
 120
 121         fd = open(v->blk, O_WRONLY);
 122         fprintf(stderr, "%s - marking with 0x%08x\n", v->blk, owrt);
 123         if (fd < 0) {
 124                 fprintf(stderr, "opening %s failed\n", v->blk);
 125                 return -1;
 126         }
 127
 128         sz = write(fd, &owrt, sizeof(owrt));
 129         close(fd);
 130
 131         if (sz != 1) {
 132                 fprintf(stderr, "writing %s failed: %s\n", v->blk, strerror(errno));
 133                 return -1;
 134         }
 135
 136         return 0;
 137 }
 138
 139 static int
 140 snapshot_read(int argc, char **argv)
 141 {
 142         struct volume *v = volume_find("rootfs_data");;
 143         int block = 0, ret = 0;
 144         char file[64];
 145
 146         if (!v)
 147                 return -1;
 148
 149         if (argc > 2) {
 150                 block = atoi(argv[2]);
 151                 if (block >= (v->size / v->block_size)) {
 152                         fprintf(stderr, "invalid block %d > %llu\n", block, v->size / v->block_size);
 153                         goto out;
 154                 }
 155                 snprintf(file, sizeof(file), "/tmp/snapshot/block%d.tar.gz", block);
 156
 157                 ret = snapshot_read_file(v, block, file, DATA);
 158                 goto out;
 159         }
 160
 161         do {
 162                 snprintf(file, sizeof(file), "/tmp/snapshot/block%d.tar.gz", block);
 163                 block = snapshot_read_file(v, block, file, DATA);
 164         } while (block > 0);
 165
 166 out:
 167         return ret;
 168 }
 169
 170 static int
 171 snapshot_info(void)
 172 {
 173         struct volume *v = volume_find("rootfs_data");
 174         struct file_header hdr = { 0 }, conf;
 175         int block = 0;
 176
 177         if (!v)
 178                 return -1;
 179
 180         fprintf(stderr, "sectors:\t%llu, block_size:\t%dK\n", v->size / v->block_size, v->block_size / 1024);
 181         do {
 182                 if (volume_read(v, &hdr, block * v->block_size, sizeof(struct file_header))) {
 183                         fprintf(stderr, "scanning for next free block failed\n");
 184                         return 0;
 185                 }
 186
 187                 be32_to_hdr(&hdr);
 188
 189                 if (hdr.magic != OWRT)
 190                         break;
 191
 192                 if (hdr.type == DATA)
 193                         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);
 194                 else if (hdr.type == CONF)
 195                         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);
 196
 197                 if (hdr.type == DATA && !valid_file_size(hdr.length))
 198                         block += pad_file_size(v, hdr.length) / v->block_size;
 199         } while (hdr.type == DATA);
 200         block = config_find(v, &conf, &hdr);
 201         if (block > 0)
 202                 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);
 203
 204         return 0;
 205 }
 206
 207 int main(int argc, char **argv)
 208 {
 209         if (argc < 2)
 210                 return -1;
 211
 212         if (!strcmp(argv[1], "config_read"))
 213                 return config_read(argc, argv);
 214         if (!strcmp(argv[1], "config_write"))
 215                 return config_write(argc, argv);
 216         if (!strcmp(argv[1], "read"))
 217                 return snapshot_read(argc, argv);
 218         if (!strcmp(argv[1], "write"))
 219                 return snapshot_write(argc, argv);
 220         if (!strcmp(argv[1], "mark"))
 221                 return snapshot_mark(argc, argv);
 222         if (!strcmp(argv[1], "info"))
 223                 return snapshot_info();
 224         return -1;
 225 }