ceph/src/crimson/os/seastore/onode_manager/simple-fltree/onode_delta.cc

   1 // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:nil -*-
   2 // vim: ts=8 sw=2 smarttab
   3
   4 #include "onode_delta.h"
   5
   6 delta_t::delta_t(delta_t&& delta)
   7 {
   8   assert(op == op_t::nop);
   9   op = delta.op;
  10   n = delta.n;
  11   oid = std::move(delta.oid);
  12   onode = std::move(delta.onode);
  13   keys = std::move(delta.keys);
  14   cells = std::move(delta.cells);
  15   delta.op = op_t::nop;
  16 }
  17
  18 delta_t& delta_t::operator=(delta_t&& delta)
  19 {
  20   assert(op == op_t::nop);
  21   op = delta.op;
  22   n = delta.n;
  23   oid = std::move(delta.oid);
  24   onode = std::move(delta.onode);
  25   keys = std::move(delta.keys);
  26   cells = std::move(delta.cells);
  27   delta.op = op_t::nop;
  28   return *this;
  29 }
  30
  31 delta_t delta_t::nop()
  32 {
  33   return delta_t{op_t::nop};
  34 }
  35
  36 delta_t delta_t::insert_onode(unsigned slot, const ghobject_t& oid, OnodeRef onode)
  37 {
  38   delta_t delta{op_t::insert_onode};
  39   delta.n = slot;
  40   delta.oid = oid;
  41   delta.onode = onode;
  42   return delta;
  43 }
  44
  45 delta_t delta_t::update_onode(unsigned slot, const ghobject_t& oid, OnodeRef onode)
  46 {
  47   delta_t delta{op_t::update_onode};
  48   delta.n = slot;
  49   delta.oid = oid;
  50   delta.onode = onode;
  51   return delta;
  52 }
  53
  54 delta_t delta_t::insert_child(unsigned slot,
  55                               const ghobject_t& oid,
  56                               crimson::os::seastore::laddr_t addr)
  57 {
  58   delta_t delta{op_t::insert_child};
  59   delta.n = slot;
  60   delta.oid = oid;
  61   delta.addr = addr;
  62   return delta;
  63 }
  64
  65 delta_t delta_t::update_key(unsigned slot, const ghobject_t& oid)
  66 {
  67   delta_t delta{op_t::update_key};
  68   delta.n = slot;
  69   delta.oid = oid;
  70   return delta;
  71 }
  72
  73 delta_t delta_t::shift_left(unsigned n)
  74 {
  75   delta_t delta{op_t::shift_left};
  76   delta.n = n;
  77   return delta;
  78 }
  79
  80 delta_t delta_t::trim_right(unsigned n)
  81 {
  82   delta_t delta{op_t::trim_right};
  83   delta.n = n;
  84   return delta;
  85 }
  86
  87 delta_t delta_t::insert_front(ceph::buffer::ptr keys,
  88                               ceph::buffer::ptr cells)
  89 {
  90   delta_t delta{op_t::insert_front};
  91   delta.keys = std::move(keys);
  92   delta.cells = std::move(cells);
  93   return delta;
  94 }
  95
  96 delta_t delta_t::insert_back(ceph::buffer::ptr keys,
  97                              ceph::buffer::ptr cells)
  98 {
  99   delta_t delta{op_t::insert_back};
 100   delta.keys = std::move(keys);
 101   delta.cells = std::move(cells);
 102   return delta;
 103 }
 104
 105 delta_t delta_t::remove_from(unsigned slot)
 106 {
 107   delta_t delta{op_t::remove_from};
 108   delta.n = slot;
 109   return delta;
 110 }
 111
 112 void delta_t::encode(ceph::bufferlist& bl)
 113 {
 114   using ceph::encode;
 115   switch (op) {
 116   case op_t::insert_onode:
 117     [[fallthrough]];
 118   case op_t::update_onode:
 119     // the slot # is not encoded, because we can alway figure it out
 120     // when we have to replay the delta by looking the oid up in the
 121     // node block
 122     encode(oid, bl);
 123     encode(*onode, bl);
 124     break;
 125   case op_t::insert_child:
 126     encode(oid, bl);
 127     encode(addr, bl);
 128   case op_t::update_key:
 129     encode(n, bl);
 130     encode(oid, bl);
 131     break;
 132   case op_t::shift_left:
 133     encode(n, bl);
 134     break;
 135   case op_t::trim_right:
 136     encode(n, bl);
 137     break;
 138   case op_t::insert_front:
 139     [[fallthrough]];
 140   case op_t::insert_back:
 141     encode(n, bl);
 142     encode(keys, bl);
 143     encode(cells, bl);
 144     break;
 145   case op_t::remove_from:
 146     encode(n, bl);
 147     break;
 148   default:
 149     assert(0 == "unknown onode op");
 150   }
 151 }
 152
 153 void delta_t::decode(ceph::bufferlist::const_iterator& p) {
 154   using ceph::decode;
 155   decode(op, p);
 156   switch (op) {
 157   case op_t::insert_onode:
 158     [[fallthrough]];
 159   case op_t::update_onode:
 160     decode(oid, p);
 161     decode(*onode, p);
 162     break;
 163   case op_t::insert_child:
 164     [[fallthrough]];
 165   case op_t::update_key:
 166     decode(n, p);
 167     decode(oid, p);
 168     break;
 169   case op_t::shift_left:
 170     decode(n, p);
 171     break;
 172   case op_t::trim_right:
 173     decode(n, p);
 174     break;
 175   case op_t::insert_front:
 176     [[fallthrough]];
 177   case op_t::insert_back:
 178     decode(n, p);
 179     decode(keys, p);
 180     decode(cells, p);
 181     break;
 182   case op_t::remove_from:
 183     decode(n, p);
 184     break;
 185   default:
 186     assert(0 == "unknown onode op");
 187   }
 188 }