thin-provisioning-tools/thin-provisioning/thin_patch_superblock.cc

194 lines
4.7 KiB
C++

#include <getopt.h>
#include "persistent-data/file_utils.h"
#include "persistent-data/space-maps/disk_structures.h"
#include "thin-provisioning/commands.h"
#include "thin-provisioning/metadata.h"
#include "thin-provisioning/superblock.h"
#include "version.h"
using namespace persistent_data;
using namespace sm_disk_detail;
using namespace thin_provisioning;
//----------------------------------------------------------------
namespace {
struct flags {
flags();
bool check_conformance();
string output;
boost::optional<uint64_t> transaction_id;
block_address data_mapping_root;
block_address device_details_root;
block_address metadata_bitmap_root;
block_address metadata_ref_count_root;
block_address data_bitmap_root;
block_address data_ref_count_root;
};
flags::flags()
: data_mapping_root(0), device_details_root(0),
metadata_bitmap_root(0), metadata_ref_count_root(0),
data_bitmap_root(0), data_ref_count_root(0) {
}
bool flags::check_conformance() {
if (!output.size())
return false;
return true;
}
void patch_space_map_root(void *root,
block_address bitmap_root,
block_address ref_count_root) {
sm_disk_detail::sm_root v;
sm_disk_detail::sm_root_disk d;
memcpy(&d, root, sizeof(d));
sm_root_traits::unpack(d, v);
if (bitmap_root)
v.bitmap_root_ = bitmap_root;
if (ref_count_root)
v.ref_count_root_ = ref_count_root;
sm_root_traits::pack(v, d);
memcpy(root, &d, sizeof(d));
}
int patch_superblock(flags const &fs) {
block_manager::ptr bm = open_bm(fs.output, block_manager::READ_WRITE);
superblock_detail::superblock sb = read_superblock(bm, superblock_detail::SUPERBLOCK_LOCATION);
if (fs.transaction_id)
sb.trans_id_ = *fs.transaction_id;
if (fs.data_mapping_root)
sb.data_mapping_root_ = fs.data_mapping_root;
if (fs.device_details_root)
sb.device_details_root_ = fs.device_details_root;
patch_space_map_root(sb.metadata_space_map_root_,
fs.metadata_bitmap_root,
fs.metadata_ref_count_root);
patch_space_map_root(sb.data_space_map_root_,
fs.data_bitmap_root,
fs.data_ref_count_root);
write_superblock(bm, sb);
return 0;
}
}
//----------------------------------------------------------------
thin_patch_superblock_cmd::thin_patch_superblock_cmd()
: command("thin_patch_superblock")
{
}
void
thin_patch_superblock_cmd::usage(std::ostream &out) const
{
out << "Usage: " << get_name() << " [options]\n"
<< "Options:\n"
<< " {-h|--help}\n"
<< " {-o|--output} <output device or file>\n"
<< " {--transaction-id} <tid>\n"
<< " {--data-mapping-root} <blocknr>\n"
<< " {--device-details-root} <blocknr>\n"
<< " {--metadata-bitmap-root} <blocknr>\n"
<< " {--metadata-ref-count-root} <blocknr>\n"
<< " {--data-bitmap-root} <blocknr>\n"
<< " {--data-ref-count-root} <blocknr>\n"
<< " {-V|--version}" << endl;
}
int
thin_patch_superblock_cmd::run(int argc, char **argv)
{
int c;
flags fs;
const char shortopts[] = "ho:V";
const struct option longopts[] = {
{ "help", no_argument, NULL, 'h'},
{ "output", required_argument, NULL, 'o'},
{ "transaction-id", required_argument, NULL, 1 },
{ "data-mapping-root", required_argument, NULL, 2 },
{ "device-details-root", required_argument, NULL, 3 },
{ "metadata-bitmap-root", required_argument, NULL, 4 },
{ "metadata-ref-count-root", required_argument, NULL, 5 },
{ "data-bitmap-root", required_argument, NULL, 6 },
{ "data-ref-count-root", required_argument, NULL, 7 },
{ "version", no_argument, NULL, 'V'},
{ NULL, no_argument, NULL, 0 }
};
while ((c = getopt_long(argc, argv, shortopts, longopts, NULL)) != -1) {
switch(c) {
case 'h':
usage(cout);
return 0;
case 'o':
fs.output = optarg;
break;
case 1:
fs.transaction_id = parse_uint64(optarg, "transaction_id");
break;
case 2:
fs.data_mapping_root = parse_uint64(optarg, "data_mapping_root");
break;
case 3:
fs.device_details_root = parse_uint64(optarg, "device_details_root");
break;
case 4:
fs.metadata_bitmap_root = parse_uint64(optarg, "metadata_bitmap_root");
break;
case 5:
fs.metadata_ref_count_root = parse_uint64(optarg, "metadata_ref_count_root");
break;
case 6:
fs.data_bitmap_root = parse_uint64(optarg, "data_bitmap_root");
break;
case 7:
fs.data_ref_count_root = parse_uint64(optarg, "data_ref_count_root");
break;
case 'V':
cout << THIN_PROVISIONING_TOOLS_VERSION << endl;
return 0;
default:
usage(cerr);
return 1;
}
}
if (!fs.check_conformance()) {
usage(cerr);
return 1;
}
return patch_superblock(fs);
}
//----------------------------------------------------------------