td shim tools support large payload

td-layout/src/build_time.rs

@@ -7,6 +7,8 @@
 /*
 Image Layout
 +----------------------------------------+ <- 0x0
+|             LARGE_PAYLOAD              |   (0x0) 0 B
++----------------------------------------+ <- 0x0
 |                 CONFIG                 |   (0x40000) 256 kB
 +----------------------------------------+ <- 0x40000
 |                MAILBOX                 |   (0x1000) 4 kB
@@ -29,6 +31,10 @@ Image size: 0x1000000 (16 MB)
 */
 
 // Image Layout Configuration
+pub const TD_SHIM_FIRMWARE_SIZE: u32 = 0x1000000;
+
+pub const TD_SHIM_LARGE_PAYLOAD_OFFSET: u32 = 0x0;
+pub const TD_SHIM_LARGE_PAYLOAD_SIZE: u32 = 0x0; // 0 B
 
 pub const TD_SHIM_CONFIG_OFFSET: u32 = 0x0;
 pub const TD_SHIM_CONFIG_SIZE: u32 = 0x40000; // 256 kB
@@ -57,16 +63,14 @@ pub const TD_SHIM_IPL_SIZE: u32 = 0x349000; // 3.29 MB
 pub const TD_SHIM_RESET_VECTOR_OFFSET: u32 = 0xFF8000;
 pub const TD_SHIM_RESET_VECTOR_SIZE: u32 = 0x8000; // 32 kB
 
-// Offset when Loading into Memory
-pub const TD_SHIM_FIRMWARE_BASE: u32 = 0xFF000000;
-pub const TD_SHIM_FIRMWARE_SIZE: u32 = 0x1000000;
-
 // TD_SHIM_SEC_INFO_OFFSET equals to firmware size - metadata pointer offset -
 // OVMF GUID table size - SEC Core information size.
 pub const TD_SHIM_SEC_CORE_INFO_OFFSET: u32 = 0xFFFFAC;
 pub const TD_SHIM_SEC_CORE_INFO_BASE: u32 = 0xFFFFFFAC;
 
-// Base Address after Loaded into Memory
+// Rom Configuration
+
+pub const TD_SHIM_FIRMWARE_BASE: u32 = 0xFF000000;
 pub const TD_SHIM_CONFIG_BASE: u32 = 0xFF000000;
 pub const TD_SHIM_MAILBOX_BASE: u32 = 0xFF040000;
 pub const TD_SHIM_TEMP_STACK_BASE: u32 = 0xFF041000;

td-layout/src/memslice.rs

@@ -2,7 +2,10 @@
 //
 // SPDX-License-Identifier: BSD-2-Clause-Patent
 
-use crate::build_time::*;
+use crate::{
+    build_time::*,
+    runtime::exec::{LARGE_PAYLOAD_BASE, LARGE_PAYLOAD_SIZE},
+};
 use core::fmt::Display;
 
 /// Type of build time and runtime memory regions.
