[ceph.git] / ceph / src / os / bluestore / bluefs_types.cc

// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab

#include <algorithm>
#include "bluefs_types.h"
#include "common/Formatter.h"
#include "include/uuid.h"
#include "include/stringify.h"

using std::list;
using std::ostream;

using ceph::bufferlist;
using ceph::Formatter;

// bluefs_extent_t
void bluefs_extent_t::dump(Formatter *f) const
{
  f->dump_unsigned("offset", offset);
  f->dump_unsigned("length", length);
  f->dump_unsigned("bdev", bdev);
}

void bluefs_extent_t::generate_test_instances(list<bluefs_extent_t*>& ls)
{
  ls.push_back(new bluefs_extent_t);
  ls.push_back(new bluefs_extent_t);
  ls.back()->offset = 1;
  ls.back()->length = 2;
  ls.back()->bdev = 1;
}

ostream& operator<<(ostream& out, const bluefs_extent_t& e)
{
  return out << (int)e.bdev << ":0x" << std::hex << e.offset << "~" << e.length
	     << std::dec;
}

// bluefs_layout_t

void bluefs_layout_t::encode(bufferlist& bl) const
{
  ENCODE_START(1, 1, bl);
  encode(shared_bdev, bl);
  encode(dedicated_db, bl);
  encode(dedicated_wal, bl);
  ENCODE_FINISH(bl);
}

void bluefs_layout_t::decode(bufferlist::const_iterator& p)
{
  DECODE_START(1, p);
  decode(shared_bdev, p);
  decode(dedicated_db, p);
  decode(dedicated_wal, p);
  DECODE_FINISH(p);
}

void bluefs_layout_t::dump(Formatter *f) const
{
  f->dump_stream("shared_bdev") << shared_bdev;
  f->dump_stream("dedicated_db") << dedicated_db;
  f->dump_stream("dedicated_wal") << dedicated_wal;
}

// bluefs_super_t

void bluefs_super_t::encode(bufferlist& bl) const
{
  ENCODE_START(2, 1, bl);
  encode(uuid, bl);
  encode(osd_uuid, bl);
  encode(version, bl);
  encode(block_size, bl);
  encode(log_fnode, bl);
  encode(memorized_layout, bl);
  ENCODE_FINISH(bl);
}

void bluefs_super_t::decode(bufferlist::const_iterator& p)
{
  DECODE_START(2, p);
  decode(uuid, p);
  decode(osd_uuid, p);
  decode(version, p);
  decode(block_size, p);
  decode(log_fnode, p);
  if (struct_v >= 2) {
    decode(memorized_layout, p);
  }
  DECODE_FINISH(p);
}

void bluefs_super_t::dump(Formatter *f) const
{
  f->dump_stream("uuid") << uuid;
  f->dump_stream("osd_uuid") << osd_uuid;
  f->dump_unsigned("version", version);
  f->dump_unsigned("block_size", block_size);
  f->dump_object("log_fnode", log_fnode);
}

void bluefs_super_t::generate_test_instances(list<bluefs_super_t*>& ls)
{
  ls.push_back(new bluefs_super_t);
  ls.push_back(new bluefs_super_t);
  ls.back()->version = 1;
  ls.back()->block_size = 4096;
}

ostream& operator<<(ostream& out, const bluefs_super_t& s)
{
  return out << "super(uuid " << s.uuid
	     << " osd " << s.osd_uuid
	     << " v " << s.version
	     << " block_size 0x" << std::hex << s.block_size
	     << " log_fnode 0x" << s.log_fnode
	     << std::dec << ")";
}

// bluefs_fnode_t

mempool::bluefs::vector<bluefs_extent_t>::iterator bluefs_fnode_t::seek(
  uint64_t offset, uint64_t *x_off)
{
  auto p = extents.begin();

  if (extents_index.size() > 4) {
    auto it = std::upper_bound(extents_index.begin(), extents_index.end(),
      offset);
    assert(it != extents_index.begin());
    --it;
    assert(offset >= *it);
    p += it - extents_index.begin();
    offset -= *it;
  }

  while (p != extents.end()) {
    if ((int64_t) offset >= p->length) {
      offset -= p->length;
      ++p;
    } else {
      break;
    }
  }
  *x_off = offset;
  return p;
}

