From: Jason Dillaman <dillaman@redhat.com>
Date: Tue, 10 Mar 2015 18:51:51 +0000 (-0400)
Subject: librbd: retrieve image size at start of resize op
X-Git-Tag: v0.94~47^2~1
X-Git-Url: http://git-server-git.apps.pok.os.sepia.ceph.com/?a=commitdiff_plain;h=194fcfd04fa2a4a9479ad48e57504be118f6b68e;p=ceph.git

librbd: retrieve image size at start of resize op

For the case where multiple resize requests were pending,
queued resizes should use the most recent value for the
current image size -- not the image size when the resize
was queued.

Signed-off-by: Jason Dillaman <dillaman@redhat.com>
---

diff --git a/src/librbd/AsyncResizeRequest.cc b/src/librbd/AsyncResizeRequest.cc
index ac64ef6516e0..621d59d967d3 100644
--- a/src/librbd/AsyncResizeRequest.cc
+++ b/src/librbd/AsyncResizeRequest.cc
@@ -17,16 +17,16 @@ namespace librbd
 {
 
 AsyncResizeRequest::AsyncResizeRequest(ImageCtx &image_ctx, Context *on_finish,
-		                       uint64_t original_size,
                                        uint64_t new_size,
-		                       ProgressContext &prog_ctx)
+                                       ProgressContext &prog_ctx)
   : AsyncRequest(image_ctx, on_finish),
-    m_original_size(original_size), m_new_size(new_size),
+    m_original_size(0), m_new_size(new_size),
     m_prog_ctx(prog_ctx), m_new_parent_overlap(0),
     m_xlist_item(this)
 {
   RWLock::WLocker l(m_image_ctx.snap_lock);
   m_image_ctx.async_resize_reqs.push_back(&m_xlist_item);
+  m_original_size = m_image_ctx.size;
   compute_parent_overlap();
 }
 
@@ -37,6 +37,7 @@ AsyncResizeRequest::~AsyncResizeRequest() {
     assert(m_xlist_item.remove_myself());
     if (!m_image_ctx.async_resize_reqs.empty()) {
       next_req = m_image_ctx.async_resize_reqs.front();
+      next_req->m_original_size = m_image_ctx.size;
       next_req->compute_parent_overlap();
     }
   }
diff --git a/src/librbd/AsyncResizeRequest.h b/src/librbd/AsyncResizeRequest.h
index ef806a8d266f..a719c9d59c4c 100644
--- a/src/librbd/AsyncResizeRequest.h
+++ b/src/librbd/AsyncResizeRequest.h
@@ -15,9 +15,8 @@ class ProgressContext;
 class AsyncResizeRequest : public AsyncRequest
 {
 public:
-  AsyncResizeRequest(ImageCtx &image_ctx, Context *on_finish,
-		     uint64_t original_size, uint64_t new_size,
-		     ProgressContext &prog_ctx);
+  AsyncResizeRequest(ImageCtx &image_ctx, Context *on_finish, uint64_t new_size,
+                     ProgressContext &prog_ctx);
   virtual ~AsyncResizeRequest();
 
   virtual void send();
diff --git a/src/librbd/internal.cc b/src/librbd/internal.cc
index f37835a8a7cb..8f5f040f52a9 100644
--- a/src/librbd/internal.cc
+++ b/src/librbd/internal.cc
@@ -1695,25 +1695,23 @@ reprotect_and_return_err:
       return r;
     }
 
-    uint64_t original_size;
     {
       RWLock::RLocker snap_locker(ictx->snap_lock);
       if (ictx->snap_id != CEPH_NOSNAP || ictx->read_only) {
         return -EROFS;
       }
-      original_size = ictx->size;
     }
 
-    async_resize_helper(ictx, ctx, original_size, size, prog_ctx);
+    async_resize_helper(ictx, ctx, size, prog_ctx);
     return 0;
   }
 
-  void async_resize_helper(ImageCtx *ictx, Context *ctx, uint64_t original_size,
-		           uint64_t new_size, ProgressContext& prog_ctx)
+  void async_resize_helper(ImageCtx *ictx, Context *ctx, uint64_t new_size,
+                           ProgressContext& prog_ctx)
   {
     assert(ictx->owner_lock.is_locked());
-    AsyncResizeRequest *req = new AsyncResizeRequest(*ictx, ctx, original_size,
-						     new_size, prog_ctx);
+    AsyncResizeRequest *req = new AsyncResizeRequest(*ictx, ctx, new_size,
+                                                     prog_ctx);
     req->send();
   }
 
@@ -2080,7 +2078,6 @@ reprotect_and_return_err:
 
     RWLock::RLocker l(ictx->owner_lock);
     snap_t snap_id;
-    uint64_t original_size;
     uint64_t new_size;
     {
       RWLock::WLocker l2(ictx->md_lock);
@@ -2112,7 +2109,6 @@ reprotect_and_return_err:
       }
 
       ictx->snap_lock.get_read();
-      original_size = ictx->size;
       new_size = ictx->get_image_size(snap_id);
       ictx->snap_lock.put_read();
 
@@ -2129,7 +2125,7 @@ reprotect_and_return_err:
     ldout(cct, 2) << "resizing to snapshot size..." << dendl;
     NoOpProgressContext no_op;
     C_SaferCond ctx;
-    async_resize_helper(ictx, &ctx, original_size, new_size, no_op);
+    async_resize_helper(ictx, &ctx, new_size, no_op);
 
     r = ctx.wait();
     if (r < 0) {
diff --git a/src/librbd/internal.h b/src/librbd/internal.h
index d164f02ff439..64395ca5ea0f 100644
--- a/src/librbd/internal.h
+++ b/src/librbd/internal.h
@@ -193,8 +193,8 @@ namespace librbd {
   int async_flatten(ImageCtx *ictx, Context *ctx, ProgressContext &prog_ctx);
   int async_resize(ImageCtx *ictx, Context *ctx, uint64_t size,
 		   ProgressContext &prog_ctx);
-  void async_resize_helper(ImageCtx *ictx, Context *ctx, uint64_t original_size,
-			   uint64_t new_size, ProgressContext& prog_ctx);
+  void async_resize_helper(ImageCtx *ictx, Context *ctx, uint64_t new_size,
+                           ProgressContext& prog_ctx);
 
   int aio_write(ImageCtx *ictx, uint64_t off, size_t len, const char *buf,
 		AioCompletion *c, int op_flags);