How to Define Different global_allocators for a Monolithic OS Kernel and Its Applications

Learn how to effectively define separate `global_allocator`s for your kernel and user applications in a Rust-based monolithic operating system. --- This video is based on the question https://stackoverflow.com/q/78089798/ asked by the user 'ebeneEinHalb' ( https://stackoverflow.com/u/7157580/ ) and on the answer https://stackoverflow.com/a/78227150/ provided by the user 'ebeneEinHalb' ( https://stackoverflow.com/u/7157580/ ) at 'Stack Overflow' website. Thanks to these great users and Stackexchange community for their contributions. Visit these links for original content and any more details, such as alternate solutions, comments, revision history etc. For example, the original title of the Question was: How to define different [global_allocator]s for a monolithic os kernel and its applications Also, Content (except music) licensed under CC BY-SA https://meta.stackexchange.com/help/l... The original Question post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license, and the original Answer post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license. If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com. --- How to Define Different global_allocators for a Monolithic OS Kernel and Its Applications When developing a monolithic operating system, particularly in Rust, one of the key challenges is properly managing memory allocation for both the kernel and user applications. This guide will guide you through the common pitfalls and effective solutions related to defining different global_allocators for your kernel and its user-space applications. Let's dive into the specifics of this essential topic! The Problem In our setup, we have created a monolithic OS for the x86 architecture within a Rust cargo workspace. The structure of our project looks something like this: [[See Video to Reveal this Text or Code Snippet]] As we compile our project, an initrd is generated that contains binaries of the user directory, which are flattened and copied into designated address spaces by the kernel. What we want to achieve is distinct heap allocators: one for the kernel and another for the user applications. This allows for optimized memory management tailored to each environment. However, complications arise when we attempt to define a new #[global_allocator] in our user applications. This results in a page fault at a memory location within the kernel's image. The critical question is: how can we properly set up distinct allocators without causing conflicts or crashes? Proposed Solution After much investigation, I pinpointed the root cause of the issue. Defining a #[global_allocator] in user applications causes the compiler to mistakenly position the eh_frame_hdr section where the text section generally resides. This misalignment is what triggers the problematic behavior we're experiencing. Steps to Implement the Solution To solve this issue, we’ll need to adjust the linker script to ensure memory sections are aligned correctly. Here’s how to do it: Edit the Linker Script Navigate to your link.ld file located in the user/arch directory. Modify the script to reposition the eh_frame_hdr section. Here’s a sample of what that might look like: [[See Video to Reveal this Text or Code Snippet]] Define the Global Allocators Separately In your kernel code (main.rs), keep your kernel allocator as defined: [[See Video to Reveal this Text or Code Snippet]] In your application code (e.g., app1.rs), you can define a separate allocator as follows: [[See Video to Reveal this Text or Code Snippet]] Testing Your Setup After making these changes, compile your project, and ensure you run adequate tests to guarantee that both your kernel and user applications function as expected without memory conflicts. Pay attention to heap usage in both environments to confirm that they operate independently and effectively. Conclusion Successfully defining different global_allocators for your monolithic OS kernel and its user applications enhances the efficiency of memory management and optimizes the performance of your operating system. By adjusting the linker script and maintaining clear boundaries between your kernel and user-space environments, you can avoid the pitfalls associated with memory alignment and access conflicts. If you encounter further issues, consider seeking support from the Rust community or refer to comprehensive documentation on Rust's memory management practices. Happy coding, and may your kernel and applications thrive in harmony!