From 24e2694b302f6602e0fc7808a53a766cb983dfb4 Mon Sep 17 00:00:00 2001

From: Nir Soffer <nsoffer@redhat.com>

Date: Fri, 5 Nov 2021 22:59:38 +0200

Subject: [PATCH] common/utils/vector: Rename `alloc` to `cap`

The `alloc` field is the maximum number of items you can append to a

vector before it need to be resized. This may confuse users with the

size of the `ptr` array which is `alloc * itemsize`. Rename to "cap",

common term for this property in many languages (e.g C++, Rust, Go).

Tested with "make check". Tests requiring root or external libraries

(vddk) not tested.

Ported from libnbd commit e3c7f02a2a844295564c832108d36c939c4e4ecf.

(cherry picked from commit 75a44237c4463524dbf7951bb62b59c373c85865)

---

 common/allocators/malloc.c | 24 ++++++++++++------------

 common/utils/vector.c      | 16 ++++++++--------

 common/utils/vector.h      | 12 ++++++------

 plugins/vddk/reexec.c      |  2 +-

 4 files changed, 27 insertions(+), 27 deletions(-)

diff --git a/common/allocators/malloc.c b/common/allocators/malloc.c

index 59409c24..f7474465 100644

--- a/common/allocators/malloc.c

+++ b/common/allocators/malloc.c

@@ -88,16 +88,16 @@ extend (struct m_alloc *ma, uint64_t new_size)

   ACQUIRE_WRLOCK_FOR_CURRENT_SCOPE (&ma->lock);

   size_t old_size, n;

