|
| 1 | +// Copyright (c) 2019 Intel Corporation. All rights reserved. |
| 2 | +// Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved. |
| 3 | +// |
| 4 | +// Copyright 2017 The Chromium OS Authors. All rights reserved. |
| 5 | +// Use of this source code is governed by a BSD-style license that can be |
| 6 | +// found in the LICENSE-BSD-3-Clause file. |
| 7 | +// |
| 8 | +// SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause |
| 9 | + |
| 10 | +//! Traits and structs for loading bzimage kernels into guest memory. |
| 11 | +
|
| 12 | +#![cfg(all(feature = "bzimage", any(target_arch = "x86", target_arch = "x86_64")))] |
| 13 | + |
| 14 | +use std::error::{self, Error as StdError}; |
| 15 | +use std::fmt::{self, Display}; |
| 16 | +use std::io::{Read, Seek, SeekFrom}; |
| 17 | + |
| 18 | +use vm_memory::{Address, Bytes, GuestAddress, GuestMemory, GuestUsize}; |
| 19 | + |
| 20 | +use super::{ |
| 21 | + bootparam, struct_util, Error as KernelLoaderError, KernelLoader, KernelLoaderResult, Result, |
| 22 | +}; |
| 23 | + |
| 24 | +#[derive(Debug, PartialEq)] |
| 25 | +/// Bzimage kernel loader errors. |
| 26 | +pub enum Error { |
| 27 | + /// Invalid bzImage binary. |
| 28 | + InvalidBzImage, |
| 29 | + /// Unable to read bzImage header. |
| 30 | + ReadBzImageHeader, |
| 31 | + /// Unable to read bzImage compressed image. |
| 32 | + ReadBzImageCompressedKernel, |
| 33 | + /// Unable to seek to bzImage end. |
| 34 | + SeekBzImageEnd, |
| 35 | + /// Unable to seek to bzImage header. |
| 36 | + SeekBzImageHeader, |
| 37 | + /// Unable to seek to bzImage compressed kernel. |
| 38 | + SeekBzImageCompressedKernel, |
| 39 | +} |
| 40 | + |
| 41 | +impl error::Error for Error { |
| 42 | + fn description(&self) -> &str { |
| 43 | + match self { |
| 44 | + Error::InvalidBzImage => "Invalid bzImage", |
| 45 | + Error::ReadBzImageHeader => "Unable to read bzImage header", |
| 46 | + Error::ReadBzImageCompressedKernel => "Unable to read bzImage compressed kernel", |
| 47 | + Error::SeekBzImageEnd => "Unable to seek bzImage end", |
| 48 | + Error::SeekBzImageHeader => "Unable to seek bzImage header", |
| 49 | + Error::SeekBzImageCompressedKernel => "Unable to seek bzImage compressed kernel", |
| 50 | + } |
| 51 | + } |
| 52 | +} |
| 53 | + |
| 54 | +impl Display for Error { |
| 55 | + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { |
| 56 | + write!(f, "Kernel Loader Error: {}", self.description()) |
| 57 | + } |
| 58 | +} |
| 59 | + |
| 60 | +/// Big zImage (bzImage) kernel image support. |
| 61 | +pub struct BzImage; |
| 62 | + |
| 63 | +impl KernelLoader for BzImage { |
| 64 | + /// Loads a kernel from a bzImage to guest memory. |
| 65 | + /// |
| 66 | + /// The kernel is loaded at `code32_start`, the default load address stored in the bzImage |
| 67 | + /// setup header. |
| 68 | + /// |
| 69 | + /// # Arguments |
| 70 | + /// |
| 71 | + /// * `guest_mem`: [`GuestMemory`] to load the kernel in. |
| 72 | + /// * `kernel_start`: Address in guest memory where the kernel is loaded. |
| 73 | + /// * `kernel_image` - Input bzImage image. |
| 74 | + /// * `highmem_start_address`: Address where high memory starts. |
| 75 | + /// |
| 76 | + /// # Examples |
| 77 | + /// |
| 78 | + /// ```rust |
| 79 | + /// # extern crate vm_memory; |
| 80 | + /// # use linux_loader::loader::*; |
| 81 | + /// # use vm_memory::{Address, GuestAddress, GuestMemoryMmap}; |
| 82 | + /// # use std::io::Cursor; |
| 83 | + /// let mem_size: usize = 0x1000000; |
| 84 | + /// let himem_start = GuestAddress(0x0); |
| 85 | + /// let kernel_addr = GuestAddress(0x200000); |
| 86 | + /// let gm = GuestMemoryMmap::from_ranges(&[(GuestAddress(0x0), mem_size)]).unwrap(); |
| 87 | + /// let mut kernel_image = vec![]; |
| 88 | + /// kernel_image.extend_from_slice(include_bytes!("bzimage")); |
| 89 | + /// assert!(BzImage::load( |
| 90 | + /// &gm, |
| 91 | + /// Some(kernel_addr), |
| 92 | + /// &mut Cursor::new(&kernel_image), |
| 93 | + /// Some(himem_start), |
| 94 | + /// ).is_ok()); |
| 95 | + /// ``` |
| 96 | + /// |
| 97 | + /// [`GuestMemory`]: https://docs.rs/vm-memory/latest/vm_memory/guest_memory/trait.GuestMemory.html |
| 98 | + fn load<F, M: GuestMemory>( |
| 99 | + guest_mem: &M, |
| 100 | + kernel_start: Option<GuestAddress>, |
| 101 | + kernel_image: &mut F, |
| 102 | + highmem_start_address: Option<GuestAddress>, |
| 103 | + ) -> Result<KernelLoaderResult> |
| 104 | + where |
| 105 | + F: Read + Seek, |
| 106 | + { |
| 107 | + let mut kernel_size = kernel_image |
| 108 | + .seek(SeekFrom::End(0)) |
| 109 | + .map_err(|_| Error::SeekBzImageEnd)? as usize; |
| 110 | + let mut boot_header: bootparam::setup_header = Default::default(); |
| 111 | + kernel_image |
| 112 | + .seek(SeekFrom::Start(0x1F1)) |
| 113 | + .map_err(|_| Error::SeekBzImageHeader)?; |
| 114 | + unsafe { |
| 115 | + // read_struct is safe when reading a POD struct. It can be used and dropped without issue. |
| 116 | + struct_util::read_struct(kernel_image, &mut boot_header) |
| 117 | + .map_err(|_| Error::ReadBzImageHeader)?; |
| 118 | + } |
| 119 | + |
| 120 | + // If the `HdrS` magic number is not found at offset 0x202, the boot protocol version is |
| 121 | + // "old", the image type is assumed as zImage, not bzImage. |
| 122 | + if boot_header.header != 0x5372_6448 { |
| 123 | + Err(Error::InvalidBzImage)?; |
| 124 | + } |
| 125 | + |
| 126 | + // Follow the section related to loading the rest of the kernel in the linux boot protocol. |
| 127 | + if (boot_header.version < 0x0200) || ((boot_header.loadflags & 0x1) == 0x0) { |
| 128 | + Err(Error::InvalidBzImage)?; |
| 129 | + } |
| 130 | + |
| 131 | + let mut setup_size = boot_header.setup_sects as usize; |
| 132 | + if setup_size == 0 { |
| 133 | + setup_size = 4; |
| 134 | + } |
| 135 | + setup_size = (setup_size + 1) * 512; |
| 136 | + kernel_size -= setup_size; |
| 137 | + |
| 138 | + // Check that `code32_start`, the default address of the kernel, is not lower than high |
| 139 | + // memory. |
| 140 | + if (highmem_start_address.is_some()) |
| 141 | + && (u64::from(boot_header.code32_start) < highmem_start_address.unwrap().raw_value()) |
| 142 | + { |
| 143 | + return Err(KernelLoaderError::InvalidKernelStartAddress); |
| 144 | + } |
| 145 | + |
| 146 | + let mem_offset = match kernel_start { |
| 147 | + Some(start) => start, |
| 148 | + None => GuestAddress(u64::from(boot_header.code32_start)), |
| 149 | + }; |
| 150 | + |
| 151 | + boot_header.code32_start = mem_offset.raw_value() as u32; |
| 152 | + |
| 153 | + let mut loader_result: KernelLoaderResult = Default::default(); |
| 154 | + loader_result.setup_header = Some(boot_header); |
| 155 | + loader_result.kernel_load = mem_offset; |
| 156 | + |
| 157 | + // Seek the compressed `vmlinux.bin` and read it to memory. |
| 158 | + kernel_image |
| 159 | + .seek(SeekFrom::Start(setup_size as u64)) |
| 160 | + .map_err(|_| Error::SeekBzImageCompressedKernel)?; |
| 161 | + guest_mem |
| 162 | + .read_exact_from(mem_offset, kernel_image, kernel_size) |
| 163 | + .map_err(|_| Error::ReadBzImageCompressedKernel)?; |
| 164 | + |
| 165 | + loader_result.kernel_end = mem_offset |
| 166 | + .raw_value() |
| 167 | + .checked_add(kernel_size as GuestUsize) |
| 168 | + .ok_or(KernelLoaderError::MemoryOverflow)?; |
| 169 | + |
| 170 | + Ok(loader_result) |
| 171 | + } |
| 172 | +} |
| 173 | + |
| 174 | +#[cfg(test)] |
| 175 | +mod tests { |
| 176 | + use super::*; |
| 177 | + |
| 178 | + use std::io::Cursor; |
| 179 | + use vm_memory::{Address, GuestAddress, GuestMemoryMmap}; |
| 180 | + |
| 181 | + const MEM_SIZE: u64 = 0x1000000; |
| 182 | + |
| 183 | + fn create_guest_mem() -> GuestMemoryMmap { |
| 184 | + GuestMemoryMmap::from_ranges(&[(GuestAddress(0x0), (MEM_SIZE as usize))]).unwrap() |
| 185 | + } |
| 186 | + |
| 187 | + fn make_bzimage() -> Vec<u8> { |
| 188 | + let mut v = Vec::new(); |
| 189 | + v.extend_from_slice(include_bytes!("bzimage")); |
| 190 | + v |
| 191 | + } |
| 192 | + |
| 193 | + #[allow(safe_packed_borrows)] |
| 194 | + #[allow(non_snake_case)] |
| 195 | + #[test] |
| 196 | + fn test_load_bzImage() { |
| 197 | + let gm = create_guest_mem(); |
| 198 | + let image = make_bzimage(); |
| 199 | + let mut kernel_start = GuestAddress(0x200000); |
| 200 | + let mut highmem_start_address = GuestAddress(0x0); |
| 201 | + |
| 202 | + // load bzImage with good kernel_start and himem_start setting |
| 203 | + let mut loader_result = BzImage::load( |
| 204 | + &gm, |
| 205 | + Some(kernel_start), |
| 206 | + &mut Cursor::new(&image), |
| 207 | + Some(highmem_start_address), |
| 208 | + ) |
| 209 | + .unwrap(); |
| 210 | + |
| 211 | + assert_eq!(loader_result.kernel_load.raw_value(), 0x200000); |
| 212 | + assert_eq!(loader_result.setup_header.unwrap().header, 0x53726448); |
| 213 | + assert_eq!(loader_result.setup_header.unwrap().version, 0x20d); |
| 214 | + assert_eq!(loader_result.setup_header.unwrap().loadflags, 1); |
| 215 | + assert_eq!(loader_result.kernel_end, 0x60c320); |
| 216 | + |
| 217 | + // load bzImage without kernel_start |
| 218 | + loader_result = BzImage::load( |
| 219 | + &gm, |
| 220 | + None, |
| 221 | + &mut Cursor::new(&image), |
| 222 | + Some(highmem_start_address), |
| 223 | + ) |
| 224 | + .unwrap(); |
| 225 | + assert_eq!(loader_result.kernel_load.raw_value(), 0x100000); |
| 226 | + |
| 227 | + // load bzImage withouth himem_start |
| 228 | + loader_result = BzImage::load(&gm, None, &mut Cursor::new(&image), None).unwrap(); |
| 229 | + assert_eq!(0x53726448, loader_result.setup_header.unwrap().header); |
| 230 | + assert_eq!(loader_result.kernel_load.raw_value(), 0x100000); |
| 231 | + |
| 232 | + // load bzImage with a bad himem setting |
| 233 | + kernel_start = GuestAddress(0x1000); |
| 234 | + highmem_start_address = GuestAddress(0x200000); |
| 235 | + |
| 236 | + assert_eq!( |
| 237 | + Some(KernelLoaderError::InvalidKernelStartAddress), |
| 238 | + BzImage::load( |
| 239 | + &gm, |
| 240 | + Some(kernel_start), |
| 241 | + &mut Cursor::new(&image), |
| 242 | + Some(highmem_start_address), |
| 243 | + ) |
| 244 | + .err() |
| 245 | + ); |
| 246 | + } |
| 247 | +} |
0 commit comments