Auto merge of #144454 - folkertdev:uefi-tests, r=<try>

move uefi test to run-make

try-job: test-various

Author: rust-bors[bot]

src/ci/docker/host-x86_64/test-various/Dockerfile

@@ -79,7 +79,6 @@ ENV MUSL_TARGETS=x86_64-unknown-linux-musl \
     CXX_x86_64_unknown_linux_musl=x86_64-linux-musl-g++
 ENV MUSL_SCRIPT python3 /checkout/x.py --stage 2 test --host='' --target $MUSL_TARGETS
 
-COPY host-x86_64/test-various/uefi_qemu_test /uefi_qemu_test
 ENV UEFI_TARGETS=aarch64-unknown-uefi,i686-unknown-uefi,x86_64-unknown-uefi \
     CC_aarch64_unknown_uefi=clang-11 \
     CXX_aarch64_unknown_uefi=clang++-11 \
@@ -88,6 +87,8 @@ ENV UEFI_TARGETS=aarch64-unknown-uefi,i686-unknown-uefi,x86_64-unknown-uefi \
     CC_x86_64_unknown_uefi=clang-11 \
     CXX_x86_64_unknown_uefi=clang++-11
 ENV UEFI_SCRIPT python3 /checkout/x.py --stage 2 build --host='' --target $UEFI_TARGETS && \
-  python3 -u /uefi_qemu_test/run.py
+  python3 /checkout/x.py --stage 2 test tests/run-make/uefi-qemu/rmake.rs --target aarch64-unknown-uefi && \
+  python3 /checkout/x.py --stage 2 test tests/run-make/uefi-qemu/rmake.rs --target i686-unknown-uefi && \
+  python3 /checkout/x.py --stage 2 test tests/run-make/uefi-qemu/rmake.rs --target x86_64-unknown-uefi
 
 ENV SCRIPT $WASM_SCRIPT && $NVPTX_SCRIPT && $MUSL_SCRIPT && $UEFI_SCRIPT

src/ci/docker/host-x86_64/test-various/uefi_qemu_test/run.py

@@ -991,6 +991,7 @@ const KNOWN_DIRECTIVE_NAMES: &[&str] = &[
     "only-stable",
     "only-thumb",
     "only-tvos",
+    "only-uefi",
     "only-unix",
     "only-visionos",
     "only-wasm32",

src/tools/compiletest/src/directives.rs

@@ -164,6 +164,12 @@ fn parse_cfg_name_directive<'a>(
         message: "when the architecture is part of the Thumb family"
     }
 