-  if (ma->ba.alloc < new_size) {

-    old_size = ma->ba.alloc;

-    n = new_size - ma->ba.alloc;

+  if (ma->ba.cap < new_size) {

+    old_size = ma->ba.cap;

+    n = new_size - ma->ba.cap;

 #ifdef HAVE_MUNLOCK

     /* Since the memory might be moved by realloc, we must unlock the

      * original array.

      */

     if (ma->use_mlock)

-      munlock (ma->ba.ptr, ma->ba.alloc);

+      munlock (ma->ba.ptr, ma->ba.cap);

 #endif

     if (bytearray_reserve (&ma->ba, n) == -1) {

@@ -110,7 +110,7 @@ extend (struct m_alloc *ma, uint64_t new_size)

 #ifdef HAVE_MLOCK

     if (ma->use_mlock) {

-      if (mlock (ma->ba.ptr, ma->ba.alloc) == -1) {

+      if (mlock (ma->ba.ptr, ma->ba.cap) == -1) {

         nbdkit_error ("allocator=malloc: mlock: %m");

         return -1;

       }

@@ -138,11 +138,11 @@ m_alloc_read (struct allocator *a, void *buf,

   /* Avoid reading beyond the end of the allocated array.  Return

    * zeroes for that part.

    */

-  if (offset >= ma->ba.alloc)

+  if (offset >= ma->ba.cap)

     memset (buf, 0, count);

-  else if (offset + count > ma->ba.alloc) {

-    memcpy (buf, ma->ba.ptr + offset, ma->ba.alloc - offset);

-    memset (buf + ma->ba.alloc - offset, 0, offset + count - ma->ba.alloc);

+  else if (offset + count > ma->ba.cap) {

+    memcpy (buf, ma->ba.ptr + offset, ma->ba.cap - offset);

+    memset (buf + ma->ba.cap - offset, 0, offset + count - ma->ba.cap);

   }

   else

     memcpy (buf, ma->ba.ptr + offset, count);

@@ -191,9 +191,9 @@ m_alloc_zero (struct allocator *a, uint64_t count, uint64_t offset)

   /* Try to avoid extending the array, since the unallocated part

    * always reads as zero.

    */

-  if (offset < ma->ba.alloc) {

-    if (offset + count > ma->ba.alloc)

-      memset (ma->ba.ptr + offset, 0, ma->ba.alloc - offset);

+  if (offset < ma->ba.cap) {

+    if (offset + count > ma->ba.cap)

+      memset (ma->ba.ptr + offset, 0, ma->ba.cap - offset);

     else

       memset (ma->ba.ptr + offset, 0, count);

   }

diff --git a/common/utils/vector.c b/common/utils/vector.c

index 7df17e1b..a4b43ce7 100644

--- a/common/utils/vector.c

+++ b/common/utils/vector.c

@@ -41,21 +41,21 @@ int

 generic_vector_reserve (struct generic_vector *v, size_t n, size_t itemsize)

 {

   void *newptr;

-  size_t reqalloc, newalloc;

+  size_t reqcap, newcap;

-  reqalloc = v->alloc + n;

-  if (reqalloc < v->alloc)

+  reqcap = v->cap + n;

+  if (reqcap < v->cap)

     return -1; /* overflow */

-  newalloc = (v->alloc * 3 + 1) / 2;

+  newcap = (v->cap * 3 + 1) / 2;

-  if (newalloc < reqalloc)

-    newalloc = reqalloc;

+  if (newcap < reqcap)

+    newcap = reqcap;

-  newptr = realloc (v->ptr, newalloc * itemsize);

+  newptr = realloc (v->ptr, newcap * itemsize);

   if (newptr == NULL)

     return -1;

   v->ptr = newptr;

-  v->alloc = newalloc;

+  v->cap = newcap;

   return 0;

 }

diff --git a/common/utils/vector.h b/common/utils/vector.h

index f6a0af78..782dcba6 100644

--- a/common/utils/vector.h

+++ b/common/utils/vector.h

@@ -86,7 +86,7 @@

   struct name {                                                         \

     type *ptr;                 /* Pointer to array of items. */         \

     size_t size;               /* Number of valid items in the array. */ \

-    size_t alloc;              /* Number of items allocated. */         \

+    size_t cap;                /* Maximum number of items. */           \

   };                                                                    \

   typedef struct name name;                                             \

                                                                         \

@@ -106,7 +106,7 @@

   name##_insert (name *v, type elem, size_t i)                          \

   {                                                                     \

     assert (i <= v->size);                                              \

-    if (v->size >= v->alloc) {                                          \

+    if (v->size >= v->cap) {                                            \

       if (name##_reserve (v, 1) == -1) return -1;                       \

     }                                                                   \

     memmove (&v->ptr[i+1], &v->ptr[i], (v->size-i) * sizeof (elem));    \

@@ -137,7 +137,7 @@

   {                                                                     \

     free (v->ptr);                                                      \

     v->ptr = NULL;                                                      \

-    v->size = v->alloc = 0;                                             \

+    v->size = v->cap = 0;                                               \

   }                                                                     \

                                                                         \

   /* Iterate over the vector, calling f() on each element. */           \

@@ -181,17 +181,17 @@

     if (newptr == NULL) return -1;                                      \

     memcpy (newptr, vptr, len);                                         \

     copy->ptr = newptr;                                                 \

-    copy->size = copy->alloc = v->size;                                 \

+    copy->size = copy->cap = v->size;                                   \

     return 0;                                                           \

   }                                                                     \

                                                                         \

-#define empty_vector { .ptr = NULL, .size = 0, .alloc = 0 }

+#define empty_vector { .ptr = NULL, .size = 0, .cap = 0 }

 struct generic_vector {

   void *ptr;

   size_t size;

-  size_t alloc;

+  size_t cap;

 };

 extern int generic_vector_reserve (struct generic_vector *v,

diff --git a/plugins/vddk/reexec.c b/plugins/vddk/reexec.c

index 46acdb62..9e87025e 100644

--- a/plugins/vddk/reexec.c

+++ b/plugins/vddk/reexec.c

@@ -116,7 +116,7 @@ perform_reexec (const char *env, const char *prepend)

       nbdkit_error ("realloc: %m");

       exit (EXIT_FAILURE);

     }

-    r = read (fd, buf.ptr + buf.size, buf.alloc - buf.size);

+    r = read (fd, buf.ptr + buf.size, buf.cap - buf.size);

     if (r == -1) {

       nbdkit_error ("read: %s: %m", cmdline_file);

       exit (EXIT_FAILURE);

-- 

2.31.1