spinner: add a moving spinner

The `spinner` command displays a moving spinner until a byte is
received over the UART.  This is useful for determining whether
the machine is frozen or not.

Also fix a panic in UFS.

Signed-off-by: Dan Cross <cross@oxidecomputer.com>

Author: dancrossnyc

Cargo.toml

@@ -5,7 +5,9 @@ version = "0.1.0"
 edition = "2024"
 license = "MPL-2.0"
 
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+[features]
+spin_prompt = []
+pulse_prompt = []
 
 [dependencies]
 bit_field = "0.10"
@@ -18,10 +20,16 @@ goblin = { version = "0.9", default-features = false, features = [
     "elf32",
     "alloc",
 ] }
-iced-x86 = { version = "1.21.0", features = ["decoder", "gas", "no_std"], default-features = false }
+iced-x86 = { version = "1.21.0", features = [
+    "decoder",
+    "gas",
+    "no_std",
+], default-features = false }
 miniz_oxide = "0.8"
 seq-macro = "0.3"
-sha2 = { version = "0.10.8", default-features = false, features = ["force-soft"] }
+sha2 = { version = "0.10.8", default-features = false, features = [
+    "force-soft",
+] }
 spin = { version = "0.10.0", default-features = false, features = [
     "barrier",
     "mutex",

README.md

@@ -208,10 +208,14 @@ Supported commands include:
   extended configuration space for the given bus/device/function
 * `ecamwr <b/d/f> <offset> <value>` writes a 32-bit word to PCIe
   extended configuration space for the given bus/device/function
-* `getbits <start>,<end> <value>` returns  the given bit range
+* `getbits <start>,<end> <value>` returns the given bit range
   from `<value>`
 * `setbits <start>,<end> <new bits> <value>` sets the given bit
   range in `<value>` to `<new bits>`
+* `spinner` displays a moving "spinner" on the terminal until a
+  byte is received on the UART.  The `pulser` and `throbber`
+  commands do essentially the same thing, with a different
+  character pattern.
 
 ## Building bldb
 

src/bldb.rs

@@ -38,6 +38,7 @@
 
 extern crate alloc;
 
+use crate::cons;
 use crate::gpio;
 use crate::idt;
 use crate::iomux;
@@ -55,6 +56,11 @@ use core::sync::atomic::{AtomicBool, Ordering};
 #[cfg(not(test))]
 core::arch::global_asm!(include_str!("start.S"), options(att_syntax));
 
+#[cfg(all(feature = "pulse_prompt", feature = "spin_prompt"))]
+compile_error!(
+    "The `pulse_prompt` and `spin_prompt` features are mutually exclusive"
+);
+
 /// The loader configuration, consumed by the rest of PHBL.
 pub(crate) struct Config {
     pub(crate) cons: Uart,
@@ -63,6 +69,7 @@ pub(crate) struct Config {
     pub(crate) loader_region: Range<mem::V4KA>,
     pub(crate) page_table: mmu::LoaderPageTable,
     pub(crate) ramdisk: Option<ufs::FileSystem<'static>>,
+    pub(crate) prompt: cons::Prompt,
 }
 
 impl Config {
@@ -82,11 +89,8 @@ impl fmt::Debug for Config {
         let vend = self.loader_region.end.addr();
         writeln!(f, "    loader: {:#x?}", vstart..vend)?;
         writeln!(f, "    pageroot: P4KA({:#x}),", self.page_table.phys_addr())?;
-        writeln!(
-            f,
-            "    ramdisk: {:?}",
-            self.ramdisk.as_ref().map(|_| "mounted")
-        )?;
+        writeln!(f, "    ramdisk: {:?}", self.ramdisk.as_ref())?;
+        writeln!(f, "    prompt: {:?}", self.prompt)?;
         write!(f, "}}")
     }
 }
@@ -143,6 +147,12 @@ pub(crate) unsafe extern "C" fn init(bist: u32) -> &'static mut Config {
             &mmio_region,
         ),
         ramdisk: None,
+        #[cfg(not(any(feature = "pulse_prompt", feature = "spin_prompt")))]
+        prompt: cons::Prompt::Tenex,
+        #[cfg(feature = "pulse_prompt")]
+        prompt: cons::Prompt::Pulser,
+        #[cfg(feature = "spin_prompt")]
+        prompt: cons::Prompt::Spinner,
     });
     if false {
         say_hi_sp(&mut config, 4);

src/clock.rs

@@ -0,0 +1,28 @@
+// Copyright 2021  The Hypatia Authors
+// All rights reserved
+//
+// Use of this source code is governed by an MIT-style
+// license that can be found in the LICENSE file or at
+// https://opensource.org/licenses/MIT.
+
+use crate::cpuid;
+
+pub const NANOS_PER_SEC: u128 = 1_000_000_000;
+
+/// Returns the clock frequency of the current CPU in Hertz.
+pub fn frequency() -> u128 {
+    const DEFAULT_HZ: u128 = 2_000_000_000;
+    if let Some(tsc_info) = cpuid::tscinfo() {
+        if tsc_info.nominal_frequency() != 0 {
+            return tsc_info
+                .tsc_frequency()
+                .map(|freq| freq.into())
+                .unwrap_or(DEFAULT_HZ);
+        }
+    }
+    DEFAULT_HZ
+}
+
+pub fn rdtsc() -> u64 {
+    unsafe { core::arch::x86_64::_rdtsc() }
+}

src/cons.rs

@@ -7,26 +7,50 @@
 
 use crate::result::{Error, Result};
 use crate::uart::Uart;
+use core::time::Duration;
 
-pub fn readline<'a>(
-    prompt: &str,
+#[derive(Debug, Eq, PartialEq)]
+pub enum Prompt {
+    Tenex,
+    Spinner,
+    Pulser,
+}
+
+const BS: u8 = 8;
+const TAB: u8 = 9;
+const NL: u8 = 10;
+const CR: u8 = 13;
+const CTLU: u8 = 21;
+const CTLW: u8 = 23;
+const ESC: u8 = 27;
+const DEL: u8 = 127;
+
+pub fn readline<'a, F>(
+    prompt: F,
     uart: &mut Uart,
     line: &'a mut [u8],
-) -> Result<&'a str> {
-    const BS: u8 = 8;
-    const TAB: u8 = 9;
-    const NL: u8 = 10;
-    const CR: u8 = 13;
-    const CTLU: u8 = 21;
-    const CTLW: u8 = 23;
-    const DEL: u8 = 127;
+) -> Result<&'a str>
+where
+    F: FnOnce(&mut Uart) -> usize,
+{
+    readline_timeout(prompt, uart, Duration::ZERO, line)
+}
 
