From: Jason Dillaman <dillaman@redhat.com>
Date: Thu, 14 Feb 2019 14:53:34 +0000 (-0500)
Subject: librbd: align discard requests to default bluestore allocation size
X-Git-Tag: v14.1.1~122^2~1
X-Git-Url: http://git-server-git.apps.pok.os.sepia.ceph.com/?a=commitdiff_plain;h=7ca1bab90f3db3aaaa4cdbfc1f18e9f5cfbf5568;p=ceph.git

librbd: align discard requests to default bluestore allocation size

This will match the new krbd behavior of aligning discards to the
default bluestore minimum allocation size. Requests that are too
small (or the misaligned head / tail of the request) will be
ignored since it will not result in freed space.

Fixes: http://tracker.ceph.com/issues/38146
Signed-off-by: Jason Dillaman <dillaman@redhat.com>
---

diff --git a/src/common/options.cc b/src/common/options.cc
index e5752c2a2f0e..d7140d76b112 100644
--- a/src/common/options.cc
+++ b/src/common/options.cc
@@ -7074,6 +7074,22 @@ static std::vector<Option> get_rbd_options() {
     .set_default(true)
     .set_description("skip discard (zero) of unaligned extents within an object"),
 
+    Option("rbd_discard_granularity_bytes", Option::TYPE_UINT,
+           Option::LEVEL_ADVANCED)
+    .set_default(64_K)
+    .set_min_max(4_K, 32_M)
+    .set_validator([](std::string *value, std::string *error_message){
+        uint64_t f = strict_si_cast<uint64_t>(value->c_str(), error_message);
+        if (!error_message->empty()) {
+          return -EINVAL;
+        } else if (!isp2(f)) {
+          *error_message = "value must be a power of two";
+          return -EINVAL;
+        }
+        return 0;
+      })
+    .set_description("minimum aligned size of discard operations"),
+
     Option("rbd_enable_alloc_hint", Option::TYPE_BOOL, Option::LEVEL_ADVANCED)
     .set_default(true)
     .set_description("when writing a object, it will issue a hint to osd backend to indicate the expected size object need"),
diff --git a/src/librbd/ImageCtx.cc b/src/librbd/ImageCtx.cc
index c4c17a974ba8..f6daba7d3d4f 100644
--- a/src/librbd/ImageCtx.cc
+++ b/src/librbd/ImageCtx.cc
@@ -788,6 +788,7 @@ public:
 #define ASSIGN_OPTION(param, type)              \
     param = config.get_val<type>("rbd_"#param)
 
+    bool skip_partial_discard = true;
     ASSIGN_OPTION(non_blocking_aio, bool);
     ASSIGN_OPTION(cache, bool);
     ASSIGN_OPTION(cache_writethrough_until_flush, bool);
@@ -801,6 +802,7 @@ public:
     ASSIGN_OPTION(mtime_update_interval, uint64_t);
     ASSIGN_OPTION(atime_update_interval, uint64_t);
     ASSIGN_OPTION(skip_partial_discard, bool);
+    ASSIGN_OPTION(discard_granularity_bytes, uint64_t);
     ASSIGN_OPTION(blkin_trace_all, bool);
 
 #undef ASSIGN_OPTION
@@ -808,6 +810,9 @@ public:
     if (sparse_read_threshold_bytes == 0) {
       sparse_read_threshold_bytes = get_object_size();
     }
+    if (!skip_partial_discard) {
+      discard_granularity_bytes = 0;
+    }
 
     io_work_queue->apply_qos_schedule_tick_min(
       config.get_val<uint64_t>("rbd_qos_schedule_tick_min"));
diff --git a/src/librbd/ImageCtx.h b/src/librbd/ImageCtx.h
index 3e97c712951c..6e6eb3403b0e 100644
--- a/src/librbd/ImageCtx.h
+++ b/src/librbd/ImageCtx.h
@@ -182,7 +182,7 @@ namespace librbd {
     uint64_t readahead_disable_after_bytes;
     bool clone_copy_on_read;
     bool enable_alloc_hint;
-    bool skip_partial_discard;
+    uint32_t discard_granularity_bytes = 0;
     bool blkin_trace_all;
     uint64_t mirroring_replay_delay;
     uint64_t mtime_update_interval;
diff --git a/src/librbd/cache/ImageCache.h b/src/librbd/cache/ImageCache.h
index f394a1a80a1e..71af11f2111a 100644
--- a/src/librbd/cache/ImageCache.h
+++ b/src/librbd/cache/ImageCache.h
@@ -28,7 +28,8 @@ struct ImageCache {
   virtual void aio_write(Extents&& image_extents, ceph::bufferlist&& bl,
                          int fadvise_flags, Context *on_finish) = 0;
   virtual void aio_discard(uint64_t offset, uint64_t length,
-                           bool skip_partial_discard, Context *on_finish) = 0;
+                           uint32_t discard_granularity_bytes,
+                           Context *on_finish) = 0;
   virtual void aio_flush(Context *on_finish) = 0;
   virtual void aio_writesame(uint64_t offset, uint64_t length,
                              ceph::bufferlist&& bl,
diff --git a/src/librbd/cache/ImageWriteback.cc b/src/librbd/cache/ImageWriteback.cc
index 54b964d90915..ad479fbd3991 100644
--- a/src/librbd/cache/ImageWriteback.cc
+++ b/src/librbd/cache/ImageWriteback.cc
@@ -53,8 +53,8 @@ void ImageWriteback<I>::aio_write(Extents &&image_extents,
 
 template <typename I>
 void ImageWriteback<I>::aio_discard(uint64_t offset, uint64_t length,
-                                    bool skip_partial_discard,
-				    Context *on_finish) {
+				    uint32_t discard_granularity_bytes,
+                                    Context *on_finish) {
   CephContext *cct = m_image_ctx.cct;
   ldout(cct, 20) << "offset=" << offset << ", "
                  << "length=" << length << ", "
@@ -63,7 +63,7 @@ void ImageWriteback<I>::aio_discard(uint64_t offset, uint64_t length,
   auto aio_comp = io::AioCompletion::create_and_start(on_finish, &m_image_ctx,
                                                       io::AIO_TYPE_DISCARD);
   io::ImageDiscardRequest<I> req(m_image_ctx, aio_comp, {{offset, length}},
-                                 skip_partial_discard, {});
+                                 discard_granularity_bytes, {});
   req.set_bypass_image_cache();
   req.send();
 }
diff --git a/src/librbd/cache/ImageWriteback.h b/src/librbd/cache/ImageWriteback.h
index 6a7907687135..382c57c1d390 100644
--- a/src/librbd/cache/ImageWriteback.h
+++ b/src/librbd/cache/ImageWriteback.h
@@ -31,7 +31,7 @@ public:
   void aio_write(Extents &&image_extents, ceph::bufferlist&& bl,
                  int fadvise_flags, Context *on_finish);
   void aio_discard(uint64_t offset, uint64_t length,
-                   bool skip_partial_discard, Context *on_finish);
+                   uint32_t discard_granularity_bytes, Context *on_finish);
   void aio_flush(Context *on_finish);
   void aio_writesame(uint64_t offset, uint64_t length,
                      ceph::bufferlist&& bl,
diff --git a/src/librbd/cache/PassthroughImageCache.cc b/src/librbd/cache/PassthroughImageCache.cc
index 5b22fc7a6ced..c3672f531a2a 100644
--- a/src/librbd/cache/PassthroughImageCache.cc
+++ b/src/librbd/cache/PassthroughImageCache.cc
@@ -45,13 +45,15 @@ void PassthroughImageCache<I>::aio_write(Extents &&image_extents,
 
 template <typename I>
 void PassthroughImageCache<I>::aio_discard(uint64_t offset, uint64_t length,
-                                           bool skip_partial_discard, Context *on_finish) {
+                                           uint32_t discard_granularity_bytes,
+                                           Context *on_finish) {
   CephContext *cct = m_image_ctx.cct;
   ldout(cct, 20) << "offset=" << offset << ", "
                  << "length=" << length << ", "
                  << "on_finish=" << on_finish << dendl;
 
-  m_image_writeback.aio_discard(offset, length, skip_partial_discard, on_finish);
+  m_image_writeback.aio_discard(offset, length, discard_granularity_bytes,
+                                on_finish);
 }
 
 template <typename I>
diff --git a/src/librbd/cache/PassthroughImageCache.h b/src/librbd/cache/PassthroughImageCache.h
index 5e676cefeb2d..4be69a50aed5 100644
--- a/src/librbd/cache/PassthroughImageCache.h
+++ b/src/librbd/cache/PassthroughImageCache.h
@@ -27,7 +27,8 @@ public:
   void aio_write(Extents&& image_extents, ceph::bufferlist&& bl,
                  int fadvise_flags, Context *on_finish) override;
   void aio_discard(uint64_t offset, uint64_t length,
-                   bool skip_partial_discard, Context *on_finish) override;
+                   uint32_t discard_granularity_bytes,
+                   Context *on_finish) override;
   void aio_flush(Context *on_finish) override;
   void aio_writesame(uint64_t offset, uint64_t length,
                      ceph::bufferlist&& bl,
diff --git a/src/librbd/io/ImageDispatchSpec.cc b/src/librbd/io/ImageDispatchSpec.cc
index dd28d16edd4b..dd39e1d5b013 100644
--- a/src/librbd/io/ImageDispatchSpec.cc
+++ b/src/librbd/io/ImageDispatchSpec.cc
@@ -28,7 +28,7 @@ struct ImageDispatchSpec<I>::SendVisitor
   void operator()(Discard& discard) const {
     ImageRequest<I>::aio_discard(
       &spec->m_image_ctx, spec->m_aio_comp, std::move(spec->m_image_extents),
-      discard.skip_partial_discard, spec->m_parent_trace);
+      discard.discard_granularity_bytes, spec->m_parent_trace);
   }
 
   void operator()(Write& write) const {
diff --git a/src/librbd/io/ImageDispatchSpec.h b/src/librbd/io/ImageDispatchSpec.h
index 82b9fc223d6b..7cdc078a0886 100644
--- a/src/librbd/io/ImageDispatchSpec.h
+++ b/src/librbd/io/ImageDispatchSpec.h
@@ -30,10 +30,10 @@ public:
   };
 
   struct Discard {
-    bool skip_partial_discard;
+    uint32_t discard_granularity_bytes;
 
-    Discard(bool skip_partial_discard)
-      : skip_partial_discard(skip_partial_discard) {
+    Discard(uint32_t discard_granularity_bytes)
+      : discard_granularity_bytes(discard_granularity_bytes) {
     }
   };
 
@@ -82,10 +82,10 @@ public:
 
   static ImageDispatchSpec* create_discard_request(
       ImageCtxT &image_ctx, AioCompletion *aio_comp, uint64_t off, uint64_t len,
-      bool skip_partial_discard, const ZTracer::Trace &parent_trace) {
+      uint32_t discard_granularity_bytes, const ZTracer::Trace &parent_trace) {
     return new ImageDispatchSpec(image_ctx, aio_comp, {{off, len}},
-                                 Discard{skip_partial_discard}, 0,
-                                 parent_trace);
+                                 Discard{discard_granularity_bytes},
+                                 0, parent_trace);
   }
 
   static ImageDispatchSpec* create_write_request(
diff --git a/src/librbd/io/ImageRequest.cc b/src/librbd/io/ImageRequest.cc
index e0c242cf046b..1b6d9756d4af 100644
--- a/src/librbd/io/ImageRequest.cc
+++ b/src/librbd/io/ImageRequest.cc
@@ -19,6 +19,7 @@
 #include "common/perf_counters.h"
 #include "common/WorkQueue.h"
 #include "osdc/Striper.h"
+#include <algorithm>
 #include <functional>
 
 #define dout_subsys ceph_subsys_rbd
@@ -98,10 +99,10 @@ void ImageRequest<I>::aio_write(I *ictx, AioCompletion *c,
 template <typename I>
 void ImageRequest<I>::aio_discard(I *ictx, AioCompletion *c,
                                   Extents &&image_extents,
-                                  bool skip_partial_discard,
+                                  uint32_t discard_granularity_bytes,
 				  const ZTracer::Trace &parent_trace) {
   ImageDiscardRequest<I> req(*ictx, c, std::move(image_extents),
-                             skip_partial_discard, parent_trace);
+                             discard_granularity_bytes, parent_trace);
   req.send();
 }
 
@@ -376,7 +377,7 @@ void AbstractImageWriteRequest<I>::send_request() {
                   image_ctx.journal->is_journal_appending());
   }
 
-  int ret = validate_object_extents(object_extents);
+  int ret = prune_object_extents(&object_extents);
   if (ret < 0) {
     aio_comp->fail(ret);
     return;
@@ -497,7 +498,7 @@ uint64_t ImageDiscardRequest<I>::append_journal_event(bool synchronous) {
     journal::EventEntry event_entry(
       journal::AioDiscardEvent(extent.first,
                                extent.second,
-                               this->m_skip_partial_discard));
+                               this->m_discard_granularity_bytes));
     tid = image_ctx.journal->append_io_event(std::move(event_entry),
                                              extent.first, extent.second,
                                              synchronous, 0);
@@ -516,7 +517,8 @@ void ImageDiscardRequest<I>::send_image_cache_request() {
   for (auto &extent : this->m_image_extents) {
     C_AioRequest *req_comp = new C_AioRequest(aio_comp);
     image_ctx.image_cache->aio_discard(extent.first, extent.second,
-                                       this->m_skip_partial_discard, req_comp);
+                                       this->m_discard_granularity_bytes,
+                                       req_comp);
   }
 }
 
@@ -525,14 +527,11 @@ ObjectDispatchSpec *ImageDiscardRequest<I>::create_object_request(
     const ObjectExtent &object_extent, const ::SnapContext &snapc,
     uint64_t journal_tid, Context *on_finish) {
   I &image_ctx = this->m_image_ctx;
-  int discard_flags = OBJECT_DISCARD_FLAG_DISABLE_CLONE_REMOVE;
-  if (m_skip_partial_discard) {
-    discard_flags |=  OBJECT_DISCARD_FLAG_SKIP_PARTIAL;
-  }
   auto req = ObjectDispatchSpec::create_discard(
     &image_ctx, OBJECT_DISPATCH_LAYER_NONE, object_extent.oid.name,
     object_extent.objectno, object_extent.offset, object_extent.length, snapc,
-    discard_flags, journal_tid, this->m_trace, on_finish);
+    OBJECT_DISCARD_FLAG_DISABLE_CLONE_REMOVE, journal_tid, this->m_trace,
+    on_finish);
   return req;
 }
 
@@ -543,6 +542,59 @@ void ImageDiscardRequest<I>::update_stats(size_t length) {
   image_ctx.perfcounter->inc(l_librbd_discard_bytes, length);
 }
 
+template <typename I>
+int ImageDiscardRequest<I>::prune_object_extents(
+    ObjectExtents* object_extents) const {
+  if (m_discard_granularity_bytes == 0) {
+    return 0;
+  }
+
+  // Align the range to discard_granularity_bytes boundary and skip
+  // and discards that are too small to free up any space.
+  //
+  // discard_granularity_bytes >= object_size && tail truncation
+  // is a special case for filestore
+  bool prune_required = false;
+  auto object_size = this->m_image_ctx.layout.object_size;
+  auto discard_granularity_bytes = std::min<uint64_t>(
+    m_discard_granularity_bytes, object_size);
+  auto xform_lambda =
+    [discard_granularity_bytes, object_size, &prune_required]
+    (ObjectExtent& object_extent) {
+      auto& offset = object_extent.offset;
+      auto& length = object_extent.length;
+      auto next_offset = offset + length;
+
+      if ((discard_granularity_bytes < object_size) ||
+          (next_offset < object_size)) {
+        static_assert(sizeof(offset) == sizeof(discard_granularity_bytes));
+        offset = p2roundup(offset, discard_granularity_bytes);
+        next_offset = p2align(next_offset, discard_granularity_bytes);
+        if (offset >= next_offset) {
+          prune_required = true;
+          length = 0;
+        } else {
+          length = next_offset - offset;
+        }
+      }
+    };
+  std::for_each(object_extents->begin(), object_extents->end(),
+                xform_lambda);
+
+  if (prune_required) {
+    // one or more object extents were skipped
+    auto remove_lambda =
+      [](const ObjectExtent& object_extent) {
+        return (object_extent.length == 0);
+      };
+    object_extents->erase(
+      std::remove_if(object_extents->begin(), object_extents->end(),
+                     remove_lambda),
+      object_extents->end());
+  }
+  return 0;
+}
+
 template <typename I>
 void ImageFlushRequest<I>::send_request() {
   I &image_ctx = this->m_image_ctx;
@@ -744,15 +796,15 @@ void ImageCompareAndWriteRequest<I>::update_stats(size_t length) {
 }
 
 template <typename I>
-int ImageCompareAndWriteRequest<I>::validate_object_extents(
-    const ObjectExtents &object_extents) const {
-  if (object_extents.size() > 1)
+int ImageCompareAndWriteRequest<I>::prune_object_extents(
+    ObjectExtents* object_extents) const {
+  if (object_extents->size() > 1)
     return -EINVAL;
 
   I &image_ctx = this->m_image_ctx;
   uint64_t sector_size = 512ULL;
   uint64_t su = image_ctx.layout.stripe_unit;
-  ObjectExtent object_extent = object_extents.front();
+  ObjectExtent object_extent = object_extents->front();
   if (object_extent.offset % sector_size + object_extent.length > sector_size ||
       (su != 0 && (object_extent.offset % su + object_extent.length > su)))
     return -EINVAL;
diff --git a/src/librbd/io/ImageRequest.h b/src/librbd/io/ImageRequest.h
index 0b8d4179c026..d7d10019d3ed 100644
--- a/src/librbd/io/ImageRequest.h
+++ b/src/librbd/io/ImageRequest.h
@@ -40,8 +40,9 @@ public:
                         Extents &&image_extents, bufferlist &&bl, int op_flags,
 			const ZTracer::Trace &parent_trace);
   static void aio_discard(ImageCtxT *ictx, AioCompletion *c,
-                          Extents &&image_extents, bool skip_partial_discard,
-			  const ZTracer::Trace &parent_trace);
+                          Extents &&image_extents,
+                          uint32_t discard_granularity_bytes,
+                          const ZTracer::Trace &parent_trace);
   static void aio_flush(ImageCtxT *ictx, AioCompletion *c,
                         FlushSource flush_source,
                         const ZTracer::Trace &parent_trace);
@@ -140,8 +141,7 @@ protected:
 
   void send_request() override;
 
-  virtual int validate_object_extents(
-      const ObjectExtents &object_extents) const {
+  virtual int prune_object_extents(ObjectExtents* object_extents) const {
     return 0;
   }
 
@@ -203,11 +203,12 @@ template <typename ImageCtxT = ImageCtx>
 class ImageDiscardRequest : public AbstractImageWriteRequest<ImageCtxT> {
 public:
   ImageDiscardRequest(ImageCtxT &image_ctx, AioCompletion *aio_comp,
-                      Extents&& image_extents, bool skip_partial_discard,
-		      const ZTracer::Trace &parent_trace)
+                      Extents&& image_extents,
+		      uint32_t discard_granularity_bytes,
+                      const ZTracer::Trace &parent_trace)
     : AbstractImageWriteRequest<ImageCtxT>(
 	image_ctx, aio_comp, std::move(image_extents), "discard", parent_trace),
-      m_skip_partial_discard(skip_partial_discard) {
+      m_discard_granularity_bytes(discard_granularity_bytes) {
   }
 
 protected:
@@ -229,8 +230,11 @@ protected:
 
   uint64_t append_journal_event(bool synchronous) override;
   void update_stats(size_t length) override;
+
+  int prune_object_extents(ObjectExtents* object_extents) const override;
+
 private:
-  bool m_skip_partial_discard;
+  uint32_t m_discard_granularity_bytes;
 };
 
 template <typename ImageCtxT = ImageCtx>
@@ -337,8 +341,7 @@ protected:
     return "aio_compare_and_write";
   }
 
-  int validate_object_extents(
-      const ObjectExtents &object_extents) const override;
+  int prune_object_extents(ObjectExtents* object_extents) const override;
 
 private:
   bufferlist m_cmp_bl;
diff --git a/src/librbd/io/ImageRequestWQ.cc b/src/librbd/io/ImageRequestWQ.cc
index 81c39d9b1420..2b38bf3b8d40 100644
--- a/src/librbd/io/ImageRequestWQ.cc
+++ b/src/librbd/io/ImageRequestWQ.cc
@@ -158,7 +158,7 @@ ssize_t ImageRequestWQ<I>::write(uint64_t off, uint64_t len,
 
 template <typename I>
 ssize_t ImageRequestWQ<I>::discard(uint64_t off, uint64_t len,
-				   bool skip_partial_discard) {
+				   uint32_t discard_granularity_bytes) {
   CephContext *cct = m_image_ctx.cct;
   ldout(cct, 20) << "ictx=" << &m_image_ctx << ", off=" << off << ", "
                  << "len = " << len << dendl;
@@ -173,7 +173,7 @@ ssize_t ImageRequestWQ<I>::discard(uint64_t off, uint64_t len,
 
   C_SaferCond cond;
   AioCompletion *c = AioCompletion::create(&cond);
-  aio_discard(c, off, len, skip_partial_discard, false);
+  aio_discard(c, off, len, discard_granularity_bytes, false);
 
   r = cond.wait();
   if (r < 0) {
@@ -338,7 +338,8 @@ void ImageRequestWQ<I>::aio_write(AioCompletion *c, uint64_t off, uint64_t len,
 
 template <typename I>
 void ImageRequestWQ<I>::aio_discard(AioCompletion *c, uint64_t off,
-				    uint64_t len, bool skip_partial_discard,
+				    uint64_t len,
+                                    uint32_t discard_granularity_bytes,
 				    bool native_async) {
   CephContext *cct = m_image_ctx.cct;
   FUNCTRACE(cct);
@@ -364,11 +365,11 @@ void ImageRequestWQ<I>::aio_discard(AioCompletion *c, uint64_t off,
   RWLock::RLocker owner_locker(m_image_ctx.owner_lock);
   if (m_image_ctx.non_blocking_aio || writes_blocked()) {
     queue(ImageDispatchSpec<I>::create_discard_request(
-            m_image_ctx, c, off, len, skip_partial_discard, trace));
+            m_image_ctx, c, off, len, discard_granularity_bytes, trace));
   } else {
     c->start_op();
     ImageRequest<I>::aio_discard(&m_image_ctx, c, {{off, len}},
-				 skip_partial_discard, trace);
+                                 discard_granularity_bytes, trace);
     finish_in_flight_io();
   }
   trace.event("finish");
diff --git a/src/librbd/io/ImageRequestWQ.h b/src/librbd/io/ImageRequestWQ.h
index 5c726985964c..a9134fc4a1bf 100644
--- a/src/librbd/io/ImageRequestWQ.h
+++ b/src/librbd/io/ImageRequestWQ.h
@@ -34,7 +34,8 @@ public:
   ssize_t read(uint64_t off, uint64_t len, ReadResult &&read_result,
                int op_flags);
   ssize_t write(uint64_t off, uint64_t len, bufferlist &&bl, int op_flags);
-  ssize_t discard(uint64_t off, uint64_t len, bool skip_partial_discard);
+  ssize_t discard(uint64_t off, uint64_t len,
+                  uint32_t discard_granularity_bytes);
   ssize_t writesame(uint64_t off, uint64_t len, bufferlist &&bl, int op_flags);
   ssize_t compare_and_write(uint64_t off, uint64_t len,
                             bufferlist &&cmp_bl, bufferlist &&bl,
@@ -46,7 +47,7 @@ public:
   void aio_write(AioCompletion *c, uint64_t off, uint64_t len,
                  bufferlist &&bl, int op_flags, bool native_async=true);
   void aio_discard(AioCompletion *c, uint64_t off, uint64_t len,
-                   bool skip_partial_discard, bool native_async=true);
+                   uint32_t discard_granularity_bytes, bool native_async=true);
   void aio_flush(AioCompletion *c, bool native_async=true);
   void aio_writesame(AioCompletion *c, uint64_t off, uint64_t len,
                      bufferlist &&bl, int op_flags, bool native_async=true);
diff --git a/src/librbd/io/ObjectRequest.cc b/src/librbd/io/ObjectRequest.cc
index fd1c509f153f..611e83677a6f 100644
--- a/src/librbd/io/ObjectRequest.cc
+++ b/src/librbd/io/ObjectRequest.cc
@@ -663,21 +663,6 @@ void ObjectWriteRequest<I>::add_write_ops(librados::ObjectWriteOperation *wr) {
   wr->set_op_flags2(m_op_flags);
 }
 
-template <typename I>
-void ObjectDiscardRequest<I>::send() {
-  I *image_ctx = this->m_ictx;
-  auto cct = image_ctx->cct;
-  if ((m_discard_flags & OBJECT_DISCARD_FLAG_SKIP_PARTIAL) != 0 &&
-      this->m_object_off + this->m_object_len < image_ctx->layout.object_size) {
-    ldout(cct, 20) << "oid " << this->m_oid << " " << this->m_object_off << "~"
-		   << this->m_object_len << ": skip partial discard" << dendl;
-    this->async_finish(0);
-    return;
-  }
-
-  AbstractObjectWriteRequest<I>::send();
-}
-
 template <typename I>
 void ObjectWriteSameRequest<I>::add_write_ops(
     librados::ObjectWriteOperation *wr) {
diff --git a/src/librbd/io/ObjectRequest.h b/src/librbd/io/ObjectRequest.h
index 7c111c968d46..63fd1da0df9c 100644
--- a/src/librbd/io/ObjectRequest.h
+++ b/src/librbd/io/ObjectRequest.h
@@ -341,8 +341,6 @@ public:
     return OBJECT_EXISTS;
   }
 
-  void send() override;
-
 protected:
   bool is_no_op_for_nonexistent_object() const override {
     return (!this->has_parent());
diff --git a/src/librbd/io/Types.h b/src/librbd/io/Types.h
index 7e09c9018c50..6bd42eac3186 100644
--- a/src/librbd/io/Types.h
+++ b/src/librbd/io/Types.h
@@ -66,8 +66,7 @@ enum ObjectDispatchLayer {
 
 enum {
   OBJECT_DISCARD_FLAG_DISABLE_CLONE_REMOVE      = 1UL << 0,
-  OBJECT_DISCARD_FLAG_DISABLE_OBJECT_MAP_UPDATE = 1UL << 1,
-  OBJECT_DISCARD_FLAG_SKIP_PARTIAL              = 1UL << 2
+  OBJECT_DISCARD_FLAG_DISABLE_OBJECT_MAP_UPDATE = 1UL << 1
 };
 
 enum {
diff --git a/src/librbd/journal/Replay.cc b/src/librbd/journal/Replay.cc
index 739034439f19..25dd61203f7b 100644
--- a/src/librbd/journal/Replay.cc
+++ b/src/librbd/journal/Replay.cc
@@ -353,7 +353,7 @@ void Replay<I>::handle_event(const journal::AioDiscardEvent &event,
   if (!clipped_io(event.offset, aio_comp)) {
     io::ImageRequest<I>::aio_discard(&m_image_ctx, aio_comp,
                                      {{event.offset, event.length}},
-                                     event.skip_partial_discard, {});
+                                     event.discard_granularity_bytes, {});
   }
 
   if (flush_required) {
diff --git a/src/librbd/journal/Types.cc b/src/librbd/journal/Types.cc
index 75e71a21e034..ee919d35d7b5 100644
--- a/src/librbd/journal/Types.cc
+++ b/src/librbd/journal/Types.cc
@@ -75,22 +75,38 @@ void AioDiscardEvent::encode(bufferlist& bl) const {
   using ceph::encode;
   encode(offset, bl);
   encode(length, bl);
+  bool skip_partial_discard = (discard_granularity_bytes > 0);
   encode(skip_partial_discard, bl);
+  encode(discard_granularity_bytes, bl);
 }
 
 void AioDiscardEvent::decode(__u8 version, bufferlist::const_iterator& it) {
   using ceph::decode;
   decode(offset, it);
   decode(length, it);
+
+  bool skip_partial_discard = false;
   if (version >= 4) {
     decode(skip_partial_discard, it);
   }
+
+  if (version >= 5) {
+    decode(discard_granularity_bytes, it);
+  } else {
+    if (skip_partial_discard) {
+      // use a size larger than the maximum object size which will
+      // truncated down to object size during IO processing
+      discard_granularity_bytes = std::numeric_limits<uint32_t>::max();
+    } else {
+      discard_granularity_bytes = 0;
+    }
+  }
 }
 
 void AioDiscardEvent::dump(Formatter *f) const {
   f->dump_unsigned("offset", offset);
   f->dump_unsigned("length", length);
-  f->dump_bool("skip_partial_discard", skip_partial_discard);
+  f->dump_unsigned("discard_granularity_bytes", discard_granularity_bytes);
 }
 
 uint32_t AioWriteEvent::get_fixed_size() {
@@ -399,7 +415,7 @@ EventType EventEntry::get_event_type() const {
 }
 
 void EventEntry::encode(bufferlist& bl) const {
-  ENCODE_START(4, 1, bl);
+  ENCODE_START(5, 1, bl);
   boost::apply_visitor(EncodeVisitor(bl), event);
   ENCODE_FINISH(bl);
   encode_metadata(bl);
@@ -501,7 +517,7 @@ void EventEntry::decode_metadata(bufferlist::const_iterator& it) {
 
 void EventEntry::generate_test_instances(std::list<EventEntry *> &o) {
   o.push_back(new EventEntry(AioDiscardEvent()));
-  o.push_back(new EventEntry(AioDiscardEvent(123, 345, false), utime_t(1, 1)));
+  o.push_back(new EventEntry(AioDiscardEvent(123, 345, 4096), utime_t(1, 1)));
 
   bufferlist bl;
   bl.append(std::string(32, '1'));
diff --git a/src/librbd/journal/Types.h b/src/librbd/journal/Types.h
index 2486d416e292..ae5681ade067 100644
--- a/src/librbd/journal/Types.h
+++ b/src/librbd/journal/Types.h
@@ -51,14 +51,16 @@ enum EventType {
 struct AioDiscardEvent {
   static const EventType TYPE = EVENT_TYPE_AIO_DISCARD;
 
-  uint64_t offset;
-  uint64_t length;
-  bool skip_partial_discard;
+  uint64_t offset = 0;
+  uint64_t length = 0;
+  uint32_t discard_granularity_bytes = 0;
 
-  AioDiscardEvent() : offset(0), length(0), skip_partial_discard(false) {
+  AioDiscardEvent() {
   }
-  AioDiscardEvent(uint64_t _offset, uint64_t _length, bool _skip_partial_discard)
-    : offset(_offset), length(_length), skip_partial_discard(_skip_partial_discard) {
+  AioDiscardEvent(uint64_t _offset, uint64_t _length,
+                  uint32_t discard_granularity_bytes)
+    : offset(_offset), length(_length),
+      discard_granularity_bytes(discard_granularity_bytes) {
   }
 
   void encode(bufferlist& bl) const;
diff --git a/src/librbd/librbd.cc b/src/librbd/librbd.cc
index 3fa1bea1eef3..3969751e5b09 100644
--- a/src/librbd/librbd.cc
+++ b/src/librbd/librbd.cc
@@ -2205,7 +2205,8 @@ namespace librbd {
         tracepoint(librbd, discard_exit, -EINVAL);
         return -EINVAL;
     }
-    int r = ictx->io_work_queue->discard(ofs, len, ictx->skip_partial_discard);
+    int r = ictx->io_work_queue->discard(
+      ofs, len, ictx->discard_granularity_bytes);
     tracepoint(librbd, discard_exit, r);
     return r;
   }
@@ -2224,7 +2225,7 @@ namespace librbd {
 
     bool discard_zero = ictx->config.get_val<bool>("rbd_discard_on_zeroed_write_same");
     if (discard_zero && mem_is_zero(bl.c_str(), bl.length())) {
-      int r = ictx->io_work_queue->discard(ofs, len, false);
+      int r = ictx->io_work_queue->discard(ofs, len, 0);
       tracepoint(librbd, writesame_exit, r);
       return r;
     }
@@ -2295,7 +2296,8 @@ namespace librbd {
   {
     ImageCtx *ictx = (ImageCtx *)ctx;
     tracepoint(librbd, aio_discard_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only, off, len, c->pc);
-    ictx->io_work_queue->aio_discard(get_aio_completion(c), off, len, ictx->skip_partial_discard);
+    ictx->io_work_queue->aio_discard(
+      get_aio_completion(c), off, len, ictx->discard_granularity_bytes);
     tracepoint(librbd, aio_discard_exit, 0);
     return 0;
   }
@@ -2361,7 +2363,7 @@ namespace librbd {
 
     bool discard_zero = ictx->config.get_val<bool>("rbd_discard_on_zeroed_write_same");
     if (discard_zero && mem_is_zero(bl.c_str(), bl.length())) {
-      ictx->io_work_queue->aio_discard(get_aio_completion(c), off, len, false);
+      ictx->io_work_queue->aio_discard(get_aio_completion(c), off, len, 0);
       tracepoint(librbd, aio_writesame_exit, 0);
       return 0;
     }
@@ -5119,7 +5121,8 @@ extern "C" int rbd_discard(rbd_image_t image, uint64_t ofs, uint64_t len)
     return -EINVAL;
   }
 
-  int r = ictx->io_work_queue->discard(ofs, len, ictx->skip_partial_discard);
+  int r = ictx->io_work_queue->discard(
+    ofs, len, ictx->discard_granularity_bytes);
   tracepoint(librbd, discard_exit, r);
   return r;
 }
@@ -5139,7 +5142,7 @@ extern "C" ssize_t rbd_writesame(rbd_image_t image, uint64_t ofs, size_t len,
 
   bool discard_zero = ictx->config.get_val<bool>("rbd_discard_on_zeroed_write_same");
   if (discard_zero && mem_is_zero(buf, data_len)) {
-    int r = ictx->io_work_queue->discard(ofs, len, false);
+    int r = ictx->io_work_queue->discard(ofs, len, 0);
     tracepoint(librbd, writesame_exit, r);
     return r;
   }
@@ -5258,7 +5261,8 @@ extern "C" int rbd_aio_discard(rbd_image_t image, uint64_t off, uint64_t len,
   librbd::ImageCtx *ictx = (librbd::ImageCtx *)image;
   librbd::RBD::AioCompletion *comp = (librbd::RBD::AioCompletion *)c;
   tracepoint(librbd, aio_discard_enter, ictx, ictx->name.c_str(), ictx->snap_name.c_str(), ictx->read_only, off, len, comp->pc);
-  ictx->io_work_queue->aio_discard(get_aio_completion(comp), off, len, ictx->skip_partial_discard);
+  ictx->io_work_queue->aio_discard(
+    get_aio_completion(comp), off, len, ictx->discard_granularity_bytes);
   tracepoint(librbd, aio_discard_exit, 0);
   return 0;
 }
@@ -5361,7 +5365,7 @@ extern "C" int rbd_aio_writesame(rbd_image_t image, uint64_t off, size_t len,
 
   bool discard_zero = ictx->config.get_val<bool>("rbd_discard_on_zeroed_write_same");
   if (discard_zero && mem_is_zero(buf, data_len)) {
-    ictx->io_work_queue->aio_discard(get_aio_completion(comp), off, len, false);
+    ictx->io_work_queue->aio_discard(get_aio_completion(comp), off, len, 0);
     tracepoint(librbd, aio_writesame_exit, 0);
     return 0;
   }
diff --git a/src/test/librbd/deep_copy/test_mock_ObjectCopyRequest.cc b/src/test/librbd/deep_copy/test_mock_ObjectCopyRequest.cc
index 8e70f153794a..73be5c2fe8e8 100644
--- a/src/test/librbd/deep_copy/test_mock_ObjectCopyRequest.cc
+++ b/src/test/librbd/deep_copy/test_mock_ObjectCopyRequest.cc
@@ -749,7 +749,7 @@ TEST_F(TestMockDeepCopyObjectCopyRequest, WriteSnaps) {
 TEST_F(TestMockDeepCopyObjectCopyRequest, Trim) {
   ASSERT_EQ(0, m_src_image_ctx->operations->metadata_set(
               "conf_rbd_skip_partial_discard", "false"));
-  m_src_image_ctx->skip_partial_discard = false;
+  m_src_image_ctx->discard_granularity_bytes = 0;
 
   // scribble some data
   interval_set<uint64_t> one;
@@ -760,7 +760,7 @@ TEST_F(TestMockDeepCopyObjectCopyRequest, Trim) {
   uint64_t trim_offset = rand() % one.range_end();
   ASSERT_LE(0, m_src_image_ctx->io_work_queue->discard(
     trim_offset, one.range_end() - trim_offset,
-    m_src_image_ctx->skip_partial_discard));
+    m_src_image_ctx->discard_granularity_bytes));
   ASSERT_EQ(0, create_snap("copy"));
 
   librbd::MockTestImageCtx mock_src_image_ctx(*m_src_image_ctx);
@@ -813,7 +813,7 @@ TEST_F(TestMockDeepCopyObjectCopyRequest, Remove) {
   // remove the object
   uint64_t object_size = 1 << m_src_image_ctx->order;
   ASSERT_LE(0, m_src_image_ctx->io_work_queue->discard(
-    0, object_size, m_src_image_ctx->skip_partial_discard));
+    0, object_size, m_src_image_ctx->discard_granularity_bytes));
   ASSERT_EQ(0, create_snap("copy"));
   librbd::MockTestImageCtx mock_src_image_ctx(*m_src_image_ctx);
   librbd::MockTestImageCtx mock_dst_image_ctx(*m_dst_image_ctx);
diff --git a/src/test/librbd/io/test_mock_ImageRequest.cc b/src/test/librbd/io/test_mock_ImageRequest.cc
index 9fb071ba08d6..5f5851c3751f 100644
--- a/src/test/librbd/io/test_mock_ImageRequest.cc
+++ b/src/test/librbd/io/test_mock_ImageRequest.cc
@@ -88,6 +88,22 @@ struct TestMockIoImageRequest : public TestMockFixture {
     }
   }
 
+  void expect_object_discard_request(MockTestImageCtx &mock_image_ctx,
+                                     uint64_t object_no, uint64_t offset,
+                                     uint32_t length, int r) {
+    EXPECT_CALL(*mock_image_ctx.io_object_dispatcher, send(_))
+      .WillOnce(Invoke([&mock_image_ctx, object_no, offset, length, r]
+                (ObjectDispatchSpec* spec) {
+                  auto* discard_spec = boost::get<ObjectDispatchSpec::DiscardRequest>(&spec->request);
+                  ASSERT_TRUE(discard_spec != nullptr);
+                  ASSERT_EQ(object_no, discard_spec->object_no);
+                  ASSERT_EQ(offset, discard_spec->object_off);
+                  ASSERT_EQ(length, discard_spec->object_len);
+
+                  spec->dispatch_result = io::DISPATCH_RESULT_COMPLETE;
+                  mock_image_ctx.image_ctx->op_work_queue->queue(&spec->dispatcher_ctx, r);
+                }));
+  }
 
   void expect_object_request_send(MockTestImageCtx &mock_image_ctx,
                                   int r) {
@@ -216,6 +232,90 @@ TEST_F(TestMockIoImageRequest, AioReadAccessTimestamp) {
   ASSERT_EQ(1, aio_comp_ctx_2.wait());
 }
 
+TEST_F(TestMockIoImageRequest, PartialDiscard) {
+  librbd::ImageCtx *ictx;
+  ASSERT_EQ(0, open_image(m_image_name, &ictx));
+  ictx->discard_granularity_bytes = 0;
+
+  MockTestImageCtx mock_image_ctx(*ictx);
+  mock_image_ctx.journal = nullptr;
+
+  InSequence seq;
+  expect_get_modify_timestamp(mock_image_ctx, false);
+  expect_object_discard_request(mock_image_ctx, 0, 16, 63, 0);
+  expect_object_discard_request(mock_image_ctx, 0, 84, 100, 0);
+
+  C_SaferCond aio_comp_ctx;
+  AioCompletion *aio_comp = AioCompletion::create_and_start(
+    &aio_comp_ctx, ictx, AIO_TYPE_DISCARD);
+  MockImageDiscardRequest mock_aio_image_discard(
+    mock_image_ctx, aio_comp, {{16, 63}, {84, 100}},
+    ictx->discard_granularity_bytes, {});
+  {
+    RWLock::RLocker owner_locker(mock_image_ctx.owner_lock);
+    mock_aio_image_discard.send();
+  }
+  ASSERT_EQ(0, aio_comp_ctx.wait());
+}
+
+TEST_F(TestMockIoImageRequest, TailDiscard) {
+  librbd::ImageCtx *ictx;
+  ASSERT_EQ(0, open_image(m_image_name, &ictx));
+  ASSERT_EQ(0, resize(ictx, ictx->layout.object_size));
+  ictx->discard_granularity_bytes = 2 * ictx->layout.object_size;
+
+  MockTestImageCtx mock_image_ctx(*ictx);
+  mock_image_ctx.journal = nullptr;
+
+  InSequence seq;
+  expect_get_modify_timestamp(mock_image_ctx, false);
+  expect_object_discard_request(
+    mock_image_ctx, 0, ictx->layout.object_size - 1024, 1024, 0);
+
+  C_SaferCond aio_comp_ctx;
+  AioCompletion *aio_comp = AioCompletion::create_and_start(
+    &aio_comp_ctx, ictx, AIO_TYPE_DISCARD);
+  MockImageDiscardRequest mock_aio_image_discard(
+    mock_image_ctx, aio_comp,
+    {{ictx->layout.object_size - 1024, 1024}},
+    ictx->discard_granularity_bytes, {});
+  {
+    RWLock::RLocker owner_locker(mock_image_ctx.owner_lock);
+    mock_aio_image_discard.send();
+  }
+  ASSERT_EQ(0, aio_comp_ctx.wait());
+}
+
+TEST_F(TestMockIoImageRequest, DiscardGranularity) {
+  librbd::ImageCtx *ictx;
+  ASSERT_EQ(0, open_image(m_image_name, &ictx));
+  ASSERT_EQ(0, resize(ictx, ictx->layout.object_size));
+  ictx->discard_granularity_bytes = 32;
+
+  MockTestImageCtx mock_image_ctx(*ictx);
+  mock_image_ctx.journal = nullptr;
+
+  InSequence seq;
+  expect_get_modify_timestamp(mock_image_ctx, false);
+  expect_object_discard_request(mock_image_ctx, 0, 32, 32, 0);
+  expect_object_discard_request(mock_image_ctx, 0, 96, 64, 0);
+  expect_object_discard_request(
+    mock_image_ctx, 0, ictx->layout.object_size - 32, 32, 0);
+
+  C_SaferCond aio_comp_ctx;
+  AioCompletion *aio_comp = AioCompletion::create_and_start(
+    &aio_comp_ctx, ictx, AIO_TYPE_DISCARD);
+  MockImageDiscardRequest mock_aio_image_discard(
+    mock_image_ctx, aio_comp,
+    {{16, 63}, {96, 31}, {84, 100}, {ictx->layout.object_size - 33, 33}},
+    ictx->discard_granularity_bytes, {});
+  {
+    RWLock::RLocker owner_locker(mock_image_ctx.owner_lock);
+    mock_aio_image_discard.send();
+  }
+  ASSERT_EQ(0, aio_comp_ctx.wait());
+}
+
 TEST_F(TestMockIoImageRequest, AioWriteJournalAppendDisabled) {
   REQUIRE_FEATURE(RBD_FEATURE_JOURNALING);
 
@@ -251,6 +351,7 @@ TEST_F(TestMockIoImageRequest, AioDiscardJournalAppendDisabled) {
 
   librbd::ImageCtx *ictx;
   ASSERT_EQ(0, open_image(m_image_name, &ictx));
+  ictx->discard_granularity_bytes = 0;
 
   MockTestImageCtx mock_image_ctx(*ictx);
   MockTestJournal mock_journal;
@@ -264,10 +365,8 @@ TEST_F(TestMockIoImageRequest, AioDiscardJournalAppendDisabled) {
   C_SaferCond aio_comp_ctx;
   AioCompletion *aio_comp = AioCompletion::create_and_start(
     &aio_comp_ctx, ictx, AIO_TYPE_DISCARD);
-  MockImageDiscardRequest mock_aio_image_discard(mock_image_ctx, aio_comp,
-                                                 {{0, 1}},
-                                                 ictx->skip_partial_discard,
-                                                 {});
+  MockImageDiscardRequest mock_aio_image_discard(
+    mock_image_ctx, aio_comp, {{0, 1}}, ictx->discard_granularity_bytes, {});
   {
     RWLock::RLocker owner_locker(mock_image_ctx.owner_lock);
     mock_aio_image_discard.send();
diff --git a/src/test/librbd/io/test_mock_ObjectRequest.cc b/src/test/librbd/io/test_mock_ObjectRequest.cc
index 72ae15251726..07f1888c8a24 100644
--- a/src/test/librbd/io/test_mock_ObjectRequest.cc
+++ b/src/test/librbd/io/test_mock_ObjectRequest.cc
@@ -1024,37 +1024,6 @@ TEST_F(TestMockIoObjectRequest, DiscardNoOp) {
   ASSERT_EQ(0, ctx.wait());
 }
 
-TEST_F(TestMockIoObjectRequest, SkipPartialDiscard) {
-  librbd::ImageCtx *ictx;
-  ASSERT_EQ(0, open_image(m_image_name, &ictx));
-
-  MockTestImageCtx mock_image_ctx(*ictx);
-  expect_get_object_size(mock_image_ctx);
-
-  MockExclusiveLock mock_exclusive_lock;
-  if (ictx->test_features(RBD_FEATURE_EXCLUSIVE_LOCK)) {
-    mock_image_ctx.exclusive_lock = &mock_exclusive_lock;
-    expect_is_lock_owner(mock_exclusive_lock);
-  }
-
-  MockObjectMap mock_object_map;
-  if (ictx->test_features(RBD_FEATURE_OBJECT_MAP)) {
-    mock_image_ctx.object_map = &mock_object_map;
-  }
-
-  expect_op_work_queue(mock_image_ctx);
-
-  InSequence seq;
-  expect_get_parent_overlap(mock_image_ctx, CEPH_NOSNAP, 0, 0);
-
-  C_SaferCond ctx;
-  auto req = MockObjectDiscardRequest::create_discard(
-    &mock_image_ctx, ictx->get_object_name(0), 0, 0, 1, mock_image_ctx.snapc,
-    OBJECT_DISCARD_FLAG_SKIP_PARTIAL, {}, &ctx);
-  req->send();
-  ASSERT_EQ(0, ctx.wait());
-}
-
 TEST_F(TestMockIoObjectRequest, WriteSame) {
   librbd::ImageCtx *ictx;
   ASSERT_EQ(0, open_image(m_image_name, &ictx));
diff --git a/src/test/librbd/journal/test_Entries.cc b/src/test/librbd/journal/test_Entries.cc
index 242a352f874a..7b013e76ad0f 100644
--- a/src/test/librbd/journal/test_Entries.cc
+++ b/src/test/librbd/journal/test_Entries.cc
@@ -175,7 +175,8 @@ TEST_F(TestJournalEntries, AioDiscard) {
   C_SaferCond cond_ctx;
   auto c = librbd::io::AioCompletion::create(&cond_ctx);
   c->get();
-  ictx->io_work_queue->aio_discard(c, 123, 234, ictx->skip_partial_discard);
+  ictx->io_work_queue->aio_discard(c, 123, 234,
+                                   ictx->discard_granularity_bytes);
   ASSERT_EQ(0, c->wait_for_complete());
   c->put();
 
diff --git a/src/test/librbd/journal/test_Replay.cc b/src/test/librbd/journal/test_Replay.cc
index 82e862381f8a..b7137b5c612b 100644
--- a/src/test/librbd/journal/test_Replay.cc
+++ b/src/test/librbd/journal/test_Replay.cc
@@ -142,8 +142,8 @@ TEST_F(TestJournalReplay, AioDiscardEvent) {
 
   // inject a discard operation into the journal
   inject_into_journal(ictx,
-                      librbd::journal::AioDiscardEvent(0, payload.size(),
-                                                       ictx->skip_partial_discard));
+                      librbd::journal::AioDiscardEvent(
+                        0, payload.size(), ictx->discard_granularity_bytes));
   close_image(ictx);
 
   // re-open the journal so that it replays the new entry
@@ -155,7 +155,7 @@ TEST_F(TestJournalReplay, AioDiscardEvent) {
                                 librbd::io::ReadResult{read_result}, 0);
   ASSERT_EQ(0, aio_comp->wait_for_complete());
   aio_comp->release();
-  if (ictx->skip_partial_discard) {
+  if (ictx->discard_granularity_bytes > 0) {
     ASSERT_EQ(payload, read_payload);
   } else {
     ASSERT_EQ(std::string(read_payload.size(), '\0'), read_payload);
@@ -170,11 +170,11 @@ TEST_F(TestJournalReplay, AioDiscardEvent) {
 
   // replay several envents and check the commit position
   inject_into_journal(ictx,
-                      librbd::journal::AioDiscardEvent(0, payload.size(),
-                                                       ictx->skip_partial_discard));
+                      librbd::journal::AioDiscardEvent(
+                        0, payload.size(), ictx->discard_granularity_bytes));
   inject_into_journal(ictx,
-                      librbd::journal::AioDiscardEvent(0, payload.size(),
-                                                       ictx->skip_partial_discard));
+                      librbd::journal::AioDiscardEvent(
+                        0, payload.size(), ictx->discard_granularity_bytes));
   close_image(ictx);
 
   ASSERT_EQ(0, open_image(m_image_name, &ictx));
@@ -186,7 +186,7 @@ TEST_F(TestJournalReplay, AioDiscardEvent) {
   // verify lock ordering constraints
   aio_comp = new librbd::io::AioCompletion();
   ictx->io_work_queue->aio_discard(aio_comp, 0, read_payload.size(),
-                                   ictx->skip_partial_discard);
+                                   ictx->discard_granularity_bytes);
   ASSERT_EQ(0, aio_comp->wait_for_complete());
   aio_comp->release();
 }
diff --git a/src/test/librbd/journal/test_mock_Replay.cc b/src/test/librbd/journal/test_mock_Replay.cc
index 19b40ddc4d99..62014bab867d 100644
--- a/src/test/librbd/journal/test_mock_Replay.cc
+++ b/src/test/librbd/journal/test_mock_Replay.cc
@@ -38,12 +38,13 @@ struct ImageRequest<MockReplayImageCtx> {
   }
 
   MOCK_METHOD3(aio_discard, void(AioCompletion *c, const Extents& image_extents,
-                                 bool skip_partial_discard));
+                                 uint32_t discard_granularity_bytes));
   static void aio_discard(MockReplayImageCtx *ictx, AioCompletion *c,
-                          Extents&& image_extents, bool skip_partial_discard,
+                          Extents&& image_extents,
+                          uint32_t discard_granularity_bytes,
                           const ZTracer::Trace &parent_trace) {
     ceph_assert(s_instance != nullptr);
-    s_instance->aio_discard(c, image_extents, skip_partial_discard);
+    s_instance->aio_discard(c, image_extents, discard_granularity_bytes);
   }
 
   MOCK_METHOD1(aio_flush, void(AioCompletion *c));
@@ -147,9 +148,9 @@ public:
 
   void expect_aio_discard(MockIoImageRequest &mock_io_image_request,
                           io::AioCompletion **aio_comp, uint64_t off,
-                          uint64_t len, bool skip_partial_discard) {
+                          uint64_t len, uint32_t discard_granularity_bytes) {
     EXPECT_CALL(mock_io_image_request, aio_discard(_, io::Extents{{off, len}},
-                                                   skip_partial_discard))
+                                                   discard_granularity_bytes))
                   .WillOnce(SaveArg<0>(aio_comp));
   }
 
@@ -385,9 +386,11 @@ TEST_F(TestMockJournalReplay, AioDiscard) {
   io::AioCompletion *aio_comp;
   C_SaferCond on_ready;
   C_SaferCond on_safe;
-  expect_aio_discard(mock_io_image_request, &aio_comp, 123, 456, ictx->skip_partial_discard);
+  expect_aio_discard(mock_io_image_request, &aio_comp, 123, 456,
+                     ictx->discard_granularity_bytes);
   when_process(mock_journal_replay,
-               EventEntry{AioDiscardEvent(123, 456, ictx->skip_partial_discard)},
+               EventEntry{AioDiscardEvent(123, 456,
+                                          ictx->discard_granularity_bytes)},
                &on_ready, &on_safe);
 
   when_complete(mock_image_ctx, aio_comp, 0);
@@ -582,9 +585,11 @@ TEST_F(TestMockJournalReplay, IOError) {
   io::AioCompletion *aio_comp;
   C_SaferCond on_ready;
   C_SaferCond on_safe;
-  expect_aio_discard(mock_io_image_request, &aio_comp, 123, 456, ictx->skip_partial_discard);
+  expect_aio_discard(mock_io_image_request, &aio_comp, 123, 456,
+                     ictx->discard_granularity_bytes);
   when_process(mock_journal_replay,
-               EventEntry{AioDiscardEvent(123, 456, ictx->skip_partial_discard)},
+               EventEntry{AioDiscardEvent(123, 456,
+                                          ictx->discard_granularity_bytes)},
                &on_ready, &on_safe);
 
   when_complete(mock_image_ctx, aio_comp, -EINVAL);
@@ -619,12 +624,14 @@ TEST_F(TestMockJournalReplay, SoftFlushIO) {
     io::AioCompletion *aio_comp;
     io::AioCompletion *flush_comp = nullptr;
     C_SaferCond on_ready;
-    expect_aio_discard(mock_io_image_request, &aio_comp, 123, 456, ictx->skip_partial_discard);
+    expect_aio_discard(mock_io_image_request, &aio_comp, 123, 456,
+                       ictx->discard_granularity_bytes);
     if (i == io_count - 1) {
       expect_aio_flush(mock_io_image_request, &flush_comp);
     }
     when_process(mock_journal_replay,
-                 EventEntry{AioDiscardEvent(123, 456, ictx->skip_partial_discard)},
+                 EventEntry{AioDiscardEvent(123, 456,
+                                            ictx->discard_granularity_bytes)},
                  &on_ready, &on_safes[i]);
     when_complete(mock_image_ctx, aio_comp, 0);
     ASSERT_EQ(0, on_ready.wait());
@@ -710,9 +717,11 @@ TEST_F(TestMockJournalReplay, Flush) {
   io::AioCompletion *aio_comp = nullptr;
   C_SaferCond on_ready;
   C_SaferCond on_safe;
-  expect_aio_discard(mock_io_image_request, &aio_comp, 123, 456, ictx->skip_partial_discard);
+  expect_aio_discard(mock_io_image_request, &aio_comp, 123, 456,
+                     ictx->discard_granularity_bytes);
   when_process(mock_journal_replay,
-               EventEntry{AioDiscardEvent(123, 456, ictx->skip_partial_discard)},
+               EventEntry{AioDiscardEvent(123, 456,
+                                          ictx->discard_granularity_bytes)},
                &on_ready, &on_safe);
 
   when_complete(mock_image_ctx, aio_comp, 0);
@@ -2056,9 +2065,9 @@ TEST_F(TestMockJournalReplay, WritebackCacheDisabled) {
   io::AioCompletion *aio_comp;
   C_SaferCond on_ready;
   C_SaferCond on_safe;
-  expect_aio_discard(mock_io_image_request, &aio_comp, 123, 456, false);
+  expect_aio_discard(mock_io_image_request, &aio_comp, 123, 456, 0);
   when_process(mock_journal_replay,
-               EventEntry{AioDiscardEvent(123, 456, false)},
+               EventEntry{AioDiscardEvent(123, 456, 0)},
                &on_ready, &on_safe);
 
   when_complete(mock_image_ctx, aio_comp, 0);
diff --git a/src/test/librbd/mock/MockImageCtx.h b/src/test/librbd/mock/MockImageCtx.h
index 88e06b7e3b1b..5d2c3d28a5d7 100644
--- a/src/test/librbd/mock/MockImageCtx.h
+++ b/src/test/librbd/mock/MockImageCtx.h
@@ -93,6 +93,7 @@ struct MockImageCtx {
       exclusive_lock(NULL), journal(NULL),
       trace_endpoint(image_ctx.trace_endpoint),
       sparse_read_threshold_bytes(image_ctx.sparse_read_threshold_bytes),
+      discard_granularity_bytes(image_ctx.discard_granularity_bytes),
       mirroring_replay_delay(image_ctx.mirroring_replay_delay),
       non_blocking_aio(image_ctx.non_blocking_aio),
       blkin_trace_all(image_ctx.blkin_trace_all),
@@ -299,6 +300,7 @@ struct MockImageCtx {
   ZTracer::Endpoint trace_endpoint;
 
   uint64_t sparse_read_threshold_bytes;
+  uint32_t discard_granularity_bytes;
   int mirroring_replay_delay;
   bool non_blocking_aio;
   bool blkin_trace_all;
diff --git a/src/test/librbd/mock/cache/MockImageCache.h b/src/test/librbd/mock/cache/MockImageCache.h
index 473f7c8a8b84..dd16a90f62e5 100644
--- a/src/test/librbd/mock/cache/MockImageCache.h
+++ b/src/test/librbd/mock/cache/MockImageCache.h
@@ -28,7 +28,7 @@ struct MockImageCache {
     aio_write_mock(image_extents, bl, fadvise_flags, on_finish);
   }
 
-  MOCK_METHOD4(aio_discard, void(uint64_t, uint64_t, bool, Context *));
+  MOCK_METHOD4(aio_discard, void(uint64_t, uint64_t, uint32_t, Context *));
   MOCK_METHOD1(aio_flush, void(Context *));
   MOCK_METHOD5(aio_writesame_mock, void(uint64_t, uint64_t, ceph::bufferlist& bl,
                                         int, Context *));
diff --git a/src/test/librbd/test_Migration.cc b/src/test/librbd/test_Migration.cc
index ace266948fec..d6c8fac62c0c 100644
--- a/src/test/librbd/test_Migration.cc
+++ b/src/test/librbd/test_Migration.cc
@@ -157,14 +157,12 @@ struct TestMigration : public TestFixture {
     m_ictxs.insert(*ictx);
 
     ASSERT_EQ(0, (*ictx)->state->open(flags));
-    (*ictx)->skip_partial_discard = false;
+    (*ictx)->discard_granularity_bytes = 0;
   }
 
   void open_image(librados::IoCtx& io_ctx, const std::string &name,
                   librbd::ImageCtx **ictx) {
     open_image(io_ctx, name, "", false, 0, ictx);
-    ASSERT_EQ(0, (*ictx)->state->open(0));
-    (*ictx)->skip_partial_discard = false;
   }
 
   void migration_prepare(librados::IoCtx& dst_io_ctx,
diff --git a/src/test/rbd_mirror/test_ImageSync.cc b/src/test/rbd_mirror/test_ImageSync.cc
index f59a8f452bbc..fbd3381116d2 100644
--- a/src/test/rbd_mirror/test_ImageSync.cc
+++ b/src/test/rbd_mirror/test_ImageSync.cc
@@ -47,7 +47,9 @@ void scribble(librbd::ImageCtx *image_ctx, int num_ops, uint64_t max_size)
     uint64_t len = 1 + rand() % max_size;
 
     if (rand() % 4 == 0) {
-      ASSERT_EQ((int)len, image_ctx->io_work_queue->discard(off, len, image_ctx->skip_partial_discard));
+      ASSERT_EQ((int)len,
+                image_ctx->io_work_queue->discard(
+                  off, len, image_ctx->discard_granularity_bytes));
     } else {
       bufferlist bl;
       bl.append(std::string(len, '1'));
@@ -224,8 +226,9 @@ TEST_F(TestImageSync, Discard) {
 
   ASSERT_EQ(0, create_snap(m_remote_image_ctx, "snap", nullptr));
 
-  ASSERT_EQ((int)len - 2, m_remote_image_ctx->io_work_queue->discard(off + 1,
-                                                                     len - 2, m_remote_image_ctx->skip_partial_discard));
+  ASSERT_EQ((int)len - 2,
+            m_remote_image_ctx->io_work_queue->discard(
+              off + 1, len - 2, m_remote_image_ctx->discard_granularity_bytes));
   {
     RWLock::RLocker owner_locker(m_remote_image_ctx->owner_lock);
     ASSERT_EQ(0, flush(m_remote_image_ctx));
diff --git a/src/test/rbd_mirror/test_mock_ImageReplayer.cc b/src/test/rbd_mirror/test_mock_ImageReplayer.cc
index e68455360e73..96aee2f9bf7a 100644
--- a/src/test/rbd_mirror/test_mock_ImageReplayer.cc
+++ b/src/test/rbd_mirror/test_mock_ImageReplayer.cc
@@ -1291,7 +1291,7 @@ TEST_F(TestMockImageReplayer, DelayedReplay) {
   // process with delay
   EXPECT_CALL(mock_replay_entry, get_data());
   librbd::journal::EventEntry event_entry(
-    librbd::journal::AioDiscardEvent(123, 345, false), ceph_clock_now());
+    librbd::journal::AioDiscardEvent(123, 345, 0), ceph_clock_now());
   EXPECT_CALL(mock_local_replay, decode(_, _))
     .WillOnce(DoAll(SetArgPointee<1>(event_entry),
                     Return(0)));