Hello community, here is the log from the commit of package thin-provisioning-tools for openSUSE:Factory checked in at 2019-08-16 15:30:33 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/thin-provisioning-tools (Old) and /work/SRC/openSUSE:Factory/.thin-provisioning-tools.new.22127 (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "thin-provisioning-tools" Fri Aug 16 15:30:33 2019 rev:19 rq:723103 version:0.8.5 Changes: -------- --- /work/SRC/openSUSE:Factory/thin-provisioning-tools/thin-provisioning-tools.changes 2019-08-08 14:22:12.772359992 +0200 +++ /work/SRC/openSUSE:Factory/.thin-provisioning-tools.new.22127/thin-provisioning-tools.changes 2019-08-16 15:30:35.169962071 +0200 @@ -1,0 +2,6 @@ +Tue Aug 13 14:53:11 UTC 2019 - Martin Pluskal <mplus...@suse.com> + +- Update to version 0.8.5 + * Mostly internal changes + +------------------------------------------------------------------- Old: ---- thin-provisioning-tools-0.8.3.tar.gz New: ---- thin-provisioning-tools-0.8.5.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ thin-provisioning-tools.spec ++++++ --- /var/tmp/diff_new_pack.n6ZwRq/_old 2019-08-16 15:30:35.725961909 +0200 +++ /var/tmp/diff_new_pack.n6ZwRq/_new 2019-08-16 15:30:35.729961908 +0200 @@ -17,7 +17,7 @@ Name: thin-provisioning-tools -Version: 0.8.3 +Version: 0.8.5 Release: 0 Summary: Thin Provisioning Tools License: GPL-3.0-only ++++++ thin-provisioning-tools-0.8.3.tar.gz -> thin-provisioning-tools-0.8.5.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/thin-provisioning-tools-0.8.3/VERSION new/thin-provisioning-tools-0.8.5/VERSION --- old/thin-provisioning-tools-0.8.3/VERSION 2019-05-28 10:24:22.000000000 +0200 +++ new/thin-provisioning-tools-0.8.5/VERSION 2019-06-05 12:07:28.000000000 +0200 @@ -1 +1 @@ -0.8.3 +0.8.5 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/thin-provisioning-tools-0.8.3/persistent-data/space-maps/noop.h new/thin-provisioning-tools-0.8.5/persistent-data/space-maps/noop.h --- old/thin-provisioning-tools-0.8.3/persistent-data/space-maps/noop.h 1970-01-01 01:00:00.000000000 +0100 +++ new/thin-provisioning-tools-0.8.5/persistent-data/space-maps/noop.h 2019-06-05 12:07:28.000000000 +0200 @@ -0,0 +1,103 @@ +// Copyright (C) 2019 Red Hat, Inc. All rights reserved. +// +// 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 +// <http://www.gnu.org/licenses/>. + +#ifndef NOOP_MAP_H +#define NOOP_MAP_H + +#include "persistent-data/space_map.h" + +//---------------------------------------------------------------- + +namespace persistent_data { + class noop_map : public checked_space_map { + public: + typedef boost::shared_ptr<noop_map> ptr; + + block_address get_nr_blocks() const { + fail(); + return 0; + } + + block_address get_nr_free() const { + fail(); + return 0; + } + + ref_t get_count(block_address b) const { + fail(); + return 0; + } + + void set_count(block_address b, ref_t c) { + fail(); + } + + void commit() { + fail(); + } + + void inc(block_address b) { + fail(); + } + + void dec(block_address b) { + fail(); + } + + maybe_block find_free(span_iterator &it) { + fail(); + return boost::optional<block_address>(0); + } + + bool count_possibly_greater_than_one(block_address b) const { + fail(); + return false; + } + + void extend(block_address extra_blocks) { + fail(); + } + + void count_metadata(block_counter &bc) const { + fail(); + } + + size_t root_size() const { + fail(); + return 0; + } + + virtual void copy_root(void *dest, size_t len) const { + fail(); + } + + checked_space_map::ptr clone() const { + return ptr(new noop_map()); + } + + private: + void fail() const { + throw std::runtime_error("noop space map used"); + } + }; +} + +//---------------------------------------------------------------- + +#endif + diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/thin-provisioning-tools-0.8.3/thin-provisioning/metadata_dumper.cc new/thin-provisioning-tools-0.8.5/thin-provisioning/metadata_dumper.cc --- old/thin-provisioning-tools-0.8.3/thin-provisioning/metadata_dumper.cc 2019-05-28 10:24:22.000000000 +0200 +++ new/thin-provisioning-tools-0.8.5/thin-provisioning/metadata_dumper.cc 2019-06-05 12:07:28.000000000 +0200 @@ -16,11 +16,12 @@ // with thin-provisioning-tools. If not, see // <http://www.gnu.org/licenses/>. -#include "thin-provisioning/emitter.h" -#include "thin-provisioning/metadata_dumper.h" -#include "thin-provisioning/mapping_tree.h" #include "persistent-data/data-structures/simple_traits.h" #include "persistent-data/file_utils.h" +#include "persistent-data/space-maps/noop.h" +#include "thin-provisioning/emitter.h" +#include "thin-provisioning/mapping_tree.h" +#include "thin-provisioning/metadata_dumper.h" #include <map> #include <vector> @@ -608,14 +609,14 @@ //---------------------------------------------------------------- namespace { - class mapping_emitter : public mapping_tree_detail::mapping_visitor { + class mapping_emit_visitor : public mapping_tree_detail::mapping_visitor { public: - mapping_emitter(emitter::ptr e) + mapping_emit_visitor(emitter::ptr e) : e_(e), in_range_(false) { } - ~mapping_emitter() { + ~mapping_emit_visitor() { end_mapping(); } @@ -667,15 +668,15 @@ bool in_range_; }; - class mapping_tree_emitter : public mapping_tree_detail::device_visitor { + class mapping_tree_emit_visitor : public mapping_tree_detail::device_visitor { public: - mapping_tree_emitter(dump_options const &opts, - metadata::ptr md, - emitter::ptr e, - dd_map const &dd, - mapping_tree_detail::damage_visitor::ptr damage_policy) + mapping_tree_emit_visitor(dump_options const &opts, + transaction_manager &tm, + emitter::ptr e, + dd_map const &dd, + mapping_tree_detail::damage_visitor::ptr damage_policy) : opts_(opts), - md_(md), + tm_(tm), e_(e), dd_(dd), damage_policy_(damage_policy) { @@ -716,26 +717,28 @@ private: void emit_mappings(uint64_t dev_id, block_address subtree_root) { - mapping_emitter me(e_); - single_mapping_tree tree(*md_->tm_, subtree_root, - mapping_tree_detail::block_time_ref_counter(md_->data_sm_)); + mapping_emit_visitor me(e_); + + // Since we're not mutating the btrees we don't need a real space map + noop_map::ptr sm(new noop_map); + single_mapping_tree tree(tm_, subtree_root, mapping_tree_detail::block_time_ref_counter(sm)); walk_mapping_tree(tree, dev_id, static_cast<mapping_tree_detail::mapping_visitor &>(me), *damage_policy_); } dump_options const &opts_; - metadata::ptr md_; + transaction_manager &tm_; emitter::ptr e_; dd_map const &dd_; mapping_tree_detail::damage_visitor::ptr damage_policy_; }; - block_address get_nr_blocks(metadata::ptr md) { - if (md->data_sm_) - return md->data_sm_->get_nr_blocks(); + block_address get_nr_blocks(metadata &md) { + if (md.data_sm_) + return md.data_sm_->get_nr_blocks(); - else if (md->sb_.blocknr_ == superblock_detail::SUPERBLOCK_LOCATION) + else if (md.sb_.blocknr_ == superblock_detail::SUPERBLOCK_LOCATION) // grab from the root structure of the space map - return get_nr_blocks_in_data_sm(*md->tm_, &md->sb_.data_space_map_root_); + return get_nr_blocks_in_data_sm(*md.tm_, &md.sb_.data_space_map_root_); else // metadata snap, we really don't know @@ -743,6 +746,32 @@ } void + do_repair_(block_manager<>::ptr bm, superblock_detail::superblock const &sb, emitter::ptr e) + { + metadata md(bm, sb); + dump_options opts; + details_extractor de(opts); + device_tree_detail::damage_visitor::ptr dd_policy(details_damage_policy(true)); + walk_device_tree(*md.details_, de, *dd_policy); + + e->begin_superblock("", sb.time_, + sb.trans_id_, + sb.flags_, + sb.version_, + sb.data_block_size_, + get_nr_blocks(md), + boost::optional<block_address>()); + + { + mapping_tree_detail::damage_visitor::ptr md_policy(mapping_damage_policy(true)); + mapping_tree_emit_visitor mte(opts, *md.tm_, e, de.get_details(), mapping_damage_policy(true)); + walk_mapping_tree(*md.mappings_top_level_, mte, *md_policy); + } + + e->end_superblock(); + } + + void metadata_repair_(block_manager<>::ptr bm, emitter::ptr e) { // We assume the superblock is wrong, and find the best roots @@ -752,51 +781,16 @@ gatherer g(*bm); auto tm = open_tm(bm, superblock_detail::SUPERBLOCK_LOCATION); auto p = g.find_best_roots(*tm); - - metadata::ptr md; + auto sb = read_superblock(*bm); if (p) { - // We found good roots, so we fill out our own superblock, - // with some help from the old sb. - - // FIXME: what happens if the superblock can't be read? - // catch and fill out defaults? what should the data_block_size be? - auto sb = read_superblock(*bm); - sb.metadata_snap_ = 0; - sb.device_details_root_ = p->first; sb.data_mapping_root_ = p->second; sb.metadata_nr_blocks_ = bm->get_nr_blocks(); - - md.reset(new metadata(bm, sb)); - - } else { - // We couldn't find any good roots, so we'll fall back to using the - // on disk superblock. - md.reset(new metadata(bm, false)); } - dump_options opts; - details_extractor de(opts); - device_tree_detail::damage_visitor::ptr dd_policy(details_damage_policy(true)); - walk_device_tree(*md->details_, de, *dd_policy); - - e->begin_superblock("", md->sb_.time_, - md->sb_.trans_id_, - md->sb_.flags_, - md->sb_.version_, - md->sb_.data_block_size_, - get_nr_blocks(md), - boost::optional<block_address>()); - - { - mapping_tree_detail::damage_visitor::ptr md_policy(mapping_damage_policy(true)); - mapping_tree_emitter mte(opts, md, e, de.get_details(), mapping_damage_policy(true)); - walk_mapping_tree(*md->mappings_top_level_, mte, *md_policy); - } - - e->end_superblock(); + do_repair_(bm, sb, e); } } @@ -814,12 +808,12 @@ md->sb_.flags_, md->sb_.version_, md->sb_.data_block_size_, - get_nr_blocks(md), + get_nr_blocks(*md), boost::optional<block_address>()); { mapping_tree_detail::damage_visitor::ptr md_policy(mapping_damage_policy(false)); - mapping_tree_emitter mte(opts, md, e, de.get_details(), mapping_damage_policy(false)); + mapping_tree_emit_visitor mte(opts, *md->tm_, e, de.get_details(), mapping_damage_policy(false)); walk_mapping_tree(*md->mappings_top_level_, mte, *md_policy); } @@ -834,10 +828,9 @@ if (get_dev_ids(*tm, sb.device_details_root_) && get_map_ids(*tm, sb.data_mapping_root_)) { // The roots in the superblock look ok (perhaps the corruption was in the - // space maps). Just dump the metadata skipping repair. - dump_options opts; - auto md = metadata::ptr(new metadata(bm, false)); - metadata_dump(md, e, opts); + // space maps). + auto sb = read_superblock(bm); + do_repair_(bm, sb, e); } else metadata_repair_(bm, e); } @@ -846,7 +839,7 @@ void thin_provisioning::metadata_dump_subtree(metadata::ptr md, emitter::ptr e, bool repair, uint64_t subtree_root) { - mapping_emitter me(e); + mapping_emit_visitor me(e); single_mapping_tree tree(*md->tm_, subtree_root, mapping_tree_detail::block_time_ref_counter(md->data_sm_)); // FIXME: pass the current device id instead of zero