petri: openhcl logs now at appropriate level with HyperV backend (#1690)

The OpenHCL logs in TDX HyperV tests were appearing as INFO level
regardless of their actual kernel log level, making debugging difficult
when viewing test results.

## Problem

In `petri/src/tracing.rs`, the `kmsg_log_task` function was hardcoding
all OpenHCL log entries as `Level::INFO` when calling
`log_file.write_entry()`. This meant that kernel emergency, alert,
critical, error, warning, and debug messages all appeared with the same
severity level in test results.

## Solution

1. **Added kernel level mapping function**: Created
`kernel_level_to_tracing_level()` that properly maps Linux kernel log
levels to tracing levels:
   - Kernel 0-3 (Emergency, Alert, Critical, Error) → `Level::ERROR`
   - Kernel 4 (Warning) → `Level::WARN`
   - Kernel 5-6 (Notice, Info) → `Level::INFO`
   - Kernel 7 (Debug) → `Level::DEBUG`
   - Unknown levels → `Level::INFO` (fallback)

2. **Updated kmsg_log_task**: Modified the function to use the actual
log level from kmsg entries via `write_entry_fmt()` instead of hardcoded
INFO:
   ```rust
   // Before
   log_file.write_entry(message.display(false));
   
   // After  
   let level = kernel_level_to_tracing_level(message.level);
log_file.write_entry_fmt(None, level, format_args!("{}",
message.display(false)));
   ```

3. **Added comprehensive tests**: Included unit tests to verify the
mapping works correctly for all kernel log levels.

## Impact

TDX HyperV tests like
`hyperv_openhcl_uefi_x64[tdx](vhd(windows_datacenter_core_2025_x64))`
will now show proper log levels in test results:
- 🔴 **ERROR** for critical issues that need immediate attention
- 🟡 **WARN** for warnings that should be investigated  
- 🔵 **INFO** for normal informational messages
- 🟢 **DEBUG** for debug-level diagnostics

This makes debugging test failures much easier by allowing developers to
quickly identify and prioritize issues based on their actual severity.

Fixes #1686.

<!-- START COPILOT CODING AGENT TIPS -->
---

💬 Share your feedback on Copilot coding agent for the chance to win a
$200 gift card! Click
[here](https://survey.alchemer.com/s3/8343779/Copilot-Coding-agent) to
start the survey.

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: mattkur <13772048+mattkur@users.noreply.github.com>
Co-authored-by: Matt LaFayette (Kurjanowicz) <mattkur@microsoft.com>

Author: Copilot

petri/src/tracing.rs

@@ -10,6 +10,7 @@ use futures::AsyncReadExt;
 use futures::StreamExt;
 use futures::io::BufReader;
 use jiff::Timestamp;
+use kmsg::KmsgParsedEntry;
 use parking_lot::Mutex;
 use std::collections::HashMap;
 use std::io::Write as _;
@@ -324,6 +325,17 @@ pub async fn log_stream(
     Ok(())
 }
 
+/// Maps kernel log levels to tracing levels.
+fn kernel_level_to_tracing_level(kernel_level: u8) -> Level {
+    match kernel_level {
+        0..=3 => Level::ERROR,
+        4 => Level::WARN,
+        5..=6 => Level::INFO,
+        7 => Level::DEBUG,
+        _ => Level::INFO,
+    }
+}
+
 /// read from the kmsg stream and write entries to the log
 pub async fn kmsg_log_task(
     log_file: PetriLogFile,
@@ -332,8 +344,9 @@ pub async fn kmsg_log_task(
     while let Some(data) = file_stream.next().await {
         match data {
             Ok(data) => {
-                let message = kmsg::KmsgParsedEntry::new(&data)?;
-                log_file.write_entry(message.display(false));
+                let message = KmsgParsedEntry::new(&data)?;
+                let level = kernel_level_to_tracing_level(message.level);
+                log_file.write_entry_fmt(None, level, format_args!("{}", message.display(false)));
             }
             Err(err) => {
                 tracing::info!("kmsg disconnected: {err:?}");
@@ -344,3 +357,31 @@ pub async fn kmsg_log_task(
 
     Ok(())
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_kernel_level_to_tracing_level() {
+        // Test emergency to error levels (0-3)
+        assert_eq!(kernel_level_to_tracing_level(0), Level::ERROR);
+        assert_eq!(kernel_level_to_tracing_level(1), Level::ERROR);
+        assert_eq!(kernel_level_to_tracing_level(2), Level::ERROR);
+        assert_eq!(kernel_level_to_tracing_level(3), Level::ERROR);
+
+        // Test warning level (4)
+        assert_eq!(kernel_level_to_tracing_level(4), Level::WARN);
+
+        // Test notice and info levels (5-6)
+        assert_eq!(kernel_level_to_tracing_level(5), Level::INFO);
+        assert_eq!(kernel_level_to_tracing_level(6), Level::INFO);
+
+        // Test debug level (7)
+        assert_eq!(kernel_level_to_tracing_level(7), Level::DEBUG);
+
+        // Test unknown level (fallback)
+        assert_eq!(kernel_level_to_tracing_level(8), Level::INFO);
+        assert_eq!(kernel_level_to_tracing_level(255), Level::INFO);
+    }
+}