[user] user module changes

Author: kuqin12

patina_mm_user_core/Cargo.toml

@@ -0,0 +1,38 @@
+[package]
+name = "patina_mm_user_core"
+version.workspace = true
+repository.workspace = true
+license.workspace = true
+edition.workspace = true
+readme = "README.md"
+description = "A pure Rust implementation of the MM User Core for standalone MM mode environments."
+
+# Metadata to tell docs.rs how to build the documentation when uploading
+[package.metadata.docs.rs]
+features = ["doc"]
+
+# Example binary showing how to build a PE/COFF MM User Core
+[[bin]]
+name = "example_mm_user"
+path = "bin/example_mm_user.rs"
+
+[dependencies]
+goblin = { workspace = true, features = ["pe32", "pe64"] }
+log = { workspace = true }
+patina = { workspace = true }
+patina_internal_depex = { workspace = true }
+patina_internal_mm_alloc = { workspace = true }
+patina_internal_mm_common = { workspace = true }
+patina_adv_logger = { workspace = true }
+r-efi = { workspace = true }
+spin = { workspace = true }
+uuid = { workspace = true }
+
+[dev-dependencies]
+mockall = { workspace = true }
+serial_test = { workspace = true }
+
+[features]
+default = []
+std = []
+doc = []

patina_mm_user_core/README.md

@@ -0,0 +1,168 @@
+# Patina MM Supervisor Core
+
+A pure Rust implementation of the MM Supervisor Core for standalone MM mode environments.
+
+## Overview
+
+This crate provides the core functionality for the MM (Management Mode) Supervisor in a standalone MM environment. It is designed to run on x64 systems where:
+
+- Page tables are already set up by the pre-MM phase
+- All images are loaded and ready to execute
+- The BSP (Bootstrap Processor) orchestrates incoming requests
+- APs (Application Processors) wait in a holding pen, checking a mailbox for work
+
+## Memory Model
+
+The core can be instantiated as a `static` with no runtime allocation required for core data structures.
+
+## Building a PE/COFF Binary
+
+### Prerequisites
+
+1. Install the Rust UEFI target:
+   ```bash
+   rustup target add x86_64-unknown-uefi
+   ```
+
+2. Ensure you have the nightly toolchain (required for `#![feature(...)]`):
+   ```bash
+   rustup override set nightly
+   ```
+
+### Build Command
+
+Build the example MM Supervisor binary:
+
+```bash
+cargo build --release --target x86_64-unknown-uefi --bin example_mm_supervisor
+```
+
+The output PE/COFF binary will be at:
+```
+target/x86_64-unknown-uefi/release/example_mm_supervisor.efi
+```
+
+### Entry Point
+
+The MM Supervisor exports `MmSupervisorMain` as its entry point, matching the EDK2 convention:
+
+```rust
+#[unsafe(export_name = "MmSupervisorMain")]
+pub extern "efiapi" fn mm_supervisor_main(hob_list: *const c_void) -> ! {
+    SUPERVISOR.entry_point(hob_list)
+}
+```
+
+The MM IPL (Initial Program Loader) calls this entry point on **all processors** after:
+1. Loading the supervisor image into MMRAM
+2. Setting up page tables
+3. Constructing the HOB list with MMRAM ranges
+
+## Architecture
+
+### Entry Point Model
+
+The entry point is executed on all cores simultaneously:
+
+1. **BSP (Bootstrap Processor)**: 
+   - First CPU to arrive (determined by atomic counter)
+   - Performs one-time initialization
+   - Sets up the request handling infrastructure
+   - Enters the main request serving loop
+
+2. **APs (Application Processors)**:
+   - All other CPUs
+   - Wait for BSP initialization to complete
+   - Enter a holding pen and poll mailboxes for commands
+
+### Mailbox System
+
+The mailbox system provides inter-processor communication:
+
+- Each AP has a dedicated mailbox (cache-line aligned to avoid false sharing)
+- BSP sends commands to APs via mailboxes
+- APs respond with results through the same mailbox
+- Supports synchronization primitives for coordinated operations
+
+## Usage
+
+### Basic Platform Implementation
+
+```rust
+#![no_std]
+#![no_main]
+
+use core::{ffi::c_void, panic::PanicInfo};
+use patina_mm_supervisor_core::*;
+
+struct MyPlatform;
+
+impl CpuInfo for MyPlatform {
+    fn ap_poll_timeout_us() -> u64 { 1000 }
+}
+
+
+
+// Static instance - no heap allocation required
+static SUPERVISOR: MmSupervisorCore<MyPlatform> = MmSupervisorCore::new();
+
+#[panic_handler]
+fn panic(_info: &PanicInfo) -> ! {
+    loop { core::hint::spin_loop(); }
+}
+
+#[unsafe(export_name = "MmSupervisorMain")]
+pub extern "efiapi" fn mm_supervisor_main(hob_list: *const c_void) -> ! {
+    SUPERVISOR.entry_point(hob_list)
+}
+```
+
+### Registering Request Handlers
+
+Handlers must be defined as static references:
+
+```rust
+use patina_mm_supervisor_core::*;
+
+struct MyHandler;
+
+impl RequestHandler for MyHandler {
+    fn guid(&self) -> r_efi::efi::Guid {
+        // Your handler's GUID
+        r_efi::efi::Guid::from_fields(0x12345678, 0x1234, 0x5678, 0x12, 0x34, &[0; 6])
+    }
+
+    fn handle(&self, context: &mut RequestContext) -> RequestResult {
+        // Handle the request
+        RequestResult::Success
+    }
+
+    fn name(&self) -> &'static str {
+        "MyHandler"
+    }
+}
+
+static MY_HANDLER: MyHandler = MyHandler;
+
+// Register before calling entry_point, or during BSP initialization
+SUPERVISOR.register_handler(&MY_HANDLER);
+```
+
+### Integration with MM IPL
+
+The MM IPL (from EDK2/MmSupervisorPkg) loads this binary and calls the entry point. The HOB list passed contains:
+
+- `gEfiMmPeiMmramMemoryReserveGuid` - MMRAM ranges
+- `gMmCommBufferHobGuid` - Communication buffer information
+- `gMmCommonRegionHobGuid` - Common memory regions
+- FV HOBs for MM driver firmware volumes
+
+## Example Binary
+
+See [bin/example_mm_supervisor.rs](bin/example_mm_supervisor.rs) for a complete example platform implementation.
+
+## License
+
+Copyright (c) Microsoft Corporation.
+
+SPDX-License-Identifier: Apache-2.0

