fatblock/fatblock.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
  17 #include <assert.h>
  18 #include <errno.h>
  19 #include <stdint.h>
  20 #include <stdio.h>
  21 #include <unistd.h>
  22
  23 #include <ublock/ublock.h>
  24
  25 #include "fatblock.h"
  26 #include "fs.h"
  27 #include "utils.h"
  28
  29 static struct fs fs;
  30 static struct ublock_ctx *ub;
  31 static int ums_lun = 0;
  32
  33 static int fs_import(struct fs *fs,
  34                      uint16_t cluster_size, offset_t data_size,
  35                      offset_t *total_size_out)
  36 {
  37         int ret;
  38
  39         ret = fs_init(fs, cluster_size, data_size, total_size_out);
  40         if (ret)
  41                 return ret;
  42
  43         ret = import_tree(fs, ".");
  44         if (ret)
  45                 return ret;
  46
  47         return 0;
  48 }
  49
  50
  51
  52 static int read_callback(char *buf, uint64_t length, uint64_t offset)
  53 {
  54         int result;
  55         int i;
  56
  57         result = fs_read(&fs, buf, offset, length);
  58         if (result == SKY_IS_FALLING) {
  59                 WARN("underlying filesystem has been modified; stopping.\n");
  60                 ublock_stop(ub);
  61         }
  62
  63         return result ? -EINVAL : 0;
  64 }
  65
  66 static int write_callback(const char *buf, uint64_t length, uint64_t offset)
  67 {
  68         DEBUG("writing to (%llu, %llu): we are read-only\n", offset, length);
  69
  70         return -EINVAL;
  71 }
  72
  73 static struct ublock_ops ops = {
  74         .read = &read_callback,
  75         .write = &write_callback
  76 };
  77
  78
  79
  80 static int set_ums_file(int index)
  81 {
  82         char filename[PATH_MAX];
  83         FILE *file;
  84
  85         sprintf(filename, "/sys/devices/platform/usb_mass_storage/lun%d/file",
  86                 ums_lun);
  87         file = fopen(filename, "w");
  88         if (!file) {
  89                 WARN("setting USB mass storage file: fopen(%s) failed: %s\n",
  90                      filename, strerror(errno));
  91                 return -1;
  92         }
  93
  94         WARN("writing '/dev/block/ublock%d' to %s.\n", index, filename);
  95
  96         fprintf(file, "/dev/block/ublock%d", index);
  97
  98         fclose(file);
  99
 100         return 0;
 101 }
 102
 103 static int clear_ums_file(void)
 104 {
 105         char filename[PATH_MAX];
 106         FILE *file;
 107
 108         sprintf(filename, "/sys/devices/platform/usb_mass_storage/lun%d/file",
 109                 ums_lun);
 110         file = fopen(filename, "w");
 111         if (!file) {
 112                 WARN("clearing USB mass storage file: fopen(%s) failed: %s\n",
 113                      filename, strerror(errno));
 114                 return -1;
 115         }
 116
 117         fclose(file);
 118
 119         return 0;
 120 }
 121
 122
 123
 124
 125 static void cleanup(void)
 126 {
 127         WARN("cleanup: clearing USB mass storage file\n");
 128         clear_ums_file();
 129         WARN("cleanup: destroying block device\n");
 130         ublock_destroy(ub);
 131 }
 132
 133 static void signal_handler(int sig)
 134 {
 135         WARN("received signal %d\n", sig);
 136         cleanup();
 137         exit(0);
 138 }
 139
 140 static int normal_exit = 0;
 141
 142 static void atexit_handler(void)
 143 {
 144         if (normal_exit)
 145                 return;
 146
 147         cleanup();
 148 }
 149
 150 int main(int argc, char *argv[]) {
 151         char *path;
 152         int mb;
 153         offset_t total_size;
 154         int index;
 155         int ret;
 156
 157         signal(SIGINT, &signal_handler);
 158         signal(SIGTERM, &signal_handler);
 159         atexit(&atexit_handler);
 160
 161         if (argc != 3)
 162                 DIE("Usage: fatblock <path> <size in MB>\n");
 163
 164         path = argv[1];
 165         mb = atoi(argv[2]);
 166
 167         INFO("fatblock: importing filesystem from %s (%d MB)\n", path, mb);
 168
 169         ret = chdir(path);
 170         if (ret < 0)
 171                 DIE("fatblock: chdir(%s) failed: %s; aborting\n", path, strerror(errno));
 172
 173         ret = fs_import(&fs, 32768, 1048576LL * mb, &total_size);
 174         if (ret)
 175                 DIE("fatblock: couldn't import filesystem; aborting\n");
 176
 177         INFO("fatblock: filesystem imported (%llu bytes)\n", total_size);
 178
 179         ret = ublock_init(&ub, &ops, total_size);
 180         if (ret)
 181                 DIE("fatblock: couldn't create block device; aborting\n");
 182         index = ublock_index(ub);
 183         if (index < 0)
 184                 DIE("fatblock: invalid ublock index %d; aborting\n", index);
 185
 186         INFO("fatblock: block device ublock%d created\n", index);
 187         set_ums_file(index);
 188
 189         INFO("fatblock: entering main loop\n");
 190         ublock_run(ub);
 191
 192         INFO("fatblock: destroying block device\n");
 193         clear_ums_file();
 194         ublock_destroy(ub);
 195
 196         normal_exit = 1;
 197
 198         INFO("fatblock: goodbye!\n");
 199         return 0;
 200 }