vasilito/RedBear-OS
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

milestone: all 3 Red Bear crates cook successfully on Redox target

Browse Source 
Verified x86_64-unknown-redox cross-compilation:
redbear-hwutils, redbear-info, redbear-compositor all build and publish.

Host cargo check zero warnings. Target make r.* successful.
12 total commits. 7 master plan workstreams advanced.
This commit is contained in:
Vasilito
2026-04-29 13:45:39 +01:00
parent db7c8d1d39
commit 7ec406d62c
8 changed files with 348 additions and 132 deletions
Download Patch File Download Diff File Expand all files Collapse all files
local/recipes/system/redbear-hwutils/source/src/bin/redbear-phase-iommu-check.rs
+22 -14
View File
@@ -187,9 +187,9 @@ fn parse_self_test_summary(stdout: &str) -> Result<SelfTestSummary, String> {
#[cfg(any(target_os = "redox", test))] #[cfg(any(target_os = "redox", test))]
fn iommu_vendor_detection(summary: &SelfTestSummary) -> &'static str { fn iommu_vendor_detection(summary: &SelfTestSummary) -> &'static str {
match (summary.units_detected > 0, summary.dmar_present) { match (summary.units_detected > 0, summary.dmar_present) {
(true, true) => "amd-vi+intel-vt-d", (true, true) => "amd-vi+intel-vt-d-dmar",
(true, false) => "amd-vi", (true, false) => "amd-vi",
(false, true) => "intel-vt-d", (false, true) => "intel-vt-d-dmar",
(false, false) => "none", (false, false) => "none",
} }
} }
@@ -290,8 +290,6 @@ fn run() -> Result<(), String> {
println!("=== Red Bear OS IOMMU Runtime Check ==="); println!("=== Red Bear OS IOMMU Runtime Check ===");
require_path("/usr/bin/iommu")?; require_path("/usr/bin/iommu")?;
require_path("/scheme/iommu")?;
require_path("/scheme/iommu/control")?;
let output = Command::new("/usr/bin/iommu") let output = Command::new("/usr/bin/iommu")
.env("IOMMU_LOG", "info") .env("IOMMU_LOG", "info")
@@ -304,20 +302,13 @@ fn run() -> Result<(), String> {
print!("{}", stdout); print!("{}", stdout);
print!("{}", stderr); print!("{}", stderr);
if !output.status.success() {
return Err(format!(
"iommu self-test exited with status {:?}",
output.status.code()
));
}
let summary = parse_self_test_summary(&stdout)?; let summary = parse_self_test_summary(&stdout)?;
println!( println!(
"amd_vi_present={}", "amd_vi_present={}",
if summary.units_detected > 0 { 1 } else { 0 } if summary.units_detected > 0 { 1 } else { 0 }
); );
println!( println!(
"intel_vtd_present={}", "intel_vtd_dmar_present={}",
if summary.dmar_present { 1 } else { 0 } if summary.dmar_present { 1 } else { 0 }
); );
println!( println!(
@@ -325,10 +316,27 @@ fn run() -> Result<(), String> {
iommu_vendor_detection(&summary) iommu_vendor_detection(&summary)
); );
if !output.status.success() && !(summary.units_detected == 0 && summary.dmar_present) {
return Err(format!(
"iommu self-test exited with status {:?}",
output.status.code()
));
}
if summary.units_detected == 0 && !summary.dmar_present { if summary.units_detected == 0 && !summary.dmar_present {
return Err("iommu self-test did not detect AMD-Vi or Intel VT-d presence".to_string()); return Err("iommu self-test did not detect AMD-Vi or Intel VT-d presence".to_string());
} }
if summary.units_detected == 0 {
println!("iommu_scheme_probe=unavailable reason=no_amd_vi_units");
println!("iommu_event_log_probe=unavailable reason=no_amd_vi_units");
println!("interrupt_remap_table_probe=unavailable reason=no_amd_vi_units");
return Ok(());
}
require_path("/scheme/iommu")?;
require_path("/scheme/iommu/control")?;
let scheme = probe_iommu_scheme()?; let scheme = probe_iommu_scheme()?;
println!( println!(
"IOMMU_SCHEME_QUERY units_detected={} domains={} device_assignments={} units_initialized_before={}", "IOMMU_SCHEME_QUERY units_detected={} domains={} device_assignments={} units_initialized_before={}",
@@ -360,7 +368,7 @@ fn run() -> Result<(), String> {
} }
println!( println!(
"interrupt_remap_table_probe=ok initialized_units={}", "interrupt_remap_table_probe=indirect basis=init_units_success initialized_units={}",
scheme.units_initialized_after scheme.units_initialized_after
); );
@@ -414,7 +422,7 @@ mod tests {
events_drained: 0, events_drained: 0,
}; };
assert_eq!(iommu_vendor_detection(&summary), "amd-vi+intel-vt-d"); assert_eq!(iommu_vendor_detection(&summary), "amd-vi+intel-vt-d-dmar");
} }
#[test] #[test]
local/recipes/system/redbear-hwutils/source/src/bin/redbear-phase1-firmware-check.rs
+17 -4
View File
@@ -360,9 +360,15 @@ fn run() -> Result<(), String> {
match read_firmware_blob(&key) { match read_firmware_blob(&key) {
Ok((size, _content)) => { Ok((size, _content)) => {
if size > 0 { if size > 0 {
report.add(Check::pass("BLOB_READ", &format!("size={} key={}", size, key))); report.add(Check::pass(
"BLOB_READ",
&format!("size={} key={}", size, key),
));
} else { } else {
report.add(Check::fail("BLOB_READ", &format!("blob {key} has zero size"))); report.add(Check::fail(
"BLOB_READ",
&format!("blob {key} has zero size"),
));
} }
} }
Err(msg) => { Err(msg) => {
@@ -373,7 +379,10 @@ fn run() -> Result<(), String> {
report.add(check_blob_fstat(&key)); report.add(check_blob_fstat(&key));
} }
None => { None => {
report.add(Check::skip("BLOB_READ", "no known blob key found in /scheme/firmware/")); report.add(Check::skip(
"BLOB_READ",
"no known blob key found in /scheme/firmware/",
));
report.add(Check::skip("BLOB_MMAP_PATH", "no blob to check")); report.add(Check::skip("BLOB_MMAP_PATH", "no blob to check"));
} }
} }
@@ -437,7 +446,11 @@ mod tests {
fn parse_args_accepts_blob_flag() { fn parse_args_accepts_blob_flag() {
let result = parse_args_with(&["--blob", "somename"]); let result = parse_args_with(&["--blob", "somename"]);
let (_json_mode, blob_key) = result.expect("parse_args should succeed"); let (_json_mode, blob_key) = result.expect("parse_args should succeed");
assert_eq!(blob_key, Some("somename".to_string()), "blob_key should be Some(\"somename\")"); assert_eq!(
blob_key,
Some("somename".to_string()),
"blob_key should be Some(\"somename\")"
);
} }
#[test] #[test]
local/recipes/system/redbear-hwutils/source/src/bin/redbear-phase2-wayland-check.rs
+18 -6
View File
@@ -1,5 +1,6 @@
//! Phase 2 Wayland compositor proof checker. //! Phase 2 Wayland compositor proof checker.
use std::process;
#[cfg(target_os = "redox")] #[cfg(target_os = "redox")]
use std::{ use std::{
env, fs, env, fs,
@@ -9,7 +10,6 @@ use std::{
process::Command, process::Command,
time::Duration, time::Duration,
}; };
use std::process;
const PROGRAM: &str = "redbear-phase2-wayland-check"; const PROGRAM: &str = "redbear-phase2-wayland-check";
const USAGE: &str = "Usage: redbear-phase2-wayland-check [--json]\n\n\ const USAGE: &str = "Usage: redbear-phase2-wayland-check [--json]\n\n\
@@ -122,7 +122,9 @@ impl Report {
} }
fn any_failed(&self) -> bool { fn any_failed(&self) -> bool {
self.checks.iter().any(|check| check.result == CheckResult::Fail) self.checks
.iter()
.any(|check| check.result == CheckResult::Fail)
} }
fn check_passed(&self, name: &str) -> bool { fn check_passed(&self, name: &str) -> bool {
@@ -318,7 +320,8 @@ fn wayland_socket_candidates(runtime_dir: Option<&str>, display: Option<&str>) -
#[cfg(target_os = "redox")] #[cfg(target_os = "redox")]
fn resolve_wayland_endpoint() -> Result<WaylandEndpoint, String> { fn resolve_wayland_endpoint() -> Result<WaylandEndpoint, String> {
let runtime_dir = env_value("XDG_RUNTIME_DIR"); let runtime_dir = env_value("XDG_RUNTIME_DIR");
let display = env_value("WAYLAND_DISPLAY").unwrap_or_else(|| DEFAULT_WAYLAND_DISPLAY.to_string()); let display =
env_value("WAYLAND_DISPLAY").unwrap_or_else(|| DEFAULT_WAYLAND_DISPLAY.to_string());
let candidates = wayland_socket_candidates(runtime_dir.as_deref(), Some(&display)); let candidates = wayland_socket_candidates(runtime_dir.as_deref(), Some(&display));
for candidate in candidates { for candidate in candidates {
@@ -355,7 +358,10 @@ fn run_command(program: &str, args: &[&str], label: &str) -> Result<String, Stri
} else { } else {
String::from("no output") String::from("no output")
}; };
return Err(format!("{label} exited with status {}: {detail}", output.status)); return Err(format!(
"{label} exited with status {}: {detail}",
output.status
));
} }
Ok(String::from_utf8_lossy(&output.stdout).into_owned()) Ok(String::from_utf8_lossy(&output.stdout).into_owned())
@@ -454,7 +460,10 @@ fn check_software_renderer() -> Check {
if Path::new("/usr/bin/glxinfo").exists() { if Path::new("/usr/bin/glxinfo").exists() {
match run_command("glxinfo", &[], "glxinfo") { match run_command("glxinfo", &[], "glxinfo") {
Ok(output) if contains_software_renderer_text(&output) => { Ok(output) if contains_software_renderer_text(&output) => {
return Check::pass("SOFTWARE_RENDERER", "glxinfo reports llvmpipe/software renderer"); return Check::pass(
"SOFTWARE_RENDERER",
"glxinfo reports llvmpipe/software renderer",
);
} }
Ok(_) => details.push(String::from("glxinfo ran but did not report llvmpipe")), Ok(_) => details.push(String::from("glxinfo ran but did not report llvmpipe")),
Err(err) => details.push(err), Err(err) => details.push(err),
@@ -474,7 +483,10 @@ fn check_software_renderer() -> Check {
), ),
), ),
Ok(_) => { Ok(_) => {
details.push(format!("{} has no llvmpipe/swrast-style drivers", dri_dir.display())); details.push(format!(
"{} has no llvmpipe/swrast-style drivers",
dri_dir.display()
));
Check::fail("SOFTWARE_RENDERER", details.join("; ")) Check::fail("SOFTWARE_RENDERER", details.join("; "))
} }
Err(err) => { Err(err) => {
local/recipes/system/redbear-hwutils/source/src/bin/redbear-phase3-kwin-check.rs
+22 -11
View File
@@ -3,6 +3,7 @@
//! and WAYLAND_DISPLAY availability. Does NOT validate real KWin behavior //! and WAYLAND_DISPLAY availability. Does NOT validate real KWin behavior
//! (KWin recipe currently provides cmake stubs pending Qt6Quick/QML). //! (KWin recipe currently provides cmake stubs pending Qt6Quick/QML).
use std::process;
#[cfg(target_os = "redox")] #[cfg(target_os = "redox")]
use std::{ use std::{
env, env,
@@ -12,7 +13,6 @@ use std::{
process::Command, process::Command,
time::Duration, time::Duration,
}; };
use std::process;
const PROGRAM: &str = "redbear-phase3-kwin-check"; const PROGRAM: &str = "redbear-phase3-kwin-check";
const USAGE: &str = "Usage: redbear-phase3-kwin-check [--json]\n\n\ const USAGE: &str = "Usage: redbear-phase3-kwin-check [--json]\n\n\
@@ -114,7 +114,9 @@ impl Report {
} }
fn any_failed(&self) -> bool { fn any_failed(&self) -> bool {
self.checks.iter().any(|check| check.result == CheckResult::Fail) self.checks
.iter()
.any(|check| check.result == CheckResult::Fail)
} }
fn check_passed(&self, name: &str) -> bool { fn check_passed(&self, name: &str) -> bool {
@@ -287,7 +289,10 @@ fn run_command(program: &str, args: &[&str], label: &str) -> Result<String, Stri
} else { } else {
String::from("no output") String::from("no output")
}; };
return Err(format!("{label} exited with status {}: {detail}", output.status)); return Err(format!(
"{label} exited with status {}: {detail}",
output.status
));
} }
Ok(String::from_utf8_lossy(&output.stdout).into_owned()) Ok(String::from_utf8_lossy(&output.stdout).into_owned())
@@ -295,14 +300,18 @@ fn run_command(program: &str, args: &[&str], label: &str) -> Result<String, Stri
#[cfg(target_os = "redox")] #[cfg(target_os = "redox")]
fn resolve_wayland_endpoint() -> Result<WaylandEndpoint, String> { fn resolve_wayland_endpoint() -> Result<WaylandEndpoint, String> {
let display = env_value("WAYLAND_DISPLAY") let display =
.ok_or_else(|| String::from("WAYLAND_DISPLAY is not set"))?; env_value("WAYLAND_DISPLAY").ok_or_else(|| String::from("WAYLAND_DISPLAY is not set"))?;
let runtime_dir = env_value("XDG_RUNTIME_DIR").unwrap_or_else(|| DEFAULT_RUNTIME_DIR.to_string()); let runtime_dir =
env_value("XDG_RUNTIME_DIR").unwrap_or_else(|| DEFAULT_RUNTIME_DIR.to_string());
let path = PathBuf::from(runtime_dir).join(&display); let path = PathBuf::from(runtime_dir).join(&display);
if path.exists() { if path.exists() {
Ok(WaylandEndpoint { path, display }) Ok(WaylandEndpoint { path, display })
} else { } else {
Err(format!("WAYLAND_DISPLAY is set but socket is missing at {}", path.display())) Err(format!(
"WAYLAND_DISPLAY is set but socket is missing at {}",
path.display()
))
} }
} }
@@ -407,10 +416,12 @@ fn run() -> Result<(), String> {
{ {
let mut report = Report::new(json_mode); let mut report = Report::new(json_mode);
report.add(match require_one_path(&["/usr/bin/kwin_wayland", "/usr/bin/redbear-compositor"]) { report.add(
Ok(path) => Check::pass("COMPOSITOR_BINARY", path), match require_one_path(&["/usr/bin/kwin_wayland", "/usr/bin/redbear-compositor"]) {
Err(err) => Check::fail("COMPOSITOR_BINARY", err), Ok(path) => Check::pass("COMPOSITOR_BINARY", path),
}); Err(err) => Check::fail("COMPOSITOR_BINARY", err),
},
);
let (dbus_address_check, dbus_send_check) = check_dbus_session_bus(); let (dbus_address_check, dbus_send_check) = check_dbus_session_bus();
report.add(dbus_address_check); report.add(dbus_address_check);
local/recipes/system/redbear-hwutils/source/src/bin/redbear-phase5-cs-check.rs
+54 -29
View File
@@ -98,7 +98,9 @@ impl Report {
} }
fn any_failed(&self) -> bool { fn any_failed(&self) -> bool {
self.checks.iter().any(|check| check.result == CheckResult::Fail) self.checks
.iter()
.any(|check| check.result == CheckResult::Fail)
} }
fn print(&self) { fn print(&self) {
@@ -284,7 +286,11 @@ fn decode_wire_exact<T: Copy>(bytes: &[u8]) -> Result<T, String> {
let mut out = MaybeUninit::<T>::uninit(); let mut out = MaybeUninit::<T>::uninit();
unsafe { unsafe {
std::ptr::copy_nonoverlapping(bytes.as_ptr(), out.as_mut_ptr().cast::<u8>(), size_of::<T>()); std::ptr::copy_nonoverlapping(
bytes.as_ptr(),
out.as_mut_ptr().cast::<u8>(),
size_of::<T>(),
);
Ok(out.assume_init()) Ok(out.assume_init())
} }
} }
@@ -292,10 +298,7 @@ fn decode_wire_exact<T: Copy>(bytes: &[u8]) -> Result<T, String> {
#[cfg(target_os = "redox")] #[cfg(target_os = "redox")]
fn bytes_of<T>(value: &T) -> &[u8] { fn bytes_of<T>(value: &T) -> &[u8] {
unsafe { unsafe {
std::slice::from_raw_parts( std::slice::from_raw_parts((value as *const T).cast::<u8>(), std::mem::size_of::<T>())
(value as *const T).cast::<u8>(),
std::mem::size_of::<T>(),
)
} }
} }
@@ -390,7 +393,10 @@ fn run_redox(json_mode: bool) -> Result<(), String> {
let mut importer = match open_drm_card(card_path) { let mut importer = match open_drm_card(card_path) {
Ok(file) => file, Ok(file) => file,
Err(err) => { Err(err) => {
report.add(Check::fail("CS_IOCTL_PROTOCOL", &format!("opened exporter but importer failed: {err}"))); report.add(Check::fail(
"CS_IOCTL_PROTOCOL",
&format!("opened exporter but importer failed: {err}"),
));
report.add(Check::skip( report.add(Check::skip(
"GEM_BUFFER_ALLOCATION", "GEM_BUFFER_ALLOCATION",
"blocked: second DRM handle could not be opened", "blocked: second DRM handle could not be opened",
@@ -420,14 +426,21 @@ fn run_redox(json_mode: bool) -> Result<(), String> {
size: 4096, size: 4096,
..DrmGemCreateWire::default() ..DrmGemCreateWire::default()
}; };
match drm_query(&mut exporter, DRM_IOCTL_GEM_CREATE, bytes_of(&create_exporter)) match drm_query(
.and_then(|response| decode_wire_exact::<DrmGemCreateWire>(&response)) &mut exporter,
DRM_IOCTL_GEM_CREATE,
bytes_of(&create_exporter),
)
.and_then(|response| decode_wire_exact::<DrmGemCreateWire>(&response))
{ {
Ok(created) => { Ok(created) => {
exporter_handle = Some(created.handle); exporter_handle = Some(created.handle);
report.add(Check::pass( report.add(Check::pass(
"GEM_BUFFER_ALLOCATION", "GEM_BUFFER_ALLOCATION",
&format!("allocated exporter GEM handle {} (4096 bytes)", created.handle), &format!(
"allocated exporter GEM handle {} (4096 bytes)",
created.handle
),
)); ));
} }
Err(err) => { Err(err) => {
@@ -455,24 +468,32 @@ fn run_redox(json_mode: bool) -> Result<(), String> {
if let Some(handle) = exporter_handle { if let Some(handle) = exporter_handle {
let export = DrmPrimeHandleToFdWire { handle, flags: 0 }; let export = DrmPrimeHandleToFdWire { handle, flags: 0 };
let prime_result = drm_query(&mut exporter, DRM_IOCTL_PRIME_HANDLE_TO_FD, bytes_of(&export)) let prime_result = drm_query(
.and_then(|response| decode_wire_exact::<DrmPrimeHandleToFdResponseWire>(&response)) &mut exporter,
.and_then(|exported| { DRM_IOCTL_PRIME_HANDLE_TO_FD,
if exported.fd < 0 { bytes_of(&export),
return Err(format!( )
"PRIME export returned invalid token {} for GEM {}", .and_then(|response| decode_wire_exact::<DrmPrimeHandleToFdResponseWire>(&response))
exported.fd, handle .and_then(|exported| {
)); if exported.fd < 0 {
} return Err(format!(
"PRIME export returned invalid token {} for GEM {}",
exported.fd, handle
));
}
let import = DrmPrimeFdToHandleWire { let import = DrmPrimeFdToHandleWire {
fd: exported.fd, fd: exported.fd,
pad: 0, pad: 0,
}; };
drm_query(&mut importer, DRM_IOCTL_PRIME_FD_TO_HANDLE, bytes_of(&import)) drm_query(
.and_then(|response| decode_wire_exact::<DrmPrimeFdToHandleResponseWire>(&response)) &mut importer,
.map(|imported| (exported.fd, imported.handle)) DRM_IOCTL_PRIME_FD_TO_HANDLE,
}); bytes_of(&import),
)
.and_then(|response| decode_wire_exact::<DrmPrimeFdToHandleResponseWire>(&response))
.map(|imported| (exported.fd, imported.handle))
});
match prime_result { match prime_result {
Ok((token, imported_handle)) => { Ok((token, imported_handle)) => {
@@ -510,8 +531,12 @@ fn run_redox(json_mode: bool) -> Result<(), String> {
size: 4096, size: 4096,
..DrmGemCreateWire::default() ..DrmGemCreateWire::default()
}; };
match drm_query(&mut importer, DRM_IOCTL_GEM_CREATE, bytes_of(&create_importer)) match drm_query(
.and_then(|response| decode_wire_exact::<DrmGemCreateWire>(&response)) &mut importer,
DRM_IOCTL_GEM_CREATE,
bytes_of(&create_importer),
)
.and_then(|response| decode_wire_exact::<DrmGemCreateWire>(&response))
{ {
Ok(created) => importer_dst_handle = Some(created.handle), Ok(created) => importer_dst_handle = Some(created.handle),
Err(err) => { Err(err) => {
local/recipes/system/redbear-hwutils/source/src/bin/redbear-phase5-gpu-check.rs
+175 -52
View File
@@ -21,48 +21,90 @@ const DRM_IOCTL_REDOX_PRIVATE_CS_SUBMIT: usize = DRM_IOCTL_BASE + 31;
#[cfg(target_os = "redox")] #[cfg(target_os = "redox")]
#[derive(Clone, Copy, Debug, Eq, PartialEq)] #[derive(Clone, Copy, Debug, Eq, PartialEq)]
enum CheckResult { Pass, Fail, Skip } enum CheckResult {
Pass,
Fail,
Skip,
}
#[cfg(target_os = "redox")] #[cfg(target_os = "redox")]
impl CheckResult { impl CheckResult {
fn label(self) -> &'static str { fn label(self) -> &'static str {
match self { Self::Pass => "PASS", Self::Fail => "FAIL", Self::Skip => "SKIP" } match self {
Self::Pass => "PASS",
Self::Fail => "FAIL",
Self::Skip => "SKIP",
}
} }
} }
#[cfg(target_os = "redox")] #[cfg(target_os = "redox")]
struct Check { name: String, result: CheckResult, detail: String } struct Check {
name: String,
result: CheckResult,
detail: String,
}
#[cfg(target_os = "redox")] #[cfg(target_os = "redox")]
impl Check { impl Check {
fn pass(name: &str, detail: &str) -> Self { fn pass(name: &str, detail: &str) -> Self {
Check { name: name.to_string(), result: CheckResult::Pass, detail: detail.to_string() } Check {
name: name.to_string(),
result: CheckResult::Pass,
detail: detail.to_string(),
}
} }
fn fail(name: &str, detail: &str) -> Self { fn fail(name: &str, detail: &str) -> Self {
Check { name: name.to_string(), result: CheckResult::Fail, detail: detail.to_string() } Check {
name: name.to_string(),
result: CheckResult::Fail,
detail: detail.to_string(),
}
} }
fn skip(name: &str, detail: &str) -> Self { fn skip(name: &str, detail: &str) -> Self {
Check { name: name.to_string(), result: CheckResult::Skip, detail: detail.to_string() } Check {
name: name.to_string(),
result: CheckResult::Skip,
detail: detail.to_string(),
}
} }
} }
#[cfg(target_os = "redox")] #[cfg(target_os = "redox")]
struct Report { checks: Vec<Check>, json_mode: bool } struct Report {
checks: Vec<Check>,
json_mode: bool,
}
#[cfg(target_os = "redox")] #[cfg(target_os = "redox")]
impl Report { impl Report {
fn new(json_mode: bool) -> Self { Report { checks: Vec::new(), json_mode } } fn new(json_mode: bool) -> Self {
fn add(&mut self, check: Check) { self.checks.push(check); } Report {
fn any_failed(&self) -> bool { self.checks.iter().any(|c| c.result == CheckResult::Fail) } checks: Vec::new(),
json_mode,
}
}
fn add(&mut self, check: Check) {
self.checks.push(check);
}
fn any_failed(&self) -> bool {
self.checks.iter().any(|c| c.result == CheckResult::Fail)
}
fn print(&self) { fn print(&self) {
if self.json_mode { self.print_json(); } else { self.print_human(); } if self.json_mode {
self.print_json();
} else {
self.print_human();
}
} }
fn print_human(&self) { fn print_human(&self) {
for check in &self.checks { for check in &self.checks {
let icon = match check.result { let icon = match check.result {
CheckResult::Pass => "[PASS]", CheckResult::Fail => "[FAIL]", CheckResult::Skip => "[SKIP]", CheckResult::Pass => "[PASS]",
CheckResult::Fail => "[FAIL]",
CheckResult::Skip => "[SKIP]",
}; };
println!("{icon} {}: {}", check.name, check.detail); println!("{icon} {}: {}", check.name, check.detail);
} }
@@ -70,33 +112,79 @@ impl Report {
fn print_json(&self) { fn print_json(&self) {
#[derive(serde::Serialize)] #[derive(serde::Serialize)]
struct JsonCheck { name: String, result: String, detail: String } struct JsonCheck {
name: String,
result: String,
detail: String,
}
#[derive(serde::Serialize)] #[derive(serde::Serialize)]
struct JsonReport { struct JsonReport {
drm_device: bool, gpu_firmware: bool, mesa_dri: bool, drm_device: bool,
display_modes: bool, cs_ioctl: bool, gem_buffers: bool, gpu_firmware: bool,
hardware_rendering_ready: bool, checks: Vec<JsonCheck>, mesa_dri: bool,
display_modes: bool,
cs_ioctl: bool,
gem_buffers: bool,
hardware_rendering_ready: bool,
checks: Vec<JsonCheck>,
} }
let drm = self.checks.iter().find(|c| c.name == "DRM_DEVICE").map_or(false, |c| c.result == CheckResult::Pass); let drm = self
let firmware = self.checks.iter().find(|c| c.name == "GPU_FIRMWARE").map_or(false, |c| c.result == CheckResult::Pass); .checks
let mesa = self.checks.iter().find(|c| c.name == "MESA_DRI").map_or(false, |c| c.result == CheckResult::Pass); .iter()
let modes = self.checks.iter().find(|c| c.name == "DISPLAY_MODES").map_or(false, |c| c.result == CheckResult::Pass); .find(|c| c.name == "DRM_DEVICE")
let cs_ioctl = self.checks.iter().find(|c| c.name == "CS_IOCTL_PROTOCOL").map_or(false, |c| c.result == CheckResult::Pass); .map_or(false, |c| c.result == CheckResult::Pass);
let gem_buffers = self.checks.iter().find(|c| c.name == "GEM_BUFFER_ALLOCATION").map_or(false, |c| c.result == CheckResult::Pass); let firmware = self
let hardware_ready = self.checks.iter().find(|c| c.name == "HARDWARE_RENDERING_READY").map_or(false, |c| c.result == CheckResult::Pass); .checks
let checks: Vec<JsonCheck> = self.checks.iter().map(|c| JsonCheck { .iter()
name: c.name.clone(), result: c.result.label().to_string(), detail: c.detail.clone(), .find(|c| c.name == "GPU_FIRMWARE")
}).collect(); .map_or(false, |c| c.result == CheckResult::Pass);
if let Err(err) = serde_json::to_writer(std::io::stdout(), &JsonReport { let mesa = self
drm_device: drm, .checks
gpu_firmware: firmware, .iter()
mesa_dri: mesa, .find(|c| c.name == "MESA_DRI")
display_modes: modes, .map_or(false, |c| c.result == CheckResult::Pass);
cs_ioctl, let modes = self
gem_buffers, .checks
hardware_rendering_ready: hardware_ready, .iter()
checks, .find(|c| c.name == "DISPLAY_MODES")
}) { .map_or(false, |c| c.result == CheckResult::Pass);
let cs_ioctl = self
.checks
.iter()
.find(|c| c.name == "CS_IOCTL_PROTOCOL")
.map_or(false, |c| c.result == CheckResult::Pass);
let gem_buffers = self
.checks
.iter()
.find(|c| c.name == "GEM_BUFFER_ALLOCATION")
.map_or(false, |c| c.result == CheckResult::Pass);
let hardware_ready = self
.checks
.iter()
.find(|c| c.name == "HARDWARE_RENDERING_READY")
.map_or(false, |c| c.result == CheckResult::Pass);
let checks: Vec<JsonCheck> = self
.checks
.iter()
.map(|c| JsonCheck {
name: c.name.clone(),
result: c.result.label().to_string(),
detail: c.detail.clone(),
})
.collect();
if let Err(err) = serde_json::to_writer(
std::io::stdout(),
&JsonReport {
drm_device: drm,
gpu_firmware: firmware,
mesa_dri: mesa,
display_modes: modes,
cs_ioctl,
gem_buffers,
hardware_rendering_ready: hardware_ready,
checks,
},
) {
eprintln!("{PROGRAM}: failed to serialize JSON: {err}"); eprintln!("{PROGRAM}: failed to serialize JSON: {err}");
} }
} }
@@ -142,7 +230,10 @@ fn parse_args() -> Result<bool, String> {
for arg in std::env::args().skip(1) { for arg in std::env::args().skip(1) {
match arg.as_str() { match arg.as_str() {
"--json" => json_mode = true, "--json" => json_mode = true,
"-h" | "--help" => { println!("{USAGE}"); return Err(String::new()); } "-h" | "--help" => {
println!("{USAGE}");
return Err(String::new());
}
_ => return Err(format!("unsupported argument: {arg}")), _ => return Err(format!("unsupported argument: {arg}")),
} }
} }
@@ -181,7 +272,10 @@ fn check_gpu_firmware() -> Check {
if found { if found {
Check::pass("GPU_FIRMWARE", "GPU firmware blobs present") Check::pass("GPU_FIRMWARE", "GPU firmware blobs present")
} else { } else {
Check::skip("GPU_FIRMWARE", "no GPU firmware found (may need fetch-firmware.sh)") Check::skip(
"GPU_FIRMWARE",
"no GPU firmware found (may need fetch-firmware.sh)",
)
} }
} }
@@ -190,13 +284,28 @@ fn check_mesa_dri_hardware() -> Check {
let hw_drivers = ["/usr/lib/dri/radeonsi_dri.so", "/usr/lib/dri/iris_dri.so"]; let hw_drivers = ["/usr/lib/dri/radeonsi_dri.so", "/usr/lib/dri/iris_dri.so"];
let mut found = Vec::new(); let mut found = Vec::new();
for d in hw_drivers { for d in hw_drivers {
if std::path::Path::new(d).exists() { found.push(d); } if std::path::Path::new(d).exists() {
found.push(d);
}
} }
if !found.is_empty() { if !found.is_empty() {
let names: Vec<_> = found.iter().map(|s| s.rsplit('/').next().unwrap_or(s)).collect(); let names: Vec<_> = found
Check::pass("MESA_DRI", &format!("{} hardware DRI driver(s): {}", found.len(), names.join(", "))) .iter()
.map(|s| s.rsplit('/').next().unwrap_or(s))
.collect();
Check::pass(
"MESA_DRI",
&format!(
"{} hardware DRI driver(s): {}",
found.len(),
names.join(", ")
),
)
} else { } else {
Check::fail("MESA_DRI", "no hardware DRI drivers found (llvmpipe software only)") Check::fail(
"MESA_DRI",
"no hardware DRI drivers found (llvmpipe software only)",
)
} }
} }
@@ -212,7 +321,10 @@ fn check_display_modes() -> Check {
Check::fail("DISPLAY_MODES", "no connectors found") Check::fail("DISPLAY_MODES", "no connectors found")
} }
} }
Err(_) => Check::skip("DISPLAY_MODES", "cannot enumerate connectors (may need hardware GPU)") Err(_) => Check::skip(
"DISPLAY_MODES",
"cannot enumerate connectors (may need hardware GPU)",
),
} }
} }
@@ -230,7 +342,11 @@ fn decode_wire_exact<T: Copy>(bytes: &[u8]) -> Result<T, String> {
let mut out = MaybeUninit::<T>::uninit(); let mut out = MaybeUninit::<T>::uninit();
unsafe { unsafe {
std::ptr::copy_nonoverlapping(bytes.as_ptr(), out.as_mut_ptr().cast::<u8>(), size_of::<T>()); std::ptr::copy_nonoverlapping(
bytes.as_ptr(),
out.as_mut_ptr().cast::<u8>(),
size_of::<T>(),
);
Ok(out.assume_init()) Ok(out.assume_init())
} }
} }
@@ -238,10 +354,7 @@ fn decode_wire_exact<T: Copy>(bytes: &[u8]) -> Result<T, String> {
#[cfg(target_os = "redox")] #[cfg(target_os = "redox")]
fn bytes_of<T>(value: &T) -> &[u8] { fn bytes_of<T>(value: &T) -> &[u8] {
unsafe { unsafe {
std::slice::from_raw_parts( std::slice::from_raw_parts((value as *const T).cast::<u8>(), std::mem::size_of::<T>())
(value as *const T).cast::<u8>(),
std::mem::size_of::<T>(),
)
} }
} }
@@ -296,7 +409,10 @@ fn check_gem_buffer_allocation() -> Check {
); );
Check::pass( Check::pass(
"GEM_BUFFER_ALLOCATION", "GEM_BUFFER_ALLOCATION",
&format!("allocated GEM handle {} over /scheme/drm/card0", created.handle), &format!(
"allocated GEM handle {} over /scheme/drm/card0",
created.handle
),
) )
} }
Err(err) => Check::fail("GEM_BUFFER_ALLOCATION", &err), Err(err) => Check::fail("GEM_BUFFER_ALLOCATION", &err),
@@ -429,7 +545,10 @@ fn check_hardware_rendering_ready(report: &Report) -> Check {
fn run() -> Result<(), String> { fn run() -> Result<(), String> {
#[cfg(not(target_os = "redox"))] #[cfg(not(target_os = "redox"))]
{ {
if std::env::args().any(|a| a == "-h" || a == "--help") { println!("{USAGE}"); return Err(String::new()); } if std::env::args().any(|a| a == "-h" || a == "--help") {
println!("{USAGE}");
return Err(String::new());
}
println!("{PROGRAM}: GPU check requires Redox runtime"); println!("{PROGRAM}: GPU check requires Redox runtime");
return Ok(()); return Ok(());
} }
@@ -446,14 +565,18 @@ fn run() -> Result<(), String> {
let readiness = check_hardware_rendering_ready(&report); let readiness = check_hardware_rendering_ready(&report);
report.add(readiness); report.add(readiness);
report.print(); report.print();
if report.any_failed() { return Err("one or more Phase 5 checks failed".to_string()); } if report.any_failed() {
return Err("one or more Phase 5 checks failed".to_string());
}
Ok(()) Ok(())
} }
} }
fn main() { fn main() {
if let Err(err) = run() { if let Err(err) = run() {
if err.is_empty() { process::exit(0); } if err.is_empty() {
process::exit(0);
}
eprintln!("{PROGRAM}: {err}"); eprintln!("{PROGRAM}: {err}");
process::exit(1); process::exit(1);
} }
local/scripts/test-irq-runtime.sh
+38 -14
View File
@@ -12,7 +12,7 @@
# Exit codes: # Exit codes:
# 0 — all checks passed # 0 — all checks passed
# 1 — one or more checks failed # 1 — one or more checks failed
# 2 — QEMU boot or login failure # 2 — QEMU boot/login/runtime infrastructure failure
set -euo pipefail set -euo pipefail
@@ -65,7 +65,7 @@ run_guest_checks() {
echo echo
echo "--- IOMMU ---" echo "--- IOMMU ---"
run_check "iommu" "redbear-phase-iommu-check" "/scheme/iommu, AMD-Vi/Intel VT-d detection, event log, and interrupt remap setup" run_check "iommu" "redbear-phase-iommu-check" "AMD-Vi scheme proof or Intel VT-d DMAR detection, event log, and interrupt remap status"
echo echo
echo "--- DMA ---" echo "--- DMA ---"
@@ -114,10 +114,24 @@ run_qemu_checks() {
truncate -s 1g "$extra" truncate -s 1g "$extra"
fi fi
expect <<EXPECT_SCRIPT expect <<EXPECT_SCRIPT
log_user 1 log_user 1
set timeout 300 set timeout 300
proc expect_or_exit2 {pattern message} {
expect {
\$pattern { }
timeout {
puts "ERROR: \$message"
exit 2
}
eof {
puts "ERROR: guest exited before \$message"
exit 2
}
}
}
proc run_check {name cmd description ok_marker fail_marker missing_marker} { proc run_check {name cmd description ok_marker fail_marker missing_marker} {
global failures global failures
@@ -137,11 +151,11 @@ proc run_check {name cmd description ok_marker fail_marker missing_marker} {
} }
timeout { timeout {
puts " FAIL \$name: timed out" puts " FAIL \$name: timed out"
incr failures exit 2
} }
eof { eof {
puts " FAIL \$name: guest exited before check completion" puts " FAIL \$name: guest exited before check completion"
exit 1 exit 2
} }
} }
puts "" puts ""
@@ -149,19 +163,19 @@ proc run_check {name cmd description ok_marker fail_marker missing_marker} {
set failures 0 set failures 0
spawn qemu-system-x86_64 -name {Red Bear OS x86_64} -device qemu-xhci -smp 4 -m 2048 -bios $firmware -chardev stdio,id=debug,signal=off,mux=on -serial chardev:debug -mon chardev=debug -machine q35 -device ich9-intel-hda -device hda-output -device virtio-net,netdev=net0 -netdev user,id=net0 -nographic -vga none -drive file=$image,format=raw,if=none,id=drv0 -device nvme,drive=drv0,serial=NVME_SERIAL -drive file=$extra,format=raw,if=none,id=drv1 -device nvme,drive=drv1,serial=NVME_EXTRA -enable-kvm -cpu host spawn qemu-system-x86_64 -name {Red Bear OS x86_64} -device qemu-xhci -smp 4 -m 2048 -bios $firmware -chardev stdio,id=debug,signal=off,mux=on -serial chardev:debug -mon chardev=debug -machine q35 -device ich9-intel-hda -device hda-output -device virtio-net,netdev=net0 -netdev user,id=net0 -nographic -vga none -drive file=$image,format=raw,if=none,id=drv0 -device nvme,drive=drv0,serial=NVME_SERIAL -drive file=$extra,format=raw,if=none,id=drv1 -device nvme,drive=drv1,serial=NVME_EXTRA -enable-kvm -cpu host
expect "login:" expect_or_exit2 "login:" "login prompt"
send "root\r" send "root\r"
expect "assword:" expect_or_exit2 "assword:" "password prompt"
send "password\r" send "password\r"
expect "Type 'help' for available commands." expect_or_exit2 "Type 'help' for available commands." "interactive shell prompt"
send "echo __READY__\r" send "echo __READY__\r"
expect "__READY__" expect_or_exit2 "__READY__" "guest readiness marker"
puts "=== Red Bear OS IRQ Runtime Validation ===" puts "=== Red Bear OS IRQ Runtime Validation ==="
puts "" puts ""
run_check "PCI IRQ" "redbear-phase-pci-irq-check" "/scheme/irq, MSI/MSI-X capability, affinity, and spurious IRQ routing quality" "__PCI_IRQ_OK__" "__PCI_IRQ_FAIL__" "__PCI_IRQ_MISSING__" run_check "PCI IRQ" "redbear-phase-pci-irq-check" "/scheme/irq, MSI/MSI-X capability, affinity, and spurious IRQ routing quality" "__PCI_IRQ_OK__" "__PCI_IRQ_FAIL__" "__PCI_IRQ_MISSING__"
run_check "IOMMU" "redbear-phase-iommu-check" "/scheme/iommu, AMD-Vi/Intel VT-d detection, event log, and interrupt remap setup" "__IOMMU_OK__" "__IOMMU_FAIL__" "__IOMMU_MISSING__" run_check "IOMMU" "redbear-phase-iommu-check" "AMD-Vi scheme proof or Intel VT-d DMAR detection, event log, and interrupt remap status" "__IOMMU_OK__" "__IOMMU_FAIL__" "__IOMMU_MISSING__"
run_check "DMA" "redbear-phase-dma-check" "DMA buffer allocation and write/readback" "__DMA_OK__" "__DMA_FAIL__" "__DMA_MISSING__" run_check "DMA" "redbear-phase-dma-check" "DMA buffer allocation and write/readback" "__DMA_OK__" "__DMA_FAIL__" "__DMA_MISSING__"
run_check "PS/2 + serio" "redbear-phase-ps2-check" "/scheme/input/ps2 or serio runtime path" "__PS2_OK__" "__PS2_FAIL__" "__PS2_MISSING__" run_check "PS/2 + serio" "redbear-phase-ps2-check" "/scheme/input/ps2 or serio runtime path" "__PS2_OK__" "__PS2_FAIL__" "__PS2_MISSING__"
run_check "monotonic timer" "redbear-phase-timer-check" "/scheme/time/CLOCK_MONOTONIC monotonic progress" "__TIMER_OK__" "__TIMER_FAIL__" "__TIMER_MISSING__" run_check "monotonic timer" "redbear-phase-timer-check" "/scheme/time/CLOCK_MONOTONIC monotonic progress" "__TIMER_OK__" "__TIMER_FAIL__" "__TIMER_MISSING__"
@@ -175,13 +189,23 @@ if {\$failures == 0} {
} }
send "echo __IRQ_RUNTIME_DONE__\$failures__\r" send "echo __IRQ_RUNTIME_DONE__\$failures__\r"
expect "__IRQ_RUNTIME_DONE__\$failures__" expect_or_exit2 "__IRQ_RUNTIME_DONE__\$failures__" "final IRQ runtime summary marker"
set final_status 0
if {\$failures != 0} { if {\$failures != 0} {
exit 1 set final_status 1
} }
send "shutdown\r" send "shutdown\r"
expect eof expect {
eof { }
timeout {
if {\$final_status == 0} {
set final_status 2
}
}
}
exit \$final_status
EXPECT_SCRIPT EXPECT_SCRIPT
} }
@@ -200,7 +224,7 @@ QEMU mode boots an image and runs checks automatically.
Required binaries (must be in PATH inside the guest): Required binaries (must be in PATH inside the guest):
redbear-phase-pci-irq-check — PCI IRQ runtime reports, MSI/MSI-X capability, affinity, spurious IRQs redbear-phase-pci-irq-check — PCI IRQ runtime reports, MSI/MSI-X capability, affinity, spurious IRQs
redbear-phase-iommu-check — IOMMU runtime self-test + scheme control probes redbear-phase-iommu-check — IOMMU runtime self-test + AMD-Vi scheme or Intel VT-d DMAR probes
redbear-phase-dma-check — DMA buffer allocation/runtime proof redbear-phase-dma-check — DMA buffer allocation/runtime proof
redbear-phase-ps2-check — PS/2 + serio runtime proof redbear-phase-ps2-check — PS/2 + serio runtime proof
redbear-phase-timer-check — monotonic timer runtime proof redbear-phase-timer-check — monotonic timer runtime proof