patina_mm_user_core/bin/example_mm_user.rs

@@ -0,0 +1,107 @@
+//! Example MM User Core Binary
+//!
+//! This is an example platform binary that demonstrates how to build a PE/COFF
+//! MM User Core using the `patina_mm_user_core` crate. It follows the same pattern
+//! as `q35_dxe_core.rs` for the DXE Core.
+//!
+//! ## Building
+//!
+//! Build with cargo for the UEFI target:
+//! ```bash
+//! cargo build --release --target x86_64-unknown-uefi --bin example_mm_user
+//! ```
+//!
+//! ## Entry Point
+//!
+//! The MM User Core is invoked by the MM Supervisor Core via `invoke_demoted_routine`
+//! after being loaded into MMRAM. The supervisor passes three arguments:
+//! - `arg1`: Command type (StartUserCore, UserRequest, UserApProcedure)
+//! - `arg2`: Command-specific data pointer (HOB list for init, buffer for requests)
+//! - `arg3`: Command-specific auxiliary data
+//!
+//! ## License
+//!
+//! Copyright (c) Microsoft Corporation.
+//!
+//! SPDX-License-Identifier: Apache-2.0
+//!
+#![cfg(all(target_os = "uefi", target_arch = "x86_64"))]
+#![no_std]
+#![no_main]
+
+use core::panic::PanicInfo;
+use core::sync::atomic::AtomicBool;
+use core::ffi::c_void;
+use patina::{log::Format, serial::uart::Uart16550};
+use patina_adv_logger::logger::AdvancedLogger;
+use patina_internal_mm_common::UserCommandType;
+use patina_mm_user_core::MmUserCore;
+
+// =============================================================================
+// Static Core Instance
+// =============================================================================
+
+/// Flag indicating that advanced logger initialization is complete.
+static ADV_LOGGER_INIT_COMPLETE: AtomicBool = AtomicBool::new(false);
+
+/// The static MM User Core instance.
+static USER_CORE: MmUserCore = MmUserCore::new();
+
+static LOGGER: AdvancedLogger<Uart16550> = AdvancedLogger::new(
+    Format::Standard,
+    &[
+        ("goblin", log::LevelFilter::Off),
+        ("allocations", log::LevelFilter::Off),
+        ("efi_memory_map", log::LevelFilter::Off),
+        ("mm_comm", log::LevelFilter::Off),
+        ("sw_mmi", log::LevelFilter::Off),
+        ("patina_performance", log::LevelFilter::Off),
+    ],
+    log::LevelFilter::Info,
+    Uart16550::Io { base: 0x402 },
+);
+
+
+// =============================================================================
+// Panic Handler
+// =============================================================================
+
+#[panic_handler]
+fn panic(_info: &PanicInfo) -> ! {
+    loop {}
+}
+
+// =============================================================================
+// Entry Point
+// =============================================================================
+
+/// The entry point for the MM User Core binary.
+///
+/// Called by the MM Supervisor via `invoke_demoted_routine` with three arguments:
+/// - `arg1`: Command type (0 = StartUserCore, 1 = UserRequest, 2 = UserApProcedure)
+/// - `arg2`: Command-specific data (HOB list pointer for init, buffer pointer for requests)
+/// - `arg3`: Command-specific auxiliary data (0 for init, context size for requests)
+///
+/// Returns 0 (`EFI_SUCCESS`) on success, or a non-zero EFI status code on failure.
+#[cfg_attr(target_os = "uefi", unsafe(export_name = "user_core_main"))]
+pub extern "efiapi" fn mm_user_main(op_code: u64, arg1: u64, arg2: u64) -> u64 {
+
+    // Initialize the advanced logger on the first CPU to arrive (BSP)
+    if !ADV_LOGGER_INIT_COMPLETE.swap(true, core::sync::atomic::Ordering::SeqCst) {
+        // If this is our first time here, it better be that the op_code being MmUserRequestTypeInit
+        if op_code != UserCommandType::StartUserCore as u64 {
+            // This means the BSP didn't send the expected init command first, which is a problem.
+            // Log an error and return failure.
+            panic!("MM User Core received non-init command before initialization: op_code = {}", op_code);
+        }
+
+        log::set_logger(&LOGGER).map(|()| log::set_max_level(log::LevelFilter::Trace)).unwrap();
+        // SAFETY: The physical_hob_list pointer is considered valid at this point as it's provided by the core
+        // to the entry point.
+        unsafe {
+            LOGGER.init(arg1 as *const c_void).unwrap();
+        }
+    }
+
+    USER_CORE.entry_point_worker(op_code, arg1, arg2)
+}