diff --git a/Makefile.in b/Makefile.in index e67b300..cbe9347 100644 --- a/Makefile.in +++ b/Makefile.in @@ -38,6 +38,7 @@ SOURCE=\ caching/cache_metadata_size.cc \ caching/cache_repair.cc \ caching/cache_restore.cc \ + caching/commands.cc \ caching/hint_array.cc \ caching/mapping_array.cc \ caching/metadata.cc \ @@ -45,6 +46,7 @@ SOURCE=\ caching/restore_emitter.cc \ caching/superblock.cc \ caching/xml_format.cc \ + era/commands.cc \ era/era_array.cc \ era/era_check.cc \ era/era_detail.cc \ @@ -71,6 +73,7 @@ SOURCE=\ persistent-data/space_map.cc \ persistent-data/transaction_manager.cc \ persistent-data/validators.cc \ + thin-provisioning/commands.cc \ thin-provisioning/device_tree.cc \ thin-provisioning/human_readable_format.cc \ thin-provisioning/mapping_tree.cc \ @@ -173,6 +176,7 @@ install: bin/pdata_tools ln -s -f pdata_tools $(BINDIR)/thin_check ln -s -f pdata_tools $(BINDIR)/thin_delta ln -s -f pdata_tools $(BINDIR)/thin_dump + ln -s -f pdata_tools $(BINDIR)/thin_ls ln -s -f pdata_tools $(BINDIR)/thin_repair ln -s -f pdata_tools $(BINDIR)/thin_restore ln -s -f pdata_tools $(BINDIR)/thin_rmap @@ -190,6 +194,7 @@ install: bin/pdata_tools $(INSTALL_DATA) man8/thin_check.8 $(MANPATH)/man8 $(INSTALL_DATA) man8/thin_delta.8 $(MANPATH)/man8 $(INSTALL_DATA) man8/thin_dump.8 $(MANPATH)/man8 + $(INSTALL_DATA) man8/thin_ls.8 $(MANPATH)/man8 $(INSTALL_DATA) man8/thin_repair.8 $(MANPATH)/man8 $(INSTALL_DATA) man8/thin_restore.8 $(MANPATH)/man8 $(INSTALL_DATA) man8/thin_rmap.8 $(MANPATH)/man8 diff --git a/base/application.cc b/base/application.cc index 9e1f0dd..0ec1749 100644 --- a/base/application.cc +++ b/base/application.cc @@ -1,14 +1,47 @@ #include "base/application.h" +#include #include #include #include +#include using namespace base; +using namespace boost; using namespace std; //---------------------------------------------------------------- +command::command(string const &name) + : name_(name) { +} + +void +command::die(string const &msg) +{ + cerr << msg << endl; + usage(cerr); + exit(1); +} + +uint64_t +command::parse_uint64(string const &str, string const &desc) +{ + try { + // FIXME: check trailing garbage is handled + return lexical_cast(str); + + } catch (...) { + ostringstream out; + out << "Couldn't parse " << desc << ": '" << str << "'"; + die(out.str()); + } + + return 0; // never get here +} + +//---------------------------------------------------------------- + int application::run(int argc, char **argv) { @@ -26,7 +59,7 @@ application::run(int argc, char **argv) cmd = argv[0]; } - std::list::const_iterator it; + std::list::const_iterator it; for (it = cmds_.begin(); it != cmds_.end(); ++it) { if (cmd == (*it)->get_name()) return (*it)->run(argc, argv); @@ -43,7 +76,7 @@ application::usage() std::cerr << "Usage: \n" << "commands:\n"; - std::list::const_iterator it; + std::list::const_iterator it; for (it = cmds_.begin(); it != cmds_.end(); ++it) { std::cerr << " " << (*it)->get_name() << "\n"; } diff --git a/base/application.h b/base/application.h index d01eb36..d3864af 100644 --- a/base/application.h +++ b/base/application.h @@ -1,40 +1,60 @@ #ifndef BASE_APPLICATION_H #define BASE_APPLICATION_H +#include #include #include #include #include +#include //---------------------------------------------------------------- namespace base { class command { public: - typedef int (*cmd_fn)(int, char **); + typedef boost::shared_ptr ptr; - command(std::string const &name, cmd_fn fn) - : name_(name), - fn_(fn) { - } + command(std::string const &name); + virtual ~command() {} + + void die(std::string const &msg); + uint64_t parse_uint64(std::string const &str, std::string const &desc); + + + virtual void usage(std::ostream &out) const = 0; + virtual int run(int argc, char **argv) = 0; std::string const &get_name() const { return name_; } + private: + std::string name_; + + }; + + class command_old : public command { + public: + typedef int (*cmd_fn)(int, char **); + + command_old(std::string const &name, cmd_fn fn) + : command(name), + fn_(fn) { + } + int run(int argc, char **argv) const { return fn_(argc, argv); } private: - std::string name_; cmd_fn fn_; }; class application { public: - void add_cmd(command const &c) { - cmds_.push_back(&c); + void add_cmd(command::ptr c) { + cmds_.push_back(c); } int run(int argc, char **argv); @@ -43,7 +63,7 @@ namespace base { void usage(); std::string get_basename(std::string const &path) const; - std::list cmds_; + std::list cmds_; }; } diff --git a/caching/cache_check.cc b/caching/cache_check.cc index 9bd34be..33d041b 100644 --- a/caching/cache_check.cc +++ b/caching/cache_check.cc @@ -31,7 +31,6 @@ using namespace std; //---------------------------------------------------------------- namespace { - class reporter_base { public: reporter_base(nested_output &o) @@ -326,24 +325,32 @@ namespace { return r; } - - void usage(ostream &out, string const &cmd) { - out << "Usage: " << cmd << " [options] {device|file}" << endl - << "Options:" << endl - << " {-q|--quiet}" << endl - << " {-h|--help}" << endl - << " {-V|--version}" << endl - << " {--clear-needs-check-flag}" << endl - << " {--super-block-only}" << endl - << " {--skip-mappings}" << endl - << " {--skip-hints}" << endl - << " {--skip-discards}" << endl; - } } //---------------------------------------------------------------- -int cache_check_main(int argc, char **argv) +cache_check_cmd::cache_check_cmd() + : command("cache_check") +{ +} + +void +cache_check_cmd::usage(std::ostream &out) const +{ + out << "Usage: " << get_name() << " [options] {device|file}" << endl + << "Options:" << endl + << " {-q|--quiet}" << endl + << " {-h|--help}" << endl + << " {-V|--version}" << endl + << " {--clear-needs-check-flag}" << endl + << " {--super-block-only}" << endl + << " {--skip-mappings}" << endl + << " {--skip-hints}" << endl + << " {--skip-discards}" << endl; +} + +int +cache_check_cmd::run(int argc, char **argv) { int c; flags fs; @@ -384,7 +391,7 @@ int cache_check_main(int argc, char **argv) break; case 'h': - usage(cout, basename(argv[0])); + usage(cout); return 0; case 'q': @@ -396,20 +403,18 @@ int cache_check_main(int argc, char **argv) return 0; default: - usage(cerr, basename(argv[0])); + usage(cerr); return 1; } } if (argc == optind) { cerr << "No input file provided." << endl; - usage(cerr, basename(argv[0])); + usage(cerr); return 1; } return check_with_exception_handling(argv[optind], fs); } -base::command caching::cache_check_cmd("cache_check", cache_check_main); - //---------------------------------------------------------------- diff --git a/caching/cache_dump.cc b/caching/cache_dump.cc index 117f86d..1831752 100644 --- a/caching/cache_dump.cc +++ b/caching/cache_dump.cc @@ -54,20 +54,28 @@ namespace { return 0; } - - void usage(ostream &out, string const &cmd) { - out << "Usage: " << cmd << " [options] {device|file}" << endl - << "Options:" << endl - << " {-h|--help}" << endl - << " {-o }" << endl - << " {-V|--version}" << endl - << " {--repair}" << endl; - } } //---------------------------------------------------------------- -int cache_dump_main(int argc, char **argv) +cache_dump_cmd::cache_dump_cmd() + : command("cache_dump") +{ +} + +void +cache_dump_cmd::usage(std::ostream &out) const +{ + out << "Usage: " << get_name() << " [options] {device|file}" << endl + << "Options:" << endl + << " {-h|--help}" << endl + << " {-o }" << endl + << " {-V|--version}" << endl + << " {--repair}" << endl; +} + +int +cache_dump_cmd::run(int argc, char **argv) { int c; flags fs; @@ -89,7 +97,7 @@ int cache_dump_main(int argc, char **argv) break; case 'h': - usage(cout, basename(argv[0])); + usage(cout); return 0; case 'o': @@ -101,20 +109,18 @@ int cache_dump_main(int argc, char **argv) return 0; default: - usage(cerr, basename(argv[0])); + usage(cerr); return 1; } } if (argc == optind) { cerr << "No input file provided." << endl; - usage(cerr, basename(argv[0])); + usage(cerr); return 1; } return dump(argv[optind], output, fs); } -base::command caching::cache_dump_cmd("cache_dump", cache_dump_main); - //---------------------------------------------------------------- diff --git a/caching/cache_metadata_size.cc b/caching/cache_metadata_size.cc index dd806c8..57cfe03 100644 --- a/caching/cache_metadata_size.cc +++ b/caching/cache_metadata_size.cc @@ -9,141 +9,145 @@ #include #include +using namespace caching; using namespace std; //---------------------------------------------------------------- -namespace { - struct flags { - flags() - : max_hint_width(4) { +cache_metadata_size_cmd::flags::flags() + : max_hint_width(4) { - // Dance around some spurious compiler warnings - device_size = 0; - block_size = 0; - nr_blocks = 0; + // Dance around some spurious compiler warnings + device_size = 0; + block_size = 0; + nr_blocks = 0; - device_size.reset(); - block_size.reset(); - nr_blocks.reset(); - } - - boost::optional device_size; - boost::optional block_size; - boost::optional nr_blocks; - uint32_t max_hint_width; - }; - - void usage(ostream &out, string const &cmd) { - out << "Usage: " << cmd << " [options]" << endl - << "Options:" << endl - << " {-h|--help}" << endl - << " {-V|--version}" << endl - << " {--block-size }" << endl - << " {--device-size }" << endl - << " {--nr-blocks }" << endl << endl - << "These all relate to the size of the fast device (eg, SSD), rather" << endl - << "than the whole cached device." << endl; - } - - enum parse_result { - FINISH, - CONTINUE - }; - - parse_result parse_command_line(string const &prog_name, int argc, char **argv, flags &fs) { - - int c; - char const short_opts[] = "hV"; - option const long_opts[] = { - { "block-size", required_argument, NULL, 0 }, - { "device-size", required_argument, NULL, 1 }, - { "nr-blocks", required_argument, NULL, 2 }, - { "max-hint-width", required_argument, NULL, 3 }, - { "help", no_argument, NULL, 'h' }, - { "version", no_argument, NULL, 'V' }, - { NULL, no_argument, NULL, 0 } - }; - - while ((c = getopt_long(argc, argv, short_opts, long_opts, NULL)) != -1) { - switch (c) { - case 0: - fs.block_size = boost::lexical_cast(optarg); - break; - - case 1: - fs.device_size = boost::lexical_cast(optarg); - break; - - case 2: - fs.nr_blocks = boost::lexical_cast(optarg); - break; - - case 3: - fs.max_hint_width = boost::lexical_cast(optarg); - break; - - case 'h': - usage(cout, prog_name); - return FINISH; - break; - - case 'V': - cout << THIN_PROVISIONING_TOOLS_VERSION << endl; - return FINISH; - break; - - default: - usage(cerr, prog_name); - throw runtime_error("Invalid command line"); - break; - } - } - - return CONTINUE; - } - - uint64_t get_nr_blocks(flags &fs) { - if (fs.device_size) { - if (!fs.block_size) - throw runtime_error("If you specify --device-size you must also give --block-size."); - - uint64_t nr_blocks = *fs.device_size / *fs.block_size; - if (fs.nr_blocks) { - if (nr_blocks != *fs.nr_blocks) - throw runtime_error( - "Contradictory arguments given, --nr-blocks doesn't match the --device-size and --block-size."); - } - - return nr_blocks; - } - - if (fs.block_size && !fs.device_size) - throw runtime_error("If you specify --block-size you must also give --device-size."); - - if (fs.nr_blocks) - return *fs.nr_blocks; - - throw runtime_error("Please specify either --device-size and --block-size, or --nr-blocks."); - } - - uint64_t meg(uint64_t n) { - return n * 2048; - } - - uint64_t calc_size(uint64_t nr_blocks, uint32_t max_hint_width) { - uint64_t const SECTOR_SIZE = 512; - uint64_t const TRANSACTION_OVERHEAD = meg(4); - uint64_t const BYTES_PER_BLOCK = 16; - uint64_t const HINT_OVERHEAD_PER_BLOCK = 8; - - uint64_t mapping_size = (nr_blocks * BYTES_PER_BLOCK) / SECTOR_SIZE; - uint64_t hint_size = (nr_blocks * (max_hint_width + HINT_OVERHEAD_PER_BLOCK)) / SECTOR_SIZE; - return TRANSACTION_OVERHEAD + mapping_size + hint_size; - } + device_size.reset(); + block_size.reset(); + nr_blocks.reset(); } -int cache_metadata_size_main(int argc, char **argv) +cache_metadata_size_cmd::parse_result +cache_metadata_size_cmd::parse_command_line(string const &prog_name, int argc, char **argv, flags &fs) +{ + int c; + char const short_opts[] = "hV"; + option const long_opts[] = { + { "block-size", required_argument, NULL, 0 }, + { "device-size", required_argument, NULL, 1 }, + { "nr-blocks", required_argument, NULL, 2 }, + { "max-hint-width", required_argument, NULL, 3 }, + { "help", no_argument, NULL, 'h' }, + { "version", no_argument, NULL, 'V' }, + { NULL, no_argument, NULL, 0 } + }; + + while ((c = getopt_long(argc, argv, short_opts, long_opts, NULL)) != -1) { + switch (c) { + case 0: + fs.block_size = boost::lexical_cast(optarg); + break; + + case 1: + fs.device_size = boost::lexical_cast(optarg); + break; + + case 2: + fs.nr_blocks = boost::lexical_cast(optarg); + break; + + case 3: + fs.max_hint_width = boost::lexical_cast(optarg); + break; + + case 'h': + usage(cout); + return FINISH; + break; + + case 'V': + cout << THIN_PROVISIONING_TOOLS_VERSION << endl; + return FINISH; + break; + + default: + usage(cerr); + throw runtime_error("Invalid command line"); + break; + } + } + + return CONTINUE; +} + +uint64_t +cache_metadata_size_cmd::get_nr_blocks(flags &fs) +{ + if (fs.device_size) { + if (!fs.block_size) + throw runtime_error("If you specify --device-size you must also give --block-size."); + + uint64_t nr_blocks = *fs.device_size / *fs.block_size; + if (fs.nr_blocks) { + if (nr_blocks != *fs.nr_blocks) + throw runtime_error( + "Contradictory arguments given, --nr-blocks doesn't match the --device-size and --block-size."); + } + + return nr_blocks; + } + + if (fs.block_size && !fs.device_size) + throw runtime_error("If you specify --block-size you must also give --device-size."); + + if (fs.nr_blocks) + return *fs.nr_blocks; + + throw runtime_error("Please specify either --device-size and --block-size, or --nr-blocks."); +} + +uint64_t +cache_metadata_size_cmd::meg(uint64_t n) +{ + return n * 2048; +} + +uint64_t +cache_metadata_size_cmd::calc_size(uint64_t nr_blocks, uint32_t max_hint_width) +{ + uint64_t const SECTOR_SIZE = 512; + uint64_t const TRANSACTION_OVERHEAD = meg(4); + uint64_t const BYTES_PER_BLOCK = 16; + uint64_t const HINT_OVERHEAD_PER_BLOCK = 8; + + uint64_t mapping_size = (nr_blocks * BYTES_PER_BLOCK) / SECTOR_SIZE; + uint64_t hint_size = (nr_blocks * (max_hint_width + HINT_OVERHEAD_PER_BLOCK)) / SECTOR_SIZE; + return TRANSACTION_OVERHEAD + mapping_size + hint_size; +} + +//---------------------------------------------------------------- + +cache_metadata_size_cmd::cache_metadata_size_cmd() + : command("cache_metadata_size") +{ +} + +void +cache_metadata_size_cmd::usage(ostream &out) const +{ + out << "Usage: " << get_name() << " [options]" << endl + << "Options:" << endl + << " {-h|--help}" << endl + << " {-V|--version}" << endl + << " {--block-size }" << endl + << " {--device-size }" << endl + << " {--nr-blocks }" << endl << endl + << "These all relate to the size of the fast device (eg, SSD), rather" << endl + << "than the whole cached device." << endl; +} + +int +cache_metadata_size_cmd::run(int argc, char **argv) { flags fs; @@ -167,6 +171,4 @@ int cache_metadata_size_main(int argc, char **argv) return 0; } -base::command caching::cache_metadata_size_cmd("cache_metadata_size", cache_metadata_size_main); - //---------------------------------------------------------------- diff --git a/caching/cache_repair.cc b/caching/cache_repair.cc index 8419796..dfe644b 100644 --- a/caching/cache_repair.cc +++ b/caching/cache_repair.cc @@ -40,20 +40,28 @@ namespace { return 0; } - - void usage(ostream &out, string const &cmd) { - out << "Usage: " << cmd << " [options] {device|file}" << endl - << "Options:" << endl - << " {-h|--help}" << endl - << " {-i|--input} " << endl - << " {-o|--output} " << endl - << " {-V|--version}" << endl; - } } //---------------------------------------------------------------- -int cache_repair_main(int argc, char **argv) +cache_repair_cmd::cache_repair_cmd() + : command("cache_repair") +{ +} + +void +cache_repair_cmd::usage(std::ostream &out) const +{ + out << "Usage: " << get_name() << " [options] {device|file}" << endl + << "Options:" << endl + << " {-h|--help}" << endl + << " {-i|--input} " << endl + << " {-o|--output} " << endl + << " {-V|--version}" << endl; +} + +int +cache_repair_cmd::run(int argc, char **argv) { int c; boost::optional input_path, output_path; @@ -70,7 +78,7 @@ int cache_repair_main(int argc, char **argv) while ((c = getopt_long(argc, argv, shortopts, longopts, NULL)) != -1) { switch(c) { case 'h': - usage(cout, basename(argv[0])); + usage(cout); return 0; case 'i': @@ -86,26 +94,24 @@ int cache_repair_main(int argc, char **argv) return 0; default: - usage(cerr, basename(argv[0])); + usage(cerr); return 1; } } if (!input_path) { cerr << "no input file provided" << endl; - usage(cerr, basename(argv[0])); + usage(cerr); return 1; } if (!output_path) { cerr << "no output file provided" << endl; - usage(cerr, basename(argv[0])); + usage(cerr); return 1; } return repair(*input_path, *output_path); } -base::command caching::cache_repair_cmd("cache_repair", cache_repair_main); - //---------------------------------------------------------------- diff --git a/caching/cache_restore.cc b/caching/cache_restore.cc index b0a6437..a357eed 100644 --- a/caching/cache_restore.cc +++ b/caching/cache_restore.cc @@ -80,27 +80,35 @@ namespace { return 0; } - - void usage(ostream &out, string const &cmd) { - out << "Usage: " << cmd << " [options]" << endl - << "Options:" << endl - << " {-h|--help}" << endl - << " {-i|--input} " << endl - << " {-o|--output} " << endl - << " {-q|--quiet}" << endl - << " {-V|--version}" << endl - << endl - << " {--debug-override-metadata-version} " << endl - << " {--omit-clean-shutdown}" << endl; - - } } -int cache_restore_main(int argc, char **argv) +//---------------------------------------------------------------- + +cache_restore_cmd::cache_restore_cmd() + : command("cache_restore") +{ +} + +void +cache_restore_cmd::usage(std::ostream &out) const +{ + out << "Usage: " << get_name() << " [options]" << endl + << "Options:" << endl + << " {-h|--help}" << endl + << " {-i|--input} " << endl + << " {-o|--output} " << endl + << " {-q|--quiet}" << endl + << " {-V|--version}" << endl + << endl + << " {--debug-override-metadata-version} " << endl + << " {--omit-clean-shutdown}" << endl; +} + +int +cache_restore_cmd::run(int argc, char **argv) { int c; flags fs; - char const *prog_name = basename(argv[0]); char const *short_opts = "hi:o:qV"; option const long_opts[] = { { "debug-override-metadata-version", required_argument, NULL, 0 }, @@ -125,7 +133,7 @@ int cache_restore_main(int argc, char **argv) break; case 'h': - usage(cout, prog_name); + usage(cout); return 0; case 'i': @@ -145,31 +153,29 @@ int cache_restore_main(int argc, char **argv) return 0; default: - usage(cerr, prog_name); + usage(cerr); return 1; } } if (argc != optind) { - usage(cerr, prog_name); + usage(cerr); return 1; } if (!fs.input) { cerr << "No input file provided." << endl << endl; - usage(cerr, prog_name); + usage(cerr); return 1; } if (!fs.output) { cerr << "No output file provided." << endl << endl; - usage(cerr, prog_name); + usage(cerr); return 1; } return restore(fs); } -base::command caching::cache_restore_cmd("cache_restore", cache_restore_main); - //---------------------------------------------------------------- diff --git a/caching/commands.cc b/caching/commands.cc new file mode 100644 index 0000000..1ab79e6 --- /dev/null +++ b/caching/commands.cc @@ -0,0 +1,18 @@ +#include "caching/commands.h" + +using namespace base; +using namespace caching; + +//---------------------------------------------------------------- + +void +caching::register_cache_commands(application &app) +{ + app.add_cmd(command::ptr(new cache_check_cmd)); + app.add_cmd(command::ptr(new cache_dump_cmd)); + app.add_cmd(command::ptr(new cache_metadata_size_cmd)); + app.add_cmd(command::ptr(new cache_restore_cmd)); + app.add_cmd(command::ptr(new cache_repair_cmd)); +} + +//---------------------------------------------------------------- diff --git a/caching/commands.h b/caching/commands.h index 1396b9b..022ac06 100644 --- a/caching/commands.h +++ b/caching/commands.h @@ -2,15 +2,68 @@ #define CACHING_COMMANDS_H #include "base/application.h" +#include "boost/optional.hpp" //---------------------------------------------------------------- namespace caching { - extern base::command cache_check_cmd; - extern base::command cache_dump_cmd; - extern base::command cache_metadata_size_cmd; - extern base::command cache_restore_cmd; - extern base::command cache_repair_cmd; + class cache_check_cmd : public base::command { + public: + cache_check_cmd(); + virtual void usage(std::ostream &out) const; + virtual int run(int argc, char **argv); + }; + + class cache_dump_cmd : public base::command { + public: + cache_dump_cmd(); + virtual void usage(std::ostream &out) const; + virtual int run(int argc, char **argv); + }; + + class cache_metadata_size_cmd : public base::command { + public: + cache_metadata_size_cmd(); + virtual void usage(std::ostream &out) const; + virtual int run(int argc, char **argv); + + + private: + struct flags { + flags(); + + boost::optional device_size; + boost::optional block_size; + boost::optional nr_blocks; + uint32_t max_hint_width; + }; + + enum parse_result { + FINISH, + CONTINUE + }; + + parse_result parse_command_line(std::string const &prog_name, int argc, char **argv, flags &fs); + uint64_t get_nr_blocks(flags &fs); + uint64_t meg(uint64_t n); + uint64_t calc_size(uint64_t nr_blocks, uint32_t max_hint_width); + }; + + class cache_repair_cmd : public base::command { + public: + cache_repair_cmd(); + virtual void usage(std::ostream &out) const; + virtual int run(int argc, char **argv); + }; + + class cache_restore_cmd : public base::command { + public: + cache_restore_cmd(); + virtual void usage(std::ostream &out) const; + virtual int run(int argc, char **argv); + }; + + void register_cache_commands(base::application &app); } //---------------------------------------------------------------- diff --git a/era/commands.cc b/era/commands.cc new file mode 100644 index 0000000..5a8efb0 --- /dev/null +++ b/era/commands.cc @@ -0,0 +1,16 @@ +#include "era/commands.h" + +using namespace base; + +//---------------------------------------------------------------- + +void +era::register_era_commands(base::application &app) +{ + app.add_cmd(command::ptr(new era_check_cmd())); + app.add_cmd(command::ptr(new era_dump_cmd())); + app.add_cmd(command::ptr(new era_invalidate_cmd())); + app.add_cmd(command::ptr(new era_restore_cmd())); +} + +//---------------------------------------------------------------- diff --git a/era/commands.h b/era/commands.h index f556fbf..8e7a92c 100644 --- a/era/commands.h +++ b/era/commands.h @@ -6,10 +6,35 @@ //---------------------------------------------------------------- namespace era { - extern base::command era_check_cmd; - extern base::command era_dump_cmd; - extern base::command era_invalidate_cmd; - extern base::command era_restore_cmd; + class era_check_cmd : public base::command { + public: + era_check_cmd(); + virtual void usage(std::ostream &out) const; + virtual int run(int argc, char **argv); + }; + + class era_dump_cmd : public base::command { + public: + era_dump_cmd(); + virtual void usage(std::ostream &out) const; + virtual int run(int argc, char **argv); + }; + + class era_invalidate_cmd : public base::command { + public: + era_invalidate_cmd(); + virtual void usage(std::ostream &out) const; + virtual int run(int argc, char **argv); + }; + + class era_restore_cmd : public base::command { + public: + era_restore_cmd(); + virtual void usage(std::ostream &out) const; + virtual int run(int argc, char **argv); + }; + + void register_era_commands(base::application &app); } //---------------------------------------------------------------- diff --git a/era/era_check.cc b/era/era_check.cc index d64999d..73e5169 100644 --- a/era/era_check.cc +++ b/era/era_check.cc @@ -262,20 +262,28 @@ namespace { return r; } - - void usage(ostream &out, string const &cmd) { - out << "Usage: " << cmd << " [options] {device|file}" << endl - << "Options:" << endl - << " {-q|--quiet}" << endl - << " {-h|--help}" << endl - << " {-V|--version}" << endl - << " {--super-block-only}" << endl; - } } //---------------------------------------------------------------- -int era_check_main(int argc, char **argv) +era_check_cmd::era_check_cmd() + : command("era_check") +{ +} + +void +era_check_cmd::usage(std::ostream &out) const +{ + out << "Usage: " << get_name() << " [options] {device|file}" << endl + << "Options:" << endl + << " {-q|--quiet}" << endl + << " {-h|--help}" << endl + << " {-V|--version}" << endl + << " {--super-block-only}" << endl; +} + +int +era_check_cmd::run(int argc, char **argv) { int c; flags fs; @@ -295,7 +303,7 @@ int era_check_main(int argc, char **argv) break; case 'h': - usage(cout, basename(argv[0])); + usage(cout); return 0; case 'q': @@ -307,20 +315,18 @@ int era_check_main(int argc, char **argv) return 0; default: - usage(cerr, basename(argv[0])); + usage(cerr); return 1; } } if (argc == optind) { cerr << "No input file provided." << endl; - usage(cerr, basename(argv[0])); + usage(cerr); return 1; } return check_with_exception_handling(argv[optind], fs); } -base::command era::era_check_cmd("era_check", era_check_main); - //---------------------------------------------------------------- diff --git a/era/era_dump.cc b/era/era_dump.cc index c279cd1..f2c1957 100644 --- a/era/era_dump.cc +++ b/era/era_dump.cc @@ -57,21 +57,29 @@ namespace { return 0; } - - void usage(ostream &out, string const &cmd) { - out << "Usage: " << cmd << " [options] {device|file}" << endl - << "Options:" << endl - << " {-h|--help}" << endl - << " {-o }" << endl - << " {-V|--version}" << endl - << " {--repair}" << endl - << " {--logical}" << endl; - } } //---------------------------------------------------------------- -int era_dump_main(int argc, char **argv) +era_dump_cmd::era_dump_cmd() + : command("era_dump") +{ +} + +void +era_dump_cmd::usage(std::ostream &out) const +{ + out << "Usage: " << get_name() << " [options] {device|file}" << endl + << "Options:" << endl + << " {-h|--help}" << endl + << " {-o }" << endl + << " {-V|--version}" << endl + << " {--repair}" << endl + << " {--logical}" << endl; +} + +int +era_dump_cmd::run(int argc, char **argv) { int c; flags fs; @@ -98,7 +106,7 @@ int era_dump_main(int argc, char **argv) break; case 'h': - usage(cout, basename(argv[0])); + usage(cout); return 0; case 'o': @@ -110,20 +118,18 @@ int era_dump_main(int argc, char **argv) return 0; default: - usage(cerr, basename(argv[0])); + usage(cerr); return 1; } } if (argc == optind) { cerr << "No input file provided." << endl; - usage(cerr, basename(argv[0])); + usage(cerr); return 1; } return dump(argv[optind], output, fs); } -base::command era::era_dump_cmd("era_dump", era_dump_main); - //---------------------------------------------------------------- diff --git a/era/era_invalidate.cc b/era/era_invalidate.cc index 20490a0..76eaadd 100644 --- a/era/era_invalidate.cc +++ b/era/era_invalidate.cc @@ -182,20 +182,28 @@ namespace { return 0; } - - void usage(ostream &out, string const &cmd) { - out << "Usage: " << cmd << " [options] --written-since {device|file}\n" - << "Options:\n" - << " {-h|--help}\n" - << " {-o }\n" - << " {--metadata-snapshot}\n" - << " {-V|--version}" << endl; - } } //---------------------------------------------------------------- -int era_invalidate_main(int argc, char **argv) +era_invalidate_cmd::era_invalidate_cmd() + : command("era_invalidate") +{ +} + +void +era_invalidate_cmd::usage(std::ostream &out) const +{ + out << "Usage: " << get_name() << " [options] --written-since {device|file}\n" + << "Options:\n" + << " {-h|--help}\n" + << " {-o }\n" + << " {--metadata-snapshot}\n" + << " {-V|--version}" << endl; +} + +int +era_invalidate_cmd::run(int argc, char **argv) { int c; flags fs; @@ -222,7 +230,7 @@ int era_invalidate_main(int argc, char **argv) break; case 'h': - usage(cout, basename(argv[0])); + usage(cout); return 0; case 'o': @@ -234,26 +242,24 @@ int era_invalidate_main(int argc, char **argv) return 0; default: - usage(cerr, basename(argv[0])); + usage(cerr); return 1; } } if (argc == optind) { cerr << "No input file provided." << endl; - usage(cerr, basename(argv[0])); + usage(cerr); return 1; } if (!fs.era_threshold_) { cerr << "Please specify --written-since" << endl; - usage(cerr, basename(argv[0])); + usage(cerr); return 1; } return invalidate(argv[optind], output, fs); } -base::command era::era_invalidate_cmd("era_invalidate", era_invalidate_main); - //---------------------------------------------------------------- diff --git a/era/era_restore.cc b/era/era_restore.cc index 761f920..0f41a96 100644 --- a/era/era_restore.cc +++ b/era/era_restore.cc @@ -46,23 +46,32 @@ namespace { return 0; } - - void usage(ostream &out, string const &cmd) { - out << "Usage: " << cmd << " [options]" << endl - << "Options:" << endl - << " {-h|--help}" << endl - << " {-i|--input} " << endl - << " {-o|--output} " << endl - << " {-q|--quiet}" << endl - << " {-V|--version}" << endl; - } } -int era_restore_main(int argc, char **argv) +//---------------------------------------------------------------- + +era_restore_cmd::era_restore_cmd() + : command("era_restore") +{ +} + +void +era_restore_cmd::usage(std::ostream &out) const +{ + out << "Usage: " << get_name() << " [options]" << endl + << "Options:" << endl + << " {-h|--help}" << endl + << " {-i|--input} " << endl + << " {-o|--output} " << endl + << " {-q|--quiet}" << endl + << " {-V|--version}" << endl; +} + +int +era_restore_cmd::run(int argc, char **argv) { int c; flags fs; - char const *prog_name = basename(argv[0]); char const *short_opts = "hi:o:qV"; option const long_opts[] = { { "help", no_argument, NULL, 'h'}, @@ -76,7 +85,7 @@ int era_restore_main(int argc, char **argv) while ((c = getopt_long(argc, argv, short_opts, long_opts, NULL)) != -1) { switch(c) { case 'h': - usage(cout, prog_name); + usage(cout); return 0; case 'i': @@ -96,31 +105,29 @@ int era_restore_main(int argc, char **argv) return 0; default: - usage(cerr, prog_name); + usage(cerr); return 1; } } if (argc != optind) { - usage(cerr, prog_name); + usage(cerr); return 1; } if (!fs.input) { cerr << "No input file provided." << endl << endl; - usage(cerr, prog_name); + usage(cerr); return 1; } if (!fs.output) { cerr << "No output file provided." << endl << endl; - usage(cerr, prog_name); + usage(cerr); return 1; } return restore(fs, fs.quiet); } -base::command era::era_restore_cmd("era_restore", era_restore_main); - //---------------------------------------------------------------- diff --git a/main.cc b/main.cc index ed69ba9..98c9003 100644 --- a/main.cc +++ b/main.cc @@ -14,27 +14,9 @@ int main(int argc, char **argv) application app; - app.add_cmd(caching::cache_check_cmd); - app.add_cmd(caching::cache_dump_cmd); - app.add_cmd(caching::cache_metadata_size_cmd); - app.add_cmd(caching::cache_restore_cmd); - app.add_cmd(caching::cache_repair_cmd); - - app.add_cmd(era::era_check_cmd); - app.add_cmd(era::era_dump_cmd); - app.add_cmd(era::era_invalidate_cmd); - app.add_cmd(era::era_restore_cmd); - - app.add_cmd(thin_provisioning::thin_check_cmd); - app.add_cmd(thin_provisioning::thin_delta_cmd); - app.add_cmd(thin_provisioning::thin_dump_cmd); - app.add_cmd(thin_provisioning::thin_metadata_size_cmd); - app.add_cmd(thin_provisioning::thin_restore_cmd); - app.add_cmd(thin_provisioning::thin_repair_cmd); - app.add_cmd(thin_provisioning::thin_rmap_cmd); - - // FIXME: convert thin_metadata_size to c++ - //app.add_cmd(thin_provisioning::thin_metadata_size_cmd); + caching::register_cache_commands(app); + era::register_era_commands(app); + thin_provisioning::register_thin_commands(app); return app.run(argc, argv); } diff --git a/thin-provisioning/commands.cc b/thin-provisioning/commands.cc new file mode 100644 index 0000000..cd51000 --- /dev/null +++ b/thin-provisioning/commands.cc @@ -0,0 +1,22 @@ +#include "thin-provisioning/commands.h" + +using namespace base; +using namespace thin_provisioning; + +//---------------------------------------------------------------- + +void +thin_provisioning::register_thin_commands(base::application &app) +{ + app.add_cmd(command::ptr(new thin_check_cmd())); + app.add_cmd(command::ptr(new thin_delta_cmd())); + app.add_cmd(command::ptr(new thin_dump_cmd())); + //app.add_cmd(command::ptr(new thin_ls_cmd())); + app.add_cmd(command::ptr(new thin_metadata_size_cmd())); + app.add_cmd(command::ptr(new thin_restore_cmd())); + app.add_cmd(command::ptr(new thin_repair_cmd())); + app.add_cmd(command::ptr(new thin_rmap_cmd())); + app.add_cmd(command::ptr(new thin_trim_cmd())); +} + +//---------------------------------------------------------------- diff --git a/thin-provisioning/commands.h b/thin-provisioning/commands.h index de63e53..ec1f1ec 100644 --- a/thin-provisioning/commands.h +++ b/thin-provisioning/commands.h @@ -2,19 +2,75 @@ #define THIN_PROVISIONING_COMMANDS_H #include "base/application.h" +#include "boost/optional.hpp" //---------------------------------------------------------------- namespace thin_provisioning { - extern base::command thin_check_cmd; - extern base::command thin_delta_cmd; - extern base::command thin_dump_cmd; - extern base::command thin_metadata_size_cmd; - extern base::command thin_restore_cmd; - extern base::command thin_repair_cmd; - extern base::command thin_rmap_cmd; - extern base::command thin_trim_cmd; - extern base::command thin_metadata_size_cmd; + class thin_check_cmd : public base::command { + public: + thin_check_cmd(); + virtual void usage(std::ostream &out) const; + virtual int run(int argc, char **argv); + }; + + class thin_delta_cmd : public base::command { + public: + thin_delta_cmd(); + virtual void usage(std::ostream &out) const; + virtual int run(int argc, char **argv); + }; + + class thin_dump_cmd : public base::command { + public: + thin_dump_cmd(); + virtual void usage(std::ostream &out) const; + virtual int run(int argc, char **argv); + }; + + class thin_ls_cmd : public base::command { + public: + thin_ls_cmd(); + virtual void usage(std::ostream &out) const; + virtual int run(int argc, char **argv); + }; + + class thin_metadata_size_cmd : public base::command { + public: + thin_metadata_size_cmd(); + virtual void usage(std::ostream &out) const; + virtual int run(int argc, char **argv); + }; + + class thin_restore_cmd : public base::command { + public: + thin_restore_cmd(); + virtual void usage(std::ostream &out) const; + virtual int run(int argc, char **argv); + }; + + class thin_repair_cmd : public base::command { + public: + thin_repair_cmd(); + virtual void usage(std::ostream &out) const; + virtual int run(int argc, char **argv); + }; + + class thin_rmap_cmd : public base::command { + public: + thin_rmap_cmd(); + virtual void usage(std::ostream &out) const; + virtual int run(int argc, char **argv); + }; + + class thin_trim_cmd : public base::command { + public: + thin_trim_cmd(); + virtual void usage(std::ostream &out) const; + virtual int run(int argc, char **argv); + }; + + void register_thin_commands(base::application &app); } //---------------------------------------------------------------- diff --git a/thin-provisioning/metadata_dumper.cc b/thin-provisioning/metadata_dumper.cc index db656ee..52199f2 100644 --- a/thin-provisioning/metadata_dumper.cc +++ b/thin-provisioning/metadata_dumper.cc @@ -84,7 +84,7 @@ namespace { //-------------------------------- - typedef map dd_map; + typedef map dd_map; class details_extractor : public device_tree_detail::device_visitor { public: diff --git a/thin-provisioning/thin_check.cc b/thin-provisioning/thin_check.cc index f14ee37..2451db2 100644 --- a/thin-provisioning/thin_check.cc +++ b/thin-provisioning/thin_check.cc @@ -344,21 +344,31 @@ namespace { return !success; } - - void usage(ostream &out, string const &cmd) { - out << "Usage: " << cmd << " [options] {device|file}" << endl - << "Options:" << endl - << " {-q|--quiet}" << endl - << " {-h|--help}" << endl - << " {-V|--version}" << endl - << " {--clear-needs-check-flag}" << endl - << " {--ignore-non-fatal-errors}" << endl - << " {--skip-mappings}" << endl - << " {--super-block-only}" << endl; - } } -int thin_check_main(int argc, char **argv) +//---------------------------------------------------------------- + +thin_check_cmd::thin_check_cmd() + : command("thin_check") +{ +} + +void +thin_check_cmd::usage(std::ostream &out) const +{ + out << "Usage: " << get_name() << " [options] {device|file}" << endl + << "Options:" << endl + << " {-q|--quiet}" << endl + << " {-h|--help}" << endl + << " {-V|--version}" << endl + << " {--clear-needs-check-flag}" << endl + << " {--ignore-non-fatal-errors}" << endl + << " {--skip-mappings}" << endl + << " {--super-block-only}" << endl; +} + +int +thin_check_cmd::run(int argc, char **argv) { int c; flags fs; @@ -378,7 +388,7 @@ int thin_check_main(int argc, char **argv) while ((c = getopt_long(argc, argv, shortopts, longopts, NULL)) != -1) { switch(c) { case 'h': - usage(cout, basename(argv[0])); + usage(cout); return 0; case 'q': @@ -412,7 +422,7 @@ int thin_check_main(int argc, char **argv) break; default: - usage(cerr, basename(argv[0])); + usage(cerr); return 1; } } @@ -420,7 +430,7 @@ int thin_check_main(int argc, char **argv) if (argc == optind) { if (!fs.quiet) { cerr << "No input file provided." << endl; - usage(cerr, basename(argv[0])); + usage(cerr); } exit(1); @@ -429,6 +439,4 @@ int thin_check_main(int argc, char **argv) return check(argv[optind], fs); } -base::command thin_provisioning::thin_check_cmd("thin_check", thin_check_main); - //---------------------------------------------------------------- diff --git a/thin-provisioning/thin_delta.cc b/thin-provisioning/thin_delta.cc index de2c0d7..3ec71c8 100644 --- a/thin-provisioning/thin_delta.cc +++ b/thin-provisioning/thin_delta.cc @@ -602,7 +602,19 @@ namespace local { // FIXME: add metadata snap switch -int thin_delta_main(int argc, char **argv) +thin_delta_cmd::thin_delta_cmd() + : command("thin_delta") +{ +} + +void +thin_delta_cmd::usage(std::ostream &out) const +{ + // FIXME: finish +} + +int +thin_delta_cmd::run(int argc, char **argv) { using namespace local; @@ -670,6 +682,4 @@ int thin_delta_main(int argc, char **argv) return delta(app, fs); } -base::command thin_provisioning::thin_delta_cmd("thin_delta", thin_delta_main); - //---------------------------------------------------------------- diff --git a/thin-provisioning/thin_dump.cc b/thin-provisioning/thin_dump.cc index 97ecf5f..4a1108b 100644 --- a/thin-provisioning/thin_dump.cc +++ b/thin-provisioning/thin_dump.cc @@ -100,7 +100,28 @@ namespace { } } -int thin_dump_main(int argc, char **argv) +//---------------------------------------------------------------- + +thin_dump_cmd::thin_dump_cmd() + : command("thin_dump") +{ +} + +void +thin_dump_cmd::usage(std::ostream &out) const +{ + out << "Usage: " << get_name() << " [options] {device|file}" << endl + << "Options:" << endl + << " {-h|--help}" << endl + << " {-f|--format} {xml|human_readable}" << endl + << " {-r|--repair}" << endl + << " {-m|--metadata-snap} [block#]" << endl + << " {-o }" << endl + << " {-V|--version}" << endl; +} + +int +thin_dump_cmd::run(int argc, char **argv) { int c; char const *output = NULL; @@ -123,7 +144,7 @@ int thin_dump_main(int argc, char **argv) while ((c = getopt_long(argc, argv, shortopts, longopts, NULL)) != -1) { switch(c) { case 'h': - usage(cout, basename(argv[0])); + usage(cout); return 0; case 'f': @@ -141,7 +162,7 @@ int thin_dump_main(int argc, char **argv) metadata_snap = strtoull(optarg, &end_ptr, 10); if (end_ptr == optarg) { cerr << "couldn't parse " << endl; - usage(cerr, basename(argv[0])); + usage(cerr); return 1; } @@ -158,20 +179,18 @@ int thin_dump_main(int argc, char **argv) return 0; default: - usage(cerr, basename(argv[0])); + usage(cerr); return 1; } } if (argc == optind) { cerr << "No input file provided." << endl; - usage(cerr, basename(argv[0])); + usage(cerr); return 1; } return dump(argv[optind], output, format, flags); } -base::command thin_provisioning::thin_dump_cmd("thin_dump", thin_dump_main); - //---------------------------------------------------------------- diff --git a/thin-provisioning/thin_metadata_size.cc b/thin-provisioning/thin_metadata_size.cc index e45e04c..8fc953c 100644 --- a/thin-provisioning/thin_metadata_size.cc +++ b/thin-provisioning/thin_metadata_size.cc @@ -35,6 +35,8 @@ #include +using namespace thin_provisioning; + /*----------------------------------------------------------------*/ enum numeric_options { BLOCKSIZE, POOLSIZE, MAXTHINS, NUMERIC, OPT_END}; @@ -362,7 +364,21 @@ static void print_estimated_result(struct global *g) print_precision(g, r, g->options.unit_idx); } -int thin_metadata_size_main(int argc, char **argv) +//---------------------------------------------------------------- + +thin_metadata_size_cmd::thin_metadata_size_cmd() + : command("thin_metadata_size") +{ +} + +void +thin_metadata_size_cmd::usage(std::ostream &out) const +{ + // FIXME: finish +} + +int +thin_metadata_size_cmd::run(int argc, char **argv) { struct global *g = init_prg(*argv); @@ -372,4 +388,4 @@ int thin_metadata_size_main(int argc, char **argv) return 0; /* Doesn't get here... */ } -base::command thin_provisioning::thin_metadata_size_cmd("thin_metadata_size", thin_metadata_size_main); +//---------------------------------------------------------------- diff --git a/thin-provisioning/thin_repair.cc b/thin-provisioning/thin_repair.cc index 8751b47..abae4ca 100644 --- a/thin-provisioning/thin_repair.cc +++ b/thin-provisioning/thin_repair.cc @@ -33,18 +33,28 @@ namespace { return 0; } - - void usage(ostream &out, string const &cmd) { - out << "Usage: " << cmd << " [options] {device|file}" << endl - << "Options:" << endl - << " {-h|--help}" << endl - << " {-i|--input} " << endl - << " {-o|--output} " << endl - << " {-V|--version}" << endl; - } } -int thin_repair_main(int argc, char **argv) +//---------------------------------------------------------------- + +thin_repair_cmd::thin_repair_cmd() + : command("thin_repair") +{ +} + +void +thin_repair_cmd::usage(std::ostream &out) const +{ + out << "Usage: " << get_name() << " [options] {device|file}" << endl + << "Options:" << endl + << " {-h|--help}" << endl + << " {-i|--input} " << endl + << " {-o|--output} " << endl + << " {-V|--version}" << endl; +} + +int +thin_repair_cmd::run(int argc, char **argv) { int c; boost::optional input_path, output_path; @@ -61,7 +71,7 @@ int thin_repair_main(int argc, char **argv) while ((c = getopt_long(argc, argv, shortopts, longopts, NULL)) != -1) { switch(c) { case 'h': - usage(cout, basename(argv[0])); + usage(cout); return 0; case 'i': @@ -77,26 +87,24 @@ int thin_repair_main(int argc, char **argv) return 0; default: - usage(cerr, basename(argv[0])); + usage(cerr); return 1; } } if (!input_path) { cerr << "no input file provided" << endl; - usage(cerr, basename(argv[0])); + usage(cerr); return 1; } if (!output_path) { cerr << "no output file provided" << endl; - usage(cerr, basename(argv[0])); + usage(cerr); return 1; } return repair(*input_path, *output_path); } -base::command thin_provisioning::thin_repair_cmd("thin_repair", thin_repair_main); - //---------------------------------------------------------------- diff --git a/thin-provisioning/thin_restore.cc b/thin-provisioning/thin_restore.cc index 293a45b..39f9c54 100644 --- a/thin-provisioning/thin_restore.cc +++ b/thin-provisioning/thin_restore.cc @@ -60,20 +60,32 @@ namespace { } void usage(ostream &out, string const &cmd) { - out << "Usage: " << cmd << " [options]" << endl - << "Options:" << endl - << " {-h|--help}" << endl - << " {-i|--input} " << endl - << " {-o|--output} " << endl - << " {-q|--quiet}" << endl - << " {-V|--version}" << endl; } } -int thin_restore_main(int argc, char **argv) +//---------------------------------------------------------------- + +thin_restore_cmd::thin_restore_cmd() + : command("thin_restore") +{ +} + +void +thin_restore_cmd::usage(std::ostream &out) const +{ + out << "Usage: " << get_name() << " [options]" << endl + << "Options:" << endl + << " {-h|--help}" << endl + << " {-i|--input} " << endl + << " {-o|--output} " << endl + << " {-q|--quiet}" << endl + << " {-V|--version}" << endl; +} + +int +thin_restore_cmd::run(int argc, char **argv) { int c; - char const *prog_name = basename(argv[0]); const char *shortopts = "hi:o:qV"; string input, output; bool quiet = false; @@ -89,7 +101,7 @@ int thin_restore_main(int argc, char **argv) while ((c = getopt_long(argc, argv, shortopts, longopts, NULL)) != -1) { switch(c) { case 'h': - usage(cout, prog_name); + usage(cout); return 0; case 'i': @@ -109,31 +121,29 @@ int thin_restore_main(int argc, char **argv) return 0; default: - usage(cerr, prog_name); + usage(cerr); return 1; } } if (argc != optind) { - usage(cerr, prog_name); + usage(cerr); return 1; } if (input.empty()) { cerr << "No input file provided." << endl << endl; - usage(cerr, prog_name); + usage(cerr); return 1; } if (output.empty()) { cerr << "No output file provided." << endl << endl; - usage(cerr, prog_name); + usage(cerr); return 1; } return restore(input, output, quiet); } -base::command thin_provisioning::thin_restore_cmd("thin_restore", thin_restore_main); - //---------------------------------------------------------------- diff --git a/thin-provisioning/thin_rmap.cc b/thin-provisioning/thin_rmap.cc index 9083c6f..956fdf4 100644 --- a/thin-provisioning/thin_rmap.cc +++ b/thin-provisioning/thin_rmap.cc @@ -111,22 +111,30 @@ namespace { return region(begin, end); }; - - void usage(ostream &out, string const &cmd) { - out << "Usage: " << cmd << " [options] {device|file}" << endl - << "Options:" << endl - << " {-h|--help}" << endl - << " {-V|--version}" << endl - << " {--region }*" << endl - << "Where:" << endl - << " is of the form .." << endl - << " for example 5..45 denotes blocks 5 to 44 inclusive, but not block 45" << endl; - } } //---------------------------------------------------------------- -int thin_rmap_main(int argc, char **argv) +thin_rmap_cmd::thin_rmap_cmd() + : command("thin_rmap") +{ +} + +void +thin_rmap_cmd::usage(std::ostream &out) const +{ + out << "Usage: " << get_name() << " [options] {device|file}" << endl + << "Options:" << endl + << " {-h|--help}" << endl + << " {-V|--version}" << endl + << " {--region }*" << endl + << "Where:" << endl + << " is of the form .." << endl + << " for example 5..45 denotes blocks 5 to 44 inclusive, but not block 45" << endl; +} + +int +thin_rmap_cmd::run(int argc, char **argv) { int c; vector regions; @@ -141,7 +149,7 @@ int thin_rmap_main(int argc, char **argv) while ((c = getopt_long(argc, argv, shortopts, longopts, NULL)) != -1) { switch (c) { case 'h': - usage(cout, basename(argv[0])); + usage(cout); return 0; case 'V': @@ -161,20 +169,18 @@ int thin_rmap_main(int argc, char **argv) break; default: - usage(cerr, basename(argv[0])); + usage(cerr); return 1; } } if (argc == optind) { cerr << "No input file provided." << endl; - usage(cerr, basename(argv[0])); + usage(cerr); exit(1); } return rmap(argv[optind], regions); } -base::command thin_provisioning::thin_rmap_cmd("thin_rmap", thin_rmap_main); - //---------------------------------------------------------------- diff --git a/thin-provisioning/thin_trim.cc b/thin-provisioning/thin_trim.cc index 19c48cd..35c4d9e 100644 --- a/thin-provisioning/thin_trim.cc +++ b/thin-provisioning/thin_trim.cc @@ -135,14 +135,6 @@ namespace { return 0; } - void usage(ostream &out, string const &cmd) { - out << "Usage: " << cmd << " [options] {device|file}\n" - << "Options:\n" - << " {--pool-inactive}\n" - << " {-h|--help}\n" - << " {-V|--version}" << endl; - } - struct flags { boost::optional metadata_dev; boost::optional data_dev; @@ -151,7 +143,23 @@ namespace { //---------------------------------------------------------------- -int thin_trim_main(int argc, char **argv) +thin_trim_cmd::thin_trim_cmd() + : command("thin_trim") +{ +} + +void +thin_trim_cmd::usage(std::ostream &out) const +{ + out << "Usage: " << get_name() << " [options] {device|file}\n" + << "Options:\n" + << " {--pool-inactive}\n" + << " {-h|--help}\n" + << " {-V|--version}" << endl; +} + +int +thin_trim_cmd::run(int argc, char **argv) { int c; flags fs; @@ -177,7 +185,7 @@ int thin_trim_main(int argc, char **argv) break; case 'h': - usage(cout, basename(argv[0])); + usage(cout); return 0; case 'V': @@ -185,13 +193,13 @@ int thin_trim_main(int argc, char **argv) return 0; default: - usage(cerr, basename(argv[0])); + usage(cerr); return 1; } } if (!fs.metadata_dev || !fs.data_dev) { - usage(cerr, basename(argv[0])); + usage(cerr); return 1; }