loader: Rename high memory field for loader trait and functions

High memory is defined in linux boot protocol where the
protected-mode kernel was relocated. It could be passed
by VMM to loader to specify where is the bottom line of
kernel image to be loaded. Rename it here to follow the
linux boot protocol definition.

Signed-off-by: Cathy Zhang <cathy.zhang@intel.com>

Author: bjzhjing

src/loader/mod.rs

@@ -125,8 +125,8 @@ pub trait KernelLoader {
         guest_mem: &M,
         kernel_start: Option<GuestAddress>,
         kernel_image: &mut F,
-        lowest_kernel_start: Option<GuestAddress>,
-    ) -> Result<(KernelLoaderResult)>
+        highmem_start_address: Option<GuestAddress>,
+    ) -> Result<KernelLoaderResult>
     where
         F: Read + Seek;
 }
@@ -143,16 +143,16 @@ impl KernelLoader for Elf {
     /// * `guest_mem` - The guest memory region the kernel is written to.
     /// * `kernel_start` - The offset into 'guest_mem' at which to load the kernel.
     /// * `kernel_image` - Input vmlinux image.
-    /// * `lowest_kernel_start` - This is the start of the high memory, kernel should above it.
+    /// * `highmem_start_address` - This is the start of the high memory, kernel should above it.
     ///
     /// # Returns
     /// * KernelLoaderResult
     fn load<F, M: GuestMemory>(
         guest_mem: &M,
         kernel_start: Option<GuestAddress>,
         kernel_image: &mut F,
-        lowest_kernel_start: Option<GuestAddress>,
-    ) -> Result<(KernelLoaderResult)>
+        highmem_start_address: Option<GuestAddress>,
+    ) -> Result<KernelLoaderResult>
     where
         F: Read + Seek,
     {
@@ -182,8 +182,8 @@ impl KernelLoader for Elf {
         if (ehdr.e_phoff as usize) < mem::size_of::<elf::Elf64_Ehdr>() {
             return Err(Error::InvalidProgramHeaderOffset);
         }
-        if (lowest_kernel_start.is_some())
-            && ((ehdr.e_entry as u64) < lowest_kernel_start.unwrap().raw_value())
+        if (highmem_start_address.is_some())
+            && ((ehdr.e_entry as u64) < highmem_start_address.unwrap().raw_value())
         {
             return Err(Error::InvalidEntryAddress);
         }
@@ -252,16 +252,16 @@ impl KernelLoader for BzImage {
     /// * `guest_mem` - The guest memory where the kernel image is loaded.
     /// * `kernel_start` - The offset into 'guest_mem' at which to load the kernel.
     /// * `kernel_image` - Input bzImage image.
-    /// * `lowest_kernel_start` - This is the start of the high memory, kernel should above it.
+    /// * `highmem_start_address` - This is the start of the high memory, kernel should above it.
     ///
     /// # Returns
     /// * KernelLoaderResult
     fn load<F, M: GuestMemory>(
         guest_mem: &M,
         kernel_start: Option<GuestAddress>,
         kernel_image: &mut F,
-        lowest_kernel_start: Option<GuestAddress>,
-    ) -> Result<(KernelLoaderResult)>
+        highmem_start_address: Option<GuestAddress>,
+    ) -> Result<KernelLoaderResult>
     where
         F: Read + Seek,
     {
@@ -298,8 +298,8 @@ impl KernelLoader for BzImage {
 
         // verify bzImage validation by checking if code32_start, the defaults to the address of
         // the kernel is not lower than high memory.
-        if (lowest_kernel_start.is_some())
-            && (u64::from(boot_header.code32_start) < lowest_kernel_start.unwrap().raw_value())
+        if (highmem_start_address.is_some())
+            && (u64::from(boot_header.code32_start) < highmem_start_address.unwrap().raw_value())
         {
             return Err(Error::InvalidKernelStartAddress);
         }
@@ -396,14 +396,14 @@ mod test {
         let gm = create_guest_mem();
         let image = make_bzImage();
         let mut kernel_start = GuestAddress(0x200000);
-        let mut lowest_kernel_start = GuestAddress(0x0);
+        let mut highmem_start_address = GuestAddress(0x0);
 
         // load bzImage with good kernel_start and himem_start setting
         let mut loader_result = BzImage::load(
             &gm,
             Some(kernel_start),
             &mut Cursor::new(&image),
-            Some(lowest_kernel_start),
+            Some(highmem_start_address),
         )
         .unwrap();
         assert_eq!(0x53726448, loader_result.setup_header.unwrap().header);
@@ -429,7 +429,7 @@ mod test {
             &gm,
             None,
             &mut Cursor::new(&image),
-            Some(lowest_kernel_start),
+            Some(highmem_start_address),
         )
         .unwrap();
         assert_eq!(0x53726448, loader_result.setup_header.unwrap().header);
@@ -448,12 +448,12 @@ mod test {
 
         // load bzImage with a bad himem setting
         kernel_start = GuestAddress(0x1000);
-        lowest_kernel_start = GuestAddress(0x200000);
+        highmem_start_address = GuestAddress(0x200000);
         let x = BzImage::load(
             &gm,
             Some(kernel_start),
             &mut Cursor::new(&image),
-            Some(lowest_kernel_start),
+            Some(highmem_start_address),
         );
         assert_eq!(x.is_ok(), false);
         println!("load bzImage with bad himem setting \n");
@@ -464,12 +464,12 @@ mod test {
         let gm = create_guest_mem();
         let image = make_elf_bin();
         let kernel_addr = GuestAddress(0x200000);
-        let mut lowest_kernel_start = GuestAddress(0x0);
+        let mut highmem_start_address = GuestAddress(0x0);
         let mut loader_result = Elf::load(
             &gm,
             Some(kernel_addr),
             &mut Cursor::new(&image),
-            Some(lowest_kernel_start),
+            Some(highmem_start_address),
         )
         .unwrap();
         println!(
@@ -487,22 +487,22 @@ mod test {
             &gm,
             None,
             &mut Cursor::new(&image),
-            Some(lowest_kernel_start),
+            Some(highmem_start_address),
         )
         .unwrap();
         println!(
             "load elf at address {:8x} \n",
             loader_result.kernel_load.raw_value()
         );
 
-        lowest_kernel_start = GuestAddress(0xa00000);
+        highmem_start_address = GuestAddress(0xa00000);
         assert_eq!(
             Err(Error::InvalidEntryAddress),
             Elf::load(
                 &gm,
                 None,
                 &mut Cursor::new(&image),
-                Some(lowest_kernel_start)
+                Some(highmem_start_address)
             )
         );
     }