bluefs_fnode_delta_t* bluefs_fnode_t::make_delta(bluefs_fnode_delta_t* delta) {
  ceph_assert(delta);
  delta->ino = ino;
  delta->size = size;
  delta->mtime = mtime;
  delta->offset = allocated_commited;
  delta->extents.clear();
  if (allocated_commited < allocated) {
    uint64_t x_off = 0;
    auto p = seek(allocated_commited, &x_off);
    ceph_assert(p != extents.end());
    if (x_off > 0) {
      ceph_assert(x_off < p->length);
      delta->extents.emplace_back(p->bdev, p->offset + x_off, p->length - x_off);
      ++p;
    }
    while (p != extents.end()) {
      delta->extents.push_back(*p);
      ++p;
    }
    reset_delta();
  }
  return delta;
}

void bluefs_fnode_t::dump(Formatter *f) const
{
  f->dump_unsigned("ino", ino);
  f->dump_unsigned("size", size);
  f->dump_stream("mtime") << mtime;
  f->open_array_section("extents");
  for (auto& p : extents)
    f->dump_object("extent", p);
  f->close_section();
}

void bluefs_fnode_t::generate_test_instances(list<bluefs_fnode_t*>& ls)
{
  ls.push_back(new bluefs_fnode_t);
  ls.push_back(new bluefs_fnode_t);
  ls.back()->ino = 123;
  ls.back()->size = 1048576;
  ls.back()->mtime = utime_t(123,45);
  ls.back()->extents.push_back(bluefs_extent_t(0, 1048576, 4096));
  ls.back()->__unused__ = 1;
}

ostream& operator<<(ostream& out, const bluefs_fnode_t& file)
{
  return out << "file(ino " << file.ino
	     << " size 0x" << std::hex << file.size << std::dec
	     << " mtime " << file.mtime
	     << " allocated " << std::hex << file.allocated << std::dec
	     << " alloc_commit " << std::hex << file.allocated_commited << std::dec
	     << " extents " << file.extents
	     << ")";
}

// bluefs_fnode_delta_t

std::ostream& operator<<(std::ostream& out, const bluefs_fnode_delta_t& delta)
{
  return out << "delta(ino " << delta.ino
	     << " size 0x" << std::hex << delta.size << std::dec
	     << " mtime " << delta.mtime
	     << " offset " << std::hex << delta.offset << std::dec
	     << " extents " << delta.extents
	     << ")";
}

// bluefs_transaction_t

void bluefs_transaction_t::encode(bufferlist& bl) const
{
  uint32_t crc = op_bl.crc32c(-1);
  ENCODE_START(1, 1, bl);
  encode(uuid, bl);
  encode(seq, bl);
  // not using bufferlist encode method, as it merely copies the bufferptr and not
  // contents, meaning we're left with fragmented target bl
  __u32 len = op_bl.length();
  encode(len, bl);
  for (auto& it : op_bl.buffers()) {
    bl.append(it.c_str(),  it.length());
  }
  encode(crc, bl);
  ENCODE_FINISH(bl);
}

void bluefs_transaction_t::decode(bufferlist::const_iterator& p)
{
  uint32_t crc;
  DECODE_START(1, p);
  decode(uuid, p);
  decode(seq, p);
  decode(op_bl, p);
  decode(crc, p);
  DECODE_FINISH(p);
  uint32_t actual = op_bl.crc32c(-1);
  if (actual != crc)
    throw ceph::buffer::malformed_input("bad crc " + stringify(actual)
				  + " expected " + stringify(crc));
}

void bluefs_transaction_t::dump(Formatter *f) const
{
  f->dump_stream("uuid") << uuid;
  f->dump_unsigned("seq", seq);
  f->dump_unsigned("op_bl_length", op_bl.length());
  f->dump_unsigned("crc", op_bl.crc32c(-1));
}

