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 "bluefs_types.h"
   5 #include "common/Formatter.h"
   6 #include "include/uuid.h"
   7 #include "include/stringify.h"
   8
   9 // bluefs_extent_t
  10 void bluefs_extent_t::dump(Formatter *f) const
  11 {
  12   f->dump_unsigned("offset", offset);
  13   f->dump_unsigned("length", length);
  14   f->dump_unsigned("bdev", bdev);
  15 }
  16
  17 void bluefs_extent_t::generate_test_instances(list<bluefs_extent_t*>& ls)
  18 {
  19   ls.push_back(new bluefs_extent_t);
  20   ls.push_back(new bluefs_extent_t);
  21   ls.back()->offset = 1;
  22   ls.back()->length = 2;
  23   ls.back()->bdev = 1;
  24 }
  25
  26 ostream& operator<<(ostream& out, const bluefs_extent_t& e)
  27 {
  28   return out << (int)e.bdev << ":0x" << std::hex << e.offset << "~" << e.length
  29              << std::dec;
  30 }
  31
  32 // bluefs_super_t
  33
  34 void bluefs_super_t::encode(bufferlist& bl) const
  35 {
  36   ENCODE_START(1, 1, bl);
  37   encode(uuid, bl);
  38   encode(osd_uuid, bl);
  39   encode(version, bl);
  40   encode(block_size, bl);
  41   encode(log_fnode, bl);
  42   ENCODE_FINISH(bl);
  43 }
  44
  45 void bluefs_super_t::decode(bufferlist::const_iterator& p)
  46 {
  47   DECODE_START(1, p);
  48   decode(uuid, p);
  49   decode(osd_uuid, p);
  50   decode(version, p);
  51   decode(block_size, p);
  52   decode(log_fnode, p);
  53   DECODE_FINISH(p);
  54 }
  55
  56 void bluefs_super_t::dump(Formatter *f) const
  57 {
  58   f->dump_stream("uuid") << uuid;
  59   f->dump_stream("osd_uuid") << osd_uuid;
  60   f->dump_unsigned("version", version);
  61   f->dump_unsigned("block_size", block_size);
  62   f->dump_object("log_fnode", log_fnode);
  63 }
  64
  65 void bluefs_super_t::generate_test_instances(list<bluefs_super_t*>& ls)
  66 {
  67   ls.push_back(new bluefs_super_t);
  68   ls.push_back(new bluefs_super_t);
  69   ls.back()->version = 1;
  70   ls.back()->block_size = 4096;
  71 }
  72
  73 ostream& operator<<(ostream& out, const bluefs_super_t& s)
  74 {
  75   return out << "super(uuid " << s.uuid
  76              << " osd " << s.osd_uuid
  77              << " v " << s.version
  78              << " block_size 0x" << std::hex << s.block_size
  79              << " log_fnode 0x" << s.log_fnode
  80              << std::dec << ")";
  81 }
  82
  83 // bluefs_fnode_t
  84
  85 mempool::bluefs::vector<bluefs_extent_t>::iterator bluefs_fnode_t::seek(
  86   uint64_t offset, uint64_t *x_off)
  87 {
  88   auto p = extents.begin();
  89   while (p != extents.end()) {
  90     if ((int64_t) offset >= p->length) {
  91       offset -= p->length;
  92       ++p;
  93     } else {
  94       break;
  95     }
  96   }
  97   *x_off = offset;
  98   return p;
  99 }
 100
 101 void bluefs_fnode_t::dump(Formatter *f) const
 102 {
 103   f->dump_unsigned("ino", ino);
 104   f->dump_unsigned("size", size);
 105   f->dump_stream("mtime") << mtime;
 106   f->dump_unsigned("prefer_bdev", prefer_bdev);
 107   f->open_array_section("extents");
 108   for (auto& p : extents)
 109     f->dump_object("extent", p);
 110   f->close_section();
 111 }
 112
 113 void bluefs_fnode_t::generate_test_instances(list<bluefs_fnode_t*>& ls)
 114 {
 115   ls.push_back(new bluefs_fnode_t);
 116   ls.push_back(new bluefs_fnode_t);
 117   ls.back()->ino = 123;
 118   ls.back()->size = 1048576;
 119   ls.back()->mtime = utime_t(123,45);
 120   ls.back()->extents.push_back(bluefs_extent_t(0, 1048576, 4096));
 121   ls.back()->prefer_bdev = 1;
 122 }
 123
 124 ostream& operator<<(ostream& out, const bluefs_fnode_t& file)
 125 {
 126   return out << "file(ino " << file.ino
 127              << " size 0x" << std::hex << file.size << std::dec
 128              << " mtime " << file.mtime
 129              << " bdev " << (int)file.prefer_bdev
 130              << " allocated " << std::hex << file.allocated << std::dec
 131              << " extents " << file.extents
 132              << ")";
 133 }
 134
 135
 136 // bluefs_transaction_t
 137
 138 void bluefs_transaction_t::encode(bufferlist& bl) const
 139 {
 140   uint32_t crc = op_bl.crc32c(-1);
 141   ENCODE_START(1, 1, bl);
 142   encode(uuid, bl);
 143   encode(seq, bl);
 144   // not using bufferlist encode method, as it merely copies the bufferptr and not
 145   // contents, meaning we're left with fragmented target bl
 146   __u32 len = op_bl.length();
 147   encode(len, bl);
 148   for (auto& it : op_bl.buffers()) {
 149     bl.append(it.c_str(),  it.length());
 150   }
 151   encode(crc, bl);
 152   ENCODE_FINISH(bl);
 153 }
 154
 155 void bluefs_transaction_t::decode(bufferlist::const_iterator& p)
 156 {
 157   uint32_t crc;
 158   DECODE_START(1, p);
 159   decode(uuid, p);
 160   decode(seq, p);
 161   decode(op_bl, p);
 162   decode(crc, p);
 163   DECODE_FINISH(p);
 164   uint32_t actual = op_bl.crc32c(-1);
 165   if (actual != crc)
 166     throw buffer::malformed_input("bad crc " + stringify(actual)
 167                                   + " expected " + stringify(crc));
 168 }
 169
 170 void bluefs_transaction_t::dump(Formatter *f) const
 171 {
 172   f->dump_stream("uuid") << uuid;
 173   f->dump_unsigned("seq", seq);
 174   f->dump_unsigned("op_bl_length", op_bl.length());
 175   f->dump_unsigned("crc", op_bl.crc32c(-1));
 176 }
 177
 178 void bluefs_transaction_t::generate_test_instances(
 179   list<bluefs_transaction_t*>& ls)
 180 {
 181   ls.push_back(new bluefs_transaction_t);
 182   ls.push_back(new bluefs_transaction_t);
 183   ls.back()->op_init();
 184   ls.back()->op_alloc_add(0, 0, 123123211);
 185   ls.back()->op_alloc_rm(1, 0, 123);
 186   ls.back()->op_dir_create("dir");
 187   ls.back()->op_dir_create("dir2");
 188   bluefs_fnode_t fnode;
 189   fnode.ino = 2;
 190   ls.back()->op_file_update(fnode);
 191   ls.back()->op_dir_link("dir", "file1", 2);
 192   ls.back()->op_dir_unlink("dir", "file1");
 193   ls.back()->op_file_remove(2);
 194   ls.back()->op_dir_remove("dir2");
 195 }
 196
 197 ostream& operator<<(ostream& out, const bluefs_transaction_t& t)
 198 {
 199   return out << "txn(seq " << t.seq
 200              << " len 0x" << std::hex << t.op_bl.length()
 201              << " crc 0x" << t.op_bl.crc32c(-1)
 202              << std::dec << ")";
 203 }