ceph/src/librbd/io/Types.h

   1 // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
   2 // vim: ts=8 sw=2 smarttab
   3
   4 #ifndef CEPH_LIBRBD_IO_TYPES_H
   5 #define CEPH_LIBRBD_IO_TYPES_H
   6
   7 #include "include/int_types.h"
   8 #include "include/rados/rados_types.hpp"
   9 #include "common/interval_map.h"
  10 #include "osdc/StriperTypes.h"
  11 #include <iosfwd>
  12 #include <map>
  13 #include <vector>
  14
  15 struct Context;
  16
  17 namespace librbd {
  18 namespace io {
  19
  20 typedef enum {
  21   AIO_TYPE_NONE = 0,
  22   AIO_TYPE_GENERIC,
  23   AIO_TYPE_OPEN,
  24   AIO_TYPE_CLOSE,
  25   AIO_TYPE_READ,
  26   AIO_TYPE_WRITE,
  27   AIO_TYPE_DISCARD,
  28   AIO_TYPE_FLUSH,
  29   AIO_TYPE_WRITESAME,
  30   AIO_TYPE_COMPARE_AND_WRITE,
  31 } aio_type_t;
  32
  33 enum FlushSource {
  34   FLUSH_SOURCE_USER,
  35   FLUSH_SOURCE_INTERNAL,
  36   FLUSH_SOURCE_SHUTDOWN,
  37   FLUSH_SOURCE_EXCLUSIVE_LOCK,
  38   FLUSH_SOURCE_EXCLUSIVE_LOCK_SKIP_REFRESH,
  39   FLUSH_SOURCE_REFRESH,
  40   FLUSH_SOURCE_WRITEBACK,
  41   FLUSH_SOURCE_WRITE_BLOCK,
  42 };
  43
  44 enum Direction {
  45   DIRECTION_READ,
  46   DIRECTION_WRITE,
  47   DIRECTION_BOTH
  48 };
  49
  50 enum DispatchResult {
  51   DISPATCH_RESULT_INVALID,
  52   DISPATCH_RESULT_RESTART,
  53   DISPATCH_RESULT_CONTINUE,
  54   DISPATCH_RESULT_COMPLETE
  55 };
  56
  57 enum ImageDispatchLayer {
  58   IMAGE_DISPATCH_LAYER_NONE = 0,
  59   IMAGE_DISPATCH_LAYER_API_START = IMAGE_DISPATCH_LAYER_NONE,
  60   IMAGE_DISPATCH_LAYER_QUEUE,
  61   IMAGE_DISPATCH_LAYER_QOS,
  62   IMAGE_DISPATCH_LAYER_EXCLUSIVE_LOCK,
  63   IMAGE_DISPATCH_LAYER_REFRESH,
  64   IMAGE_DISPATCH_LAYER_INTERNAL_START = IMAGE_DISPATCH_LAYER_REFRESH,
  65   IMAGE_DISPATCH_LAYER_MIGRATION,
  66   IMAGE_DISPATCH_LAYER_JOURNAL,
  67   IMAGE_DISPATCH_LAYER_WRITE_BLOCK,
  68   IMAGE_DISPATCH_LAYER_WRITEBACK_CACHE,
  69   IMAGE_DISPATCH_LAYER_CRYPTO,
  70   IMAGE_DISPATCH_LAYER_CORE,
  71   IMAGE_DISPATCH_LAYER_LAST
  72 };
  73
  74 enum {
  75   IMAGE_DISPATCH_FLAG_QOS_IOPS_THROTTLE       = 1 << 0,
  76   IMAGE_DISPATCH_FLAG_QOS_BPS_THROTTLE        = 1 << 1,
  77   IMAGE_DISPATCH_FLAG_QOS_READ_IOPS_THROTTLE  = 1 << 2,
  78   IMAGE_DISPATCH_FLAG_QOS_WRITE_IOPS_THROTTLE = 1 << 3,
  79   IMAGE_DISPATCH_FLAG_QOS_READ_BPS_THROTTLE   = 1 << 4,
  80   IMAGE_DISPATCH_FLAG_QOS_WRITE_BPS_THROTTLE  = 1 << 5,
  81   IMAGE_DISPATCH_FLAG_QOS_BPS_MASK            = (
  82     IMAGE_DISPATCH_FLAG_QOS_BPS_THROTTLE |
  83     IMAGE_DISPATCH_FLAG_QOS_READ_BPS_THROTTLE |
  84     IMAGE_DISPATCH_FLAG_QOS_WRITE_BPS_THROTTLE),
  85   IMAGE_DISPATCH_FLAG_QOS_IOPS_MASK           = (
  86     IMAGE_DISPATCH_FLAG_QOS_IOPS_THROTTLE |
  87     IMAGE_DISPATCH_FLAG_QOS_READ_IOPS_THROTTLE |
  88     IMAGE_DISPATCH_FLAG_QOS_WRITE_IOPS_THROTTLE),
  89   IMAGE_DISPATCH_FLAG_QOS_READ_MASK           = (
  90     IMAGE_DISPATCH_FLAG_QOS_READ_IOPS_THROTTLE |
  91     IMAGE_DISPATCH_FLAG_QOS_READ_BPS_THROTTLE),
  92   IMAGE_DISPATCH_FLAG_QOS_WRITE_MASK          = (
  93     IMAGE_DISPATCH_FLAG_QOS_WRITE_IOPS_THROTTLE |
  94     IMAGE_DISPATCH_FLAG_QOS_WRITE_BPS_THROTTLE),
  95   IMAGE_DISPATCH_FLAG_QOS_MASK                = (
  96     IMAGE_DISPATCH_FLAG_QOS_BPS_MASK |
  97     IMAGE_DISPATCH_FLAG_QOS_IOPS_MASK),
  98 };
  99
 100 enum {
 101   RBD_IO_OPERATIONS_DEFAULT             = 0,
 102   RBD_IO_OPERATION_READ                 = 1 << 0,
 103   RBD_IO_OPERATION_WRITE                = 1 << 1,
 104   RBD_IO_OPERATION_DISCARD              = 1 << 2,
 105   RBD_IO_OPERATION_WRITE_SAME           = 1 << 3,
 106   RBD_IO_OPERATION_COMPARE_AND_WRITE    = 1 << 4,
 107   RBD_IO_OPERATIONS_ALL                 = (
 108     RBD_IO_OPERATION_READ |
 109     RBD_IO_OPERATION_WRITE |
 110     RBD_IO_OPERATION_DISCARD |
 111     RBD_IO_OPERATION_WRITE_SAME |
 112     RBD_IO_OPERATION_COMPARE_AND_WRITE)
 113 };
 114
 115 enum ImageExtentsMapType {
 116     IMAGE_EXTENTS_MAP_TYPE_LOGICAL_TO_PHYSICAL,
 117     IMAGE_EXTENTS_MAP_TYPE_PHYSICAL_TO_LOGICAL,
 118 };
 119
 120 enum ObjectDispatchLayer {
 121   OBJECT_DISPATCH_LAYER_NONE = 0,
 122   OBJECT_DISPATCH_LAYER_CACHE,
 123   OBJECT_DISPATCH_LAYER_CRYPTO,
 124   OBJECT_DISPATCH_LAYER_JOURNAL,
 125   OBJECT_DISPATCH_LAYER_PARENT_CACHE,
 126   OBJECT_DISPATCH_LAYER_SCHEDULER,
 127   OBJECT_DISPATCH_LAYER_CORE,
 128   OBJECT_DISPATCH_LAYER_LAST
 129 };
 130
 131 enum {
 132   READ_FLAG_DISABLE_READ_FROM_PARENT            = 1UL << 0,
 133   READ_FLAG_DISABLE_CLIPPING                    = 1UL << 1,
 134 };
 135
 136 enum {
 137   OBJECT_WRITE_FLAG_CREATE_EXCLUSIVE            = 1UL << 0
 138 };
 139
 140 enum {
 141   OBJECT_DISCARD_FLAG_DISABLE_CLONE_REMOVE      = 1UL << 0,
 142   OBJECT_DISCARD_FLAG_DISABLE_OBJECT_MAP_UPDATE = 1UL << 1
 143 };
 144
 145 enum {
 146   OBJECT_DISPATCH_FLAG_FLUSH                    = 1UL << 0,
 147   OBJECT_DISPATCH_FLAG_WILL_RETRY_ON_ERROR      = 1UL << 1
 148 };
 149
 150 enum {
 151   LIST_SNAPS_FLAG_DISABLE_LIST_FROM_PARENT      = 1UL << 0,
 152   LIST_SNAPS_FLAG_WHOLE_OBJECT                  = 1UL << 1,
 153   LIST_SNAPS_FLAG_IGNORE_ZEROED_EXTENTS         = 1UL << 2,
 154 };
 155
 156 enum SparseExtentState {
 157   SPARSE_EXTENT_STATE_DNE,    /* does not exist */
 158   SPARSE_EXTENT_STATE_ZEROED,
 159   SPARSE_EXTENT_STATE_DATA
 160 };
 161
 162 std::ostream& operator<<(std::ostream& os, SparseExtentState state);
 163
 164 struct SparseExtent {
 165   SparseExtentState state;
 166   uint64_t length;
 167
 168   SparseExtent(SparseExtentState state, uint64_t length)
 169     : state(state), length(length) {
 170   }
 171
 172   operator SparseExtentState() const {
 173     return state;
 174   }
 175
 176   bool operator==(const SparseExtent& rhs) const {
 177     return state == rhs.state && length == rhs.length;
 178   }
 179 };
 180
 181 std::ostream& operator<<(std::ostream& os, const SparseExtent& state);
 182
 183 struct SparseExtentSplitMerge {
 184   SparseExtent split(uint64_t offset, uint64_t length, SparseExtent &se) const {
 185     return SparseExtent(se.state, se.length);
 186   }
 187
 188   bool can_merge(const SparseExtent& left, const SparseExtent& right) const {
 189     return left.state == right.state;
 190   }
 191
 192   SparseExtent merge(SparseExtent&& left, SparseExtent&& right) const {
 193     SparseExtent se(left);
 194     se.length += right.length;
 195     return se;
 196   }
 197
 198   uint64_t length(const SparseExtent& se) const {
 199     return se.length;
 200   }
 201 };
 202
 203 typedef interval_map<uint64_t,
 204                      SparseExtent,
 205                      SparseExtentSplitMerge> SparseExtents;
 206
 207 typedef std::vector<uint64_t> SnapIds;
 208
 209 typedef std::pair<librados::snap_t, librados::snap_t> WriteReadSnapIds;
 210 extern const WriteReadSnapIds INITIAL_WRITE_READ_SNAP_IDS;
 211
 212 typedef std::map<WriteReadSnapIds, SparseExtents> SnapshotDelta;
 213
 214 struct SparseBufferlistExtent : public SparseExtent {
 215   ceph::bufferlist bl;
 216
 217   SparseBufferlistExtent(SparseExtentState state, uint64_t length)
 218     : SparseExtent(state, length) {
 219     ceph_assert(state != SPARSE_EXTENT_STATE_DATA);
 220   }
 221   SparseBufferlistExtent(SparseExtentState state, uint64_t length,
 222                          ceph::bufferlist&& bl_)
 223     : SparseExtent(state, length), bl(std::move(bl_)) {
 224     ceph_assert(state != SPARSE_EXTENT_STATE_DATA || length == bl.length());
 225   }
 226
 227   bool operator==(const SparseBufferlistExtent& rhs) const {
 228     return (state == rhs.state &&
 229             length == rhs.length &&
 230             bl.contents_equal(rhs.bl));
 231   }
 232 };
 233
 234 struct SparseBufferlistExtentSplitMerge {
 235   SparseBufferlistExtent split(uint64_t offset, uint64_t length,
 236                                SparseBufferlistExtent& sbe) const {
 237     ceph::bufferlist bl;
 238     if (sbe.state == SPARSE_EXTENT_STATE_DATA) {
 239       bl.substr_of(bl, offset, length);
 240     }
 241     return SparseBufferlistExtent(sbe.state, length, std::move(bl));
 242   }
 243
 244   bool can_merge(const SparseBufferlistExtent& left,
 245                  const SparseBufferlistExtent& right) const {
 246     return left.state == right.state;
 247   }
 248
 249   SparseBufferlistExtent merge(SparseBufferlistExtent&& left,
 250                                SparseBufferlistExtent&& right) const {
 251     if (left.state == SPARSE_EXTENT_STATE_DATA) {
 252       ceph::bufferlist bl{std::move(left.bl)};
 253       bl.claim_append(std::move(right.bl));
 254       return SparseBufferlistExtent(SPARSE_EXTENT_STATE_DATA,
 255                                     bl.length(), std::move(bl));
 256     } else {
 257       return SparseBufferlistExtent(left.state, left.length + right.length, {});
 258     }
 259   }
 260
 261   uint64_t length(const SparseBufferlistExtent& sbe) const {
 262     return sbe.length;
 263   }
 264 };
 265
 266 typedef interval_map<uint64_t,
 267                      SparseBufferlistExtent,
 268                      SparseBufferlistExtentSplitMerge> SparseBufferlist;
 269 typedef std::map<uint64_t, SparseBufferlist> SnapshotSparseBufferlist;
 270
 271 using striper::LightweightBufferExtents;
 272 using striper::LightweightObjectExtent;
 273 using striper::LightweightObjectExtents;
 274
 275 typedef std::pair<uint64_t,uint64_t> Extent;
 276 typedef std::vector<Extent> Extents;
 277
 278 struct ReadExtent {
 279     const uint64_t offset;
 280     const uint64_t length;
 281     const LightweightBufferExtents buffer_extents;
 282     ceph::bufferlist bl;
 283     Extents extent_map;
 284
 285     ReadExtent(uint64_t offset,
 286                uint64_t length) : offset(offset), length(length) {};
 287     ReadExtent(uint64_t offset,
 288                uint64_t length,
 289                const LightweightBufferExtents&& buffer_extents)
 290                : offset(offset),
 291                  length(length),
 292                  buffer_extents(buffer_extents) {}
 293     ReadExtent(uint64_t offset,
 294                uint64_t length,
 295                const LightweightBufferExtents&& buffer_extents,
 296                ceph::bufferlist&& bl,
 297                Extents&& extent_map) : offset(offset),
 298                                        length(length),
 299                                        buffer_extents(buffer_extents),
 300                                        bl(bl),
 301                                        extent_map(extent_map) {};
 302
 303     friend inline std::ostream& operator<<(
 304             std::ostream& os,
 305             const ReadExtent &extent) {
 306       os << "offset=" << extent.offset << ", "
 307          << "length=" << extent.length << ", "
 308          << "buffer_extents=" << extent.buffer_extents << ", "
 309          << "bl.length=" << extent.bl.length() << ", "
 310          << "extent_map=" << extent.extent_map;
 311       return os;
 312     }
 313 };
 314
 315 typedef std::vector<ReadExtent> ReadExtents;
 316
 317 typedef std::map<uint64_t, uint64_t> ExtentMap;
 318
 319 } // namespace io
 320 } // namespace librbd
 321
 322 #endif // CEPH_LIBRBD_IO_TYPES_H