void bluefs_transaction_t::generate_test_instances(
  list<bluefs_transaction_t*>& ls)
{
  ls.push_back(new bluefs_transaction_t);
  ls.push_back(new bluefs_transaction_t);
  ls.back()->op_init();
  ls.back()->op_dir_create("dir");
  ls.back()->op_dir_create("dir2");
  bluefs_fnode_t fnode;
  fnode.ino = 2;
  ls.back()->op_file_update(fnode);
  ls.back()->op_dir_link("dir", "file1", 2);
  ls.back()->op_dir_unlink("dir", "file1");
  ls.back()->op_file_remove(2);
  ls.back()->op_dir_remove("dir2");
}

ostream& operator<<(ostream& out, const bluefs_transaction_t& t)
{
  return out << "txn(seq " << t.seq
	     << " len 0x" << std::hex << t.op_bl.length()
	     << " crc 0x" << t.op_bl.crc32c(-1)
	     << std::dec << ")";
}
Commit	Line	Data
7c673cae FG	1	// -- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t --
	2	// vim: ts=8 sw=2 smarttab
	3
494da23a	4	#include <algorithm>
7c673cae FG	5	#include "bluefs_types.h"
	6	#include "common/Formatter.h"
	7	#include "include/uuid.h"
	8	#include "include/stringify.h"
	9
f67539c2 TL	10	using std::list;
	11	using std::ostream;
	12
	13	using ceph::bufferlist;
	14	using ceph::Formatter;
	15
7c673cae FG	16	// bluefs_extent_t
	17	void bluefs_extent_t::dump(Formatter *f) const
	18	{
	19	f->dump_unsigned("offset", offset);
	20	f->dump_unsigned("length", length);
	21	f->dump_unsigned("bdev", bdev);
	22	}
	23
	24	void bluefs_extent_t::generate_test_instances(list<bluefs_extent_t*>& ls)
	25	{
	26	ls.push_back(new bluefs_extent_t);
	27	ls.push_back(new bluefs_extent_t);
	28	ls.back()->offset = 1;
	29	ls.back()->length = 2;
	30	ls.back()->bdev = 1;
	31	}
	32
31f18b77	33	ostream& operator<<(ostream& out, const bluefs_extent_t& e)
7c673cae	34	{
11fdf7f2	35	return out << (int)e.bdev << ":0x" << std::hex << e.offset << "~" << e.length
7c673cae FG	36	<< std::dec;
	37	}
	38
9f95a23c TL	39	// bluefs_layout_t
	40
	41	void bluefs_layout_t::encode(bufferlist& bl) const
	42	{
	43	ENCODE_START(1, 1, bl);
	44	encode(shared_bdev, bl);
	45	encode(dedicated_db, bl);
	46	encode(dedicated_wal, bl);
	47	ENCODE_FINISH(bl);
	48	}
	49
	50	void bluefs_layout_t::decode(bufferlist::const_iterator& p)
	51	{
	52	DECODE_START(1, p);
	53	decode(shared_bdev, p);
	54	decode(dedicated_db, p);
	55	decode(dedicated_wal, p);
	56	DECODE_FINISH(p);
	57	}
	58
	59	void bluefs_layout_t::dump(Formatter *f) const
	60	{
	61	f->dump_stream("shared_bdev") << shared_bdev;
	62	f->dump_stream("dedicated_db") << dedicated_db;
	63	f->dump_stream("dedicated_wal") << dedicated_wal;
	64	}
	65
7c673cae FG	66	// bluefs_super_t
	67
	68	void bluefs_super_t::encode(bufferlist& bl) const
	69	{
9f95a23c	70	ENCODE_START(2, 1, bl);
11fdf7f2 TL	71	encode(uuid, bl);
	72	encode(osd_uuid, bl);
	73	encode(version, bl);
	74	encode(block_size, bl);
	75	encode(log_fnode, bl);
9f95a23c	76	encode(memorized_layout, bl);
7c673cae FG	77	ENCODE_FINISH(bl);
	78	}
	79
