Skip to content

Commit b8e18d7

Browse files
nicholasbishopnicholasbishop
committed
WIP: UEFI shell protocol testing
1 parent c8f414e commit b8e18d7

File tree

3 files changed

+204
-19
lines changed

3 files changed

+204
-19
lines changed

‎uefi-test-runner/src/bin/shell_launcher.rs‎

Lines changed: 141 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,141 @@
1+
#![no_std]
2+
#![no_main]
3+
4+
extern crate alloc;
5+
6+
use alloc::string::ToString;
7+
use alloc::vec::Vec;
8+
use uefi::prelude::*;
9+
use uefi::proto::device_path::build::{self, DevicePathBuilder};
10+
use uefi::proto::device_path::{DeviceSubType, DeviceType, LoadedImageDevicePath};
11+
use uefi::proto::loaded_image::LoadedImage;
12+
use uefi::table::boot::LoadImageSource;
13+
use uefi::table::runtime::{ResetType, VariableVendor};
14+
use uefi::{CStr16, Result, Status};
15+
16+
fn boot_internal_shell(runtime_services: &RuntimeServices) -> Result {
17+
for var in runtime_services.variable_keys().unwrap() {
18+
if var.vendor != VariableVendor::GLOBAL_VARIABLE {
19+
continue;
20+
}
21+
let name = var.name().unwrap();
22+
let name_string = name.to_string();
23+
if !name_string.starts_with("Boot") {
24+
continue;
25+
}
26+
if name_string.len() != 8 {
27+
continue;
28+
}
29+
let number = &name_string[4..];
30+
let number = if let Ok(number) = u16::from_str_radix(number, 16) {
31+
number
32+
} else {
33+
continue;
34+
};
35+
36+
log::info!("var: {}", name);
37+
let (data, attr) = runtime_services
38+
.get_variable_boxed(name, &var.vendor)
39+
.unwrap();
40+
let description = unsafe { CStr16::from_ptr(data[6..].as_ptr().cast()) };
41+
log::info!("description: {}", description);
42+
43+
if description == cstr16!("EFI Internal Shell") {
44+
let file_path_list_length = u16::from_le_bytes(data[4..6].try_into().unwrap());
45+
log::info!("file_path_list_length: {file_path_list_length}");
46+
47+
// Convert to a vec, and chop off any existing `OptionalData[]` bytes.
48+
let mut data =
49+
data[..4 + 2 + description.num_bytes() + file_path_list_length as usize].to_vec();
50+
data.extend(cstr16!("shell.efi test_runner.efi").as_bytes());
51+
52+
log::info!("Setting up next boot for internal shell");
53+
54+
runtime_services
55+
.set_variable(name, &VariableVendor::GLOBAL_VARIABLE, attr, &data)
56+
.unwrap();
57+
58+
runtime_services
59+
.set_variable(
60+
cstr16!("BootNext"),
61+
&VariableVendor::GLOBAL_VARIABLE,
62+
attr,
63+
&number.to_le_bytes(),
64+
)
65+
.unwrap();
66+
67+
return Ok(());
68+
}
69+
}
70+
71+
Status::ABORTED.to_result()
72+
}
73+
74+
// This launcher attempts to launch the shell app and run the main
75+
// uefi-test-running app inside that shell. This allows testing of protocols
76+
// that require the shell.
77+
//
78+
// Launching the shell programmatically allows us to avoid the built-in five
79+
// second delay when starting the shell.
80+
//
81+
// If the shell app is not present, the UEFI test runner is launched directly.
82+
#[entry]
83+
fn efi_main(image: Handle, mut st: SystemTable<Boot>) -> Status {
84+
uefi_services::init(&mut st).unwrap();
85+
86+
let boot_services = st.boot_services();
87+
88+
let loaded_image_device_path = boot_services
89+
.open_protocol_exclusive::<LoadedImageDevicePath>(image)
90+
.unwrap();
91+
92+
let mut storage = Vec::new();
93+
let mut builder = DevicePathBuilder::with_vec(&mut storage);
94+
for node in loaded_image_device_path.node_iter() {
95+
if node.full_type() == (DeviceType::MEDIA, DeviceSubType::MEDIA_FILE_PATH) {
96+
break;
97+
}
98+
builder = builder.push(&node).unwrap();
99+
}
100+
builder = builder
101+
.push(&build::media::FilePath {
102+
path_name: cstr16!(r"efi\boot\shell.efi"),
103+
})
104+
.unwrap();
105+
let new_image_path = builder.finalize().unwrap();
106+
107+
// TODO
108+
let new_image = if let Ok(new_image) = boot_services.load_image(
109+
image,
110+
LoadImageSource::FromFilePath {
111+
file_path: new_image_path,
112+
from_boot_manager: false,
113+
},
114+
) {
115+
new_image
116+
} else {
117+
log::info!("EFI shell app not found");
118+
119+
let runtime_services = st.runtime_services();
120+
121+
boot_internal_shell(runtime_services).unwrap();
122+
123+
log::info!("Rebooting");
124+
runtime_services.reset(ResetType::Warm, Status::SUCCESS, None);
125+
};
126+
127+
let mut new_loaded_image = boot_services
128+
.open_protocol_exclusive::<LoadedImage>(new_image)
129+
.unwrap();
130+
let load_options = cstr16!(r"shell.efi test_runner.efi");
131+
unsafe {
132+
new_loaded_image.set_load_options(
133+
load_options.as_ptr().cast(),
134+
load_options.num_bytes() as u32,
135+
);
136+
}
137+
138+
boot_services.start_image(new_image).unwrap();
139+
140+
Status::SUCCESS
141+
}

