[base] introduce a command type that gets registered with the app

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

base/application.cc

@@ -1,14 +1,47 @@
 #include "base/application.h"
 
+#include <boost/lexical_cast.hpp>
 #include <libgen.h>
 #include <linux/limits.h>
 #include <string.h>
+#include <stdlib.h>
 
 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<uint64_t>(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<command const *>::const_iterator it;
+	std::list<command::ptr>::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: <command> <args>\n"
 		  << "commands:\n";
 
-	std::list<command const *>::const_iterator it;
+	std::list<command::ptr>::const_iterator it;
 	for (it = cmds_.begin(); it != cmds_.end(); ++it) {
 		std::cerr << "  " << (*it)->get_name() << "\n";
 	}

base/application.h

@@ -1,40 +1,60 @@
 #ifndef BASE_APPLICATION_H
 #define BASE_APPLICATION_H
 
+#include <boost/shared_ptr.hpp>
 #include <iostream>
 #include <list>
 #include <string>
 #include <stdexcept>
+#include <stdint.h>
 
 //----------------------------------------------------------------
 
 namespace base {
 	class command {
 	public:
-		typedef int (*cmd_fn)(int, char **);
+		typedef boost::shared_ptr<command> ptr;
 
-		command(std::string const &name, cmd_fn fn)
+		command(std::string const &name);
-			: name_(name),
+		virtual ~command() {}
-			  fn_(fn) {
+
-		}
+		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) {
+		void add_cmd(command::ptr c) {
-			cmds_.push_back(&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<command const *> cmds_;
+		std::list<command::ptr> cmds_;
 	};
 }
 

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);
-
 //----------------------------------------------------------------

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 <xml file>}" << 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 <xml file>}" << 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);
-
 //----------------------------------------------------------------

caching/cache_metadata_size.cc

@@ -9,141 +9,145 @@
 #include <stdint.h>
 #include <stdexcept>
 
+using namespace caching;
 using namespace std;
 
 //----------------------------------------------------------------
 
-namespace {
+cache_metadata_size_cmd::flags::flags()
-	struct flags {
+  : max_hint_width(4) {
-		flags()
-			: max_hint_width(4) {
 
-			// Dance around some spurious compiler warnings
+	// Dance around some spurious compiler warnings
-			device_size = 0;
+	device_size = 0;
-			block_size = 0;
+	block_size = 0;
-			nr_blocks = 0;
+	nr_blocks = 0;
 
-			device_size.reset();
+	device_size.reset();
-			block_size.reset();
+	block_size.reset();
-			nr_blocks.reset();
+	nr_blocks.reset();
-		}
-
-		boost::optional<uint64_t> device_size;
-		boost::optional<uint32_t> block_size;
-		boost::optional<uint64_t> 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 <sectors>}" << endl
-		    << "  {--device-size <sectors>}" << endl
-		    << "  {--nr-blocks <natural>}" << 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<uint32_t>(optarg);
-				break;
-
-			case 1:
-				fs.device_size = boost::lexical_cast<uint64_t>(optarg);
-				break;
-
-			case 2:
-				fs.nr_blocks = boost::lexical_cast<uint64_t>(optarg);
-				break;
-
-			case 3:
-				fs.max_hint_width = boost::lexical_cast<uint32_t>(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;
-	}
 }
 
-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<uint32_t>(optarg);
+			break;
+
+		case 1:
+			fs.device_size = boost::lexical_cast<uint64_t>(optarg);
+			break;
+
+		case 2:
+			fs.nr_blocks = boost::lexical_cast<uint64_t>(optarg);
+			break;
+
+		case 3:
+			fs.max_hint_width = boost::lexical_cast<uint32_t>(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 <sectors>}" << endl
+	    << "  {--device-size <sectors>}" << endl
+	    << "  {--nr-blocks <natural>}" << 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);
-
 //----------------------------------------------------------------

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} <input metadata (binary format)>" << endl
-		    << "  {-o|--output} <output metadata (binary format)>" << 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} <input metadata (binary format)>" << endl
+	    << "  {-o|--output} <output metadata (binary format)>" << endl
+	    << "  {-V|--version}" << endl;
+}
+
+int
+cache_repair_cmd::run(int argc, char **argv)
 {
 	int c;
 	boost::optional<string> 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);
-
 //----------------------------------------------------------------

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} <input xml file>" << endl
-		    << "  {-o|--output} <output device or file>" << endl
-		    << "  {-q|--quiet}" << endl
-		    << "  {-V|--version}" << endl
-		    << endl
-		    << "  {--debug-override-metadata-version} <integer>" << 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} <input xml file>" << endl
+	    << "  {-o|--output} <output device or file>" << endl
+	    << "  {-q|--quiet}" << endl
+	    << "  {-V|--version}" << endl
+	    << endl
+	    << "  {--debug-override-metadata-version} <integer>" << 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);
-
 //----------------------------------------------------------------

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));
+}
+
+//----------------------------------------------------------------

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;
+	class cache_check_cmd : public base::command {
-	extern base::command cache_dump_cmd;
+	public:
-	extern base::command cache_metadata_size_cmd;
+		cache_check_cmd();
-	extern base::command cache_restore_cmd;
+		virtual void usage(std::ostream &out) const;
-	extern base::command cache_repair_cmd;
+		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<uint64_t> device_size;
+			boost::optional<uint32_t> block_size;
+			boost::optional<uint64_t> 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);
 }
 
 //----------------------------------------------------------------

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()));
+}
+
+//----------------------------------------------------------------