@@ -16,6 +19,8 @@ pub enum SliceType {
     ShimPayload,
     /// The `TD_MAILBOX` region in image file
     MailBox,
+    /// The `Large PAYLOAD` region in runtime memory layout
+    LargePayload,
     /// The `PAYLOAD` region in runtime memory layout
     Payload,
     /// The `Kernel Parameter` region in runtime memory layout
@@ -41,6 +46,7 @@ impl SliceType {
             SliceType::TdHob => "TdHob",
             SliceType::ShimPayload => "ShimPayload",
             SliceType::MailBox => "MailBox",
+            SliceType::LargePayload => "LargePayload",
             SliceType::Payload => "Payload",
             SliceType::PayloadParameter => "PayloadParameter",
             SliceType::PayloadHob => "PayloadHob",
@@ -73,6 +79,10 @@ pub fn get_mem_slice<'a>(t: SliceType) -> &'a [u8] {
                 TD_SHIM_PAYLOAD_BASE as *const u8,
                 TD_SHIM_PAYLOAD_SIZE as usize,
             ),
+            SliceType::LargePayload => core::slice::from_raw_parts(
+                LARGE_PAYLOAD_BASE as *const u8,
+                LARGE_PAYLOAD_SIZE as usize,
+            ),
             SliceType::MailBox => core::slice::from_raw_parts(
                 TD_SHIM_MAILBOX_BASE as *const u8,
                 TD_SHIM_MAILBOX_SIZE as usize,
@@ -94,7 +104,7 @@ pub unsafe fn get_mem_slice_mut<'a>(t: SliceType) -> &'a mut [u8] {
             TD_SHIM_MAILBOX_BASE as *const u8 as *mut u8,
             TD_SHIM_MAILBOX_SIZE as usize,
         ),
-        SliceType::Config | SliceType::ShimPayload => {
+        SliceType::Config | SliceType::ShimPayload | SliceType::LargePayload => {
             panic!("get_mem_slice_mut: read only")
         }
         _ => panic!("get_mem_slice_mut: not support"),

td-layout/src/runtime/exec.rs

@@ -20,6 +20,8 @@ Top of Low Memory: 0x80000000
 +----------------------------------------+ <- 0x7DDDE000
 |                  FREE                  |   (0x7D5BE000) 1.96 GB
 +----------------------------------------+ <- 0x820000
+|             LARGE_PAYLOAD              |   (0x0) 0 B
++----------------------------------------+ <- 0x820000
 |                 TD_HOB                 |   (0x20000) 128 kB
 +----------------------------------------+ <- 0x800000
 |               BOOTLOADER               |   (0x800000) 8 MB
@@ -34,6 +36,8 @@ pub const BOOTLOADER_BASE: usize = 0x0;
 pub const BOOTLOADER_SIZE: usize = 0x800000; // 8 MB
 pub const TD_HOB_BASE: usize = 0x800000;
 pub const TD_HOB_SIZE: usize = 0x20000; // 128 kB
+pub const LARGE_PAYLOAD_BASE: usize = 0x820000;
+pub const LARGE_PAYLOAD_SIZE: usize = 0x0; // 0 B
 pub const ACPI_SIZE: usize = 0x100000; // 1 MB
 pub const PAYLOAD_SIZE: usize = 0x2000000; // 32 MB
 pub const PAYLOAD_PAGE_TABLE_SIZE: usize = 0x20000; // 128 kB
@@ -44,6 +48,7 @@ pub const MEMORY_LAYOUT_CONFIG: &[(&'static str, usize, &'static str)] = &[
     // (name of memory region, region size, region type)
     ("Bootloader", 0x800000, "Memory"),
     ("TdHob", 0x20000, "Memory"),
+    ("LargePayload", 0x0, "Memory"),
     ("Acpi", 0x100000, "Acpi"),
     ("Payload", 0x2000000, "Reserved"),
     ("PayloadPageTable", 0x20000, "Reserved"),

td-shim-interface/src/td_uefi_pi/fv.rs

@@ -58,10 +58,10 @@ pub fn get_image_from_fv(
 
     let files = Files::parse(fv_data, fv_header.header_length as usize)?;
     for (file_header, file_data) in files {
-        if !validate_ffs_file_header(file_header) {
+        if !file_header.validate() {
             return None;
         }
-        if file_header.r#type == fv_file_type {
+        if file_header.r#type() == fv_file_type {
             return get_image_from_sections(file_data, section_type);
         }
     }
@@ -78,10 +78,10 @@ pub fn get_file_from_fv(
 
     let files = Files::parse(fv_data, fv_header.header_length as usize)?;
     for (file_header, file_data) in files {
-        if !validate_ffs_file_header(file_header) {
+        if !file_header.validate() {
             return None;
         }
-        if file_header.r#type == fv_file_type && &file_header.name == file_name.as_bytes() {
+        if file_header.r#type() == fv_file_type && file_header.name() == file_name.as_bytes() {
             return Some(file_data);
         }
     }
@@ -93,14 +93,28 @@ fn get_image_from_sections(sections_data: &[u8], section_type: SectionType) -> O
     let sections = Sections::parse(sections_data, 0)?;
 
     for (section_header, section_data) in sections {
-        if section_header.r#type == section_type {
+        if section_header.r#type() == section_type {
             return Some(section_data);
         }
     }
 
     None
 }
 
+enum CommonSectionHeaderType {
+    Header(CommonSectionHeader),
+    Header2(CommonSectionHeader2),
+}
+
+impl CommonSectionHeaderType {
+    fn r#type(&self) -> FvFileType {
+        match self {
+            Self::Header(header) => header.r#type,
+            Self::Header2(header2) => header2.r#type,
+        }
+    }
+}
+
 struct Sections<'a> {
     buffer: &'a [u8],
 }
@@ -118,17 +132,32 @@ impl<'a> Sections<'a> {
 }
 
 impl<'a> Iterator for Sections<'a> {
-    type Item = (CommonSectionHeader, &'a [u8]);
+    type Item = (CommonSectionHeaderType, &'a [u8]);
 
     fn next(&mut self) -> Option<Self::Item> {
-        const HEADER_SIZE: usize = core::mem::size_of::<CommonSectionHeader>();
         let header: CommonSectionHeader = self.buffer.pread(0).ok()?;
-        let section_size = header.size[0] as usize
-            + ((header.size[1] as usize) << 8)
-            + ((header.size[2] as usize) << 16);
-        section_size.checked_sub(HEADER_SIZE)?;
+        let is_large_section = header.size == [0xff, 0xff, 0xff];
+
+        let (section_size, section_header, header_size) = if is_large_section {
+            let header2: CommonSectionHeader2 = self.buffer.pread(0).ok()?;
+            (
+                header2.extended_size as usize,
+                CommonSectionHeaderType::Header2(header2),
+                core::mem::size_of::<CommonSectionHeader2>(),
+            )
+        } else {
+            (
+                header.size[0] as usize
+                    + ((header.size[1] as usize) << 8)
+                    + ((header.size[2] as usize) << 16),
+                CommonSectionHeaderType::Header(header),
+                core::mem::size_of::<CommonSectionHeader>(),
+            )
+        };
+
+        section_size.checked_sub(header_size)?;
         self.buffer.len().checked_sub(section_size)?;
-        let buf = &self.buffer[HEADER_SIZE..section_size];
+        let buf = &self.buffer[header_size..section_size];
 
         // Align to 4 bytes.
         let section_size = (section_size + 3) & !3;
@@ -138,7 +167,39 @@ impl<'a> Iterator for Sections<'a> {
             self.buffer = &self.buffer[0..0];
         }
 
-        Some((header, buf))
+        Some((section_header, buf))
+    }
+}
+
+enum FfsFileHeaderType {
+    Header(FfsFileHeader),
+    Header2(FfsFileHeader2),
+}
+
+impl FfsFileHeaderType {
+    fn r#type(&self) -> FvFileType {
+        match self {
+            FfsFileHeaderType::Header(header) => header.r#type,
+            FfsFileHeaderType::Header2(header2) => header2.r#type,
+        }
+    }
+
+    fn name(&self) -> &[u8] {
+        match self {
+            FfsFileHeaderType::Header(header) => &header.name,
+            FfsFileHeaderType::Header2(header2) => &header2.name,
+        }
+    }
+
+    // Validate Ffs File header
+    fn validate(&self) -> bool {
+        // Do the sanity check for Ffs header.
+        // Verify the header integrity,
+        //
+        match self {
+            FfsFileHeaderType::Header(header) => header.validate_checksum(),
+            FfsFileHeaderType::Header2(header2) => header2.validate_checksum(),
+        }
     }
 }
 
@@ -159,18 +220,32 @@ impl<'a> Files<'a> {
 }
 
 impl<'a> Iterator for Files<'a> {
-    type Item = (FfsFileHeader, &'a [u8]);
+    type Item = (FfsFileHeaderType, &'a [u8]);
 
     fn next(&mut self) -> Option<Self::Item> {
-        const HEADER_SIZE: usize = core::mem::size_of::<FfsFileHeader>();
-
         let header: FfsFileHeader = self.buffer.pread(0).ok()?;
-        let data_size = header.size[0] as usize
-            + ((header.size[1] as usize) << 8)
-            + ((header.size[2] as usize) << 16);
-        data_size.checked_sub(HEADER_SIZE)?;
+        let is_large_file = header.attributes & FFS_ATTRIB_LARGE_FILE != 0;
+
+        let (data_size, ffs_header, header_size) = if is_large_file {
+            let header2: FfsFileHeader2 = self.buffer.pread(0).ok()?;
+            (
+                header2.extended_size as usize,
+                FfsFileHeaderType::Header2(header2),
+                core::mem::size_of::<FfsFileHeader2>(),
+            )
+        } else {
+            (
+                header.size[0] as usize
+                    + ((header.size[1] as usize) << 8)
+                    + ((header.size[2] as usize) << 16),
+                FfsFileHeaderType::Header(header),
+                core::mem::size_of::<FfsFileHeader>(),
+            )
+        };
+
+        data_size.checked_sub(header_size)?;
         self.buffer.len().checked_sub(data_size)?;
-        let buf = &self.buffer[HEADER_SIZE..data_size];
+        let buf = &self.buffer[header_size..data_size];
 
         // Align to 8 bytes.
         let data_size = (data_size + 7) & !7;
@@ -180,7 +255,7 @@ impl<'a> Iterator for Files<'a> {
             self.buffer = &self.buffer[0..0];
         }
 
-        Some((header, buf))
+        Some((ffs_header, buf))
     }
 }