diff mbox series

[v3,3/6] malloc: Add scratch_buffer_dupfree

Message ID 20201229193454.34558-4-adhemerval.zanella@linaro.org
State New
Headers show
Series Multiple fixes to realpath | expand

Commit Message

Adhemerval Zanella Dec. 29, 2020, 7:34 p.m. UTC
It returns a copy of the buffer up to a defined size.  It will be used
on realpath sync with gnulib.
---
 include/scratch_buffer.h        | 16 +++++++++++++
 malloc/Makefile                 |  1 +
 malloc/Versions                 |  1 +
 malloc/scratch_buffer_dupfree.c | 41 +++++++++++++++++++++++++++++++++
 malloc/tst-scratch_buffer.c     | 26 +++++++++++++++++++--
 5 files changed, 83 insertions(+), 2 deletions(-)
 create mode 100644 malloc/scratch_buffer_dupfree.c
diff mbox series

Patch

diff --git a/include/scratch_buffer.h b/include/scratch_buffer.h
index c39da78629..48d651b41a 100644
--- a/include/scratch_buffer.h
+++ b/include/scratch_buffer.h
@@ -132,4 +132,20 @@  scratch_buffer_set_array_size (struct scratch_buffer *buffer,
 			 (buffer, nelem, size));
 }
 
+/* Return a copy of *BUFFER's first SIZE bytes as a heap-allocated block,
+   deallocating *BUFFER if it was heap-allocated.  SIZE must be at
+   most *BUFFER's size.  Return NULL (setting errno) on memory
+   exhaustion.  */
+void *__libc_scratch_buffer_dupfree (struct scratch_buffer *buffer,
+                                     size_t size);
+libc_hidden_proto (__libc_scratch_buffer_dupfree)
+
+/* Alias for __libc_scratch_dupfree.  */
+static __always_inline void *
+scratch_buffer_dupfree (struct scratch_buffer *buffer, size_t size)
+{
+  void *r = __libc_scratch_buffer_dupfree (buffer, size);
+  return __glibc_likely (r != NULL) ? r : NULL;
+}
+
 #endif /* _SCRATCH_BUFFER_H */
diff --git a/malloc/Makefile b/malloc/Makefile
index 39ffaa7161..ef70b547f9 100644
--- a/malloc/Makefile
+++ b/malloc/Makefile
@@ -74,6 +74,7 @@  tests-exclude-mcheck = tst-mcheck tst-malloc-usable \
 tests-mcheck = $(filter-out $(tests-exclude-mcheck),$(tests))
 
 routines = malloc morecore mcheck mtrace obstack reallocarray \
+  scratch_buffer_dupfree \
   scratch_buffer_grow scratch_buffer_grow_preserve \
   scratch_buffer_set_array_size \
   dynarray_at_failure \
diff --git a/malloc/Versions b/malloc/Versions
index 94c8ba8040..6693c46ee2 100644
--- a/malloc/Versions
+++ b/malloc/Versions
@@ -75,6 +75,7 @@  libc {
     __libc_thread_freeres;
 
     # struct scratch_buffer support
+    __libc_scratch_buffer_dupfree;
     __libc_scratch_buffer_grow;
     __libc_scratch_buffer_grow_preserve;
     __libc_scratch_buffer_set_array_size;
diff --git a/malloc/scratch_buffer_dupfree.c b/malloc/scratch_buffer_dupfree.c
new file mode 100644
index 0000000000..5561e99b0a
--- /dev/null
+++ b/malloc/scratch_buffer_dupfree.c
@@ -0,0 +1,41 @@ 
+/* Variable-sized buffer with on-stack default allocation.
+   Copyright (C) 2020 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <https://www.gnu.org/licenses/>.  */
+
+#ifndef _LIBC
+# include <libc-config.h>
+#endif
+
+#include <scratch_buffer.h>
+#include <string.h>
+
+void *
+__libc_scratch_buffer_dupfree (struct scratch_buffer *buffer, size_t size)
+{
+  void *data = buffer->data;
+  if (data == buffer->__space.__c)
+    {
+      void *copy = malloc (size);
+      return copy != NULL ? memcpy (copy, data, size) : NULL;
+    }
+  else
+    {
+      void *copy = realloc (data, size);
+      return copy != NULL ? copy : data;
+    }
+}
+libc_hidden_def (__libc_scratch_buffer_dupfree)
diff --git a/malloc/tst-scratch_buffer.c b/malloc/tst-scratch_buffer.c
index ef5fb0a8eb..6008113174 100644
--- a/malloc/tst-scratch_buffer.c
+++ b/malloc/tst-scratch_buffer.c
@@ -16,7 +16,10 @@ 
    License along with the GNU C Library; if not, see
    <https://www.gnu.org/licenses/>.  */
 
+#include <array_length.h>
 #include <scratch_buffer.h>
+#include <support/check.h>
+#include <support/support.h>
 #include <stdbool.h>
 #include <stdio.h>
 #include <string.h>
@@ -148,8 +151,27 @@  do_test (void)
 	  && array_size_must_fail (4, ((size_t)-1) / 4)))
 	return 1;
   }
+  {
+    struct scratch_buffer buf;
+    scratch_buffer_init (&buf);
+    memset (buf.data, '@', buf.length);
+
+    size_t sizes[] = { 16, buf.length, buf.length + 16 };
+    for (int i = 0; i < array_length (sizes); i++)
+      {
+        /* The extra size is unitialized through realloc.  */
+        size_t l = sizes[i] > buf.length ? sizes[i] : buf.length;
+        void *r = scratch_buffer_dupfree (&buf, l);
+        void *c = xmalloc (l);
+        memset (c, '@', l);
+        TEST_COMPARE_BLOB (r, l, buf.data, l);
+        free (r);
+        free (c);
+      }
+
+    scratch_buffer_free (&buf);
+  }
   return 0;
 }
 
-#define TEST_FUNCTION do_test ()
-#include "../test-skeleton.c"
+#include <support/test-driver.c>