import quincy beta 17.1.0

[ceph.git] / ceph / src / blk / zoned / HMSMRDevice.h

diff --git a/ceph/src/blk/zoned/HMSMRDevice.h b/ceph/src/blk/zoned/HMSMRDevice.h
index 30941f2f9c6bd8b50af3ac227d4fff250c6d87c6..326f9ab27f4ba15214d70db0c4a824275761ca56 100644 (file)
--- a/ceph/src/blk/zoned/HMSMRDevice.h
+++ b/ceph/src/blk/zoned/HMSMRDevice.h
@@ -13,9 +13,6 @@
  *
  */
 
-// Copied from KernelDevice with HM-SMR specific functionality added.  Will be
-// further specialized for HM-SMR.
-
 #ifndef CEPH_BLK_HMSMRDEVICE_H
 #define CEPH_BLK_HMSMRDEVICE_H
 
@@ -28,136 +25,33 @@
 
 #include "aio/aio.h"
 #include "BlockDevice.h"
+#include "../kernel/KernelDevice.h"
 
-#define RW_IO_MAX (INT_MAX & CEPH_PAGE_MASK)
-
-class HMSMRDevice final : public BlockDevice {
-  std::vector<int> fd_directs, fd_buffereds;
-  bool enable_wrt = true;
-  std::string path;
-  bool aio, dio;
-
-  int vdo_fd = -1;      ///< fd for vdo sysfs directory
-  string vdo_name;
-
-  std::string devname;  ///< kernel dev name (/sys/block/$devname), if any
-
-  ceph::mutex debug_lock = ceph::make_mutex("HMSMRDevice::debug_lock");
-  interval_set<uint64_t> debug_inflight;
-
-  std::atomic<bool> io_since_flush = {false};
-  ceph::mutex flush_mutex = ceph::make_mutex("HMSMRDevice::flush_mutex");
-
-  std::unique_ptr<io_queue_t> io_queue;
-  aio_callback_t discard_callback;
-  void *discard_callback_priv;
-  bool aio_stop;
-  bool discard_started;
-  bool discard_stop;
-
-  ceph::mutex discard_lock = ceph::make_mutex("HMSMRDevice::discard_lock");
-  ceph::condition_variable discard_cond;
-  bool discard_running = false;
-  interval_set<uint64_t> discard_queued;
-  interval_set<uint64_t> discard_finishing;
-
-  struct AioCompletionThread : public Thread {
-    HMSMRDevice *bdev;
-    explicit AioCompletionThread(HMSMRDevice *b) : bdev(b) {}
-    void *entry() override {
-      bdev->_aio_thread();
-      return NULL;
-    }
-  } aio_thread;
-
-  struct DiscardThread : public Thread {
-    HMSMRDevice *bdev;
-    explicit DiscardThread(HMSMRDevice *b) : bdev(b) {}
-    void *entry() override {
-      bdev->_discard_thread();
-      return NULL;
-    }
-  } discard_thread;
-
-  std::atomic_int injecting_crash;
-
-  void _aio_thread();
-  void _discard_thread();
-  int queue_discard(interval_set<uint64_t> &to_release) final;
-
-  int _aio_start();
-  void _aio_stop();
-
-  int _discard_start();
-  void _discard_stop();
 
-  void _aio_log_start(IOContext *ioc, uint64_t offset, uint64_t length);
-  void _aio_log_finish(IOContext *ioc, uint64_t offset, uint64_t length);
-
-  int _sync_write(uint64_t off, bufferlist& bl, bool buffered, int write_hint);
-
-  int _lock();
-
-  int direct_read_unaligned(uint64_t off, uint64_t len, char *buf);
-
-  // stalled aio debugging
-  aio_list_t debug_queue;
-  ceph::mutex debug_queue_lock =
-      ceph::make_mutex("HMSMRDevice::debug_queue_lock");
-  aio_t *debug_oldest = nullptr;
-  utime_t debug_stall_since;
-  void debug_aio_link(aio_t& aio);
-  void debug_aio_unlink(aio_t& aio);
-
-  void _detect_vdo();
-  int choose_fd(bool buffered, int write_hint) const;
-
-  bool set_smr_params(const std::string& path);
+class HMSMRDevice final : public KernelDevice {
+  int zbd_fd = -1;     ///< fd for the zoned block device
 
 public:
   HMSMRDevice(CephContext* cct, aio_callback_t cb, void *cbpriv,
               aio_callback_t d_cb, void *d_cbpriv);
-  static bool support(const std::string& path);
 
-  void aio_submit(IOContext *ioc) final;
-  void discard_drain() final;
+  static bool support(const std::string& path);
 
-  int collect_metadata(const std::string& prefix,
-                       map<std::string,std::string> *pm) const final;
-  int get_devname(std::string *s) const final {
-    if (devname.empty()) {
-      return -ENOENT;
-    }
-    *s = devname;
-    return 0;
-  }
-  int get_devices(std::set<std::string> *ls) const final;
+  // open/close hooks for libzbd
+  int _post_open() override;
+  void _pre_close() override;
 
+  // smr-specific methods
   bool is_smr() const final { return true; }
+  void reset_all_zones() override;
+  void reset_zone(uint64_t zone) override;
+  std::vector<uint64_t> get_zones() override;
 
-  bool get_thin_utilization(uint64_t *total, uint64_t *avail) const final;
-
-  int read(uint64_t off, uint64_t len, bufferlist *pbl,
-          IOContext *ioc,
-          bool buffered) final;
-  int aio_read(uint64_t off, uint64_t len, bufferlist *pbl,
-              IOContext *ioc) final;
-  int read_random(uint64_t off, uint64_t len, char *buf,
-                  bool buffered) final;
-
-  int write(uint64_t off, bufferlist& bl, bool buffered,
-            int write_hint = WRITE_LIFE_NOT_SET) final;
-  int aio_write(uint64_t off, bufferlist& bl,
-               IOContext *ioc,
-               bool buffered,
-               int write_hint = WRITE_LIFE_NOT_SET) final;
-  int flush() final;
-  int discard(uint64_t offset, uint64_t len) final;
+  int discard(uint64_t offset, uint64_t len) override {
+    // discard is a no-op on a zoned device
+    return 0;
+  }
 
-  // for managing buffered readers/writers
-  int invalidate_cache(uint64_t off, uint64_t len) final;
-  int open(const std::string& path) final;
-  void close() final;
 };
 
 #endif //CEPH_BLK_HMSMRDEVICE_H