ceph/src/librbd/ObjectMap.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_OBJECT_MAP_H
   5 #define CEPH_LIBRBD_OBJECT_MAP_H
   6
   7 #include "include/int_types.h"
   8 #include "include/fs_types.h"
   9 #include "include/rbd/object_map_types.h"
  10 #include "common/bit_vector.hpp"
  11 #include "librbd/Utils.h"
  12 #include <boost/optional.hpp>
  13
  14 class Context;
  15 class RWLock;
  16 namespace librados {
  17   class IoCtx;
  18 }
  19
  20 namespace librbd {
  21
  22 template <typename Op> class BlockGuard;
  23 struct BlockGuardCell;
  24 class ImageCtx;
  25
  26 template <typename ImageCtxT = ImageCtx>
  27 class ObjectMap {
  28 public:
  29   static ObjectMap *create(ImageCtxT &image_ctx, uint64_t snap_id) {
  30     return new ObjectMap(image_ctx, snap_id);
  31   }
  32
  33   ObjectMap(ImageCtxT &image_ctx, uint64_t snap_id);
  34   ~ObjectMap();
  35
  36   static int aio_remove(librados::IoCtx &io_ctx, const std::string &image_id, librados::AioCompletion *c);
  37   static std::string object_map_name(const std::string &image_id,
  38                                      uint64_t snap_id);
  39
  40   static bool is_compatible(const file_layout_t& layout, uint64_t size);
  41
  42   ceph::BitVector<2u>::Reference operator[](uint64_t object_no);
  43   uint8_t operator[](uint64_t object_no) const;
  44   inline uint64_t size() const {
  45     return m_object_map.size();
  46   }
  47
  48   void open(Context *on_finish);
  49   void close(Context *on_finish);
  50
  51   bool object_may_exist(uint64_t object_no) const;
  52
  53   void aio_save(Context *on_finish);
  54   void aio_resize(uint64_t new_size, uint8_t default_object_state,
  55                   Context *on_finish);
  56
  57   template <typename T, void(T::*MF)(int) = &T::complete>
  58   bool aio_update(uint64_t snap_id, uint64_t start_object_no, uint8_t new_state,
  59                   const boost::optional<uint8_t> &current_state,
  60                   T *callback_object) {
  61     return aio_update<T, MF>(snap_id, start_object_no, start_object_no + 1,
  62                              new_state, current_state, callback_object);
  63   }
  64
  65   template <typename T, void(T::*MF)(int) = &T::complete>
  66   bool aio_update(uint64_t snap_id, uint64_t start_object_no,
  67                   uint64_t end_object_no, uint8_t new_state,
  68                   const boost::optional<uint8_t> &current_state,
  69                   T *callback_object) {
  70     assert(start_object_no < end_object_no);
  71     if (snap_id == CEPH_NOSNAP) {
  72       uint64_t object_no;
  73       for (object_no = start_object_no; object_no < end_object_no;
  74            ++object_no) {
  75         if (update_required(object_no, new_state)) {
  76           break;
  77         }
  78       }
  79
  80       if (object_no == end_object_no) {
  81         return false;
  82       }
  83
  84       UpdateOperation update_operation(start_object_no, end_object_no,
  85                                        new_state, current_state,
  86                                        util::create_context_callback<T, MF>(
  87                                          callback_object));
  88       detained_aio_update(std::move(update_operation));
  89     } else {
  90       aio_update(snap_id, start_object_no, end_object_no, new_state,
  91                  current_state,
  92                  util::create_context_callback<T, MF>(callback_object));
  93     }
  94     return true;
  95   }
  96
  97   void rollback(uint64_t snap_id, Context *on_finish);
  98   void snapshot_add(uint64_t snap_id, Context *on_finish);
  99   void snapshot_remove(uint64_t snap_id, Context *on_finish);
 100
 101 private:
 102   struct UpdateOperation {
 103     uint64_t start_object_no;
 104     uint64_t end_object_no;
 105     uint8_t new_state;
 106     boost::optional<uint8_t> current_state;
 107     Context *on_finish;
 108
 109     UpdateOperation(uint64_t start_object_no, uint64_t end_object_no,
 110                     uint8_t new_state,
 111                     const boost::optional<uint8_t> &current_state,
 112                     Context *on_finish)
 113       : start_object_no(start_object_no), end_object_no(end_object_no),
 114         new_state(new_state), current_state(current_state),
 115         on_finish(on_finish) {
 116     }
 117   };
 118
 119   typedef BlockGuard<UpdateOperation> UpdateGuard;
 120
 121   ImageCtxT &m_image_ctx;
 122   ceph::BitVector<2> m_object_map;
 123   uint64_t m_snap_id;
 124
 125   UpdateGuard *m_update_guard = nullptr;
 126
 127   void detained_aio_update(UpdateOperation &&update_operation);
 128   void handle_detained_aio_update(BlockGuardCell *cell, int r,
 129                                   Context *on_finish);
 130
 131   void aio_update(uint64_t snap_id, uint64_t start_object_no,
 132                   uint64_t end_object_no, uint8_t new_state,
 133                   const boost::optional<uint8_t> &current_state,
 134                   Context *on_finish);
 135   bool update_required(uint64_t object_no, uint8_t new_state);
 136
 137 };
 138
 139 } // namespace librbd
 140
 141 extern template class librbd::ObjectMap<librbd::ImageCtx>;
 142
 143 #endif // CEPH_LIBRBD_OBJECT_MAP_H