From afcf52a35d83edab84d1670d1e72d0062b3fa440 Mon Sep 17 00:00:00 2001 From: Heinz Mauelshagen Date: Jul 18 2013 13:37:32 +0000 Subject: Supprt metadata snapshots in thin_dump tool. New thin_medata_size calculator. New man pages and man page fixes. --- diff --git a/device-mapper-persistent-data-0.2.1-man-pages-new-thin_metadata_size-and-fixes.patch b/device-mapper-persistent-data-0.2.1-man-pages-new-thin_metadata_size-and-fixes.patch new file mode 100644 index 0000000..85af857 --- /dev/null +++ b/device-mapper-persistent-data-0.2.1-man-pages-new-thin_metadata_size-and-fixes.patch @@ -0,0 +1,281 @@ +diff --git a/Makefile.in b/Makefile.in +index 1e7bd54..b44cbd7 100644 +--- a/Makefile.in ++++ b/Makefile.in +@@ -264,7 +264,10 @@ install: $(PROGRAMS) + $(INSTALL_DIR) $(MANPATH)/man8 + $(INSTALL_DATA) man8/thin_check.8 $(MANPATH)/man8 + $(INSTALL_DATA) man8/thin_dump.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 ++ $(INSTALL_DATA) man8/thin_metadata_size.8 $(MANPATH)/man8 + + .PHONY: install + +diff --git a/man8/thin_check.8 b/man8/thin_check.8 +index f9606e0..1489078 100644 +--- a/man8/thin_check.8 ++++ b/man8/thin_check.8 +@@ -55,7 +55,10 @@ returns an exit code of 0 for success or 1 for error. + + .SH SEE ALSO + .B thin_dump(8) ++.B thin_repair(8) + .B thin_restore(8) ++.B thin_rmap(8) ++.B thin_metadata_size(8) + + .SH AUTHOR + Joe Thornber +diff --git a/man8/thin_dump.8 b/man8/thin_dump.8 +index 697df83..e60a6e5 100644 +--- a/man8/thin_dump.8 ++++ b/man8/thin_dump.8 +@@ -9,7 +9,8 @@ thin_dump \- dump thin provisioning metadata from device or file to standard out + + .SH DESCRIPTION + .B thin_dump +-dumps thin provisioning metadata created by the device-mapper ++dumps binary thin provisioning metadata (optionally from alternate block; ++see option \-\-metadata-snap) created by the device-mapper + thin provisioning target on a device or file to standard output for + analysis or postprocessing in either XML or human readable format. + XML formated metadata can be fed into thin_restore (see +@@ -22,6 +23,10 @@ Print output in XML or human readable format. + + .IP "\fB\-r, \-\-repair\fP". + ++.IP "\fB\-m, \-\-metadata_snap\fP block#". ++Dump metadata snapshot created by device-mapper thin provisioning target at block# ++ ++ + .IP "\fB\-h, \-\-help\fP". + Print help and exit. + +@@ -45,8 +50,10 @@ returns an exit code of 0 for success or 1 for error. + + .SH SEE ALSO + .B thin_check(8) ++.B thin_repair(8) + .B thin_restore(8) +- ++.B thin_rmap(8) ++.B thin_metadata_size(8) + .SH AUTHOR + Joe Thornber + .br +diff --git a/man8/thin_metadata_size.8 b/man8/thin_metadata_size.8 +new file mode 100644 +index 0000000..33b36b3 +--- /dev/null ++++ b/man8/thin_metadata_size.8 +@@ -0,0 +1,77 @@ ++.TH THIN_METADATA_SIZE 8 "Thin Provisioning Tools" "Red Hat, Inc." \" -*- nroff -*- ++.SH NAME ++thin_metadata_size \- thin provisioning metadata file/device size calculator. ++ ++.SH SYNOPSIS ++.B thin_metadata_size ++.RB [ options ] ++ ++.SH DESCRIPTION ++.B thin_metadata_size ++calculates the size of the thin provisioning metadata based on the block size ++of the thin provisioned devices, the size of the thin provisioning pool and ++the maximum number of all thin prisioned devices and snapshots. Size/number ++option arguments can be followed by unit specifiers in short one character ++and long form (eg. -b1m or -b1megabytes). ++ ++.IP "\fB\-b, \-\-block-size\fP \fIBLOCKSIZE[bskKmMgGtTpPeEzZyY]\fP" ++Block size of thin provisioned devices in units of bytes,sectors,kilobytes,kibibytes,... respectively. ++Default is in sectors without a block size unit specifier. ++ ++.IP "\fB\-s, \-\-pool-size\fP \fIPOOLSIZE[bskKmMgGtTpPeEzZyY]\fP" ++Thin provisioning pool size in units of bytes,sectors,kilobytes,kibibytes,... respectively. ++Default is in sectors without a pool size unit specifier. ++ ++.IP "\fB\-m, \-\-max-thins\fP \fI#[bskKmMgGtTpPeEzZyY]\fP" ++Maximum sum of all thin provisioned devices and snapshots. ++Unit identifier supported to allow for convenient entry of large quantities, eg. 1000000 = 1M. ++Default is absolut quantity without a number unit specifier. ++ ++.IP "\fB\-u, \-\-unit\fP \fI{bskKmMgGtTpPeEzZyY}\fP" ++Output unit specifier in units of bytes,sectors,kilobytes,kibibytes,... respectively. ++Default is in sectors without an output unit specifier. ++ ++.IP "\fB\-n, \-\-numeric-only [short|long]\fP" ++Limit output to just the size number with the optional unit specifier character/string. ++ ++.IP "\fB\-h, \-\-help\fP" ++Print help and exit. ++ ++.IP "\fB\-V, \-\-version\fP" ++Output version information and exit. ++ ++.SH EXAMPLES ++Calculates the thin privisioning metadata device size for block size 64 kilobytes, ++pool size 1 terabytes and maximum number of thin provisioned devices and snapshots of 1000 ++in units of sectors with long output: ++.sp ++.B thin_metadata_size -b64k -s1t -m1000 ++ ++Or (using the long options instead) for block size 1 gigabyte, pool size 1 petabytes and maximum number of thin provisioned devices ++and snapshots of 1 million with numeric only output in units of gigabytes: ++.sp ++.B thin_metadata_size --block-size=1g --pool-size=1p --max-thins=1M --unit=g --numeric-only ++ ++Same as before (1g,1p,1M,numeric-only) but with unit specifier character appended: ++.sp ++.B thin_metadata_size --block-size=1giga --pool-size=1petabytes --max-thins=1mebi --unit=g --numeric-only=short ++ ++Or with unit specifier string appended: ++.sp ++.B thin_metadata_size --block-size=1giga --pool-size=1petabytes --max-thins=1mebi --unit=g -nlong ++ ++.SH DIAGNOSTICS ++.B thin_metadata_size ++returns an exit code of 0 for success or 1 for error. ++ ++.SH SEE ALSO ++.B thin_dump(8) ++.B thin_check(8) ++.B thin_repair(8) ++.B thin_restore(8) ++.B thin_rmap(8) ++ ++.SH AUTHOR ++Joe Thornber ++.br ++Heinz Mauelshagen +diff --git a/man8/thin_repair.8 b/man8/thin_repair.8 +new file mode 100644 +index 0000000..69cddea +--- /dev/null ++++ b/man8/thin_repair.8 +@@ -0,0 +1,54 @@ ++.TH THIN_REPAIR 8 "Thin Provisioning Tools" "Red Hat, Inc." \" -*- nroff -*- ++.SH NAME ++thin_repair \- repair thin provisioning binary metadata from device/file to device/file ++ ++.SH SYNOPSIS ++.B thin_repair ++.RB [ options ] ++.RB -i ++.I {device|file} ++.RB -o ++.I {device|file} ++ ++.SH DESCRIPTION ++.B thin_repair ++repairs binary thin provisioning metadata created by the ++respective device-mapper target processing to another device or file. ++If repaired to a metadata device, the metadata can be processed ++by the device-mapper target. ++ ++.IP "\fB\-i, \-\-input\fP \fI{device|file}\fP" ++Input file or device with binary metadata. ++ ++.IP "\fB\-o, \-\-output\fP \fI{device|file}\fP" ++Output file or device for repaired binary metadata. ++ ++.IP "\fB\-h, \-\-help\fP" ++Print help and exit. ++ ++.IP "\fB\-V, \-\-version\fP" ++Output version information and exit. ++ ++.SH EXAMPLE ++Repairs the binary thin provisioning metadata on file ++.B metadata ++to logical volume /dev/vg/metadata for further processing by the ++respective device-mapper target: ++.sp ++.B thin_repair -i metadata -o /dev/vg/metadata ++ ++.SH DIAGNOSTICS ++.B thin_repair ++returns an exit code of 0 for success or 1 for error. ++ ++.SH SEE ALSO ++.B thin_dump(8) ++.B thin_check(8) ++.B thin_restore(8) ++.B thin_rmap(8) ++.B thin_metadata_size(8) ++ ++.SH AUTHOR ++Joe Thornber ++.br ++Heinz Mauelshagen +diff --git a/man8/thin_restore.8 b/man8/thin_restore.8 +index b4a07aa..8ab2976 100644 +--- a/man8/thin_restore.8 ++++ b/man8/thin_restore.8 +@@ -40,12 +40,15 @@ respective device-mapper target: + .B thin_restore -i metadata -o /dev/vg/metadata + + .SH DIAGNOSTICS +-.B thin_dump ++.B thin_restore + returns an exit code of 0 for success or 1 for error. + + .SH SEE ALSO + .B thin_dump(8) + .B thin_check(8) ++.B thin_repair(8) ++.B thin_rmap(8) ++.B thin_metadata_size(8) + + .SH AUTHOR + Joe Thornber +diff --git a/man8/thin_rmap.8 b/man8/thin_rmap.8 +new file mode 100644 +index 0000000..d68defb +--- /dev/null ++++ b/man8/thin_rmap.8 +@@ -0,0 +1,44 @@ ++.TH THIN_DUMP 8 "Thin Provisioning Tools" "Red Hat, Inc." \" -*- nroff -*- ++.SH NAME ++thin_rmap \- output reverse map of a thin provisioned region of blocks ++ ++.SH SYNOPSIS ++.B thin_rmap ++.RB [options] ++.I {metadata device|file} ++ ++.SH DESCRIPTION ++.B thin_rmap ++outputs the reverse mapping for a region of thin provisioned pool blocks ++to the respective thin provisioned devices. ++ ++.IP "\fB\\-\-region\fP \fI\fP". ++output reverse map ++ ++.IP "\fB\-h, \-\-help\fP". ++Print help and exit. ++ ++.IP "\fB\-V, \-\-version\fP". ++Output version information and exit. ++ ++.SH EXAMPLES ++output reverse map for pool blocks 5..45 (denotes blocks 5 to 44 inclusive, but not block 45) ++ ++.sp ++.B thin_rmap -r 5..45 /dev/vg/pool ++ ++.SH DIAGNOSTICS ++.B thin_rmap ++returns an exit code of 0 for success or 1 for error. ++ ++.SH SEE ALSO ++.B thin_check(8) ++.B thin_dump(8) ++.B thin_repair(8) ++.B thin_restore(8) ++.B thin_metadata_size(8) ++ ++.SH AUTHOR ++Joe Thornber ++.br ++Heinz Mauelshagen diff --git a/device-mapper-persistent-data-0.2.1-new-thin_metadata_size.c.patch b/device-mapper-persistent-data-0.2.1-new-thin_metadata_size.c.patch new file mode 100644 index 0000000..9610ca5 --- /dev/null +++ b/device-mapper-persistent-data-0.2.1-new-thin_metadata_size.c.patch @@ -0,0 +1,494 @@ +diff --git a/Makefile.in b/Makefile.in +index a82ff67..1e7bd54 100644 +--- a/Makefile.in ++++ b/Makefile.in +@@ -24,7 +24,8 @@ PROGRAMS=\ + thin_dump \ + thin_restore \ + thin_repair \ +- thin_rmap ++ thin_rmap \ ++ thin_metadata_size + + all: $(PROGRAMS) + +@@ -64,7 +65,7 @@ SOURCE=\ + + PDATA_OBJECTS=$(subst .cc,.o,$(SOURCE)) + +-PROGRAM_SOURCE=\ ++CXX_PROGRAM_SOURCE=\ + cache/check.cc \ + \ + thin-provisioning/thin_check.cc \ +@@ -73,10 +74,15 @@ PROGRAM_SOURCE=\ + thin-provisioning/thin_repair.cc \ + thin-provisioning/thin_rmap.cc + ++C_PROGRAM_SOURCE=\ ++ thin-provisioning/thin_metadata_size.c ++ ++CC:=@CC@ + CXX:=@CXX@ + OBJECTS:=$(subst .cc,.o,$(SOURCE)) + TOP_DIR:=@top_srcdir@ + TOP_BUILDDIR:=@top_builddir@ ++CFLAGS+=-g -Wall -O3 + CXXFLAGS+=-std=c++11 -g -Wall -fno-strict-aliasing + CXXFLAGS+=@CXXOPTIMISE_FLAG@ + CXXFLAGS+=@CXXDEBUG_FLAG@ +@@ -104,6 +110,14 @@ endif + + .SUFFIXES: .d + ++%.o: %.c ++ @echo " [CC] $<" ++ $(V) $(CC) -c $(INCLUDES) $(CFLAGS) -o $@ $< ++ @echo " [DEP] $<" ++ $(V) $(CC) -MM -MT $(subst .c,.o,$<) $(INCLUDES) $(CFLAGS) $< > $*.$$$$; \ ++ sed 's,\([^ :]*\)\.o[ :]*,\1.o \1.gmo $* : Makefile ,g' < $*.$$$$ > $*.d; \ ++ $(RM) $*.$$$$ ++ + %.o: %.cc + @echo " [CXX] $<" + $(V) $(CXX) -c $(INCLUDES) $(CXXFLAGS) -o $@ $< +@@ -195,6 +209,10 @@ thin_rmap: $(THIN_RMAP_OBJECTS) thin-provisioning/thin_rmap.o + @echo " [LD] $@" + $(V) $(CXX) $(CXXFLAGS) -o $@ $+ $(LIBS) + ++thin_metadata_size: thin-provisioning/thin_metadata_size.o ++ @echo " [LD] $@" ++ $(V) $(CC) $(CFLAGS) -o $@ $+ -lm ++ + #---------------------------------------------------------------- + # Cache tools + +@@ -221,29 +239,33 @@ cache_check: $(CACHE_CHECK_OBJECTS) cache/check.o + DEPEND_FILES=\ + $(subst .cc,.d,$(SOURCE)) \ + $(subst .cc,.d,$(TEST_SOURCE)) \ +- $(subst .cc,.d,$(PROGRAM_SOURCE)) ++ $(subst .cc,.d,$(CXX_PROGRAM_SOURCE)) \ ++ $(subst .c,.d,$(C_PROGRAM_SOURCE)) + + .PHONY: clean distclean + + clean: + find . -name \*.o -delete + find . -name \*.gmo -delete +- $(RM) $(DEPEND_FILES) $(TEST_PROGRAMS) $(PROGRAMS) $(GMOCK_OBJECTS) lib/*.a ++ find . -name \*.d -delete ++ $(RM) $(TEST_PROGRAMS) $(PROGRAMS) $(GMOCK_OBJECTS) lib/*.a + + distclean: clean + $(RM) config.cache config.log config.status configure.h version.h Makefile unit-tests/Makefile + + install: $(PROGRAMS) + $(INSTALL_DIR) $(BINDIR) +- $(INSTALL_PROGRAM) thin_check $(BINDIR) +- $(INSTALL_PROGRAM) thin_dump $(BINDIR) +- $(INSTALL_PROGRAM) thin_repair $(BINDIR) +- $(INSTALL_PROGRAM) thin_restore $(BINDIR) +- $(INSTALL_PROGRAM) thin_rmap $(BINDIR) ++ $(INSTALL_PROGRAM) -s thin_check $(BINDIR) ++ $(INSTALL_PROGRAM) -s thin_dump $(BINDIR) ++ $(INSTALL_PROGRAM) -s thin_repair $(BINDIR) ++ $(INSTALL_PROGRAM) -s thin_restore $(BINDIR) ++ $(INSTALL_PROGRAM) -s thin_rmap $(BINDIR) ++ $(INSTALL_PROGRAM) -s thin_metadata_size $(BINDIR) + $(INSTALL_DIR) $(MANPATH)/man8 + $(INSTALL_DATA) man8/thin_check.8 $(MANPATH)/man8 + $(INSTALL_DATA) man8/thin_dump.8 $(MANPATH)/man8 + $(INSTALL_DATA) man8/thin_restore.8 $(MANPATH)/man8 ++ + .PHONY: install + + ifeq ("@TESTING@", "yes") +diff --git a/configure.in b/configure.in +index 78d88c1..8f25002 100644 +--- a/configure.in ++++ b/configure.in +@@ -30,6 +30,7 @@ dnl -- Setup the directory where autoconf has auxilary files + AC_CONFIG_AUX_DIR(autoconf) + AC_CANONICAL_TARGET([]) + AC_PROG_CXX([g++]) ++AC_PROG_CC([gcc]) + AC_LANG(C++) + + ################################################################ +diff --git a/thin-provisioning/thin_metadata_size.c b/thin-provisioning/thin_metadata_size.c +new file mode 100755 +index 0000000..1f52d51 +--- /dev/null ++++ b/thin-provisioning/thin_metadata_size.c +@@ -0,0 +1,370 @@ ++/* ++ * Copyright (C) 2013 Red Hat, GmbH ++ * ++ * Calculates device-mapper thin privisioning ++ * metadata device size based on pool, block size and ++ * maximum expected thin provisioned devices and snapshots. ++ * ++ * This file is part of the thin-provisioning-tools source. ++ * ++ * thin-provisioning-tools is free software: you can redistribute it ++ * and/or modify it under the terms of the GNU General Public License ++ * as published by the Free Software Foundation, either version 3 of ++ * the License, or (at your option) any later version. ++ * ++ * thin-provisioning-tools is distributed in the hope that it will be ++ * useful, but WITHOUT ANY WARRANTY; without even the implied warranty ++ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License along ++ * with thin-provisioning-tools. If not, see ++ * . ++ * ++ */ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++#include "version.h" ++ ++#include ++ ++/*----------------------------------------------------------------*/ ++ ++enum numeric_options { BLOCKSIZE, POOLSIZE, MAXTHINS, NUMERIC, OPT_END}; ++enum return_units { RETURN_BYTES, RETURN_SECTORS }; ++enum numeric_type { NO_NUMBER, NUMBER, NUMBER_SHORT, NUMBER_LONG }; ++typedef unsigned bool; ++enum bool_value { false = 0, true = 1}; ++struct global { ++ char *prg; /* program name */ ++ ++ /* Unit representations in characters, strings and numeric factors. */ ++ struct { ++ char *chars; ++ char **strings; ++ unsigned long long *factors; ++ } unit; ++ ++ /* Command line option properties. */ ++ struct options { ++ unsigned unit_idx; ++ char *s[OPT_END]; ++ unsigned long long n[OPT_END]; ++ } options; ++}; ++ ++static void exit_prg(struct global *g, int ret) ++{ ++ if (g) { ++ unsigned u = OPT_END; ++ ++ while (u--) { ++ if (g->options.s[u]) ++ free (g->options.s[u]); ++ } ++ ++ free(g); ++ } ++ ++ exit(ret); ++} ++ ++static void abort_prg(struct global *g, const char *msg) ++{ ++ fprintf(stderr, "%s - %s\n", g ? g->prg : "fatal", msg); ++ exit_prg(g, 1); ++} ++ ++static int unit_index(struct global *g, char *unit_string) ++{ ++ unsigned len; ++ ++ if (!unit_string) ++ return unit_index(g, "sectors"); ++ ++ len = strlen(unit_string); ++ if (len == 1) { ++ char *o = strchr(g->unit.chars, *unit_string); ++ ++ if (o) ++ return o - g->unit.chars; ++ ++ } else { ++ char **s; ++ ++ for (s = g->unit.strings; *s; s++) ++ if (!strncmp(*s, unit_string, len)) ++ return s - g->unit.strings; ++ } ++ ++ return -1; ++} ++ ++#define ARRAY_SIZE(a) (sizeof(a)/sizeof(a[0])) ++static struct global *init_prg(char *prg_path) ++{ ++ unsigned u; ++ static char *unit_chars = "bskKmMgGtTpPeEzZyY"; ++ static char *unit_strings[] = { "bytes", "sectors", ++ "kilobytes", "kibibytes", "megabytes", "mebibytes", ++ "gigabytes", "gibibytes", "terabytes", "tebibytes", ++ "petabytes", "pebibytes", "exabytes", "ebibytes", ++ "zetabytes", "zebibytes", "yottabytes", "yobibytes", NULL }; ++ static unsigned long long unit_factors[ARRAY_SIZE(unit_strings) - 1] = { 1, 512, 1024, 1000 }; ++ struct global *r = malloc(sizeof(*r)); ++ ++ if (!r) ++ abort_prg(r, "failed to allocate global context!"); ++ ++ memset(r, 0, sizeof(*r)); ++ ++ for (u = 4; unit_strings[u]; u += 2) { ++ unit_factors[u] = unit_factors[u-2] * unit_factors[2]; ++ unit_factors[u+1] = unit_factors[u-1] * unit_factors[3]; ++ } ++ ++ r->prg = basename(prg_path); ++ r->unit.chars = unit_chars; ++ r->unit.strings = unit_strings; ++ r->unit.factors = unit_factors; ++ r->options.unit_idx = unit_index(r, NULL); ++ ++ return r; ++} ++ ++static unsigned long long bytes_per_sector(struct global *g) ++{ ++ return g->unit.factors[unit_index(g, "sectors")]; ++} ++ ++static void check_opts(struct global *g) ++{ ++ struct options *o = &g->options; ++ ++ if (!o->n[BLOCKSIZE]) ++ abort_prg(g, "block size required!"); ++ else if (!o->n[POOLSIZE]) ++ abort_prg(g, "pool size required!"); ++ else if (!o->n[MAXTHINS]) ++ abort_prg(g, "max thins required!"); ++ else if (o->n[BLOCKSIZE] & (o->n[BLOCKSIZE] - 1)) ++ abort_prg(g, "block size must be 2^^N"); ++ else if (o->n[POOLSIZE] <= o->n[BLOCKSIZE]) ++ abort_prg(g, "pool size must be larger than block size"); ++} ++ ++static unsigned long long to_bytes(struct global *g, char *sz, enum return_units unit, int *index) ++{ ++ int idx; ++ unsigned long long r; ++ char *us = sz; ++ ++ /* Get pointer to unit identifier. */ ++ us += strspn(sz, "0123456789"); ++ if (*us) { ++ idx = unit_index(g, us); ++ if (idx < 0) ++ abort_prg(g, "Invalid unit specifier!"); ++ ++ *us = 0; ++ *index = idx; ++ } else { ++ idx = unit_index(g, NULL); ++ us = NULL; ++ *index = -1; ++ } ++ ++ r = atoll(sz) * g->unit.factors[idx]; ++ return (!us || unit == RETURN_SECTORS) ? r / bytes_per_sector(g) : r; ++} ++ ++static void printf_aligned(struct global *g, char *a, char *b, char *c, bool units, bool mandatory) ++{ ++ char buf[80]; ++ ++ strcpy(buf, b); ++ if (units) ++ strcat(buf, mandatory ? "{" :"["), strcat(buf, g->unit.chars), strcat(buf, mandatory ? "}" : "]"); ++ ++ printf("\t%-4s%-44s%s\n", a, buf, c); ++} ++ ++static void help(struct global *g) ++{ ++ printf ("Thin Provisioning Metadata Device Size Calculator.\nUsage: %s [options]\n", g->prg); ++ printf_aligned(g, "-b", "--block-size BLOCKSIZE", "Block size of thin provisioned devices.", true, false); ++ printf_aligned(g, "-s", "--pool-size SIZE", "Size of pool device.", true, false); ++ printf_aligned(g, "-m", "--max-thins #MAXTHINS", "Maximum sum of all thin devices and snapshots.", true, false); ++ printf_aligned(g, "-u", "--unit ", "Output unit specifier.", true, true); ++ printf_aligned(g, "-n", "--numeric-only [short|long]", "Output numeric value only (optionally with short/long unit identifier).", false, false); ++ printf_aligned(g, "-h", "--help", "This help.", false, false); ++ printf_aligned(g, "-V", "--version", "Print thin provisioning tools version.", false, false); ++ exit_prg(g, 0); ++} ++ ++static void version(struct global *g) ++{ ++ printf("%s\n", THIN_PROVISIONING_TOOLS_VERSION); ++ exit_prg(g, 1); ++} ++ ++static void check_unit(struct global *g, char *arg) ++{ ++ int idx = unit_index(g, arg); ++ ++ if (idx < 0) ++ abort_prg(g, "output unit specifier invalid!"); ++ ++ g->options.unit_idx = idx; ++} ++ ++static void check_numeric_option(struct global *g, char *arg) ++{ ++ if (g->options.n[NUMERIC] != NO_NUMBER) ++ abort_prg(g, "-n already given!"); ++ ++ g->options.n[NUMERIC] = NUMBER; ++ ++ if (arg) { ++ bool unit_long = !strncmp("long", arg, strlen(arg)); ++ ++ if (!*arg || (strncmp("short", arg, strlen(arg)) && !unit_long)) ++ abort_prg(g, "-n invalid option argument"); ++ ++ g->options.n[NUMERIC] = unit_long ? NUMBER_LONG : NUMBER_SHORT; ++ } ++} ++ ++static void check_size(struct global *g, enum numeric_options o, char *arg) ++{ ++ int idx; ++ bool valid_index = true; ++ ++ if (g->options.n[o]) ++ abort_prg(g, "option already given!"); ++ ++ g->options.n[o] = to_bytes(g, arg, o == MAXTHINS ? RETURN_BYTES : RETURN_SECTORS, &idx); ++ if (idx < 0) { ++ valid_index = false; ++ idx = g->options.unit_idx; ++ } ++ ++ g->options.s[o] = malloc(strlen(arg) + strlen(g->unit.strings[idx]) + 1); ++ if (!g->options.s[o]) ++ abort_prg(g, "failed to allocate string!"); ++ ++ strcpy(g->options.s[o], arg); ++ if (o != MAXTHINS || valid_index) ++ strcat(g->options.s[o], g->unit.strings[idx]); ++ ++} ++ ++static void parse_command_line(struct global *g, int argc, char **argv) ++{ ++ int c; ++ static struct option long_options[] = { ++ {"block-size", required_argument, NULL, 'b' }, ++ {"pool-size", required_argument, NULL, 's' }, ++ {"max-thins", required_argument, NULL, 'm' }, ++ {"unit", required_argument, NULL, 'u' }, ++ {"numeric-only",optional_argument, NULL, 'n' }, ++ {"help", no_argument, NULL, 'h' }, ++ {"version", no_argument, NULL, 'V' }, ++ {NULL, 0, NULL, 0 } ++ }; ++ ++ while ((c = getopt_long(argc, argv, "b:s:m:u:n::hV", long_options, NULL)) != -1) { ++ switch (c) { ++ case 'b': ++ check_size(g, BLOCKSIZE, optarg); ++ break; ++ case 's': ++ check_size(g, POOLSIZE, optarg); ++ break; ++ case 'm': ++ check_size(g, MAXTHINS, optarg); ++ break; ++ case 'u': ++ check_unit(g, optarg); ++ break; ++ case 'n': ++ check_numeric_option(g, optarg); ++ break; ++ case 'h': ++ help(g); /* exits */ ++ case 'V': ++ version(g); /* exits */ ++ default: ++ exit_prg(g, 1); ++ } ++ } ++ ++ check_opts(g); ++} ++ ++static const unsigned mappings_per_block(void) ++{ ++ const struct { ++ const unsigned node; ++ const unsigned node_header; ++ const unsigned entry; ++ } btree_size = { 4096, 64, 16 }; ++ ++ return (btree_size.node - btree_size.node_header) / btree_size.entry; ++} ++ ++static void print_precision(struct global *g, double r, unsigned idx) ++{ ++ bool full = g->options.n[NUMERIC] == NO_NUMBER; ++ double rtrunc = truncl(r); ++ ++ if (full) ++ printf("%s - ", g->prg); ++ ++ if (r == rtrunc) ++ printf("%llu", (unsigned long long) r); ++ else ++ printf(r - rtrunc < 1E-2 ? "%0.2e" : "%0.2f", r); ++ ++ if (full) ++ printf(" %s", g->unit.strings[idx]); ++ else if (g->options.n[NUMERIC] > NUMBER) { ++ if (g->options.n[NUMERIC] == NUMBER_SHORT) ++ printf("%c", g->unit.chars[idx]); ++ else ++ printf("%s", g->unit.strings[idx]); ++ } ++ ++ if (full) ++ printf(" estimated metadata area size for \"--block-size=%s --pool-size=%s --max-thins=%s\"", ++ g->options.s[BLOCKSIZE], g->options.s[POOLSIZE], g->options.s[MAXTHINS]); ++ ++ putchar('\n'); ++} ++ ++static void print_estimated_result(struct global *g) ++{ ++ double r; ++ ++ /* double-fold # of nodes, because they aren't fully populated in average */ ++ r = (1.0 + (2 * g->options.n[POOLSIZE] / g->options.n[BLOCKSIZE] / mappings_per_block() + g->options.n[MAXTHINS])); /* in 4k blocks */ ++ r *= 8 * bytes_per_sector(g); /* in bytes! */ ++ r /= g->unit.factors[g->options.unit_idx]; /* in requested unit */ ++ ++ print_precision(g, r, g->options.unit_idx); ++} ++ ++int main(int argc, char **argv) ++{ ++ struct global *g = init_prg(*argv); ++ ++ parse_command_line(g, argc, argv); ++ print_estimated_result(g); ++ exit_prg(g, 0); ++ return 0; /* Doesn't get here... */ ++} diff --git a/device-mapper-persistent-data-0.2.1-thin_dump-support-metadata-snap-block.patch b/device-mapper-persistent-data-0.2.1-thin_dump-support-metadata-snap-block.patch new file mode 100644 index 0000000..b2e9195 --- /dev/null +++ b/device-mapper-persistent-data-0.2.1-thin_dump-support-metadata-snap-block.patch @@ -0,0 +1,114 @@ +diff --git a/thin-provisioning/metadata.cc b/thin-provisioning/metadata.cc +index c841614..771325a 100644 +--- a/thin-provisioning/metadata.cc ++++ b/thin-provisioning/metadata.cc +@@ -57,15 +57,6 @@ namespace { + return tm; + } + +- superblock +- read_superblock(block_manager<>::ptr bm, block_address location = SUPERBLOCK_LOCATION) { +- superblock sb; +- block_manager<>::read_ref r = bm->read_lock(location, superblock_validator()); +- superblock_disk const *sbd = reinterpret_cast(&r.data()); +- superblock_traits::unpack(*sbd, sb); +- return sb; +- } +- + void + copy_space_maps(space_map::ptr lhs, space_map::ptr rhs) { + for (block_address b = 0; b < rhs->get_nr_blocks(); b++) { +@@ -149,10 +140,10 @@ metadata::metadata(std::string const &dev_path, open_type ot, + } + } + +-metadata::metadata(std::string const &dev_path) ++metadata::metadata(std::string const &dev_path, block_address metadata_snap) + { + tm_ = open_tm(open_bm(dev_path, false)); +- sb_ = read_superblock(tm_->get_bm()); ++ sb_ = read_superblock(tm_->get_bm(), metadata_snap); + + // We don't open the metadata sm for a held root + //metadata_sm_ = open_metadata_sm(tm_, &sb_.metadata_space_map_root_); +diff --git a/thin-provisioning/metadata.h b/thin-provisioning/metadata.h +index 250c216..9749acb 100644 +--- a/thin-provisioning/metadata.h ++++ b/thin-provisioning/metadata.h +@@ -62,10 +62,11 @@ namespace thin_provisioning { + // Deprecated: it would be better if we passed in an already + // constructed block_manager. + metadata(std::string const &dev_path, open_type ot, +- sector_t data_block_size = 128, ++ sector_t data_block_size = 128, // Only used if CREATE + block_address nr_data_blocks = 0); // Only used if CREATE + +- metadata(std::string const &dev_path); ++ metadata(std::string const &dev_path, ++ block_address metadata_snap = 0); + + // ... use these instead ... + metadata(block_manager<>::ptr bm, open_type ot, +diff --git a/thin-provisioning/superblock.cc b/thin-provisioning/superblock.cc +index c23fbc1..bf9544b 100644 +--- a/thin-provisioning/superblock.cc ++++ b/thin-provisioning/superblock.cc +@@ -126,17 +126,22 @@ namespace thin_provisioning { + } + } + +- superblock_detail::superblock read_superblock(block_manager<>::ptr bm) ++ superblock_detail::superblock read_superblock(block_manager<>::ptr bm, block_address location) + { + using namespace superblock_detail; + + superblock sb; +- auto r = bm->read_lock(SUPERBLOCK_LOCATION, superblock_validator()); ++ auto r = bm->read_lock(location, superblock_validator()); + superblock_disk const *sbd = reinterpret_cast(&r.data()); + superblock_traits::unpack(*sbd, sb); + return sb; + } + ++ superblock_detail::superblock read_superblock(block_manager<>::ptr bm) ++ { ++ return read_superblock(bm, SUPERBLOCK_LOCATION); ++ } ++ + void + check_superblock(block_manager<>::ptr bm, + superblock_detail::damage_visitor &visitor) { +diff --git a/thin-provisioning/superblock.h b/thin-provisioning/superblock.h +index e993497..a9377b0 100644 +--- a/thin-provisioning/superblock.h ++++ b/thin-provisioning/superblock.h +@@ -123,6 +123,7 @@ namespace thin_provisioning { + persistent_data::block_manager<>::validator::ptr superblock_validator(); + + superblock_detail::superblock read_superblock(persistent_data::block_manager<>::ptr bm); ++ superblock_detail::superblock read_superblock(persistent_data::block_manager<>::ptr bm, persistent_data::block_address location); + void check_superblock(persistent_data::block_manager<>::ptr bm, + superblock_detail::damage_visitor &visitor); + } +diff --git a/thin-provisioning/thin_dump.cc b/thin-provisioning/thin_dump.cc +index a4bcf66..029a635 100644 +--- a/thin-provisioning/thin_dump.cc ++++ b/thin-provisioning/thin_dump.cc +@@ -35,7 +35,7 @@ namespace { + int dump(string const &path, ostream &out, string const &format, bool repair, + block_address metadata_snap = 0) { + try { +- metadata::ptr md(new metadata(path, metadata::OPEN)); ++ metadata::ptr md(metadata_snap ? new metadata(path, metadata_snap) : new metadata(path, metadata::OPEN, 0, 0)); + emitter::ptr e; + + if (format == "xml") +@@ -63,7 +63,7 @@ namespace { + << " {-h|--help}" << endl + << " {-f|--format} {xml|human_readable}" << endl + << " {-r|--repair}" << endl +- << " {-m|--metadata-snap}" << endl ++ << " {-m|--metadata-snap} block#" << endl + << " {-o }" << endl + << " {-V|--version}" << endl; + } diff --git a/device-mapper-persistent-data.spec b/device-mapper-persistent-data.spec index 080af40..27c6ef4 100644 --- a/device-mapper-persistent-data.spec +++ b/device-mapper-persistent-data.spec @@ -4,23 +4,29 @@ Summary: Device-mapper thin provisioning tools Name: device-mapper-persistent-data Version: 0.2.1 -Release: 2%{?dist} +Release: 3%{?dist} License: GPLv3+ Group: System Environment/Base URL: https://github.com/jthornber/thin-provisioning-tools Source0: https://github.com/jthornber/thin-provisioning-tools/archive/thin-provisioning-tools-v%{version}.tar.bz2 # Source1: https://github.com/jthornber/thin-provisioning-tools/archive/v%{version}.tar.gz Patch0: %{name}-0.2.1-nostrip.patch +Patch1: %{name}-0.2.1-thin_dump-support-metadata-snap-block.patch +Patch2: %{name}-0.2.1-new-thin_metadata_size.c.patch +Patch3: %{name}-0.2.1-man-pages-new-thin_metadata_size-and-fixes.patch BuildRequires: autoconf, expat-devel, libstdc++-devel, boost-devel Requires: expat %description -thin-provisioning-tools contains check,dump,restore,repair and rmap tools to -manage device-mapper thin provisioning target metadata devices. +thin-provisioning-tools contains check,dump,restore,repair,rmap and metadata_size +tools to manage device-mapper thin provisioning target metadata devices. %prep %setup -q -n thin-provisioning-tools-%{version} %patch0 -p1 +%patch1 -p1 +%patch2 -p1 +%patch3 -p1 %build autoconf @@ -34,16 +40,26 @@ make DESTDIR=%{buildroot} MANDIR=%{_mandir} install %files %doc COPYING README.md -%{_mandir}/man8/thin_dump.8.gz %{_mandir}/man8/thin_check.8.gz +%{_mandir}/man8/thin_dump.8.gz +%{_mandir}/man8/thin_metadata_size.8.gz +%{_mandir}/man8/thin_repair.8.gz %{_mandir}/man8/thin_restore.8.gz -%{_sbindir}/thin_dump +%{_mandir}/man8/thin_rmap.8.gz %{_sbindir}/thin_check +%{_sbindir}/thin_dump +%{_sbindir}/thin_metadata_size %{_sbindir}/thin_repair %{_sbindir}/thin_restore %{_sbindir}/thin_rmap %changelog +* Thu Jul 18 2013 Heinz Mauelshagen - 0.2.1-3 +- New thin_metadata_size tool to estimate amount of metadata space + based on block size, pool size and maximum amount of thin devs and snapshots +- support metadata snapshots in thin_dump tool +- New man pages for thin_metadata_size, thin_repair and thin_rmap and man page fixes + * Tue Jul 16 2013 Heinz Mauelshagen - 0.2.1-2 - Build with nostrip fix from Ville Skyttä