When working on memory, it's nice to be able to test your work.
Add a memtest module. When compiled with --enable-mm-debug, it exposes
3 commands:
* lsmem - print all allocations and free space in all regions
* lsfreemem - print free space in all regions
* stress_big_allocs - stress test large allocations:
- how much memory can we allocate in one chunk?
- how many 1MB chunks can we allocate?
- check that gap-filling works with a 1MB aligned 900kB alloc + a
100kB alloc.
Signed-off-by: Daniel Axtens <d...@axtens.net>
---
I've put this as copyright IBM for now - hopefully we can conclude on
whether we're still doing FSF copyright assignments?
---
grub-core/Makefile.core.def | 5 ++
grub-core/commands/memtools.c | 157 ++++++++++++++++++++++++++++++++++
grub-core/kern/mm.c | 4 +
include/grub/mm.h | 4 +-
4 files changed, 168 insertions(+), 2 deletions(-)
create mode 100644 grub-core/commands/memtools.c
diff --git a/grub-core/Makefile.core.def b/grub-core/Makefile.core.def
index 8022e1c0a794..0cc3a4a500ec 100644
--- a/grub-core/Makefile.core.def
+++ b/grub-core/Makefile.core.def
@@ -2527,3 +2527,8 @@ module = {
common = commands/i386/wrmsr.c;
enable = x86;
};
+
+module = {
+ name = memtools;
+ common = commands/memtools.c;
+};
diff --git a/grub-core/commands/memtools.c b/grub-core/commands/memtools.c
new file mode 100644
index 000000000000..6d5778f4a1b0
--- /dev/null
+++ b/grub-core/commands/memtools.c
@@ -0,0 +1,157 @@
+/*
+ * GRUB -- GRand Unified Bootloader
+ * Copyright (C) 2021 IBM Corporation
+ *
+ * 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 <config.h>
+#include <grub/dl.h>
+#include <grub/misc.h>
+#include <grub/command.h>
+#include <grub/i18n.h>
+#include <grub/memory.h>
+#include <grub/mm.h>
+
+GRUB_MOD_LICENSE ("GPLv3+");
+
+#ifdef MM_DEBUG
+
+static grub_err_t
+grub_cmd_lsmem (grub_command_t cmd __attribute__ ((unused)),
+ int argc __attribute__ ((unused)),
+ char **args __attribute__ ((unused)))
+
+{
+#ifndef GRUB_MACHINE_EMU
+ grub_mm_dump(0);
+#endif
+
+ return 0;
+}
+
+static grub_err_t
+grub_cmd_lsfreemem (grub_command_t cmd __attribute__ ((unused)),
+ int argc __attribute__ ((unused)),
+ char **args __attribute__ ((unused)))
+
+{
+#ifndef GRUB_MACHINE_EMU
+ grub_mm_dump_free();
+#endif
+
+ return 0;
+}
+
+
+#define BIG_ALLOC (64 * 1024 * 1024)
+#define SMALL_ALLOC 32
+
+static grub_err_t
+grub_cmd_stress_big_allocs (grub_command_t cmd __attribute__ ((unused)),
+ int argc __attribute__ ((unused)),
+ char **args __attribute__ ((unused)))
+{
+ int i, max_mb, blocks_alloced;
+ void *mem;
+ void **blocklist;
+
+ grub_printf ("Test 1: increasingly sized allocs to 1GB block\n");
+ for (i = 1; i < 1024; i++) {
+ grub_printf ("%d MB . ", i);
+ mem = grub_malloc (i * 1024 * 1024);
+ if (mem == NULL)
+ {
+ grub_printf ("failed\n");
+ break;
+ }
+ else
+ grub_free (mem);
+
+ if (i % 10 == 0)
+ grub_printf ("\n");
+ }
+
+ max_mb = i - 1;
+ grub_printf ("Max sized allocation we did was %d MB\n", max_mb);
+
+ grub_printf ("Test 2: 1MB at a time, max 4GB\n");
+ blocklist = grub_calloc (4096, sizeof (void *));
+ for (i = 0; i < 4096; i++)
+ {
+ blocklist[i] = grub_malloc (1024 * 1024);
+ if (!blocklist[i])
+ {
+ grub_printf ("Ran out of memory at iteration %d\n", i);
+ break;
+ }
+ }
+ blocks_alloced = i;
+ for (i = 0; i < blocks_alloced; i++)
+ grub_free (blocklist[i]);
+
+ grub_printf ("\nTest 3: 1MB aligned 900kB + 100kB\n");
+ //grub_mm_debug=1;
+ for (i = 0; i < 4096; i += 2)
+ {
+ blocklist[i] = grub_memalign (1024 * 1024, 900 * 1024);
+ if (!blocklist[i])
+ {
+ grub_printf ("Failed big allocation, iteration %d\n", i);
+ blocks_alloced = i;
+ break;
+ }
+
+ blocklist[i + 1] = grub_malloc (100 * 1024);
+ if (!blocklist[i + 1])
+ {
+ grub_printf ("Failed small allocation, iteration %d\n", i);
+ blocks_alloced = i + 1;
+ break;
+ }
+ grub_printf (".");
+ }
+ for (i = 0; i < blocks_alloced; i++)
+ grub_free (blocklist[i]);
+
+ grub_free (blocklist);
+
+ grub_errno = GRUB_ERR_NONE;
+ return GRUB_ERR_NONE;
+}
+
+static grub_command_t cmd_lsmem, cmd_lsfreemem, cmd_sba;
+
+#endif /* MM_DEBUG */
+
+GRUB_MOD_INIT(memtools)
+{
+#ifdef MM_DEBUG
+ cmd_lsmem = grub_register_command ("lsmem", grub_cmd_lsmem,
+ 0, N_("List free and allocated memory
blocks."));
+ cmd_lsfreemem = grub_register_command ("lsfreemem", grub_cmd_lsfreemem,
+ 0, N_("List free memory blocks."));
+ cmd_sba = grub_register_command ("stress_big_allocs",
grub_cmd_stress_big_allocs,
+ 0, N_("Stress test large allocations."));
+#endif
+}
+
+GRUB_MOD_FINI(memtools)
+{
+#ifdef MM_DEBUG
+ grub_unregister_command (cmd_lsmem);
+ grub_unregister_command (cmd_lsfreemem);
+ grub_unregister_command (cmd_sba);
+#endif
+}
diff --git a/grub-core/kern/mm.c b/grub-core/kern/mm.c
index 835ed8a8f6f9..032c8f71aed2 100644
--- a/grub-core/kern/mm.c
+++ b/grub-core/kern/mm.c
@@ -556,6 +556,8 @@ grub_mm_dump_free (void)
{
grub_mm_header_t p;
+ grub_printf ("Region %p (size %" PRIuGRUB_SIZE ")\n\n", r, r->size);
+
/* Follow the free list. */
p = r->first;
do
@@ -583,6 +585,8 @@ grub_mm_dump (unsigned lineno)
{
grub_mm_header_t p;
+ grub_printf ("Region %p (size %" PRIuGRUB_SIZE ")\n\n", r, r->size);
+
for (p = (grub_mm_header_t) ALIGN_UP ((grub_addr_t) (r + 1),
GRUB_MM_ALIGN);
(grub_addr_t) p < (grub_addr_t) (r+1) + r->size;
diff --git a/include/grub/mm.h b/include/grub/mm.h
index 9c38dd3ca5d2..44fde7cb9033 100644
--- a/include/grub/mm.h
+++ b/include/grub/mm.h
@@ -46,8 +46,8 @@ void grub_mm_check_real (const char *file, int line);
/* Set this variable to 1 when you want to trace all memory function calls. */
extern int EXPORT_VAR(grub_mm_debug);
-void grub_mm_dump_free (void);
-void grub_mm_dump (unsigned lineno);
+void EXPORT_FUNC(grub_mm_dump_free) (void);
+void EXPORT_FUNC(grub_mm_dump) (unsigned lineno);
#define grub_calloc(nmemb, size) \
grub_debug_calloc (GRUB_FILE, __LINE__, nmemb, size)
--
2.30.2
_______________________________________________
Grub-devel mailing list
Grub-devel@gnu.org
https://lists.gnu.org/mailman/listinfo/grub-devel
