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 <[email protected]>
+
+- 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