+    condition! {
+        name: "uefi",
+        condition: config.target.ends_with("uefi"),
+        message: "when target platform is UEFI"
+    }
+
     condition! {
         name: "apple",
         condition: config.target.contains("apple"),

src/tools/compiletest/src/directives/cfg.rs

@@ -73,14 +73,14 @@ pub(crate) const WORKSPACES: &[(&str, ExceptionList, Option<(&[&str], &[&str])>,
     // tidy-alphabetical-start
     ("compiler/rustc_codegen_gcc", EXCEPTIONS_GCC, None, &[]),
     ("src/bootstrap", EXCEPTIONS_BOOTSTRAP, None, &[]),
-    ("src/ci/docker/host-x86_64/test-various/uefi_qemu_test", EXCEPTIONS_UEFI_QEMU_TEST, None, &[]),
     ("src/tools/cargo", EXCEPTIONS_CARGO, None, &["src/tools/cargo"]),
     //("src/tools/miri/test-cargo-miri", &[], None), // FIXME uncomment once all deps are vendored
     //("src/tools/miri/test_dependencies", &[], None), // FIXME uncomment once all deps are vendored
     ("src/tools/rust-analyzer", EXCEPTIONS_RUST_ANALYZER, None, &[]),
     ("src/tools/rustbook", EXCEPTIONS_RUSTBOOK, None, &["src/doc/book", "src/doc/reference"]),
     ("src/tools/rustc-perf", EXCEPTIONS_RUSTC_PERF, None, &["src/tools/rustc-perf"]),
     ("src/tools/test-float-parse", EXCEPTIONS, None, &[]),
+    ("tests/run-make/uefi-qemu/uefi_qemu_test", EXCEPTIONS_UEFI_QEMU_TEST, None, &[]),
     // tidy-alphabetical-end
 ];
 

src/tools/tidy/src/deps.rs

@@ -0,0 +1,111 @@
+//! This test builds and runs a basic UEFI application on QEMU for various targets.
+//!
+//! You must have the relevant OVMF or AAVMF firmware installed for this to work.
+//!
+//! Requires: qemu-system-x86_64, qemu-system-aarch64
+//!           OVMF/AAVMF firmware
+//!
+//! Note: test assumes `/uefi_qemu_test` exists and is a self-contained crate.
+
+//@ only-uefi
+
+use std::path::Path;
+
+use run_make_support::{cargo, cmd, path, target};
+
+fn main() {
+    let tmp = std::env::temp_dir();
+    build_and_run(&target(), &tmp);
+}
+
+fn build_and_run(target: &str, tmp: &Path) {
+    let (boot_filename, ovmf_dir, ovmf_code_name, ovmf_vars_name, qemu, machine, cpu) = match target
+    {
+        "aarch64-unknown-uefi" => (
+            "bootaa64.efi",
+            Path::new("/usr/share/AAVMF"),
+            "AAVMF_CODE.fd",
+            "AAVMF_VARS.fd",
+            "qemu-system-aarch64",
+            "virt",
+            "cortex-a72",
+        ),
+        "i686-unknown-uefi" => (
+            "bootia32.efi",
+            Path::new("/usr/share/OVMF"),
+            "OVMF32_CODE_4M.secboot.fd",
+            "OVMF32_VARS_4M.fd",
+            "qemu-system-x86_64",
+            "q35",
+            "qemu64",
+        ),
+        "x86_64-unknown-uefi" => (
+            "bootx64.efi",
+            Path::new("/usr/share/OVMF"),
+            "OVMF_CODE_4M.fd",
+            "OVMF_VARS_4M.fd",
+            "qemu-system-x86_64",
+            "q35",
+            "qemu64",
+        ),
+        _ => panic!("unsupported target {target}"),
+    };
+
+    let test_crate = tmp.join("uefi_qemu_test");
+    copy_tree(path("uefi_qemu_test"), &test_crate);
+
+    // Build
+    cargo().args(&["build", "--target", target]).current_dir(&test_crate).run();
+
+    // Prepare ESP
+    let esp = test_crate.join("esp");
+    let boot = esp.join("efi/boot");
+    std::fs::create_dir_all(&boot).unwrap();
+
+    let src_efi = test_crate.join("target").join(target).join("debug/uefi_qemu_test.efi");
+    let dst_efi = boot.join(boot_filename);
+    std::fs::copy(&src_efi, &dst_efi).unwrap();
+
+    // Copy OVMF files
+    let code = ovmf_dir.join(ovmf_code_name);
+    let vars_src = ovmf_dir.join(ovmf_vars_name);
+    let vars_dst = tmp.join("vars.fd");
+    std::fs::copy(&vars_src, &vars_dst).unwrap();
+
+    // Run QEMU
+    let output = cmd(qemu)
+        .args(["-machine", machine])
+        .args(["-cpu", cpu])
+        .args(["-display", "none"])
+        .args(["-serial", "stdio"])
+        .args(["-drive", &format!("if=pflash,format=raw,readonly=on,file={}", code.display())])
+        .args(["-drive", &format!("if=pflash,format=raw,readonly=off,file={}", vars_dst.display())])
+        .args(["-drive", &format!("format=raw,file=fat:rw:{}", esp.display())])
+        .run()
+        .stdout_utf8();
+
+    assert!(output.contains("Hello World!"), "invalid output for {target}:\n{output}");
+}
+
+fn copy_tree(src: impl AsRef<Path>, dst: impl AsRef<Path>) {
+    fn inner(src: &Path, dst: &Path) {
+        if !dst.exists() {
+            std::fs::create_dir_all(dst).unwrap();
+        }
+
+        for entry in std::fs::read_dir(src).unwrap() {
+            let entry = entry.unwrap();
+            let file_type = entry.file_type().unwrap();
+            let src_path = entry.path();
+            let dst_path = dst.join(entry.file_name());
+
+            if file_type.is_dir() {
+                inner(&src_path, &dst_path);
+            } else if file_type.is_file() {
+                std::fs::copy(&src_path, &dst_path).unwrap();
+            }
+        }
+    }
+
+    inner(src.as_ref(), dst.as_ref());
+}

tests/run-make/uefi-qemu/rmake.rs

@@ -15,14 +15,7 @@ fn panic_handler(_info: &panic::PanicInfo) -> ! {
 
 #[export_name = "efi_main"]
 pub extern "C" fn main(_h: Handle, st: *mut SystemTable) -> Status {
-    let s = [
-        0x0048u16, 0x0065u16, 0x006cu16, 0x006cu16, 0x006fu16, // "Hello"
-        0x0020u16, //                                             " "
-        0x0057u16, 0x006fu16, 0x0072u16, 0x006cu16, 0x0064u16, // "World"
-        0x0021u16, //                                             "!"
-        0x000au16, //                                             "\n"
-        0x0000u16, //                                             NUL
-    ];
+    let s = b"Hello World!\n\0".map(|c| u16::from(c));
 
     // Print "Hello World!".
     let r = unsafe { ((*(*st).con_out).output_string)((*st).con_out, s.as_ptr() as *mut Char16) };