+pub fn readline_timeout<'a, F>(
+    prompt: F,
+    uart: &mut Uart,
+    timeout: Duration,
+    line: &'a mut [u8],
+) -> Result<&'a str>
+where
+    F: FnOnce(&mut Uart) -> usize,
+{
     fn find_prev_col(line: &[u8], start: usize) -> usize {
         line.iter()
             .fold(start, |v, &b| v + if b == TAB { 8 - (v & 0b111) } else { 1 })
     }
 
-    fn backspace(
+    fn backup(
         uart: &mut Uart,
         line: &[u8],
         start: usize,
@@ -43,11 +67,7 @@ pub fn readline<'a>(
             _ => (col - 1, true),
         };
         for _ in pcol..col {
-            uart.putb(BS);
-            if overstrike {
-                uart.putb(b' ');
-                uart.putb(BS);
-            }
+            backspace(uart, overstrike);
         }
         (pcol, line.len() - 1)
     }
@@ -60,43 +80,47 @@ pub fn readline<'a>(
         return Ok("");
     }
 
-    let start = prompt.len();
-    uart.puts(prompt);
+    let start = prompt(uart);
 
     let mut k = 0;
     let mut col = start;
     while k < line.len() {
-        match uart.getb() {
-            CR | NL => {
+        match uart.getb_timeout(timeout) {
+            None => {
+                if k == 0 {
+                    return Err(Error::Timeout);
+                }
+            }
+            Some(CR | NL) => {
                 uart.putb(CR);
                 uart.putb(NL);
                 break;
             }
-            BS | DEL => {
+            Some(BS | DEL) => {
                 if k > 0 {
-                    (col, k) = backspace(uart, &line[..k], start, col);
+                    (col, k) = backup(uart, &line[..k], start, col);
                 }
             }
-            CTLU => {
+            Some(CTLU) => {
                 while k > 0 {
-                    (col, k) = backspace(uart, &line[..k], start, col);
+                    (col, k) = backup(uart, &line[..k], start, col);
                 }
             }
-            CTLW => {
+            Some(CTLW) => {
                 while k > 0 && line[k - 1].is_ascii_whitespace() {
-                    (col, k) = backspace(uart, &line[..k], start, col);
+                    (col, k) = backup(uart, &line[..k], start, col);
                 }
                 if k > 0 {
                     let cond = isword(line[k - 1]);
                     while k > 0
                         && !line[k - 1].is_ascii_whitespace()
                         && isword(line[k - 1]) == cond
                     {
-                        (col, k) = backspace(uart, &line[..k], start, col);
+                        (col, k) = backup(uart, &line[..k], start, col);
                     }
                 }
             }
-            TAB => {
+            Some(TAB) => {
                 line[k] = TAB;
                 k += 1;
                 let ncol = (8 + col) & !0b111;
@@ -105,7 +129,7 @@ pub fn readline<'a>(
                 }
                 col = ncol;
             }
-            b => {
+            Some(b) => {
                 line[k] = b;
                 k += 1;
                 uart.putb(b);
@@ -117,10 +141,45 @@ pub fn readline<'a>(
     core::str::from_utf8(&line[..k]).map_err(|_| Error::Utf8)
 }
 
+pub fn backspace(term: &mut Uart, overstrike: bool) {
+    term.putb(BS);
+    if overstrike {
+        term.putb(b' ');
+        term.putb(BS);
+    }
+}
+
 pub fn clear(term: &mut Uart) {
-    const ESC: u8 = 27;
     term.putb(ESC);
     term.puts("[H");
     term.putb(ESC);
     term.puts("[2J");
 }
+
+pub fn cycle(
+    term: &mut Uart,
+    prefix: &[u8],
+    cycle: &[u8],
+    suffix: &[u8],
+    wait: Duration,
+) {
+    fn erase(term: &mut Uart, bs: &[u8]) {
+        for &b in bs.iter().rev() {
+            backspace(term, b != b' ');
+        }
+    }
+    let _ = term.putbs(prefix);
+    for &b in cycle.iter().cycle() {
+        term.putb(b);
+        let _ = term.putbs(suffix);
+        match term.wait_data_ready(wait) {
+            Ok(true) | Err(_) => break,
+            _ => {}
+        }
+        erase(term, suffix);
+        erase(term, &[b]);
+    }
+    erase(term, suffix);
+    erase(term, &[0]);
+    erase(term, prefix);
+}

src/cpuid.rs

@@ -2,17 +2,24 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
-pub(crate) fn cpuid(leaf: u32, subleaf: u32) -> x86::cpuid::CpuIdResult {
-    x86::cpuid::native_cpuid::cpuid_count(leaf, subleaf)
+use x86::cpuid;
+
+pub(crate) fn cpuid(leaf: u32, subleaf: u32) -> cpuid::CpuIdResult {
+    cpuid::native_cpuid::cpuid_count(leaf, subleaf)
 }
 
 /// Returns information about the current processor and its
 /// package.
 pub(crate) fn cpuinfo() -> Option<(u8, u8, u8, Option<u32>)> {
-    let cpuid = x86::cpuid::CpuId::new();
+    let cpuid = cpuid::CpuId::new();
     let features = cpuid.get_feature_info()?;
     let family = features.family_id();
     let ext = cpuid.get_extended_processor_and_feature_identifiers()?;
     let pkg_type = (family > 0x10).then_some(ext.pkg_type());
     Some((family, features.model_id(), features.stepping_id(), pkg_type))
 }
+
+pub(crate) fn tscinfo() -> Option<cpuid::TscInfo> {
+    let cpuid = cpuid::CpuId::new();
+    cpuid.get_tsc_info()
+}

src/main.rs

@@ -16,6 +16,7 @@ extern crate alloc;
 
 mod allocator;
 mod bldb;
+mod clock;
 mod cons;
 mod cpuid;
 mod gpio;

src/ramdisk.rs

@@ -12,7 +12,7 @@ use crate::ufs;
 pub fn mount(
     ramdisk: &'static [u8],
 ) -> Result<Option<ufs::FileSystem<'static>>> {
-    let fs = ufs::FileSystem::new(ramdisk);
+    let fs = ufs::FileSystem::new(ramdisk)?;
     if let Ok(ufs::State::Clean) = fs.state() {
         let flags = fs.flags();
         println!("ramdisk mounted successfully (Clean, {flags:?})");

src/repl/mod.rs

@@ -31,6 +31,7 @@ mod memory;
 mod mount;
 mod msr;
 mod pio;
+mod prompt;
 mod reader;
 mod rx;
 mod rz;
@@ -244,13 +245,16 @@ fn evalcmd(
         "map" => vm::map(config, env),
         "mapping" => vm::mapping(config, env),
         "mappings" => vm::mappings(config, env),
+        "megapulser" => prompt::mega_pulser(config, env),
         "mount" => mount::run(config, env),
         "outb" => pio::outb(config, env),
         "outl" => pio::outl(config, env),
         "outw" => pio::outw(config, env),
         "peek" => memory::read(config, env),
         "poke" => memory::write(config, env),
         "pop" => Ok(pop2(env)),
+        "prompt" => prompt::prompt(config, env),
+        "pulser" | "throbber" => prompt::pulser(config, env),
         "push" => Ok(Value::Nil),
         "rdmsr" => msr::read(config, env),
         "rdsmn" => smn::read(config, env),
@@ -259,6 +263,7 @@ fn evalcmd(
         "setbits" => bits::set(config, env),
         "sha256" => sha::run(config, env),
         "sha256mem" => sha::mem(config, env),
+        "spinner" => prompt::spinner(config, env),
         "unmap" => vm::unmap(config, env),
         "wrmsr" => msr::write(config, env),
         "wrsmn" => smn::write(config, env),