‎uefi-test-runner/src/main.rs‎

Lines changed: 9 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -51,6 +51,15 @@ fn efi_main(image: Handle, mut st: SystemTable<Boot>) -> Status {
5151

5252
boot::test(bt);
5353

54+
{
55+
let handles = bt
56+
.locate_handle_buffer(uefi::table::boot::SearchType::ByProtocol(&uefi::guid!(
57+
"752f3136-4e16-4fdc-a22a-e5f46812f4ca"
58+
)))
59+
.unwrap();
60+
info!("BISH: {handles:?}");
61+
}
62+
5463
// Test all the supported protocols.
5564
proto::test(image, &mut st);
5665

‎xtask/src/qemu.rs‎

Lines changed: 54 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -21,13 +21,15 @@ use {std::fs::Permissions, std::os::unix::fs::PermissionsExt};
2121
enum OvmfFileType {
2222
Code,
2323
Vars,
24+
Shell,
2425
}
2526

2627
impl OvmfFileType {
2728
fn as_str(&self) -> &'static str {
2829
match self {
2930
Self::Code => "code",
3031
Self::Vars => "vars",
32+
Self::Shell => "shell",
3133
}
3234
}
3335

@@ -47,6 +49,10 @@ impl OvmfFileType {
4749
opt_path = &opt.ovmf_vars;
4850
var_name = "OVMF_VARS";
4951
}
52+
Self::Shell => {
53+
opt_path = &None;
54+
var_name = "OVMF_SHELL";
55+
}
5056
}
5157
if let Some(path) = opt_path {
5258
Some(path.clone())
@@ -59,6 +65,7 @@ impl OvmfFileType {
5965
struct OvmfPaths {
6066
code: PathBuf,
6167
vars: PathBuf,
68+
shell: PathBuf,
6269
}
6370

6471
impl OvmfPaths {
@@ -78,6 +85,7 @@ impl OvmfPaths {
7885
match file_type {
7986
OvmfFileType::Code => &self.code,
8087
OvmfFileType::Vars => &self.vars,
88+
OvmfFileType::Shell => &self.shell,
8189
}
8290
}
8391

@@ -88,16 +96,19 @@ impl OvmfPaths {
8896
UefiArch::AArch64 => Self {
8997
code: "/usr/share/edk2-armvirt/aarch64/QEMU_CODE.fd".into(),
9098
vars: "/usr/share/edk2-armvirt/aarch64/QEMU_VARS.fd".into(),
99+
shell: "".into(),
91100
},
92101
// Package "edk2-ovmf".
93102
UefiArch::IA32 => Self {
94103
code: "/usr/share/edk2-ovmf/ia32/OVMF_CODE.fd".into(),
95104
vars: "/usr/share/edk2-ovmf/ia32/OVMF_VARS.fd".into(),
105+
shell: "".into(),
96106
},
97107
// Package "edk2-ovmf".
98108
UefiArch::X86_64 => Self {
99109
code: "/usr/share/edk2-ovmf/x64/OVMF_CODE.fd".into(),
100110
vars: "/usr/share/edk2-ovmf/x64/OVMF_VARS.fd".into(),
111+
shell: "".into(),
101112
},
102113
}
103114
}
@@ -109,6 +120,7 @@ impl OvmfPaths {
109120
UefiArch::AArch64 => Some(Self {
110121
code: "/usr/share/edk2/aarch64/QEMU_EFI-pflash.raw".into(),
111122
vars: "/usr/share/edk2/aarch64/vars-template-pflash.raw".into(),
123+
shell: "".into(),
112124
}),
113125
// There's no official ia32 package.
114126
UefiArch::IA32 => None,
@@ -118,6 +130,7 @@ impl OvmfPaths {
118130
// doesn't have a plain "OVMF_CODE.fd".
119131
code: "/usr/share/edk2/ovmf/OVMF_CODE.secboot.fd".into(),
120132
vars: "/usr/share/edk2/ovmf/OVMF_VARS.fd".into(),
133+
shell: "".into(),
121134
}),
122135
}
123136
}
@@ -130,16 +143,19 @@ impl OvmfPaths {
130143
UefiArch::AArch64 => Self {
131144
code: "/usr/share/AAVMF/AAVMF_CODE.fd".into(),
132145
vars: "/usr/share/AAVMF/AAVMF_VARS.fd".into(),
146+
shell: "".into(),
133147
},
134148
// Package "ovmf-ia32".
135149
UefiArch::IA32 => Self {
136150
code: "/usr/share/OVMF/OVMF32_CODE_4M.secboot.fd".into(),
137151
vars: "/usr/share/OVMF/OVMF32_VARS_4M.fd".into(),
152+
shell: "".into(),
138153
},
139154
// Package "ovmf".
140155
UefiArch::X86_64 => Self {
141156
code: "/usr/share/OVMF/OVMF_CODE.fd".into(),
142157
vars: "/usr/share/OVMF/OVMF_VARS.fd".into(),
158+
shell: "".into(),
143159
},
144160
}
145161
}
@@ -151,16 +167,19 @@ impl OvmfPaths {
151167
UefiArch::AArch64 => Self {
152168
code: "/usr/share/edk2/aarch64/QEMU_EFI-pflash.raw".into(),
153169
vars: "/usr/share/edk2/aarch64/vars-template-pflash.raw".into(),
170+
shell: "".into(),
154171
},
155172
// Package "edk2-ovmf-ia32".
156173
UefiArch::IA32 => Self {
157174
code: "/usr/share/edk2/ovmf-ia32/OVMF_CODE.fd".into(),
158175
vars: "/usr/share/edk2/ovmf-ia32/OVMF_VARS.fd".into(),
176+
shell: "/usr/share/edk2/ovmf-ia32/Shell.efi".into(),
159177
},
160178
// Package "edk2-ovmf".
161179
UefiArch::X86_64 => Self {
162180
code: "/usr/share/edk2/ovmf/OVMF_CODE.fd".into(),
163181
vars: "/usr/share/edk2/ovmf/OVMF_VARS.fd".into(),
182+
shell: "/usr/share/edk2/ovmf/Shell.efi".into(),
164183
},
165184
}
166185
}
@@ -189,15 +208,18 @@ impl OvmfPaths {
189208
UefiArch::AArch64 => Self {
190209
code: r"C:\Program Files\qemu\share\edk2-aarch64-code.fd".into(),
191210
vars: r"C:\Program Files\qemu\share\edk2-arm-vars.fd".into(),
211+
shell: "".into(),
192212
},
193213
UefiArch::IA32 => Self {
194214
code: r"C:\Program Files\qemu\share\edk2-i386-code.fd".into(),
195215
vars: r"C:\Program Files\qemu\share\edk2-i386-vars.fd".into(),
216+
shell: "".into(),
196217
},
197218
UefiArch::X86_64 => Self {
198219
code: r"C:\Program Files\qemu\share\edk2-x86_64-code.fd".into(),
199220
// There's no x86_64 vars file, but the i386 one works.
200221
vars: r"C:\Program Files\qemu\share\edk2-i386-vars.fd".into(),
222+
shell: "".into(),
201223
},
202224
}
203225
}
@@ -271,8 +293,9 @@ impl OvmfPaths {
271293

272294
let code = Self::find_ovmf_file(OvmfFileType::Code, opt, &candidates)?;
273295
let vars = Self::find_ovmf_file(OvmfFileType::Vars, opt, &candidates)?;
296+
let shell = Self::find_ovmf_file(OvmfFileType::Shell, opt, &candidates).unwrap_or_default();
274297

275-
Ok(Self { code, vars })
298+
Ok(Self { code, vars, shell })
276299
}
277300
}
278301

