nbdkit/0021-common-utils-vector-Rename-alloc-to-cap.patch

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