os/bluestore: return blocks allocated from allocate()

Instead of having a separate output argument with the number of
blocks allocated, just return it via the return value.  Simplifies
the calling convention.

Signed-off-by: Sage Weil <sage@redhat.com>
(cherry picked from commit 95c78706317f2fe61b8f48de5e8539ed49221d64)

diff --git a/src/os/bluestore/Allocator.h b/src/os/bluestore/Allocator.h
index cbcbc3693be9db2b4d2e9693f49aab670c002c43..71549bc3fe73319eda01f748777ce1e2426d3bb2 100644 (file)
--- a/src/os/bluestore/Allocator.h
+++ b/src/os/bluestore/Allocator.h
@@ -35,13 +35,13 @@ public:
    * Apart from that extents can vary between these lower and higher limits according
    * to free block search algorithm and availability of contiguous space.
    */
-  virtual int allocate(uint64_t want_size, uint64_t alloc_unit,
-                       uint64_t max_alloc_size, int64_t hint,
-                       AllocExtentVector *extents, int *count, uint64_t *ret_len) = 0;
+  virtual int64_t allocate(uint64_t want_size, uint64_t alloc_unit,
+                          uint64_t max_alloc_size, int64_t hint,
+                          AllocExtentVector *extents, int *count) = 0;
 
   int allocate(uint64_t want_size, uint64_t alloc_unit,
-               int64_t hint, AllocExtentVector *extents, int *count, uint64_t *ret_len) {
-    return allocate(want_size, alloc_unit, want_size, hint, extents, count, ret_len);
+               int64_t hint, AllocExtentVector *extents, int *count) {
+    return allocate(want_size, alloc_unit, want_size, hint, extents, count);
   }
 
   virtual int release(

diff --git a/src/os/bluestore/BitMapAllocator.cc b/src/os/bluestore/BitMapAllocator.cc
index 326442f5edffd1f1e2d8b53d0cd7cade1996d1ef..7c0877662d93f7987782c5f2786773ee58e1eb56 100644 (file)
--- a/src/os/bluestore/BitMapAllocator.cc
+++ b/src/os/bluestore/BitMapAllocator.cc
@@ -105,9 +105,9 @@ void BitMapAllocator::unreserve(uint64_t unused)
   m_bit_alloc->unreserve_blocks(nblks);
 }
 
-int BitMapAllocator::allocate(
+int64_t BitMapAllocator::allocate(
   uint64_t want_size, uint64_t alloc_unit, uint64_t max_alloc_size,
-  int64_t hint, mempool::bluestore_alloc::vector<AllocExtent> *extents, int *count, uint64_t *ret_len)
+  int64_t hint, mempool::bluestore_alloc::vector<AllocExtent> *extents, int *count)
 {
 
   assert(!(alloc_unit % m_block_size));
@@ -122,27 +122,25 @@ int BitMapAllocator::allocate(
      << dendl;
 
   return allocate_dis(want_size, alloc_unit / m_block_size,
-                      max_alloc_size, hint / m_block_size, extents, count, ret_len); 
+                      max_alloc_size, hint / m_block_size, extents, count);
 }
 
