feat(coreutils): add true, false, head, tail, wc utilities

Implements 5 new POSIX-compatible coreutils for the ext2 filesystem:

- true: always exits with status 0 (16 bytes)
- false: always exits with status 1 (17 bytes)
- head: output first N lines of files (-n option, default 10)
- tail: output last N lines of files (-n option, default 10)
- wc: word, line, and byte count (-l/-w/-c options)

All utilities:
- Support reading from stdin when no files specified
- Support multiple file arguments with headers
- Use libbreenix syscall wrappers
- Follow POSIX conventions

Updated build.sh and Cargo.toml to include new binaries.
Updated create_ext2_disk.sh to install in ext2 /bin/.
Regenerated testdata/ext2.img with all 13 coreutils.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: ryanbreen

scripts/create_ext2_disk.sh

@@ -3,7 +3,7 @@
 #
 # This script creates a 4MB ext2 filesystem image with:
 #   - Test files for filesystem testing
-#   - Coreutils binaries in /bin/ (cat, ls, echo, mkdir, rmdir, rm, cp, mv)
+#   - Coreutils binaries in /bin/ (cat, ls, echo, mkdir, rmdir, rm, cp, mv, true, false, head, tail, wc)
 #   - hello_world binary for exec testing
 #
 # Requires Docker on macOS (or mke2fs on Linux).
@@ -25,7 +25,7 @@ TESTDATA_FILE="$PROJECT_ROOT/testdata/ext2.img"
 SIZE_MB=4
 
 # Coreutils to install in /bin
-COREUTILS="cat ls echo mkdir rmdir rm cp mv"
+COREUTILS="cat ls echo mkdir rmdir rm cp mv true false head tail wc"
 
 echo "Creating ext2 disk image..."
 echo "  Output: $OUTPUT_FILE"
@@ -76,7 +76,7 @@ if [[ "$(uname)" == "Darwin" ]]; then
 
             # Copy coreutils binaries
             echo "Installing coreutils in /bin..."
-            for bin in cat ls echo mkdir rmdir rm cp mv; do
+            for bin in cat ls echo mkdir rmdir rm cp mv true false head tail wc; do
                 if [ -f /binaries/${bin}.elf ]; then
                     cp /binaries/${bin}.elf /mnt/ext2/bin/${bin}
                     chmod 755 /mnt/ext2/bin/${bin}
@@ -148,7 +148,7 @@ else
 
     # Copy coreutils binaries
     echo "Installing coreutils in /bin..."
-    for bin in cat ls echo mkdir rmdir rm cp mv; do
+    for bin in cat ls echo mkdir rmdir rm cp mv true false head tail wc; do
         if [ -f "$USERSPACE_DIR/${bin}.elf" ]; then
             cp "$USERSPACE_DIR/${bin}.elf" "$MOUNT_DIR/bin/${bin}"
             chmod 755 "$MOUNT_DIR/bin/${bin}"
@@ -196,7 +196,9 @@ if [[ -f "$OUTPUT_FILE" ]]; then
     echo "  Size: $SIZE"
     echo ""
     echo "Contents:"
-    echo "  /bin/cat, ls, echo, mkdir, rmdir, rm, cp, mv - coreutils"
+    echo "  /bin/cat, ls, echo, mkdir, rmdir, rm, cp, mv - file coreutils"
+    echo "  /bin/true, false - exit status coreutils"
+    echo "  /bin/head, tail, wc - text processing coreutils"
     echo "  /bin/hello_world - exec test binary (exit code 42)"
     echo "  /hello.txt - test file"
     echo "  /test/nested.txt - nested test file"

testdata/ext2.img

@@ -275,6 +275,26 @@ path = "cp.rs"
 name = "mv"
 path = "mv.rs"
 
+[[bin]]
+name = "true"
+path = "true.rs"
+
+[[bin]]
+name = "false"
+path = "false.rs"
+
+[[bin]]
+name = "head"
+path = "head.rs"
+
+[[bin]]
+name = "tail"
+path = "tail.rs"
+
+[[bin]]
+name = "wc"
+path = "wc.rs"
+
 [[bin]]
 name = "fork_memory_test"
 path = "fork_memory_test.rs"

userspace/tests/Cargo.toml

@@ -114,6 +114,11 @@ BINARIES=(
     "rm"
     "cp"
     "mv"
+    "true"
+    "false"
+    "head"
+    "tail"
+    "wc"
 )
 
 echo "Building ${#BINARIES[@]} userspace binaries with libbreenix..."

userspace/tests/build.sh

@@ -0,0 +1,22 @@
+//! false - return unsuccessful exit status
+//!
+//! Usage: false
+//!
+//! Exit with a status code indicating failure (1).
+//! This command does nothing and always fails.
+
+#![no_std]
+#![no_main]
+
+use core::panic::PanicInfo;
+use libbreenix::process::exit;
+
+#[no_mangle]
+pub extern "C" fn _start() -> ! {
+    exit(1);
+}
+
+#[panic_handler]
+fn panic(_info: &PanicInfo) -> ! {
+    exit(1);
+}

userspace/tests/false.rs