11fdf7f2	80	void bluefs_super_t::decode(bufferlist::const_iterator& p)
7c673cae	81	{
9f95a23c	82	DECODE_START(2, p);
11fdf7f2 TL	83	decode(uuid, p);
	84	decode(osd_uuid, p);
	85	decode(version, p);
	86	decode(block_size, p);
	87	decode(log_fnode, p);
9f95a23c TL	88	if (struct_v >= 2) {
	89	decode(memorized_layout, p);
	90	}
7c673cae FG	91	DECODE_FINISH(p);
	92	}
	93
	94	void bluefs_super_t::dump(Formatter *f) const
	95	{
	96	f->dump_stream("uuid") << uuid;
	97	f->dump_stream("osd_uuid") << osd_uuid;
	98	f->dump_unsigned("version", version);
	99	f->dump_unsigned("block_size", block_size);
	100	f->dump_object("log_fnode", log_fnode);
	101	}
	102
	103	void bluefs_super_t::generate_test_instances(list<bluefs_super_t*>& ls)
	104	{
	105	ls.push_back(new bluefs_super_t);
	106	ls.push_back(new bluefs_super_t);
	107	ls.back()->version = 1;
	108	ls.back()->block_size = 4096;
	109	}
	110
	111	ostream& operator<<(ostream& out, const bluefs_super_t& s)
	112	{
	113	return out << "super(uuid " << s.uuid
	114	<< " osd " << s.osd_uuid
	115	<< " v " << s.version
	116	<< " block_size 0x" << std::hex << s.block_size
	117	<< " log_fnode 0x" << s.log_fnode
	118	<< std::dec << ")";
	119	}
	120
	121	// bluefs_fnode_t
	122
	123	mempool::bluefs::vector<bluefs_extent_t>::iterator bluefs_fnode_t::seek(
	124	uint64_t offset, uint64_t *x_off)
	125	{
	126	auto p = extents.begin();
494da23a TL	127
	128	if (extents_index.size() > 4) {
	129	auto it = std::upper_bound(extents_index.begin(), extents_index.end(),
	130	offset);
	131	assert(it != extents_index.begin());
	132	--it;
	133	assert(offset >= *it);
	134	p += it - extents_index.begin();
	135	offset -= *it;
	136	}
	137
7c673cae FG	138	while (p != extents.end()) {
	139	if ((int64_t) offset >= p->length) {
	140	offset -= p->length;
	141	++p;
	142	} else {
	143	break;
	144	}
	145	}
	146	*x_off = offset;
	147	return p;
	148	}
	149
20effc67 TL	150	bluefs_fnode_delta_t* bluefs_fnode_t::make_delta(bluefs_fnode_delta_t* delta) {
	151	ceph_assert(delta);
	152	delta->ino = ino;
	153	delta->size = size;
	154	delta->mtime = mtime;
	155	delta->offset = allocated_commited;
	156	delta->extents.clear();
	157	if (allocated_commited < allocated) {
	158	uint64_t x_off = 0;
	159	auto p = seek(allocated_commited, &x_off);
	160	ceph_assert(p != extents.end());
	161	if (x_off > 0) {
	162	ceph_assert(x_off < p->length);
	163	delta->extents.emplace_back(p->bdev, p->offset + x_off, p->length - x_off);
	164	++p;
	165	}
	166	while (p != extents.end()) {
	167	delta->extents.push_back(*p);
	168	++p;
	169	}
	170	reset_delta();
	171	}
	172	return delta;
	173	}
	174
7c673cae FG	175	void bluefs_fnode_t::dump(Formatter *f) const
	176	{
	177	f->dump_unsigned("ino", ino);
	178	f->dump_unsigned("size", size);
	179	f->dump_stream("mtime") << mtime;
7c673cae FG	180	f->open_array_section("extents");
	181	for (auto& p : extents)
	182	f->dump_object("extent", p);
	183	f->close_section();
	184	}
	185
	186	void bluefs_fnode_t::generate_test_instances(list<bluefs_fnode_t*>& ls)
	187	{
	188	ls.push_back(new bluefs_fnode_t);
	189	ls.push_back(new bluefs_fnode_t);
	190	ls.back()->ino = 123;
	191	ls.back()->size = 1048576;
	192	ls.back()->mtime = utime_t(123,45);
	193	ls.back()->extents.push_back(bluefs_extent_t(0, 1048576, 4096));
9f95a23c	194	ls.back()->__unused__ = 1;
7c673cae FG	195	}
	196
	197	ostream& operator<<(ostream& out, const bluefs_fnode_t& file)
	198	{
	199	return out << "file(ino " << file.ino
	200	<< " size 0x" << std::hex << file.size << std::dec
	201	<< " mtime " << file.mtime
94b18763	202	<< " allocated " << std::hex << file.allocated << std::dec
20effc67	203	<< " alloc_commit " << std::hex << file.allocated_commited << std::dec
7c673cae FG	204	<< " extents " << file.extents
	205	<< ")";
	206	}
	207