-int BitMapAllocator::allocate_dis(
+int64_t BitMapAllocator::allocate_dis(
   uint64_t want_size, uint64_t alloc_unit, uint64_t max_alloc_size,
-  int64_t hint, mempool::bluestore_alloc::vector<AllocExtent> *extents, int *count, uint64_t *ret_len)
+  int64_t hint, mempool::bluestore_alloc::vector<AllocExtent> *extents, int *count)
 {
   ExtentList block_list = ExtentList(extents, m_block_size, max_alloc_size);
   int64_t nblks = (want_size + m_block_size - 1) / m_block_size;
   int64_t num = 0;
   *count = 0;
-  *ret_len = 0;
 
   num = m_bit_alloc->alloc_blocks_dis_res(nblks, alloc_unit, hint, &block_list);
   if (num == 0) {
     return -ENOSPC;
   }
   *count = block_list.get_extent_count();
-  *ret_len = num * m_block_size;
 
-  return 0;
+  return num * m_block_size;
 }
 
 int BitMapAllocator::release(

diff --git a/src/os/bluestore/BitMapAllocator.h b/src/os/bluestore/BitMapAllocator.h
index a721e23ca057797a0186dad5917ed2043685eea2..bc8a302912846c1408b86dce8f8e9f275c4e78f6 100644 (file)
--- a/src/os/bluestore/BitMapAllocator.h
+++ b/src/os/bluestore/BitMapAllocator.h
@@ -20,8 +20,10 @@ class BitMapAllocator : public Allocator {
 
   void insert_free(uint64_t offset, uint64_t len);
 
-  int allocate_dis(uint64_t want_size, uint64_t alloc_unit, uint64_t max_alloc_size,
-                        int64_t hint, mempool::bluestore_alloc::vector<AllocExtent> *extents, int *count, uint64_t *ret_len);
+  int64_t allocate_dis(
+    uint64_t want_size, uint64_t alloc_unit, uint64_t max_alloc_size,
+    int64_t hint, mempool::bluestore_alloc::vector<AllocExtent> *extents,
+    int *count);
 
 public:
   BitMapAllocator();
@@ -31,9 +33,10 @@ public:
   int reserve(uint64_t need);
   void unreserve(uint64_t unused);
 
-  int allocate(
+  int64_t allocate(
     uint64_t want_size, uint64_t alloc_unit, uint64_t max_alloc_size,
-    int64_t hint, mempool::bluestore_alloc::vector<AllocExtent> *extents, int *count, uint64_t *ret_len);
+    int64_t hint, mempool::bluestore_alloc::vector<AllocExtent> *extents,
+    int *count);
 
   int release(
     uint64_t offset, uint64_t length);

diff --git a/src/os/bluestore/BlueFS.cc b/src/os/bluestore/BlueFS.cc
index 180fb9cf1fbaf8dab51bdca44b5a0a69ba7e2761..2b68791637813c8921782c33c37be2b9b05f33ed 100644 (file)
--- a/src/os/bluestore/BlueFS.cc
+++ b/src/os/bluestore/BlueFS.cc
@@ -178,12 +178,10 @@ int BlueFS::reclaim_blocks(unsigned id, uint64_t want,
   int r = alloc[id]->reserve(want);
   assert(r == 0); // caller shouldn't ask for more than they can get
   int count = 0;
-  uint64_t got = 0;
-  r = alloc[id]->allocate(want, g_conf->bluefs_alloc_size, 0,
-                          extents, &count, &got);
-
-  assert(r >= 0);
-  if (got < want)
+  int64_t got = alloc[id]->allocate(want, g_conf->bluefs_alloc_size, 0,
+                                   extents, &count);
+  assert(got > 0);
+  if (got < (int64_t)want)
     alloc[id]->unreserve(want - got);
 
   for (int i = 0; i < count; i++) {
@@ -1766,16 +1764,15 @@ int BlueFS::_allocate(uint8_t id, uint64_t len,
   }
 
   int count = 0;
-  uint64_t alloc_len = 0;
   AllocExtentVector extents;
-  r = alloc[id]->allocate(left, min_alloc_size, hint,
-                          &extents, &count, &alloc_len);
-  if (r < 0 || alloc_len < left) {
+  int64_t alloc_len = alloc[id]->allocate(left, min_alloc_size, hint,
+                          &extents, &count);
+  if (alloc_len < (int64_t)left) {
     derr << __func__ << " allocate failed on 0x" << std::hex << left
         << " min_alloc_size 0x" << min_alloc_size << std::dec << dendl;
     alloc[id]->dump();
     assert(0 == "allocate failed... wtf");
-    return r;
+    return -ENOSPC;
   }
 
   for (int i = 0; i < count; i++) {

diff --git a/src/os/bluestore/BlueStore.cc b/src/os/bluestore/BlueStore.cc
index d05dd11b279393484fd9a1fff3107aaa9c701e75..f72cfdd17159a7de65542592467bdcbc0085fb2a 100644 (file)
--- a/src/os/bluestore/BlueStore.cc
+++ b/src/os/bluestore/BlueStore.cc
@@ -3621,17 +3621,16 @@ int BlueStore::_balance_bluefs_freespace(vector<bluestore_pextent_t> *extents)
     assert(r == 0);
 
     int count = 0;
-    uint64_t alloc_len = 0;
     AllocExtentVector exts;
-    r = alloc->allocate(gift, g_conf->bluefs_alloc_size, 0, 0, &exts,
-                       &count, &alloc_len);
+    int64_t alloc_len = alloc->allocate(gift, g_conf->bluefs_alloc_size,
+                                       0, 0, &exts, &count);
 
-    if (r < 0 || alloc_len < gift) {
+    if (alloc_len < (int64_t)gift) {
       derr << __func__ << " allocate failed on 0x" << std::hex << gift
            << " min_alloc_size 0x" << min_alloc_size << std::dec << dendl;
       alloc->dump();
       assert(0 == "allocate failed, wtf");
-      return r;
+      return -ENOSPC;
     }
     assert(count > 0);
     
@@ -7877,20 +7876,17 @@ int BlueStore::_do_alloc_write(
     }
 
     int count = 0;
-    uint64_t alloc_len = 0;
     AllocExtentVector extents;
-    int r = alloc->allocate(final_length, min_alloc_size, max_alloc_size,
-                            hint, &extents, &count, &alloc_len);
-    assert(r == 0 && alloc_len == final_length);
-    need -= final_length;
-    txc->statfs_delta.allocated() += final_length;
-    assert(count > 0);
-    hint = extents[count - 1].end();
-
-    for (int i = 0; i < count; i++) {
-      bluestore_pextent_t e = bluestore_pextent_t(extents[i]);
+    int64_t got = alloc->allocate(final_length, min_alloc_size, max_alloc_size,
+                            hint, &extents, &count);
+    assert(got == (int64_t)final_length);
+    need -= got;
+    txc->statfs_delta.allocated() += got;
+    for (auto& p : extents) {
+      bluestore_pextent_t e = bluestore_pextent_t(p);
       txc->allocated.insert(e.offset, e.length);
       dblob.extents.push_back(e);
+      hint = p.end();
     }
 
     dout(20) << __func__ << " blob " << *b

diff --git a/src/os/bluestore/StupidAllocator.cc b/src/os/bluestore/StupidAllocator.cc
index c84ae7bb7268edce570bf1d0f8bc5eb0492f9da0..1cea965da38d22ea2745a80cc1ccb195f46a8280 100644 (file)
--- a/src/os/bluestore/StupidAllocator.cc
+++ b/src/os/bluestore/StupidAllocator.cc
@@ -82,7 +82,7 @@ static uint64_t aligned_len(btree_interval_set<uint64_t>::iterator p,
     return p.get_len() - skew;
 }
 
-int StupidAllocator::allocate_int(
+int64_t StupidAllocator::allocate_int(
   uint64_t want_size, uint64_t alloc_unit, int64_t hint,
   uint64_t *offset, uint32_t *length)
 {
@@ -200,14 +200,13 @@ int StupidAllocator::allocate_int(
   return 0;
 }
 
-int StupidAllocator::allocate(
+int64_t StupidAllocator::allocate(
   uint64_t want_size,
   uint64_t alloc_unit,
   uint64_t max_alloc_size,
   int64_t hint,
   mempool::bluestore_alloc::vector<AllocExtent> *extents,
-  int *count,
-  uint64_t *ret_len)
+  int *count)
 {
   uint64_t allocated_size = 0;
   uint64_t offset = 0;
@@ -218,7 +217,6 @@ int StupidAllocator::allocate(
     max_alloc_size = want_size;
   }
   *count = 0;
-  *ret_len = 0;
 
   ExtentList block_list = ExtentList(extents, 1, max_alloc_size);
 
@@ -237,12 +235,10 @@ int StupidAllocator::allocate(
   }
 
   *count = block_list.get_extent_count();
-  *ret_len = allocated_size;
   if (allocated_size == 0) {
     return -ENOSPC;
   }
-
-  return 0;
+  return allocated_size;
 }
 
 int StupidAllocator::release(

diff --git a/src/os/bluestore/StupidAllocator.h b/src/os/bluestore/StupidAllocator.h
index 004b6d604574fe7ea161ee18cab768270b95e57f..b5bf17295fbdf048ad77da72390ce0149adb46ac 100644 (file)
--- a/src/os/bluestore/StupidAllocator.h
+++ b/src/os/bluestore/StupidAllocator.h
@@ -30,11 +30,12 @@ public:
   int reserve(uint64_t need);
   void unreserve(uint64_t unused);
 
-  int allocate(
+  int64_t allocate(
     uint64_t want_size, uint64_t alloc_unit, uint64_t max_alloc_size,
-    int64_t hint, mempool::bluestore_alloc::vector<AllocExtent> *extents, int *count, uint64_t *ret_len);
+    int64_t hint, mempool::bluestore_alloc::vector<AllocExtent> *extents,
+    int *count);
 
-  int allocate_int(
+  int64_t allocate_int(
     uint64_t want_size, uint64_t alloc_unit, int64_t hint,
     uint64_t *offset, uint32_t *length);