era/commands.h

@@ -6,10 +6,35 @@
 //----------------------------------------------------------------
 
 namespace era {
-	extern base::command era_check_cmd;
+	class era_check_cmd : public base::command {
-	extern base::command era_dump_cmd;
+	public:
-	extern base::command era_invalidate_cmd;
+		era_check_cmd();
-	extern base::command era_restore_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);
 }
 
 //----------------------------------------------------------------

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);
-
 //----------------------------------------------------------------

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 <xml file>}" << 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 <xml file>}" << 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);
-
 //----------------------------------------------------------------

era/era_invalidate.cc

@@ -182,20 +182,28 @@ namespace {
 
 		return 0;
 	}
-
-	void usage(ostream &out, string const &cmd) {
-		out << "Usage: " << cmd << " [options] --written-since <era> {device|file}\n"
-		    << "Options:\n"
-		    << "  {-h|--help}\n"
-		    << "  {-o <xml file>}\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 <era> {device|file}\n"
+	    << "Options:\n"
+	    << "  {-h|--help}\n"
+	    << "  {-o <xml file>}\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);
-
 //----------------------------------------------------------------

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} <input xml file>" << endl
-		    << "  {-o|--output} <output device or file>" << 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} <input xml file>" << endl
+	    << "  {-o|--output} <output device or file>" << 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);
-
 //----------------------------------------------------------------

main.cc

@@ -14,27 +14,9 @@ int main(int argc, char **argv)
 
 	application app;
 
-	app.add_cmd(caching::cache_check_cmd);
+	caching::register_cache_commands(app);
-	app.add_cmd(caching::cache_dump_cmd);
+	era::register_era_commands(app);
-	app.add_cmd(caching::cache_metadata_size_cmd);
+	thin_provisioning::register_thin_commands(app);
-	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);
 
 	return app.run(argc, argv);
 }

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()));
+}
+
+//----------------------------------------------------------------

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;
+	class thin_check_cmd : public base::command {
-	extern base::command thin_delta_cmd;
+	public:
-	extern base::command thin_dump_cmd;
+		thin_check_cmd();
-	extern base::command thin_metadata_size_cmd;
+		virtual void usage(std::ostream &out) const;
-	extern base::command thin_restore_cmd;
+		virtual int run(int argc, char **argv);
-	extern base::command thin_repair_cmd;
+	};
-	extern base::command thin_rmap_cmd;
+
-	extern base::command thin_trim_cmd;
+	class thin_delta_cmd : public base::command {
-	extern base::command thin_metadata_size_cmd;
+	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);
 }
 
 //----------------------------------------------------------------

thin-provisioning/metadata_dumper.cc

@@ -84,7 +84,7 @@ namespace {
 
 	//--------------------------------
 
-	typedef map<block_address, device_tree_detail::device_details> dd_map;
+ 	typedef map<block_address, device_tree_detail::device_details> dd_map;
 
 	class details_extractor : public device_tree_detail::device_visitor {
 	public:

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);
-
 //----------------------------------------------------------------

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);
-
 //----------------------------------------------------------------

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 <xml file>}" << 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 <metadata_snap>" << 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);
-
 //----------------------------------------------------------------

thin-provisioning/thin_metadata_size.cc

@@ -35,6 +35,8 @@
 
 #include <search.h>
 
+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);
+//----------------------------------------------------------------

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} <input metadata (binary format)>" << endl
-		    << "  {-o|--output} <output metadata (binary format)>" << 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} <input metadata (binary format)>" << endl
+	    << "  {-o|--output} <output metadata (binary format)>" << endl
+	    << "  {-V|--version}" << endl;
+}
+
+int
+thin_repair_cmd::run(int argc, char **argv)
 {
 	int c;
 	boost::optional<string> 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);
-
 //----------------------------------------------------------------

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} <input xml file>" << endl
-		    << "  {-o|--output} <output device or file>" << 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} <input xml file>" << endl
+	    << "  {-o|--output} <output device or file>" << 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);
-
 //----------------------------------------------------------------

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 <block range>}*" << endl
-		    << "Where:" << endl
-		    << "  <block range> is of the form <begin>..<one-past-the-end>" << 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 <block range>}*" << endl
+	    << "Where:" << endl
+	    << "  <block range> is of the form <begin>..<one-past-the-end>" << 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<region> 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);
-
 //----------------------------------------------------------------

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<string> metadata_dev;
 		boost::optional<string> 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;
 	}