@@ -415,7 +438,7 @@ fn process_qemu_io(mut monitor_io: Io, mut serial_io: Io, tmp_dir: &Path) -> Res
415438
}
416439

417440
/// Create an EFI boot directory to pass into QEMU.
418-
fn build_esp_dir(opt: &QemuOpt) -> Result<PathBuf> {
441+
fn build_esp_dir(opt: &QemuOpt, ovmf_paths: &OvmfPaths) -> Result<PathBuf> {
419442
let build_mode = if opt.build_mode.release {
420443
"release"
421444
} else {
@@ -425,24 +448,37 @@ fn build_esp_dir(opt: &QemuOpt) -> Result<PathBuf> {
425448
.join(opt.target.as_triple())
426449
.join(build_mode);
427450
let esp_dir = build_dir.join("esp");
451+
452+
// Create boot dir.
428453
let boot_dir = esp_dir.join("EFI").join("Boot");
429-
let built_file = if let Some(example) = &opt.example {
430-
build_dir.join("examples").join(format!("{example}.efi"))
431-
} else {
432-
build_dir.join("uefi-test-runner.efi")
433-
};
434-
let output_file = match *opt.target {
454+
if !boot_dir.exists() {
455+
fs_err::create_dir_all(&boot_dir)?;
456+
}
457+
458+
let boot_file_name = match *opt.target {
435459
UefiArch::AArch64 => "BootAA64.efi",
436460
UefiArch::IA32 => "BootIA32.efi",
437461
UefiArch::X86_64 => "BootX64.efi",
438462
};
439-
if !boot_dir.exists() {
440-
fs_err::create_dir_all(&boot_dir)?;
441-
}
442-
fs_err::copy(built_file, boot_dir.join(output_file))?;
443463

444-
// Add a test file that is used in the media protocol tests.
445-
fs_err::write(boot_dir.join("test_input.txt"), "test input data")?;
464+
if let Some(example) = &opt.example {
465+
let src_path = build_dir.join("examples").join(format!("{example}.efi"));
466+
fs_err::copy(src_path, boot_dir.join(boot_file_name))?;
467+
} else {
468+
let shell_launcher = build_dir.join("shell_launcher.efi");
469+
fs_err::copy(shell_launcher, boot_dir.join(boot_file_name))?;
470+
471+
let test_runner = build_dir.join("uefi-test-runner.efi");
472+
fs_err::copy(test_runner, boot_dir.join("test_runner.efi"))?;
473+
474+
// TODO:
475+
// Does Ubuntu (as used in the CI pipeline) even ship the shell app?
476+
// Ignore error since there may not be a shell app.
477+
let _ = fs_err::copy(&ovmf_paths.shell, boot_dir.join("shell.efi"));
478+
479+
// Add a test file that is used in the media protocol tests.
480+
fs_err::write(boot_dir.join("test_input.txt"), "test input data")?;
481+
};
446482

447483
Ok(esp_dir)
448484
}
@@ -469,8 +505,6 @@ impl Drop for ChildWrapper {
469505
}
470506

471507
pub fn run_qemu(arch: UefiArch, opt: &QemuOpt) -> Result<()> {
472-
let esp_dir = build_esp_dir(opt)?;
473-
474508
let qemu_exe = match arch {
475509
UefiArch::AArch64 => "qemu-system-aarch64",
476510
UefiArch::IA32 | UefiArch::X86_64 => "qemu-system-x86_64",
@@ -526,9 +560,9 @@ pub fn run_qemu(arch: UefiArch, opt: &QemuOpt) -> Result<()> {
526560
}
527561

528562
// Exit instead of rebooting in the CI.
529-
if opt.ci {
530-
cmd.arg("-no-reboot");
531-
}
563+
// if opt.ci {
564+
// cmd.arg("-no-reboot");
565+
// }
532566

533567
// Map the QEMU exit signal to port f4.
534568
cmd.args(["-device", "isa-debug-exit,iobase=0xf4,iosize=0x04"]);
@@ -566,6 +600,7 @@ pub fn run_qemu(arch: UefiArch, opt: &QemuOpt) -> Result<()> {
566600
// Mount a local directory as a FAT partition.
567601
cmd.arg("-drive");
568602
let mut drive_arg = OsString::from("format=raw,file=fat:rw:");
603+
let esp_dir = build_esp_dir(opt, &ovmf_paths)?;
569604
drive_arg.push(esp_dir);
570605
cmd.arg(drive_arg);
571606

0 commit comments

Comments
 (0)