ceph/src/os/bluestore/bluefs_types.cc

   1 // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
   2 // vim: ts=8 sw=2 smarttab
   3
   4 #include <algorithm>
   5 #include "bluefs_types.h"
   6 #include "common/Formatter.h"
   7 #include "include/uuid.h"
   8 #include "include/stringify.h"
   9
  10 using std::list;
  11 using std::ostream;
  12
  13 using ceph::bufferlist;
  14 using ceph::Formatter;
  15
  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
  33 ostream& operator<<(ostream& out, const bluefs_extent_t& e)
  34 {
  35   return out << (int)e.bdev << ":0x" << std::hex << e.offset << "~" << e.length
  36              << std::dec;
  37 }
  38
  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
  66 // bluefs_super_t
  67
  68 void bluefs_super_t::encode(bufferlist& bl) const
  69 {
  70   ENCODE_START(2, 1, bl);
  71   encode(uuid, bl);
  72   encode(osd_uuid, bl);
  73   encode(version, bl);
  74   encode(block_size, bl);
  75   encode(log_fnode, bl);
  76   encode(memorized_layout, bl);
  77   ENCODE_FINISH(bl);
  78 }
  79
  80 void bluefs_super_t::decode(bufferlist::const_iterator& p)
  81 {
  82   DECODE_START(2, p);
  83   decode(uuid, p);
  84   decode(osd_uuid, p);
  85   decode(version, p);
  86   decode(block_size, p);
  87   decode(log_fnode, p);
  88   if (struct_v >= 2) {
  89     decode(memorized_layout, p);
  90   }
  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();
 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
 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
 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
 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;
 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));
 194   ls.back()->__unused__ = 1;
 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
 202              << " allocated " << std::hex << file.allocated << std::dec
 203              << " alloc_commit " << std::hex << file.allocated_commited << std::dec
 204              << " extents " << file.extents
 205              << ")";
 206 }
 207
 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 }
 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);
 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);
 236   ENCODE_FINISH(bl);
 237 }
 238
 239 void bluefs_transaction_t::decode(bufferlist::const_iterator& p)
 240 {
 241   uint32_t crc;
 242   DECODE_START(1, p);
 243   decode(uuid, p);
 244   decode(seq, p);
 245   decode(op_bl, p);
 246   decode(crc, p);
 247   DECODE_FINISH(p);
 248   uint32_t actual = op_bl.crc32c(-1);
 249   if (actual != crc)
 250     throw ceph::buffer::malformed_input("bad crc " + stringify(actual)
 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
 262 void bluefs_transaction_t::generate_test_instances(
 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();
 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 }