os/bluestore: add logical offset to lex_old vector for bluestore_onode_t::punch_hole...

Signed-off-by: Igor Fedotov <ifedotov@mirantis.com>

diff --git a/src/os/bluestore/BlueStore.cc b/src/os/bluestore/BlueStore.cc
index fc66885296b7a1542dd4acf1b051f664d27d936d..3ed60bd0c16bdc602d17da507285dce606117786 100644 (file)
--- a/src/os/bluestore/BlueStore.cc
+++ b/src/os/bluestore/BlueStore.cc
@@ -6097,7 +6097,8 @@ void BlueStore::_wctx_finish(
   WriteContext *wctx)
 {
   dout(10) << __func__ << " lex_old " << wctx->lex_old << dendl;
-  for (auto &l : wctx->lex_old) {
+  for (auto &lo : wctx->lex_old) {
+    bluestore_lextent_t& l = lo.second;
     Blob *b = c->get_blob(o, l.blob);
     vector<bluestore_pextent_t> r;
     bool compressed = b->blob.is_compressed();

diff --git a/src/os/bluestore/BlueStore.h b/src/os/bluestore/BlueStore.h
index 9a3b7b1017cb569514643783c535e4ade36436de..343ecebce1b80d04f0000fa0e7f9f45357706fcf 100644 (file)
--- a/src/os/bluestore/BlueStore.h
+++ b/src/os/bluestore/BlueStore.h
@@ -1498,7 +1498,7 @@ private:
     uint64_t comp_blob_size = 0; ///< target compressed blob size
     unsigned csum_order = 0;     ///< target checksum chunk order
 
-    vector<bluestore_lextent_t> lex_old;       ///< must deref blobs
+    vector<std::pair<uint64_t, bluestore_lextent_t> > lex_old; ///< must deref blobs
 
     struct write_item {
       Blob *b;

diff --git a/src/os/bluestore/bluestore_types.cc b/src/os/bluestore/bluestore_types.cc
index efad0a24c8c9a963382f4290ef3f94cc143a06fc..41aa3ec9380e17d608ec788c93db43409d9ed706 100644 (file)
--- a/src/os/bluestore/bluestore_types.cc
+++ b/src/os/bluestore/bluestore_types.cc
@@ -931,7 +931,7 @@ int bluestore_onode_t::compress_extent_map()
 void bluestore_onode_t::punch_hole(
   uint64_t offset,
   uint64_t length,
-  vector<bluestore_lextent_t> *deref)
+  vector<std::pair<uint64_t, bluestore_lextent_t> >*deref)
 {
   auto p = seek_lextent(offset);
   uint64_t end = offset + length;
@@ -944,10 +944,12 @@ void bluestore_onode_t::punch_hole(
        // split and deref middle
        uint64_t front = offset - p->first;
        deref->emplace_back(
-         bluestore_lextent_t(
-           p->second.blob,
-           p->second.offset + front,
-           length));
+          std::make_pair(
+            offset,
+            bluestore_lextent_t(
+              p->second.blob,
+              p->second.offset + front,
+              length)));
        extent_map[end] = bluestore_lextent_t(
          p->second.blob,
          p->second.offset + front + length,
@@ -956,13 +958,15 @@ void bluestore_onode_t::punch_hole(
        break;
       } else {
        // deref tail
-       assert(p->first + p->second.length > offset); // else bug in find_lextent
+       assert(p->first + p->second.length > offset); // else bug in seek_lextent
        uint64_t keep = offset - p->first;
        deref->emplace_back(
-         bluestore_lextent_t(
-           p->second.blob,
-           p->second.offset + keep,
-           p->second.length - keep));
+          std::make_pair(
+            offset,
+            bluestore_lextent_t(
+              p->second.blob,
+              p->second.offset + keep,
+              p->second.length - keep)));
        p->second.length = keep;
        ++p;
        continue;
@@ -970,17 +974,19 @@ void bluestore_onode_t::punch_hole(
     }
     if (p->first + p->second.length <= end) {
       // deref whole lextent
-      deref->push_back(p->second);
+      deref->push_back(std::make_pair(p->first, p->second));
       extent_map.erase(p++);
       continue;
     }
     // deref head
     uint64_t keep = (p->first + p->second.length) - end;
     deref->emplace_back(
-      bluestore_lextent_t(
-       p->second.blob,
-       p->second.offset,
-       p->second.length - keep));
+      std::make_pair(
+        p->first,
+        bluestore_lextent_t(
+          p->second.blob,
+          p->second.offset,
+          p->second.length - keep)));
     extent_map[end] = bluestore_lextent_t(
       p->second.blob,
       p->second.offset + p->second.length - keep,
@@ -993,7 +999,7 @@ void bluestore_onode_t::punch_hole(
 void bluestore_onode_t::set_lextent(uint64_t offset,
                    const bluestore_lextent_t& lext,
                    bluestore_blob_t* b,
-                   vector<bluestore_lextent_t> *deref)
+                   vector<std::pair<uint64_t, bluestore_lextent_t> >*deref)
 {
   punch_hole(offset, lext.length, deref);
   extent_map[offset] = lext;

diff --git a/src/os/bluestore/bluestore_types.h b/src/os/bluestore/bluestore_types.h
index 5547936b1fb6b81fa217292add7a9ff8d383f002..7e8cd858c4ae704c9a7b3a68995439a4565215f9 100644 (file)
--- a/src/os/bluestore/bluestore_types.h
+++ b/src/os/bluestore/bluestore_types.h
@@ -630,13 +630,13 @@ struct bluestore_onode_t {
 
   /// punch a logical hole.  add lextents to deref to target list.
   void punch_hole(uint64_t offset, uint64_t length,
-                 vector<bluestore_lextent_t> *deref);
+                 vector<std::pair<uint64_t, bluestore_lextent_t> >*deref);
 
   /// put new lextent into lextent_map overwriting existing ones if any and update references accordingly
   void set_lextent(uint64_t offset,
                   const bluestore_lextent_t& lext,
                   bluestore_blob_t* b,
-                  vector<bluestore_lextent_t> *deref);
+                  vector<std::pair<uint64_t, bluestore_lextent_t> >*deref);
 
   /// post process removed lextent to take care of blob references
   /// returns true is underlying blob has to be released

diff --git a/src/test/objectstore/test_bluestore_types.cc b/src/test/objectstore/test_bluestore_types.cc
index 1fbff0e515ec376e81b638622d73d1b67833f780..e09e4926f11c6336f3378c8bdc1b772b0c78dbb6 100644 (file)
--- a/src/test/objectstore/test_bluestore_types.cc
+++ b/src/test/objectstore/test_bluestore_types.cc
@@ -767,16 +767,16 @@ TEST(bluestore_onode_t, compress_extent_map)
 TEST(bluestore_onode_t, punch_hole)
 {
   bluestore_onode_t on;
-  vector<bluestore_lextent_t> r;
+  vector<std::pair<uint64_t, bluestore_lextent_t> > r;
   on.extent_map[0] = bluestore_lextent_t(1, 0, 100);
   on.extent_map[100] = bluestore_lextent_t(2, 0, 100);
 
   on.punch_hole(0, 100, &r);
   ASSERT_EQ(1u, on.extent_map.size());
   ASSERT_EQ(1u, r.size());
-  ASSERT_EQ(1, r[0].blob);
-  ASSERT_EQ(0u, r[0].offset);
-  ASSERT_EQ(100u, r[0].length);
+  ASSERT_EQ(1, r[0].second.blob);
+  ASSERT_EQ(0u, r[0].second.offset);
+  ASSERT_EQ(100u, r[0].second.length);
   r.clear();
 
   on.punch_hole(150, 10, &r);
@@ -788,9 +788,9 @@ TEST(bluestore_onode_t, punch_hole)
   ASSERT_EQ(60u, on.extent_map.rbegin()->second.offset);
   ASSERT_EQ(40u, on.extent_map.rbegin()->second.length);
   ASSERT_EQ(1u, r.size());
-  ASSERT_EQ(2, r[0].blob);
-  ASSERT_EQ(50u, r[0].offset);
-  ASSERT_EQ(10u, r[0].length);
+  ASSERT_EQ(2, r[0].second.blob);
+  ASSERT_EQ(50u, r[0].second.offset);
+  ASSERT_EQ(10u, r[0].second.length);
   r.clear();
 
   on.punch_hole(140, 20, &r);
@@ -802,9 +802,9 @@ TEST(bluestore_onode_t, punch_hole)
   ASSERT_EQ(60u, on.extent_map.rbegin()->second.offset);
   ASSERT_EQ(40u, on.extent_map.rbegin()->second.length);
   ASSERT_EQ(1u, r.size());
-  ASSERT_EQ(2, r[0].blob);
-  ASSERT_EQ(40u, r[0].offset);
-  ASSERT_EQ(10u, r[0].length);
+  ASSERT_EQ(2, r[0].second.blob);
+  ASSERT_EQ(40u, r[0].second.offset);
+  ASSERT_EQ(10u, r[0].second.length);
   r.clear();
 
   on.punch_hole(130, 40, &r);
@@ -816,12 +816,12 @@ TEST(bluestore_onode_t, punch_hole)
   ASSERT_EQ(70u, on.extent_map.rbegin()->second.offset);
   ASSERT_EQ(30u, on.extent_map.rbegin()->second.length);
   ASSERT_EQ(2u, r.size());
-  ASSERT_EQ(2, r[0].blob);
-  ASSERT_EQ(30u, r[0].offset);
-  ASSERT_EQ(10u, r[0].length);
-  ASSERT_EQ(2, r[1].blob);
-  ASSERT_EQ(60u, r[1].offset);
-  ASSERT_EQ(10u, r[1].length);
+  ASSERT_EQ(2, r[0].second.blob);
+  ASSERT_EQ(30u, r[0].second.offset);
+  ASSERT_EQ(10u, r[0].second.length);
+  ASSERT_EQ(2, r[1].second.blob);
+  ASSERT_EQ(60u, r[1].second.offset);
+  ASSERT_EQ(10u, r[1].second.length);
   r.clear();
 
   on.punch_hole(110, 10, &r);
@@ -835,30 +835,30 @@ TEST(bluestore_onode_t, punch_hole)
   ASSERT_EQ(70u, on.extent_map.rbegin()->second.offset);
   ASSERT_EQ(30u, on.extent_map.rbegin()->second.length);
   ASSERT_EQ(1u, r.size());
-  ASSERT_EQ(2, r[0].blob);
-  ASSERT_EQ(10u, r[0].offset);
-  ASSERT_EQ(10u, r[0].length);
+  ASSERT_EQ(2, r[0].second.blob);
+  ASSERT_EQ(10u, r[0].second.offset);
+  ASSERT_EQ(10u, r[0].second.length);
   r.clear();
 
   on.punch_hole(0, 1000, &r);
   ASSERT_EQ(0u, on.extent_map.size());
   ASSERT_EQ(3u, r.size());
-  ASSERT_EQ(2, r[0].blob);
-  ASSERT_EQ(0u, r[0].offset);
-  ASSERT_EQ(10u, r[0].length);
-  ASSERT_EQ(2, r[1].blob);
-  ASSERT_EQ(20u, r[1].offset);
-  ASSERT_EQ(10u, r[1].length);
-  ASSERT_EQ(2, r[2].blob);
-  ASSERT_EQ(70u, r[2].offset);
-  ASSERT_EQ(30u, r[2].length);
+  ASSERT_EQ(2, r[0].second.blob);
+  ASSERT_EQ(0u, r[0].second.offset);
+  ASSERT_EQ(10u, r[0].second.length);
+  ASSERT_EQ(2, r[1].second.blob);
+  ASSERT_EQ(20u, r[1].second.offset);
+  ASSERT_EQ(10u, r[1].second.length);
+  ASSERT_EQ(2, r[2].second.blob);
+  ASSERT_EQ(70u, r[2].second.offset);
+  ASSERT_EQ(30u, r[2].second.length);
   r.clear();
 }
 
 TEST(bluestore_onode_t, insert_remove_lextent)
 {
   bluestore_onode_t on;
-  vector<bluestore_lextent_t> r;
+  vector<std::pair<uint64_t, bluestore_lextent_t> > r;
   vector<bluestore_pextent_t> rp;
 
   bluestore_pextent_t pext1(1, 0x10000);
@@ -903,15 +903,15 @@ TEST(bluestore_onode_t, insert_remove_lextent)
 
   ASSERT_EQ(2u, on.extent_map.size());
   ASSERT_EQ(1u, r.size());
-  ASSERT_EQ(2, r[0].blob);
-  ASSERT_EQ(1u, r[0].offset);
-  ASSERT_EQ(99u, r[0].length);
+  ASSERT_EQ(2, r[0].second.blob);
+  ASSERT_EQ(1u, r[0].second.offset);
+  ASSERT_EQ(99u, r[0].second.length);
   ASSERT_TRUE(blob.ref_map.contains(0,100));
   ASSERT_TRUE(blob2.ref_map.empty());
   ASSERT_TRUE(blob3.ref_map.empty());
 
   //deref overwritten lextent
-  empty = on.deref_lextent(100, r[0], &blob2, 0x10000, &rp);
+  empty = on.deref_lextent(100, r[0].second, &blob2, 0x10000, &rp);
   ASSERT_TRUE(empty);
   ASSERT_EQ(1u, rp.size());
   ASSERT_TRUE(pext2.offset == rp[0].offset);
@@ -930,15 +930,15 @@ TEST(bluestore_onode_t, insert_remove_lextent)
 
   ASSERT_EQ(2u, on.extent_map.size());
   ASSERT_EQ(1u, r.size());
-  ASSERT_EQ(1, r[0].blob);
-  ASSERT_EQ(0u, r[0].offset);
-  ASSERT_EQ(100u, r[0].length);
+  ASSERT_EQ(1, r[0].second.blob);
+  ASSERT_EQ(0u, r[0].second.offset);
+  ASSERT_EQ(100u, r[0].second.length);
   ASSERT_TRUE(blob.ref_map.contains(0,100));
   ASSERT_TRUE(blob2.ref_map.empty());
   ASSERT_TRUE(blob3.ref_map.empty());
 
   //deref overwritten lextent
-  empty = on.deref_lextent(0, r[0], &blob, 0x10000, &rp);
+  empty = on.deref_lextent(0, r[0].second, &blob, 0x10000, &rp);
   ASSERT_TRUE(empty);
   ASSERT_EQ(1u, rp.size());
   ASSERT_TRUE(pext1.offset == rp[0].offset);
@@ -961,11 +961,11 @@ TEST(bluestore_onode_t, insert_remove_lextent)
   //deref lextent with underlying blob having multiple references (no ref_map case)
   on.punch_hole(100, 100, &r);
   ASSERT_EQ(1u, r.size());
-  ASSERT_EQ(3, r[0].blob);
-  ASSERT_EQ(1u, r[0].offset);
-  ASSERT_EQ(99u, r[0].length);
+  ASSERT_EQ(3, r[0].second.blob);
+  ASSERT_EQ(1u, r[0].second.offset);
+  ASSERT_EQ(99u, r[0].second.length);
 
-  empty = on.deref_lextent(100, r[0], &blob3, 0x10000, &rp);
+  empty = on.deref_lextent(100, r[0].second, &blob3, 0x10000, &rp);
   ASSERT_FALSE(empty);
   ASSERT_EQ(0u, rp.size());
 
@@ -975,11 +975,11 @@ TEST(bluestore_onode_t, insert_remove_lextent)
   //deref lextent with underlying blob having single reference (no ref_map case)
   on.punch_hole(300, 100, &r);
   ASSERT_EQ(1u, r.size());
-  ASSERT_EQ(3, r[0].blob);
-  ASSERT_EQ(200u, r[0].offset);
-  ASSERT_EQ(50u, r[0].length);
+  ASSERT_EQ(3, r[0].second.blob);
+  ASSERT_EQ(200u, r[0].second.offset);
+  ASSERT_EQ(50u, r[0].second.length);
 
-  empty = on.deref_lextent(300, r[0], &blob3, 0x10000, &rp);
+  empty = on.deref_lextent(300, r[0].second, &blob3, 0x10000, &rp);
   ASSERT_TRUE(empty);
   ASSERT_EQ(1u, rp.size());
   ASSERT_TRUE(pext3.offset == rp[0].offset);
@@ -991,11 +991,11 @@ TEST(bluestore_onode_t, insert_remove_lextent)
 
   //deref lextent partially (no ref_map case)
   on.punch_hole(20, 10, &r);
-  ASSERT_EQ(2, r[0].blob);
-  ASSERT_EQ(20u, r[0].offset);
-  ASSERT_EQ(10u, r[0].length);
+  ASSERT_EQ(2, r[0].second.blob);
+  ASSERT_EQ(20u, r[0].second.offset);
+  ASSERT_EQ(10u, r[0].second.length);
 
-  empty = on.deref_lextent(20, r[0], &blob2, 0x10000, &rp);
+  empty = on.deref_lextent(20, r[0].second, &blob2, 0x10000, &rp);
   ASSERT_FALSE(empty);
   ASSERT_EQ(0u, rp.size());
 
@@ -1005,11 +1005,11 @@ TEST(bluestore_onode_t, insert_remove_lextent)
   //deref lextent partially once again(no ref_map case)
   on.punch_hole(70, 10, &r);
   ASSERT_EQ(1u, r.size());
-  ASSERT_EQ(2, r[0].blob);
-  ASSERT_EQ(70u, r[0].offset);
-  ASSERT_EQ(10u, r[0].length);
+  ASSERT_EQ(2, r[0].second.blob);
+  ASSERT_EQ(70u, r[0].second.offset);
+  ASSERT_EQ(10u, r[0].second.length);
 
-  empty = on.deref_lextent(70, r[0], &blob2, 0x10000, &rp);
+  empty = on.deref_lextent(70, r[0].second, &blob2, 0x10000, &rp);
   ASSERT_FALSE(empty);
   ASSERT_EQ(0u, rp.size());
 
@@ -1019,29 +1019,29 @@ TEST(bluestore_onode_t, insert_remove_lextent)
   //deref fragmented lextent totally (no ref_map case)
   on.punch_hole(0, 100, &r);
   ASSERT_EQ(3u, r.size());
-  ASSERT_EQ(2, r[0].blob);
-  ASSERT_EQ(0u, r[0].offset);
-  ASSERT_EQ(20u, r[0].length);
-  ASSERT_EQ(2, r[1].blob);
-  ASSERT_EQ(30u, r[1].offset);
-  ASSERT_EQ(40u, r[1].length);
-  ASSERT_EQ(2, r[2].blob);
-  ASSERT_EQ(80u, r[2].offset);
-  ASSERT_EQ(20u, r[2].length);
-
-  empty = on.deref_lextent(0, r[0], &blob2, 0x10000, &rp);
+  ASSERT_EQ(2, r[0].second.blob);
+  ASSERT_EQ(0u, r[0].second.offset);
+  ASSERT_EQ(20u, r[0].second.length);
+  ASSERT_EQ(2, r[1].second.blob);
+  ASSERT_EQ(30u, r[1].second.offset);
+  ASSERT_EQ(40u, r[1].second.length);
+  ASSERT_EQ(2, r[2].second.blob);
+  ASSERT_EQ(80u, r[2].second.offset);
+  ASSERT_EQ(20u, r[2].second.length);
+
+  empty = on.deref_lextent(0, r[0].second, &blob2, 0x10000, &rp);
   ASSERT_TRUE(empty);
   ASSERT_EQ(1u, rp.size());
   ASSERT_TRUE(pext2.offset == rp[0].offset);
   ASSERT_TRUE(pext2.length == rp[0].length);
   rp.clear();
 
-  empty = on.deref_lextent(30, r[1], &blob2, 0x10000, &rp);
+  empty = on.deref_lextent(30, r[1].second, &blob2, 0x10000, &rp);
   ASSERT_TRUE(empty);
   ASSERT_EQ(0u, rp.size()); //no more pextents for the blob, already deallocated above
   rp.clear();
 
-  empty = on.deref_lextent(80, r[2], &blob2, 0x10000, &rp);
+  empty = on.deref_lextent(80, r[2].second, &blob2, 0x10000, &rp);
   ASSERT_TRUE(empty);
   ASSERT_EQ(0u, rp.size()); //no more pextents for the blob, already deallocated above