20effc67 TL	208	// bluefs_fnode_delta_t
	209
	210	std::ostream& operator<<(std::ostream& out, const bluefs_fnode_delta_t& delta)
	211	{
	212	return out << "delta(ino " << delta.ino
	213	<< " size 0x" << std::hex << delta.size << std::dec
	214	<< " mtime " << delta.mtime
	215	<< " offset " << std::hex << delta.offset << std::dec
	216	<< " extents " << delta.extents
	217	<< ")";
	218	}
7c673cae FG	219
	220	// bluefs_transaction_t
	221
	222	void bluefs_transaction_t::encode(bufferlist& bl) const
	223	{
	224	uint32_t crc = op_bl.crc32c(-1);
	225	ENCODE_START(1, 1, bl);
11fdf7f2 TL	226	encode(uuid, bl);
	227	encode(seq, bl);
	228	// not using bufferlist encode method, as it merely copies the bufferptr and not
	229	// contents, meaning we're left with fragmented target bl
	230	__u32 len = op_bl.length();
	231	encode(len, bl);
	232	for (auto& it : op_bl.buffers()) {
	233	bl.append(it.c_str(), it.length());
	234	}
	235	encode(crc, bl);
7c673cae FG	236	ENCODE_FINISH(bl);
	237	}
	238
11fdf7f2	239	void bluefs_transaction_t::decode(bufferlist::const_iterator& p)
7c673cae FG	240	{
	241	uint32_t crc;
	242	DECODE_START(1, p);
11fdf7f2 TL	243	decode(uuid, p);
	244	decode(seq, p);
	245	decode(op_bl, p);
	246	decode(crc, p);
7c673cae FG	247	DECODE_FINISH(p);
	248	uint32_t actual = op_bl.crc32c(-1);
	249	if (actual != crc)
f67539c2	250	throw ceph::buffer::malformed_input("bad crc " + stringify(actual)
7c673cae FG	251	+ " expected " + stringify(crc));
	252	}
	253
	254	void bluefs_transaction_t::dump(Formatter *f) const
	255	{
	256	f->dump_stream("uuid") << uuid;
	257	f->dump_unsigned("seq", seq);
	258	f->dump_unsigned("op_bl_length", op_bl.length());
	259	f->dump_unsigned("crc", op_bl.crc32c(-1));
	260	}
	261
11fdf7f2	262	void bluefs_transaction_t::generate_test_instances(
7c673cae FG	263	list<bluefs_transaction_t*>& ls)
	264	{
	265	ls.push_back(new bluefs_transaction_t);
	266	ls.push_back(new bluefs_transaction_t);
	267	ls.back()->op_init();
7c673cae FG	268	ls.back()->op_dir_create("dir");
	269	ls.back()->op_dir_create("dir2");
	270	bluefs_fnode_t fnode;
	271	fnode.ino = 2;
	272	ls.back()->op_file_update(fnode);
	273	ls.back()->op_dir_link("dir", "file1", 2);
	274	ls.back()->op_dir_unlink("dir", "file1");
	275	ls.back()->op_file_remove(2);
	276	ls.back()->op_dir_remove("dir2");
	277	}
	278
	279	ostream& operator<<(ostream& out, const bluefs_transaction_t& t)
	280	{
	281	return out << "txn(seq " << t.seq
	282	<< " len 0x" << std::hex << t.op_bl.length()
	283	<< " crc 0x" << t.op_bl.crc32c(-1)
	284	<< std::dec << ")";
	285	}