Transforming EFI Memory Map to Linux Kernel Style

in

Well, if you’re using UEFI instead of the old BIOS system, then this is how your operating system communicates with hardware devices. It basically allows for more efficient and flexible access to memory resources by creating a virtual address space that can be mapped onto physical memory.

But here’s where things get interesting (or confusing, depending on your perspective). The Linux kernel doesn’t use EFI memory mapping in the same way as other operating systems do. Instead, it has its own unique method for handling memory resources and this is what we need to convert our EFI memory map into.

So how do we go about doing that? Well, first you’ll want to grab your trusty terminal (or command prompt if you prefer) and navigate to the directory where your kernel source code lives. Then, open up a text editor or use your favorite IDE to create a new file called `arch/x86/boot/map-efi.c`.

Now that we have our file set up, let’s start by defining some variables and constants that will help us convert the EFI memory map into something more Linux-friendly. Here’s what you might want to include:

// Define a macro called MAP_EFI_MEMORY that takes in a start address and size
#define MAP_EFI_MEMORY(start, size) \
    { .name = "efi", .base = (unsigned long)(start), .size = (size), .node = NULL }

// Declare a static array of type struct resource called efi_resources and initialize it with __initdata
static struct resource efi_resources[] __initdata = {
    // Add your EFI memory map entries here using the MAP_EFI_MEMORY macro
    MAP_EFI_MEMORY(start_address, size), // Example entry using the macro
    MAP_EFI_MEMORY(start_address2, size2), // Another example entry using the macro
};

The `MAP_EFI_MEMORY()` macro is used to define a new memory region for our kernel. The first argument (start) specifies the starting address of this region, while the second argument (size) tells us how much memory it occupies. We’re also defining an array called `efi_resources`, which will hold all of our EFI memory map entries.

Next, let’s add some code to actually populate that array with data:

// Defining a static struct called "efi_resources" which will hold EFI memory map entries
static struct resource efi_resources[] __initdata = {
    // Mapping EFI System Memory starting at address 0x100000000 with a size of 0x200000
    MAP_EFI_MEMORY(0x100000000, 0x200000), /* EFI System Memory */
    // Mapping EFI Boot Services Data starting at address 0x30000000 with a size of 0x8000000
    MAP_EFI_MEMORY(0x30000000, 0x8000000), /* EFI Boot Services Data */
};

In this example, we’re defining two memory regions one for the EFI System Memory (starting at address `0x100000000`) and another for the EFI Boot Services Data (starting at address `0x30000000`).

Now that our array is populated, let’s add some code to actually use it:

// This function is used to map EFI memory regions.
static void __init map_efi_memory(void) {
    int i; // Declaring a variable 'i' to be used as a counter in the for loop.

    // Looping through the efi_resources array using the ARRAY_SIZE macro.
    for (i = 0; i < ARRAY_SIZE(efi_resources); i++) {
        // Adding each resource in the efi_resources array using the resource_add function.
        resource_add(&efi_resources[i]);
    }
}

This function simply iterates through our `efi_resources` array and adds each memory region to the kernel’s resource table using the `resource_add()` function.

Finally, let’s add some code to actually call this function during boot time:


// This function is used to initialize the EFI memory by calling the map_efi_memory() function.
// It returns an integer value of 0 to indicate successful initialization.
static int __init efi_memory(void) {
    map_efi_memory(); // Calls the map_efi_memory() function to iterate through the efi_resources array and add each memory region to the kernel's resource table.
    
    return 0; // Returns 0 to indicate successful initialization.
}

// This line adds the efi_memory function to the list of functions to be called during kernel initialization.
arch_initcall(efi_memory);

This function simply calls our `map_efi_memory()` function and returns a value of zero. We’re also using the `arch_initcall()` macro to ensure that this function is called during boot time (before any other kernel initialization code).

And there you have it transforming EFI memory maps into Linux kernel style! It might seem like a daunting task at first, but with a little bit of knowledge and some helpful resources, anyone can do it. Just remember to take breaks when needed, drink plenty of water, and don’t forget to thank your grandma for being such an awesome tech-savvy Linux guru!

SICORPS