@@ -0,0 +1,210 @@
+//! head - output the first part of files
+//!
+//! Usage: head [-n NUM] [FILE...]
+//!
+//! Print the first 10 lines of each FILE to standard output.
+//! With more than one FILE, precede each with a header giving the file name.
+//!
+//! Options:
+//!   -n NUM   print the first NUM lines instead of the first 10
+
+#![no_std]
+#![no_main]
+
+use core::arch::naked_asm;
+use core::panic::PanicInfo;
+use libbreenix::argv;
+use libbreenix::errno::Errno;
+use libbreenix::fs::{close, open, read, O_RDONLY};
+use libbreenix::io::{stdout, stderr};
+use libbreenix::process::exit;
+
+const DEFAULT_LINES: usize = 10;
+const BUF_SIZE: usize = 4096;
+
+/// Parse a number from bytes
+fn parse_num(s: &[u8]) -> Option<usize> {
+    let mut n: usize = 0;
+    for &c in s {
+        if c < b'0' || c > b'9' {
+            return None;
+        }
+        n = n.checked_mul(10)?.checked_add((c - b'0') as usize)?;
+    }
+    Some(n)
+}
+
+/// Read and output up to `max_lines` lines from stdin
+fn head_stdin(max_lines: usize) -> Result<(), Errno> {
+    let mut buf = [0u8; BUF_SIZE];
+    let mut lines_output = 0;
+
+    'outer: loop {
+        let n = libbreenix::io::read(0, &mut buf);
+        if n < 0 {
+            return Err(Errno::from_raw(-n));
+        }
+        if n == 0 {
+            break; // EOF
+        }
+
+        // Output bytes, counting newlines
+        for i in 0..n as usize {
+            let _ = stdout().write(&buf[i..i + 1]);
+            if buf[i] == b'\n' {
+                lines_output += 1;
+                if lines_output >= max_lines {
+                    break 'outer;
+                }
+            }
+        }
+    }
+    Ok(())
+}
+
+/// Read and output up to `max_lines` lines from a file
+fn head_file(path: &[u8], max_lines: usize) -> Result<(), Errno> {
+    let mut path_buf = [0u8; 256];
+    let len = path.len().min(255);
+    path_buf[..len].copy_from_slice(&path[..len]);
+    path_buf[len] = 0;
+
+    let path_str = match core::str::from_utf8(&path_buf[..len + 1]) {
+        Ok(s) => s,
+        Err(_) => return Err(Errno::EINVAL),
+    };
+
+    let fd = open(path_str, O_RDONLY)?;
+
+    let mut buf = [0u8; BUF_SIZE];
+    let mut lines_output = 0;
+
+    'outer: loop {
+        let n = read(fd, &mut buf)?;
+        if n == 0 {
+            break; // EOF
+        }
+
+        for i in 0..n {
+            let _ = stdout().write(&buf[i..i + 1]);
+            if buf[i] == b'\n' {
+                lines_output += 1;
+                if lines_output >= max_lines {
+                    break 'outer;
+                }
+            }
+        }
+    }
+
+    let _ = close(fd);
+    Ok(())
+}
+
+fn print_header(path: &[u8]) {
+    let _ = stdout().write_str("==> ");
+    let _ = stdout().write(path);
+    let _ = stdout().write_str(" <==\n");
+}
+
+fn print_error_bytes(path: &[u8], e: Errno) {
+    let _ = stderr().write_str("head: ");
+    let _ = stderr().write(path);
+    let _ = stderr().write_str(": ");
+    let _ = stderr().write_str(match e {
+        Errno::ENOENT => "No such file or directory",
+        Errno::EACCES => "Permission denied",
+        Errno::EISDIR => "Is a directory",
+        Errno::EINVAL => "Invalid argument",
+        _ => "Error",
+    });
+    let _ = stderr().write(b"\n");
+}
+
+#[unsafe(naked)]
+#[no_mangle]
+pub extern "C" fn _start() -> ! {
+    naked_asm!(
+        "mov rdi, rsp",
+        "and rsp, -16",
+        "call {main}",
+        "ud2",
+        main = sym rust_main,
+    )
+}
+
+extern "C" fn rust_main(stack_ptr: *const u64) -> ! {
+    let args = unsafe { argv::get_args_from_stack(stack_ptr) };
+
+    let mut max_lines = DEFAULT_LINES;
+    let mut file_start_idx = 1usize;
+
+    // Parse -n option
+    if args.argc >= 2 {
+        if let Some(arg) = args.argv(1) {
+            if arg.len() >= 2 && arg[0] == b'-' && arg[1] == b'n' {
+                // -nNUM or -n NUM
+                if arg.len() > 2 {
+                    // -nNUM format
+                    if let Some(n) = parse_num(&arg[2..]) {
+                        max_lines = n;
+                        file_start_idx = 2;
+                    } else {
+                        let _ = stderr().write_str("head: invalid number of lines\n");
+                        exit(1);
+                    }
+                } else if args.argc >= 3 {
+                    // -n NUM format
+                    if let Some(num_arg) = args.argv(2) {
+                        if let Some(n) = parse_num(num_arg) {
+                            max_lines = n;
+                            file_start_idx = 3;
+                        } else {
+                            let _ = stderr().write_str("head: invalid number of lines\n");
+                            exit(1);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    // If no files, read from stdin
+    if file_start_idx >= args.argc {
+        if let Err(_e) = head_stdin(max_lines) {
+            let _ = stderr().write_str("head: error reading stdin\n");
+            exit(1);
+        }
+        exit(0);
+    }
+
+    // Process files
+    let mut exit_code = 0;
+    let file_count = args.argc - file_start_idx;
+    let mut first_file = true;
+
+    for i in file_start_idx..args.argc {
+        if let Some(path) = args.argv(i) {
+            // Print header if multiple files
+            if file_count > 1 {
+                if !first_file {
+                    let _ = stdout().write(b"\n");
+                }
+                print_header(path);
+            }
+            first_file = false;
+
+            if let Err(e) = head_file(path, max_lines) {
+                print_error_bytes(path, e);
+                exit_code = 1;
+            }
+        }
+    }
+
+    exit(exit_code);
+}
+
+#[panic_handler]
+fn panic(_info: &PanicInfo) -> ! {
+    let _ = stderr().write_str("head: panic!\n");
+    exit(2);
+}