Skip to content

Commit 16767d4

Browse files
author
Alexandra Iordache
committed
code reorganization: elf & bzimage modules
In preparation for more incoming code that's either elf or bzimage specific, the respective blocks of functionality now sit in separate modules. This makes the code easier to navigate and improves readability. Fixes #22 as well. Signed-off-by: Alexandra Iordache <aghecen@amazon.com>
1 parent 0ce5bfa commit 16767d4

File tree

9 files changed

+761
-636
lines changed

9 files changed

+761
-636
lines changed

src/loader/bzimage/mod.rs

Lines changed: 247 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,247 @@
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+
}
File renamed without changes.

0 commit comments

Comments
 (0)