From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001

From: Chris Coulson <chris.coulson@canonical.com>

Date: Thu, 7 Jan 2021 15:15:43 +0000

Subject: [PATCH] kern/buffer: Add variable sized heap buffer

Add a new variable sized heap buffer type (grub_buffer_t) with simple

operations for appending data, accessing the data and maintaining

a read cursor.

Signed-off-by: Chris Coulson <chris.coulson@canonical.com>

Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>

---

 grub-core/Makefile.core.def |   1 +

 grub-core/kern/buffer.c     | 117 +++++++++++++++++++++++++++++++++++

 include/grub/buffer.h       | 144 ++++++++++++++++++++++++++++++++++++++++++++

 3 files changed, 262 insertions(+)

 create mode 100644 grub-core/kern/buffer.c

 create mode 100644 include/grub/buffer.h

diff --git a/grub-core/Makefile.core.def b/grub-core/Makefile.core.def

index 02fbecd4b..612df2e9c 100644

--- a/grub-core/Makefile.core.def

+++ b/grub-core/Makefile.core.def

@@ -112,6 +112,7 @@ kernel = {

   arm_efi_startup = kern/arm/efi/startup.S;

   arm64_efi_startup = kern/arm64/efi/startup.S;

+  common = kern/buffer.c;

   common = kern/command.c;

   common = kern/corecmd.c;

   common = kern/device.c;

diff --git a/grub-core/kern/buffer.c b/grub-core/kern/buffer.c

new file mode 100644

index 000000000..9f5f8b867

--- /dev/null

+++ b/grub-core/kern/buffer.c

@@ -0,0 +1,117 @@

+/*

+ *  GRUB  --  GRand Unified Bootloader

+ *  Copyright (C) 2021  Free Software Foundation, Inc.

+ *

+ *  GRUB is free software: you can redistribute it and/or modify

+ *  it under the terms of the GNU General Public License as published by

+ *  the Free Software Foundation, either version 3 of the License, or

+ *  (at your option) any later version.

+ *

+ *  GRUB 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 General Public License for more details.

+ *

+ *  You should have received a copy of the GNU General Public License

+ *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.

+ */

+

+#include <grub/buffer.h>

+#include <grub/err.h>

+#include <grub/misc.h>

+#include <grub/mm.h>

+#include <grub/safemath.h>

+#include <grub/types.h>

+

+grub_buffer_t

+grub_buffer_new (grub_size_t sz)

+{

+  struct grub_buffer *ret;

+

+  ret = (struct grub_buffer *) grub_malloc (sizeof (*ret));

+  if (ret == NULL)

+    return NULL;

+

+  ret->data = (grub_uint8_t *) grub_malloc (sz);

+  if (ret->data == NULL)

+    {

+      grub_free (ret);

+      return NULL;

+    }

+

+  ret->sz = sz;

+  ret->pos = 0;

+  ret->used = 0;

+

+  return ret;

+}

+

+void

+grub_buffer_free (grub_buffer_t buf)

+{

+  grub_free (buf->data);

+  grub_free (buf);

+}

+

+grub_err_t

+grub_buffer_ensure_space (grub_buffer_t buf, grub_size_t req)

+{

+  grub_uint8_t *d;

+  grub_size_t newsz = 1;

+

+  /* Is the current buffer size adequate? */

+  if (buf->sz >= req)

+    return GRUB_ERR_NONE;

+

+  /* Find the smallest power-of-2 size that satisfies the request. */

+  while (newsz < req)

+    {

+      if (newsz == 0)

+	return grub_error (GRUB_ERR_OUT_OF_RANGE,

+			   N_("requested buffer size is too large"));

+      newsz <<= 1;

+    }

+

+  d = (grub_uint8_t *) grub_realloc (buf->data, newsz);

+  if (d == NULL)

+    return grub_errno;

+

+  buf->data = d;

+  buf->sz = newsz;

+

+  return GRUB_ERR_NONE;

+}

+

+void *

+grub_buffer_take_data (grub_buffer_t buf)

+{

+  void *data = buf->data;

+

+  buf->data = NULL;

+  buf->sz = buf->pos = buf->used = 0;

+

+  return data;

+}

+

+void

+grub_buffer_reset (grub_buffer_t buf)

+{

+  buf->pos = buf->used = 0;

+}

+

+grub_err_t

+grub_buffer_advance_read_pos (grub_buffer_t buf, grub_size_t n)

+{

+  grub_size_t newpos;

+

+  if (grub_add (buf->pos, n, &newpos))

+    return grub_error (GRUB_ERR_OUT_OF_RANGE, N_("overflow is detected"));

+

+  if (newpos > buf->used)

+    return grub_error (GRUB_ERR_OUT_OF_RANGE,

+		       N_("new read is position beyond the end of the written data"));

+

+  buf->pos = newpos;

+

+  return GRUB_ERR_NONE;

+}

diff --git a/include/grub/buffer.h b/include/grub/buffer.h

new file mode 100644

index 000000000..f4b10cf28

--- /dev/null

+++ b/include/grub/buffer.h

@@ -0,0 +1,144 @@

+/*

+ *  GRUB  --  GRand Unified Bootloader

+ *  Copyright (C) 2021  Free Software Foundation, Inc.

+ *

+ *  GRUB is free software: you can redistribute it and/or modify

+ *  it under the terms of the GNU General Public License as published by

+ *  the Free Software Foundation, either version 3 of the License, or

+ *  (at your option) any later version.

+ *

+ *  GRUB 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 General Public License for more details.

+ *

+ *  You should have received a copy of the GNU General Public License

+ *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.

+ */

+

+#ifndef GRUB_BUFFER_H

+#define GRUB_BUFFER_H	1

+

+#include <grub/err.h>

+#include <grub/misc.h>

+#include <grub/mm.h>

+#include <grub/safemath.h>

+#include <grub/types.h>

+

+struct grub_buffer

+{

+  grub_uint8_t *data;

+  grub_size_t sz;

+  grub_size_t pos;

+  grub_size_t used;

+};

+

+/*

+ * grub_buffer_t represents a simple variable sized byte buffer with

+ * read and write cursors. It currently only implements

+ * functionality required by the only user in GRUB (append byte[s],

+ * peeking data at a specified position and updating the read cursor.

+ * Some things that this doesn't do yet are:

+ * - Reading a portion of the buffer by copying data from the current

+ *   read position in to a caller supplied destination buffer and then

+ *   automatically updating the read cursor.

+ * - Dropping the read part at the start of the buffer when an append

+ *   requires more space.

+ */

+typedef struct grub_buffer *grub_buffer_t;

+

+/* Allocate a new buffer with the specified initial size. */

+extern grub_buffer_t grub_buffer_new (grub_size_t sz);

+

+/* Free the buffer and its resources. */

+extern void grub_buffer_free (grub_buffer_t buf);

+

+/* Return the number of unread bytes in this buffer. */

+static inline grub_size_t

+grub_buffer_get_unread_bytes (grub_buffer_t buf)

+{

+  return buf->used - buf->pos;

+}

+

+/*

+ * Ensure that the buffer size is at least the requested

+ * number of bytes.

+ */

+extern grub_err_t grub_buffer_ensure_space (grub_buffer_t buf, grub_size_t req);

+

+/*

+ * Append the specified number of bytes from the supplied

+ * data to the buffer.

+ */

+static inline grub_err_t

+grub_buffer_append_data (grub_buffer_t buf, const void *data, grub_size_t len)

+{

+  grub_size_t req;

+

+  if (grub_add (buf->used, len, &req))

+    return grub_error (GRUB_ERR_OUT_OF_RANGE, N_("overflow is detected"));

+

+  if (grub_buffer_ensure_space (buf, req) != GRUB_ERR_NONE)

+    return grub_errno;

+

+  grub_memcpy (&buf->data[buf->used], data, len);

+  buf->used = req;

+

+  return GRUB_ERR_NONE;

+}

+

+/* Append the supplied character to the buffer. */

+static inline grub_err_t

+grub_buffer_append_char (grub_buffer_t buf, char c)

+{

+  return grub_buffer_append_data (buf, &c, 1);

+}

+

+/*

+ * Forget and return the underlying data buffer. The caller

+ * becomes the owner of this buffer, and must free it when it

+ * is no longer required.

+ */

+extern void *grub_buffer_take_data (grub_buffer_t buf);

+

+/* Reset this buffer. Note that this does not deallocate any resources. */

+void grub_buffer_reset (grub_buffer_t buf);

+

+/*

+ * Return a pointer to the underlying data buffer at the specified

+ * offset from the current read position. Note that this pointer may

+ * become invalid if the buffer is mutated further.

+ */

+static inline void *

+grub_buffer_peek_data_at (grub_buffer_t buf, grub_size_t off)

+{

+  if (grub_add (buf->pos, off, &off))

+    {

+      grub_error (GRUB_ERR_OUT_OF_RANGE, N_("overflow is detected."));

+      return NULL;

+    }

+

+  if (off >= buf->used)

+    {

+      grub_error (GRUB_ERR_OUT_OF_RANGE, N_("peek out of range"));

+      return NULL;

+    }

+

+  return &buf->data[off];

+}

+

+/*

+ * Return a pointer to the underlying data buffer at the current

+ * read position. Note that this pointer may become invalid if the

+ * buffer is mutated further.

+ */

+static inline void *

+grub_buffer_peek_data (grub_buffer_t buf)

+{

+  return grub_buffer_peek_data_at (buf, 0);

+}

+

+/* Advance the read position by the specified number of bytes. */

+extern grub_err_t grub_buffer_advance_read_pos (grub_buffer_t buf, grub_size_t n);

+

+#endif /* GRUB_BUFFER_H */