[thin_journal_check] first code drop

thin-provisioning/thin_journal.h

@@ -0,0 +1,203 @@
+// Copyright (C) 2018 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 THIN_PROVISIONING_THIN_JOURNAL_H
+#define THIN_PROVISIONING_THIN_JOURNAL_H
+
+#include "persistent-data/block.h"
+
+#include <vector>
+
+//----------------------------------------------------------------
+
+namespace thin_provisioning {
+	uint32_t const JOURNAL_BLOCK_SIZE = 256 * 1024;
+	uint32_t const JOURNAL_NR_CHUNKS = 32;
+	uint32_t const JOURNAL_CHUNK_SIZE = 4096 / JOURNAL_NR_CHUNKS;
+
+	class byte_stream {
+	public:
+		byte_stream(persistent_data::block_manager<JOURNAL_BLOCK_SIZE>::ptr bm);
+
+		void read_bytes(uint8_t *b, uint8_t *e);
+
+	private:
+		void next_block_();
+		size_t read_some_(uint8_t *b, uint8_t *e);
+
+		persistent_data::block_manager<JOURNAL_BLOCK_SIZE>::ptr bm_;
+
+		uint64_t current_block_;
+		uint64_t cursor_;
+	};
+
+	//---------------------------------
+
+	class journal_visitor;
+
+	struct journal_msg {
+		journal_msg(bool success);
+
+		virtual ~journal_msg() {}
+		virtual void visit(journal_visitor &v) const = 0;
+
+		bool success_;
+	};
+
+	struct block_msg : public journal_msg {
+		block_msg(bool success, uint64_t index);
+		uint64_t index_;
+	};
+
+	struct read_lock_msg : public block_msg {
+		read_lock_msg(bool success, uint64_t index);
+		virtual void visit(journal_visitor &v) const;
+	};
+
+	struct write_lock_msg : public block_msg {
+		write_lock_msg(bool success, uint64_t index);
+		virtual void visit(journal_visitor &v) const;
+	};
+
+	struct zero_lock_msg : public block_msg {
+		zero_lock_msg(bool success, uint64_t index);
+		virtual void visit(journal_visitor &v) const;
+	};
+
+	struct try_read_lock_msg : public block_msg {
+		try_read_lock_msg(bool success, uint64_t index);
+		virtual void visit(journal_visitor &v) const;
+	};
+
+	struct delta {
+		delta(uint32_t offset, std::vector<uint8_t> &bytes)
+			: offset_(offset),
+			  bytes_(bytes) {
+		}
+
+		uint32_t offset_;
+		std::vector<uint8_t> bytes_;
+	};
+
+	using delta_list = std::vector<delta>;
+
+	struct unlock_msg : public block_msg {
+		unlock_msg(bool success, uint64_t index, delta_list const &deltas);
+		virtual void visit(journal_visitor &v) const;
+
+		delta_list deltas_;
+	};
+
+	struct verify_msg : public block_msg {
+		verify_msg(bool success, uint64_t index);
+		virtual void visit(journal_visitor &v) const;
+	};
+
+	struct prepare_msg : public block_msg {
+		prepare_msg(bool success, uint64_t index);
+		virtual void visit(journal_visitor &v) const;
+	};
+
+	struct flush_msg : public journal_msg {
+		flush_msg(bool success);
+		virtual void visit(journal_visitor &v) const;
+	};
+
+	struct flush_and_unlock_msg : public block_msg {
+		flush_and_unlock_msg(bool success, uint64_t index, delta_list const &deltas);
+		virtual void visit(journal_visitor &v) const;
+
+		delta_list deltas_;
+	};
+
+	struct prefetch_msg : public block_msg {
+		prefetch_msg(bool success, uint64_t index);
+		virtual void visit(journal_visitor &v) const;
+	};
+
+	struct set_read_only_msg : public journal_msg {
+		set_read_only_msg();
+		virtual void visit(journal_visitor &v) const;
+	};
+
+	struct set_read_write_msg : public journal_msg {
+		set_read_write_msg();
+		virtual void visit(journal_visitor &v) const;
+	};
+
+	struct journal_visitor {
+	public:
+		virtual ~journal_visitor() {};
+
+		void visit(journal_msg const &msg) {
+			msg.visit(*this);
+		}
+
+		virtual void visit(read_lock_msg const &msg) = 0;
+		virtual void visit(write_lock_msg const &msg) = 0;
+		virtual void visit(zero_lock_msg const &msg) = 0;
+		virtual void visit(try_read_lock_msg const &msg) = 0;
+		virtual void visit(unlock_msg const &msg) = 0;
+		virtual void visit(verify_msg const &msg) = 0;
+		virtual void visit(prepare_msg const &msg) = 0;
+		virtual void visit(flush_msg const &msg) = 0;
+		virtual void visit(flush_and_unlock_msg const &msg) = 0;
+		virtual void visit(prefetch_msg const &msg) = 0;
+		virtual void visit(set_read_only_msg const &msg) = 0;
+		virtual void visit(set_read_write_msg const &msg) = 0;
+	};
+
+	enum msg_type {
+		MT_READ_LOCK = 0,
+		MT_WRITE_LOCK,
+		MT_ZERO_LOCK,
+		MT_TRY_READ_LOCK,
+		MT_UNLOCK,
+		MT_VERIFY,
+		MT_PREPARE,
+		MT_FLUSH,
+		MT_FLUSH_AND_UNLOCK,
+		MT_PREFETCH,
+		MT_SET_READ_ONLY,
+		MT_SET_READ_WRITE,
+		MT_END_OF_JOURNAL,
+	};
+
+	class journal {
+	public:
+		journal(persistent_data::block_manager<JOURNAL_BLOCK_SIZE>::ptr bm);
+		void read_journal(struct journal_visitor &v);
+
+	private:
+		bool read_delta_(delta_list &ds);
+		delta_list read_deltas_();
+		bool read_one_(struct journal_visitor &v);
+
+		template <typename T> T read_() {
+			T r;
+			in_.read_bytes(reinterpret_cast<uint8_t *>(&r), reinterpret_cast<uint8_t *>(&r + 1));
+			return r;
+		}
+
+		byte_stream in_;
+	};
+}
+
+//----------------------------------------------------------------
+
+#endif