[memmap] Allow explicit colour selection for memory map debug messages

Provide DBGC_MEMMAP() as a replacement for memmap_dump(), allowing the
colour used to match other messages within the same message group.

Retain a dedicated colour for output from memmap_dump_all(), on the
basis that it is generally most useful to visually compare full memory
dumps against previous full memory dumps.

Signed-off-by: Michael Brown <mcb30@ipxe.org>

diff --git a/src/arch/x86/core/relocate.c b/src/arch/x86/core/relocate.c
index 0a8f0b8dc3e4286584331ad1a675bc044ca4c4dd..3cdc53c2e1ea4f9288ecb442ca6825b1b21b3a63 100644 (file)
--- a/src/arch/x86/core/relocate.c
+++ b/src/arch/x86/core/relocate.c
@@ -80,7 +80,7 @@ __asmcall void relocate ( struct i386_all_regs *ix86 ) {
                 * away with using just 32-bit arithmetic after this
                 * stage.
                 */
-               memmap_dump ( &region );
+               DBGC_MEMMAP ( &region, &region );
                if ( region.min > max ) {
                        DBGC ( &region, "...starts after max=%#08lx\n", max );
                        break;

diff --git a/src/arch/x86/image/multiboot.c b/src/arch/x86/image/multiboot.c
index c6bc01d4c0848bb61b9d4e728f1b82898941a1a1..40d6941dae93f2045c940853bc802cc15d5233c3 100644 (file)
--- a/src/arch/x86/image/multiboot.c
+++ b/src/arch/x86/image/multiboot.c
@@ -120,7 +120,7 @@ static void multiboot_build_memmap ( struct image *image,
                /* Ignore any non-memory regions */
                if ( ! ( region.flags & MEMMAP_FL_MEMORY ) )
                        continue;
-               memmap_dump ( &region );
+               DBGC_MEMMAP ( image, &region );
 
                /* Check Multiboot memory map limit */
                if ( ! remaining ) {

diff --git a/src/core/fdtmem.c b/src/core/fdtmem.c
index bb8786d3ce1d6ba7f357c45610ceec94998bdadc..fb44397af6f752fdf16def4149d2e3dcac721bc1 100644 (file)
--- a/src/core/fdtmem.c
+++ b/src/core/fdtmem.c
@@ -273,7 +273,7 @@ physaddr_t fdtmem_relocate ( struct fdt_header *hdr, physaddr_t max ) {
 
        /* Parse FDT */
        if ( ( rc = fdt_parse ( &fdt, hdr, -1UL ) ) != 0 ) {
-               DBGC ( &region, "FDTMEM could not parse FDT: %s\n",
+               DBGC ( hdr, "FDTMEM could not parse FDT: %s\n",
                       strerror ( rc ) );
                /* Refuse relocation if we have no FDT */
                return old;
@@ -282,7 +282,7 @@ physaddr_t fdtmem_relocate ( struct fdt_header *hdr, physaddr_t max ) {
        /* Determine required length */
        len = fdtmem_len ( &fdt );
        assert ( len > 0 );
-       DBGC ( &region, "FDTMEM requires %#zx + %#zx => %#zx bytes for "
+       DBGC ( hdr, "FDTMEM requires %#zx + %#zx => %#zx bytes for "
               "relocation\n", memsz, fdt.len, len );
 
        /* Construct memory map and choose a relocation address */
@@ -297,7 +297,7 @@ physaddr_t fdtmem_relocate ( struct fdt_header *hdr, physaddr_t max ) {
                next = ( region.max + 1 );
 
                /* Dump region descriptor (for debugging) */
-               memmap_dump ( &region );
+               DBGC_MEMMAP ( hdr, &region );
                assert ( region.max >= region.min );
 
                /* Use highest possible region */
@@ -313,7 +313,7 @@ physaddr_t fdtmem_relocate ( struct fdt_header *hdr, physaddr_t max ) {
                }
        }
 
-       DBGC ( &region, "FDTMEM relocating %#08lx => [%#08lx,%#08lx]\n",
+       DBGC ( hdr, "FDTMEM relocating %#08lx => [%#08lx,%#08lx]\n",
               old, new, ( ( physaddr_t ) ( new + len - 1 ) ) );
        return new;
 }

diff --git a/src/core/memmap.c b/src/core/memmap.c
index 2939e855b5160d76fc6fd880a6723ab9e9b42677..4a96055e6e6ddbf9db7e1932e7567adf7d4f24c0 100644 (file)
--- a/src/core/memmap.c
+++ b/src/core/memmap.c
@@ -127,7 +127,7 @@ size_t memmap_largest ( physaddr_t *start ) {
        *start = 0;
        largest = 0;
        for_each_memmap ( &region, 1 ) {
-               memmap_dump ( &region );
+               DBGC_MEMMAP ( &region, &region );
                if ( ! memmap_is_usable ( &region ) )
                        continue;
                size = memmap_size ( &region );

diff --git a/src/image/lkrn.c b/src/image/lkrn.c
index 8a7c577cdd563c15d28b636dcc2343677cd0f6d6..a2044cb828bf2a0b3335ec2637a9f77bcf548544 100644 (file)
--- a/src/image/lkrn.c
+++ b/src/image/lkrn.c
@@ -102,7 +102,7 @@ static int lkrn_ram ( struct image *image, struct lkrn_context *ctx ) {
 
        /* Locate start of RAM */
        for_each_memmap ( &region, 0 ) {
-               memmap_dump ( &region );
+               DBGC_MEMMAP ( image, &region );
                if ( ! ( region.flags & MEMMAP_FL_MEMORY ) )
                        continue;
                ctx->ram = region.min;

diff --git a/src/image/segment.c b/src/image/segment.c
index 469a66321f5319dba24f3806da088f0b7f9b34e8..d90da709c8e19030ccf47abe0b188284f0278195 100644 (file)
--- a/src/image/segment.c
+++ b/src/image/segment.c
@@ -65,11 +65,11 @@ int prep_segment ( void *segment, size_t filesz, size_t memsz ) {
        physaddr_t end = ( start + memsz );
        physaddr_t max;
 
-       DBGC ( &region, "SEGMENT [%#08lx,%#08lx,%#08lx)\n", start, mid, end );
+       DBGC ( segment, "SEGMENT [%#08lx,%#08lx,%#08lx)\n", start, mid, end );
 
        /* Check for malformed lengths */
        if ( filesz > memsz ) {
-               DBGC ( &region, "SEGMENT [%#08lx,%#08lx,%#08lx) is "
+               DBGC ( segment, "SEGMENT [%#08lx,%#08lx,%#08lx) is "
                       "malformed\n", start, mid, end );
                return -EINVAL;
        }
@@ -81,18 +81,18 @@ int prep_segment ( void *segment, size_t filesz, size_t memsz ) {
 
        /* Check for address space overflow */
        if ( max < start ) {
-               DBGC ( &region, "SEGMENT [%#08lx,%#08lx,%#08lx) wraps "
+               DBGC ( segment, "SEGMENT [%#08lx,%#08lx,%#08lx) wraps "
                       "around\n", start, mid, end );
                return -EINVAL;
        }
 
        /* Describe region containing this segment */
        memmap_describe ( start, 1, &region );
-       memmap_dump ( &region );
+       DBGC_MEMMAP ( segment, &region );
 
        /* Fail unless region is usable and sufficiently large */
        if ( ( ! memmap_is_usable ( &region ) ) || ( region.max < max ) ) {
-               DBGC ( &region, "SEGMENT [%#08lx,%#08lx,%#08lx) does not fit "
+               DBGC ( segment, "SEGMENT [%#08lx,%#08lx,%#08lx) does not fit "
                       "into available memory\n", start, mid, end );
                return -ERANGE_SEGMENT;
        }

diff --git a/src/include/ipxe/memmap.h b/src/include/ipxe/memmap.h
index 405a74bafb7b100fc2c9823c5de52eff01fdcf46..c16e25daaa7fed17b387b076e7dcb55c21e4ebfc 100644 (file)
--- a/src/include/ipxe/memmap.h
+++ b/src/include/ipxe/memmap.h
@@ -183,26 +183,29 @@ memmap_use ( struct used_region *used, physaddr_t start, size_t size ) {
 #define for_each_memmap( region, hide )                                        \
        for_each_memmap_from ( (region), 0, (hide) )
 
-
-/**
- * Dump memory region descriptor (for debugging)
- *
- * @v region           Region descriptor
- */
-static inline void memmap_dump ( const struct memmap_region *region ) {
-       const char *name = region->name;
-       unsigned int flags = region->flags;
-
-       /* Dump region information */
-       DBGC ( region, "MEMMAP (%s%s%s%s) [%#08llx,%#08llx]%s%s\n",
-              ( ( flags & MEMMAP_FL_MEMORY ) ? "M" : "-" ),
-              ( ( flags & MEMMAP_FL_RESERVED ) ? "R" : "-" ),
-              ( ( flags & MEMMAP_FL_USED ) ? "U" : "-" ),
-              ( ( flags & MEMMAP_FL_INACCESSIBLE ) ? "X" : "-" ),
-              ( ( unsigned long long ) region->min ),
-              ( ( unsigned long long ) region->max ),
-              ( name ? " " : "" ), ( name ? name : "" ) );
-}
+#define DBG_MEMMAP_IF( level, region ) do {                            \
+       const char *name = (region)->name;                              \
+       unsigned int flags = (region)->flags;                           \
+                                                                       \
+       DBG_IF ( level, "MEMMAP (%s%s%s%s) [%#08llx,%#08llx]%s%s\n",    \
+                ( ( flags & MEMMAP_FL_MEMORY ) ? "M" : "-" ),          \
+                ( ( flags & MEMMAP_FL_RESERVED ) ? "R" : "-" ),        \
+                ( ( flags & MEMMAP_FL_USED ) ? "U" : "-" ),            \
+                ( ( flags & MEMMAP_FL_INACCESSIBLE ) ? "X" : "-" ),    \
+                ( ( unsigned long long ) (region)->min ),              \
+                ( ( unsigned long long ) (region)->max ),              \
+                ( name ? " " : "" ), ( name ? name : "" ) );           \
+       } while ( 0 )
+
+#define DBGC_MEMMAP_IF( level, id, ... ) do {                          \
+               DBG_AC_IF ( level, id );                                \
+               DBG_MEMMAP_IF ( level, __VA_ARGS__ );                   \
+               DBG_DC_IF ( level );                                    \
+       } while ( 0 )
+
+#define DBGC_MEMMAP( ... )     DBGC_MEMMAP_IF ( LOG, ##__VA_ARGS__ )
+#define DBGC2_MEMMAP( ... )    DBGC_MEMMAP_IF ( EXTRA, ##__VA_ARGS__ )
+#define DBGCP_MEMMAP( ... )    DBGC_MEMMAP_IF ( PROFILE, ##__VA_ARGS__ )
 
 /**
  * Dump system memory map (for debugging)
@@ -217,10 +220,10 @@ static inline void memmap_dump_all ( int hide ) {
                return;
 
        /* Describe all memory regions */
-       DBGC ( &region, "MEMMAP with in-use regions %s:\n",
+       DBGC ( &memmap_describe, "MEMMAP with in-use regions %s:\n",
               ( hide ? "hidden" : "ignored" ) );
        for_each_memmap ( &region, hide )
-               memmap_dump ( &region );
+               DBGC_MEMMAP ( &memmap_describe, &region );
 }
 
 extern void memmap_update ( struct memmap_region *region, uint64_t start,