From d7169bcbb6762f9cfee14f0d52f3fac2f4ec144f Mon Sep 17 00:00:00 2001 From: Stefan Berger Date: Thu, 30 Nov 2023 09:17:15 -0500 Subject: [PATCH 01/10] kern/ieee1275/init/ppc64: Introduce a request for regions_claim() The regions_claim() function limits the allocation of memory regions by excluding certain memory areas from being used by GRUB. This for example includes a gap between 640MB and 768MB as well as an upper limit beyond which no memory may be used when an fadump is present. However, the ieee1275 loader for kernel and initrd currently does not use regions_claim() for memory allocation on PowerVM and KVM on Power and therefore may allocate memory in those areas that it should not use. To make the regions_claim() function more flexible and ultimately usable for the ieee1275 loader, introduce a request structure to pass various parameters to the regions_claim() function that describe the properties of requested memory chunks. In a first step, move the total and flags variables into this structure. Signed-off-by: Stefan Berger Reviewed-by: Daniel Kiper Cc: Hari Bathini Cc: Pavithra Prakash Cc: Michael Ellerman Cc: Carolyn Scherrer Cc: Mahesh Salgaonkar Cc: Sourabh Jain --- grub-core/Makefile.am | 2 ++ grub-core/kern/ieee1275/init.c | 43 ++++++++++++++++++++++++++-------- include/grub/ieee1275/alloc.h | 31 ++++++++++++++++++++++++ 3 files changed, 66 insertions(+), 10 deletions(-) create mode 100644 include/grub/ieee1275/alloc.h diff --git a/grub-core/Makefile.am b/grub-core/Makefile.am index dd49939aaa..dc1c158450 100644 --- a/grub-core/Makefile.am +++ b/grub-core/Makefile.am @@ -155,6 +155,7 @@ endif if COND_i386_ieee1275 KERNEL_HEADER_FILES += $(top_builddir)/include/grub/machine/kernel.h KERNEL_HEADER_FILES += $(top_srcdir)/include/grub/ieee1275/ieee1275.h +KERNEL_HEADER_FILES += $(top_srcdir)/include/grub/ieee1275/alloc.h KERNEL_HEADER_FILES += $(top_srcdir)/include/grub/terminfo.h KERNEL_HEADER_FILES += $(top_srcdir)/include/grub/extcmd.h KERNEL_HEADER_FILES += $(top_srcdir)/include/grub/lib/arg.h @@ -242,6 +243,7 @@ endif if COND_powerpc_ieee1275 KERNEL_HEADER_FILES += $(top_srcdir)/include/grub/ieee1275/ieee1275.h +KERNEL_HEADER_FILES += $(top_srcdir)/include/grub/ieee1275/alloc.h KERNEL_HEADER_FILES += $(top_srcdir)/include/grub/terminfo.h KERNEL_HEADER_FILES += $(top_srcdir)/include/grub/extcmd.h KERNEL_HEADER_FILES += $(top_srcdir)/include/grub/lib/arg.h diff --git a/grub-core/kern/ieee1275/init.c b/grub-core/kern/ieee1275/init.c index 8e7f742fad..80100eca1d 100644 --- a/grub-core/kern/ieee1275/init.c +++ b/grub-core/kern/ieee1275/init.c @@ -46,6 +46,9 @@ #ifdef __sparc__ #include #endif +#if defined(__powerpc__) || defined(__i386__) +#include +#endif #include /* The maximum heap size we're going to claim at boot. Not used by sparc. */ @@ -319,9 +322,9 @@ count_free (grub_uint64_t addr, grub_uint64_t len, grub_memory_type_t type, static int regions_claim (grub_uint64_t addr, grub_uint64_t len, grub_memory_type_t type, - unsigned int flags, void *data) + void *data) { - grub_uint32_t total = *(grub_uint32_t *) data; + struct regions_claim_request *rcr = data; grub_uint64_t linux_rmo_save; if (type != GRUB_MEMORY_AVAILABLE) @@ -501,11 +504,11 @@ regions_claim (grub_uint64_t addr, grub_uint64_t len, grub_memory_type_t type, } } } - if (flags & GRUB_MM_ADD_REGION_CONSECUTIVE && len < total) + if (rcr->flags & GRUB_MM_ADD_REGION_CONSECUTIVE && len < rcr->total) return 0; - if (len > total) - len = total; + if (len > rcr->total) + len = rcr->total; if (len) { @@ -515,12 +518,12 @@ regions_claim (grub_uint64_t addr, grub_uint64_t len, grub_memory_type_t type, if (err) return err; grub_mm_init_region ((void *) (grub_addr_t) addr, len); - total -= len; + rcr->total -= len; } - *(grub_uint32_t *) data = total; + *(grub_uint32_t *) data = rcr->total; - if (total == 0) + if (rcr->total == 0) return 1; return 0; @@ -530,14 +533,34 @@ static int heap_init (grub_uint64_t addr, grub_uint64_t len, grub_memory_type_t type, void *data) { - return regions_claim (addr, len, type, GRUB_MM_ADD_REGION_NONE, data); + struct regions_claim_request rcr = { + .flags = GRUB_MM_ADD_REGION_NONE, + .total = *(grub_uint32_t *) data, + }; + int ret; + + ret = regions_claim (addr, len, type, &rcr); + + *(grub_uint32_t *) data = rcr.total; + + return ret; } static int region_claim (grub_uint64_t addr, grub_uint64_t len, grub_memory_type_t type, void *data) { - return regions_claim (addr, len, type, GRUB_MM_ADD_REGION_CONSECUTIVE, data); + struct regions_claim_request rcr = { + .flags = GRUB_MM_ADD_REGION_CONSECUTIVE, + .total = *(grub_uint32_t *) data, + }; + int ret; + + ret = regions_claim (addr, len, type, &rcr); + + *(grub_uint32_t *) data = rcr.total; + + return ret; } static grub_err_t diff --git a/include/grub/ieee1275/alloc.h b/include/grub/ieee1275/alloc.h new file mode 100644 index 0000000000..12fade5e4c --- /dev/null +++ b/include/grub/ieee1275/alloc.h @@ -0,0 +1,31 @@ +/* alloc.h - Memory allocation for PowerVM, KVM on Power, and i386 */ +/* + * GRUB -- GRand Unified Bootloader + * Copyright (C) 2023 Free Software Foundation, Inc. + * Copyright (C) 2023 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 . + */ + +#ifndef GRUB_IEEE1275_ALLOC_HEADER +#define GRUB_IEEE1275_ALLOC_HEADER 1 + +#include + +struct regions_claim_request { + unsigned int flags; /* GRUB_MM_ADD_REGION_(NONE|CONSECUTIVE) */ + grub_uint32_t total; /* number of requested bytes */ +}; + +#endif /* GRUB_IEEE1275_ALLOC_HEADER */ From 0d9ab5fe17da29821e0ca7494a7a85c025e443c8 Mon Sep 17 00:00:00 2001 From: Stefan Berger Date: Thu, 30 Nov 2023 09:17:16 -0500 Subject: [PATCH 02/10] kern/ieee1275/init/ppc64: Decide by request whether to initialize region Let the regions_claim() request structure's init_region determine whether to call grub_mm_init_region() on it. This allows for adding memory to GRUB's memory heap if init_region is set to true, or direct usage of the memory otherwise. Set all current callers' init_region to true since they want to add memory regions to GRUB's heap. Signed-off-by: Stefan Berger Reviewed-by: Daniel Kiper Cc: Hari Bathini Cc: Pavithra Prakash Cc: Michael Ellerman Cc: Carolyn Scherrer Cc: Mahesh Salgaonkar Cc: Sourabh Jain --- grub-core/kern/ieee1275/init.c | 5 ++++- include/grub/ieee1275/alloc.h | 3 +++ 2 files changed, 7 insertions(+), 1 deletion(-) diff --git a/grub-core/kern/ieee1275/init.c b/grub-core/kern/ieee1275/init.c index 80100eca1d..c4c6168dda 100644 --- a/grub-core/kern/ieee1275/init.c +++ b/grub-core/kern/ieee1275/init.c @@ -517,7 +517,8 @@ regions_claim (grub_uint64_t addr, grub_uint64_t len, grub_memory_type_t type, err = grub_claimmap (addr, len); if (err) return err; - grub_mm_init_region ((void *) (grub_addr_t) addr, len); + if (rcr->init_region) + grub_mm_init_region ((void *) (grub_addr_t) addr, len); rcr->total -= len; } @@ -536,6 +537,7 @@ heap_init (grub_uint64_t addr, grub_uint64_t len, grub_memory_type_t type, struct regions_claim_request rcr = { .flags = GRUB_MM_ADD_REGION_NONE, .total = *(grub_uint32_t *) data, + .init_region = true, }; int ret; @@ -553,6 +555,7 @@ region_claim (grub_uint64_t addr, grub_uint64_t len, grub_memory_type_t type, struct regions_claim_request rcr = { .flags = GRUB_MM_ADD_REGION_CONSECUTIVE, .total = *(grub_uint32_t *) data, + .init_region = true, }; int ret; diff --git a/include/grub/ieee1275/alloc.h b/include/grub/ieee1275/alloc.h index 12fade5e4c..523f51fc6b 100644 --- a/include/grub/ieee1275/alloc.h +++ b/include/grub/ieee1275/alloc.h @@ -21,11 +21,14 @@ #ifndef GRUB_IEEE1275_ALLOC_HEADER #define GRUB_IEEE1275_ALLOC_HEADER 1 +#include + #include struct regions_claim_request { unsigned int flags; /* GRUB_MM_ADD_REGION_(NONE|CONSECUTIVE) */ grub_uint32_t total; /* number of requested bytes */ + bool init_region; /* whether to add memory to the heap using grub_mm_init_region() */ }; #endif /* GRUB_IEEE1275_ALLOC_HEADER */ From e13993a725fd49c744aadd5c32faf583cfd28611 Mon Sep 17 00:00:00 2001 From: Stefan Berger Date: Thu, 30 Nov 2023 09:17:17 -0500 Subject: [PATCH 03/10] kern/ieee1275/init/ppc64: Return allocated address using context Return the allocated address of the memory block in the request structure if a memory allocation was actually done. Leave the address untouched otherwise. This enables a caller who wants to use the allocated memory directly, rather than adding the memory to the heap, to see where memory was allocated. None of the current callers need this but the converted ieee1275 loader will make use of it. Signed-off-by: Stefan Berger Reviewed-by: Daniel Kiper Cc: Hari Bathini Cc: Pavithra Prakash Cc: Michael Ellerman Cc: Carolyn Scherrer Cc: Mahesh Salgaonkar Cc: Sourabh Jain --- grub-core/kern/ieee1275/init.c | 2 ++ include/grub/ieee1275/alloc.h | 1 + 2 files changed, 3 insertions(+) diff --git a/grub-core/kern/ieee1275/init.c b/grub-core/kern/ieee1275/init.c index c4c6168dda..a619b09c6c 100644 --- a/grub-core/kern/ieee1275/init.c +++ b/grub-core/kern/ieee1275/init.c @@ -520,6 +520,8 @@ regions_claim (grub_uint64_t addr, grub_uint64_t len, grub_memory_type_t type, if (rcr->init_region) grub_mm_init_region ((void *) (grub_addr_t) addr, len); rcr->total -= len; + + rcr->addr = addr; } *(grub_uint32_t *) data = rcr->total; diff --git a/include/grub/ieee1275/alloc.h b/include/grub/ieee1275/alloc.h index 523f51fc6b..f3065ff31f 100644 --- a/include/grub/ieee1275/alloc.h +++ b/include/grub/ieee1275/alloc.h @@ -29,6 +29,7 @@ struct regions_claim_request { unsigned int flags; /* GRUB_MM_ADD_REGION_(NONE|CONSECUTIVE) */ grub_uint32_t total; /* number of requested bytes */ bool init_region; /* whether to add memory to the heap using grub_mm_init_region() */ + grub_uint64_t addr; /* result address */ }; #endif /* GRUB_IEEE1275_ALLOC_HEADER */ From 5629bbf9c9f4cba61ccba46cd639978a70350b6a Mon Sep 17 00:00:00 2001 From: Stefan Berger Date: Thu, 30 Nov 2023 09:17:18 -0500 Subject: [PATCH 04/10] kern/ieee1275/init/ppc64: Add support for alignment requirements Add support for memory alignment requirements and adjust a candidate address to it before checking whether the block is large enough. This must be done in this order since the alignment adjustment can make a block smaller than what was requested. None of the current callers has memory alignment requirements but the ieee1275 loader for kernel and initrd will use it to convey them. Signed-off-by: Stefan Berger Reviewed-by: Daniel Kiper Cc: Hari Bathini Cc: Pavithra Prakash Cc: Michael Ellerman Cc: Carolyn Scherrer Cc: Mahesh Salgaonkar Cc: Sourabh Jain --- grub-core/kern/ieee1275/init.c | 14 ++++++++++++++ include/grub/ieee1275/alloc.h | 1 + 2 files changed, 15 insertions(+) diff --git a/grub-core/kern/ieee1275/init.c b/grub-core/kern/ieee1275/init.c index a619b09c6c..3d60534fa7 100644 --- a/grub-core/kern/ieee1275/init.c +++ b/grub-core/kern/ieee1275/init.c @@ -504,6 +504,20 @@ regions_claim (grub_uint64_t addr, grub_uint64_t len, grub_memory_type_t type, } } } + + /* Honor alignment restrictions on candidate addr */ + if (rcr->align) + { + grub_uint64_t align_addr = ALIGN_UP (addr, rcr->align); + grub_uint64_t d = align_addr - addr; + + if (d > len) + return 0; + + len -= d; + addr = align_addr; + } + if (rcr->flags & GRUB_MM_ADD_REGION_CONSECUTIVE && len < rcr->total) return 0; diff --git a/include/grub/ieee1275/alloc.h b/include/grub/ieee1275/alloc.h index f3065ff31f..e314c989de 100644 --- a/include/grub/ieee1275/alloc.h +++ b/include/grub/ieee1275/alloc.h @@ -30,6 +30,7 @@ struct regions_claim_request { grub_uint32_t total; /* number of requested bytes */ bool init_region; /* whether to add memory to the heap using grub_mm_init_region() */ grub_uint64_t addr; /* result address */ + grub_size_t align; /* alignment restrictions */ }; #endif /* GRUB_IEEE1275_ALLOC_HEADER */ From a9682bdab6bf5c0b3913a3077eecb55e755b36fb Mon Sep 17 00:00:00 2001 From: Stefan Berger Date: Thu, 30 Nov 2023 09:17:19 -0500 Subject: [PATCH 05/10] kern/ieee1275/init/ppc64: Rename regions_claim() to grub_regions_claim() Rename regions_claim() to grub_regions_claim() to make it available for memory allocation. The ieee1275 loader will use this function on PowerVM and KVM on Power and thus avoid usage of memory that it is not allowed to use. Signed-off-by: Stefan Berger Reviewed-by: Daniel Kiper Cc: Hari Bathini Cc: Pavithra Prakash Cc: Michael Ellerman Cc: Carolyn Scherrer Cc: Mahesh Salgaonkar Cc: Sourabh Jain --- grub-core/kern/ieee1275/init.c | 10 +++++----- include/grub/ieee1275/alloc.h | 3 +++ 2 files changed, 8 insertions(+), 5 deletions(-) diff --git a/grub-core/kern/ieee1275/init.c b/grub-core/kern/ieee1275/init.c index 3d60534fa7..2771db87c4 100644 --- a/grub-core/kern/ieee1275/init.c +++ b/grub-core/kern/ieee1275/init.c @@ -320,9 +320,9 @@ count_free (grub_uint64_t addr, grub_uint64_t len, grub_memory_type_t type, return 0; } -static int -regions_claim (grub_uint64_t addr, grub_uint64_t len, grub_memory_type_t type, - void *data) +int +grub_regions_claim (grub_uint64_t addr, grub_uint64_t len, + grub_memory_type_t type, void *data) { struct regions_claim_request *rcr = data; grub_uint64_t linux_rmo_save; @@ -557,7 +557,7 @@ heap_init (grub_uint64_t addr, grub_uint64_t len, grub_memory_type_t type, }; int ret; - ret = regions_claim (addr, len, type, &rcr); + ret = grub_regions_claim (addr, len, type, &rcr); *(grub_uint32_t *) data = rcr.total; @@ -575,7 +575,7 @@ region_claim (grub_uint64_t addr, grub_uint64_t len, grub_memory_type_t type, }; int ret; - ret = regions_claim (addr, len, type, &rcr); + ret = grub_regions_claim (addr, len, type, &rcr); *(grub_uint32_t *) data = rcr.total; diff --git a/include/grub/ieee1275/alloc.h b/include/grub/ieee1275/alloc.h index e314c989de..67a7856572 100644 --- a/include/grub/ieee1275/alloc.h +++ b/include/grub/ieee1275/alloc.h @@ -33,4 +33,7 @@ struct regions_claim_request { grub_size_t align; /* alignment restrictions */ }; +int EXPORT_FUNC(grub_regions_claim) (grub_uint64_t addr, grub_uint64_t len, + grub_memory_type_t type, void *data); + #endif /* GRUB_IEEE1275_ALLOC_HEADER */ From dfa79a764ddaf5526d627df4e7ba57af83bf9f80 Mon Sep 17 00:00:00 2001 From: Stefan Berger Date: Thu, 30 Nov 2023 09:17:20 -0500 Subject: [PATCH 06/10] kern/ieee1275/cmain/ppc64: Introduce flags to identify KVM and PowerVM Introduce flags to identify PowerVM and KVM on Power and set them where each type of host has been detected. Signed-off-by: Stefan Berger Reviewed-by: Daniel Kiper Cc: Hari Bathini Cc: Pavithra Prakash Cc: Michael Ellerman Cc: Carolyn Scherrer Cc: Mahesh Salgaonkar Cc: Sourabh Jain --- grub-core/kern/ieee1275/cmain.c | 8 +++++++- include/grub/ieee1275/ieee1275.h | 4 ++++ 2 files changed, 11 insertions(+), 1 deletion(-) diff --git a/grub-core/kern/ieee1275/cmain.c b/grub-core/kern/ieee1275/cmain.c index cb42f60ebe..810a089a93 100644 --- a/grub-core/kern/ieee1275/cmain.c +++ b/grub-core/kern/ieee1275/cmain.c @@ -129,7 +129,10 @@ grub_ieee1275_find_options (void) #if defined(__powerpc__) if (grub_strncmp (tmp, "IBM,", 4) == 0) - grub_ieee1275_set_flag (GRUB_IEEE1275_FLAG_CAN_TRY_CAS_FOR_MORE_MEMORY); + { + grub_ieee1275_set_flag (GRUB_IEEE1275_FLAG_CAN_TRY_CAS_FOR_MORE_MEMORY); + grub_ieee1275_set_flag (GRUB_IEEE1275_FLAG_POWER_VM); + } #endif } @@ -196,6 +199,9 @@ grub_ieee1275_find_options (void) grub_ieee1275_set_flag (GRUB_IEEE1275_FLAG_NO_PRE1_5M_CLAIM); grub_ieee1275_set_flag (GRUB_IEEE1275_FLAG_HAS_CURSORONOFF); +#if defined(__powerpc__) + grub_ieee1275_set_flag (GRUB_IEEE1275_FLAG_POWER_KVM); +#endif } } diff --git a/include/grub/ieee1275/ieee1275.h b/include/grub/ieee1275/ieee1275.h index 27b9cf259b..3fee66569d 100644 --- a/include/grub/ieee1275/ieee1275.h +++ b/include/grub/ieee1275/ieee1275.h @@ -152,6 +152,10 @@ enum grub_ieee1275_flag */ GRUB_IEEE1275_FLAG_CAN_TRY_CAS_FOR_MORE_MEMORY, #endif + + GRUB_IEEE1275_FLAG_POWER_VM, + + GRUB_IEEE1275_FLAG_POWER_KVM, }; extern int EXPORT_FUNC(grub_ieee1275_test_flag) (enum grub_ieee1275_flag flag); From f716e38bbcc3146dbae049d852f1912143e862a6 Mon Sep 17 00:00:00 2001 From: Stefan Berger Date: Thu, 30 Nov 2023 09:17:21 -0500 Subject: [PATCH 07/10] loader/powerpc/ieee1275: Use new allocation function for kernel and initrd On PowerVM and KVM on Power use the new memory allocation function that honors restrictions on which memory GRUB can actually use. In the request structure indicate the request for a single memory block along with address alignment restrictions. Request direct usage of the memory block by setting init_region to false (prevent it from being added to GRUB's heap). Initialize the found addr to -1, so that -1 will be returned to the loader in case no memory could be allocated. Report an out-of-memory error in case the initrd could not be loaded. Signed-off-by: Stefan Berger Reviewed-by: Daniel Kiper Cc: Hari Bathini Cc: Pavithra Prakash Cc: Michael Ellerman Cc: Carolyn Scherrer Cc: Mahesh Salgaonkar Cc: Sourabh Jain --- grub-core/loader/powerpc/ieee1275/linux.c | 55 +++++++++++++++++++---- 1 file changed, 46 insertions(+), 9 deletions(-) diff --git a/grub-core/loader/powerpc/ieee1275/linux.c b/grub-core/loader/powerpc/ieee1275/linux.c index 6fdd863130..5c9ad4867a 100644 --- a/grub-core/loader/powerpc/ieee1275/linux.c +++ b/grub-core/loader/powerpc/ieee1275/linux.c @@ -30,6 +30,7 @@ #include #include #include +#include GRUB_MOD_LICENSE ("GPLv3+"); @@ -116,6 +117,22 @@ grub_linux_claimmap_iterate (grub_addr_t target, grub_size_t size, return ctx.found_addr; } +static grub_addr_t +grub_linux_claimmap_iterate_restricted (grub_size_t size, grub_size_t align) +{ + struct regions_claim_request rcr = { + .flags = GRUB_MM_ADD_REGION_CONSECUTIVE, + .total = size, + .init_region = false, + .addr = (grub_uint64_t) -1, + .align = align, + }; + + grub_machine_mmap_iterate (grub_regions_claim, &rcr); + + return rcr.addr; +} + static grub_err_t grub_linux_boot (void) { @@ -227,10 +244,18 @@ grub_linux_load64 (grub_elf_t elf, const char *filename) offset = entry - base_addr; /* Linux's incorrectly contains a virtual address. */ - /* On some systems, firmware occupies the memory we're trying to use. - * Happily, Linux can be loaded anywhere (it relocates itself). Iterate - * until we find an open area. */ - seg_addr = grub_linux_claimmap_iterate (base_addr & ~ELF64_LOADMASK, linux_size, align); + if (grub_ieee1275_test_flag (GRUB_IEEE1275_FLAG_POWER_VM) || + grub_ieee1275_test_flag (GRUB_IEEE1275_FLAG_POWER_KVM)) + { + seg_addr = grub_linux_claimmap_iterate_restricted (linux_size, align); + } + else + { + /* On some systems, firmware occupies the memory we're trying to use. + * Happily, Linux can be loaded anywhere (it relocates itself). Iterate + * until we find an open area. */ + seg_addr = grub_linux_claimmap_iterate (base_addr & ~ELF64_LOADMASK, linux_size, align); + } if (seg_addr == (grub_addr_t) -1) return grub_error (GRUB_ERR_OUT_OF_MEMORY, "couldn't claim memory"); @@ -339,13 +364,25 @@ grub_cmd_initrd (grub_command_t cmd __attribute__ ((unused)), size = grub_get_initrd_size (&initrd_ctx); - first_addr = linux_addr + linux_size; - /* Attempt to claim at a series of addresses until successful in - the same way that grub_rescue_cmd_linux does. */ - addr = grub_linux_claimmap_iterate (first_addr, size, 0x100000); + if (grub_ieee1275_test_flag (GRUB_IEEE1275_FLAG_POWER_VM) || + grub_ieee1275_test_flag (GRUB_IEEE1275_FLAG_POWER_KVM)) + { + addr = grub_linux_claimmap_iterate_restricted (size, 0x100000); + } + else + { + /* Attempt to claim at a series of addresses until successful in + the same way that grub_rescue_cmd_linux does. */ + first_addr = linux_addr + linux_size; + addr = grub_linux_claimmap_iterate (first_addr, size, 0x100000); + } + if (addr == (grub_addr_t) -1) - goto fail; + { + grub_error (GRUB_ERR_OUT_OF_MEMORY, "out of memory"); + goto fail; + } grub_dprintf ("loader", "Loading initrd at 0x%x, size 0x%x\n", addr, size); From fadedec314ea22a7ac046ed4cca20ab2e7794f14 Mon Sep 17 00:00:00 2001 From: Stefan Berger Date: Thu, 30 Nov 2023 09:17:22 -0500 Subject: [PATCH 08/10] kern/ieee1275/ieee1275: Display successful memory claims when debugging Display successful memory claims with exact address and rounded-down MiB location and rounded-up size in MiB. Signed-off-by: Stefan Berger Reviewed-by: Daniel Kiper Cc: Eric Snowberg Cc: Hari Bathini Cc: Pavithra Prakash Cc: Michael Ellerman Cc: Carolyn Scherrer Cc: Mahesh Salgaonkar Cc: Sourabh Jain --- grub-core/kern/ieee1275/ieee1275.c | 3 +++ include/grub/powerpc/ieee1275/ieee1275.h | 3 +++ include/grub/sparc64/ieee1275/ieee1275.h | 3 +++ 3 files changed, 9 insertions(+) diff --git a/grub-core/kern/ieee1275/ieee1275.c b/grub-core/kern/ieee1275/ieee1275.c index 86f81a3c46..f8a195e663 100644 --- a/grub-core/kern/ieee1275/ieee1275.c +++ b/grub-core/kern/ieee1275/ieee1275.c @@ -593,6 +593,9 @@ grub_ieee1275_claim (grub_addr_t addr, grub_size_t size, unsigned int align, *result = args.base; if (args.base == IEEE1275_CELL_INVALID) return -1; + grub_dprintf ("mmap", "CLAIMED: 0x%" PRIxGRUB_IEEE1275_CELL_T " (%" + PRIuGRUB_IEEE1275_CELL_T " MiB) size: %" PRIuGRUB_SIZE " MiB\n", + args.base, args.base >> 20, ALIGN_UP (size, 1 << 20) >> 20); return 0; } diff --git a/include/grub/powerpc/ieee1275/ieee1275.h b/include/grub/powerpc/ieee1275/ieee1275.h index 3c7683fad2..4eb2070188 100644 --- a/include/grub/powerpc/ieee1275/ieee1275.h +++ b/include/grub/powerpc/ieee1275/ieee1275.h @@ -25,4 +25,7 @@ #define GRUB_IEEE1275_CELL_SIZEOF 4 typedef grub_uint32_t grub_ieee1275_cell_t; +#define PRIxGRUB_IEEE1275_CELL_T PRIxGRUB_UINT32_T +#define PRIuGRUB_IEEE1275_CELL_T PRIuGRUB_UINT32_T + #endif /* ! GRUB_IEEE1275_MACHINE_HEADER */ diff --git a/include/grub/sparc64/ieee1275/ieee1275.h b/include/grub/sparc64/ieee1275/ieee1275.h index 4b18468d8d..ccc71aac66 100644 --- a/include/grub/sparc64/ieee1275/ieee1275.h +++ b/include/grub/sparc64/ieee1275/ieee1275.h @@ -25,6 +25,9 @@ #define GRUB_IEEE1275_CELL_SIZEOF 8 typedef grub_uint64_t grub_ieee1275_cell_t; +#define PRIxGRUB_IEEE1275_CELL_T PRIxGRUB_UINT64_T +#define PRIuGRUB_IEEE1275_CELL_T PRIuGRUB_UINT64_T + /* Encoding of 'mode' argument to grub_ieee1275_map_physical() */ #define IEEE1275_MAP_WRITE 0x0001 /* Writable */ #define IEEE1275_MAP_READ 0x0002 /* Readable */ From 7dad85dc91c89811cfe0084b14c0a4e5e545f887 Mon Sep 17 00:00:00 2001 From: Stefan Berger Date: Thu, 30 Nov 2023 09:17:23 -0500 Subject: [PATCH 09/10] kern/ieee1275/init/ppc64: Fix a comment Signed-off-by: Stefan Berger Reviewed-by: Daniel Kiper --- grub-core/kern/ieee1275/init.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/grub-core/kern/ieee1275/init.c b/grub-core/kern/ieee1275/init.c index 2771db87c4..bb753fd00d 100644 --- a/grub-core/kern/ieee1275/init.c +++ b/grub-core/kern/ieee1275/init.c @@ -474,7 +474,7 @@ grub_regions_claim (grub_uint64_t addr, grub_uint64_t len, /* We must not exceed the upper_mem_limit (assuming it's >= RMO_ADDR_MAX) */ if (addr + len > upper_mem_limit) { - /* take the bigger chunk from either below linux_rmo_save or above upper_mem_limit */ + /* Take the bigger chunk from either below linux_rmo_save or above RMO_ADDR_MAX. */ len = upper_mem_limit - addr; if (orig_addr < linux_rmo_save && linux_rmo_save - orig_addr > len) { From 9fd8ec04825ef5c743685da07b31d2d1701ac7de Mon Sep 17 00:00:00 2001 From: Stefan Berger Date: Thu, 30 Nov 2023 09:17:24 -0500 Subject: [PATCH 10/10] kern/ieee1275/init/ppc64: Display upper_mem_limit when debugging Display upper_mem_limit and its rounded-down value in MiB. Signed-off-by: Stefan Berger Reviewed-by: Daniel Kiper --- grub-core/kern/ieee1275/init.c | 3 +++ 1 file changed, 3 insertions(+) diff --git a/grub-core/kern/ieee1275/init.c b/grub-core/kern/ieee1275/init.c index bb753fd00d..48f938afcd 100644 --- a/grub-core/kern/ieee1275/init.c +++ b/grub-core/kern/ieee1275/init.c @@ -456,6 +456,9 @@ grub_regions_claim (grub_uint64_t addr, grub_uint64_t len, check_kernel_dump (&upper_mem_limit); + grub_dprintf ("ieee1275", "upper_mem_limit is at %llx (%lld MiB)\n", + upper_mem_limit, upper_mem_limit >> 20); + /* * we order these cases to prefer higher addresses and avoid some * splitting issues