Finishing PS/2 bus driver

system/kernel/process.zig

@@ -700,6 +700,11 @@ fn systemIrqAck(state: *architecture.CpuState) void {
     if (irq.ack(gsi)) architecture.setSystemCallResult(state, 0) else fail(state);
 }
 
+/// Whether the debug_write stream sits at the start of a line — the last emitted
+/// byte was a newline (true at boot: nothing emitted yet). Guarded by the kernel
+/// lock in `systemDebugWrite`, like the stream it describes.
+var write_at_line_start: bool = true;
+
 /// debug_write(ptr, len): copy bytes from user memory into the kernel log.
 /// A bring-up diagnostic — real output goes through the VFS/console later.
 ///
@@ -709,17 +714,27 @@ fn systemIrqAck(state: *architecture.CpuState) void {
 /// Known gap (fine for trusted user code): a pointer into an *unmapped* hole in
 /// the user half passes the check and the read #PFs -> on_fault halts — a
 /// self-DoS, not an isolation break. Fault-recovering copy-in is a later item.
+///
+/// The emit runs under the kernel lock, so a message is atomic on the wire — two
+/// processes writing from different cores can interleave *messages*, never bytes.
+/// The "DANOS-INIT: " marker is emitted only at the start of a line (not per
+/// call), so a process may assemble a line from several writes without the marker
+/// (or, with the lock, another byte) landing in the middle. Cleanly-terminated
+/// lines from concurrent writers stay whole either way.
 fn systemDebugWrite(state: *architecture.CpuState) void {
     const ptr = architecture.systemCallArg(state, 0);
     const len = architecture.systemCallArg(state, 1);
     if (len <= write_buffer.len and ptr < user_half_end and ptr + len <= user_half_end) {
         const source: [*]const u8 = @ptrFromInt(ptr);
+        const flags = sync.enter();
+        defer sync.leave(flags);
         @memcpy(write_buffer[0..len], source[0..len]); // keep the latest message
         write_len = len;
         write_from_user = architecture.fromUser(state);
         write_count += 1;
-        log.write("DANOS-INIT: ");
+        if (write_at_line_start) log.write("DANOS-INIT: ");
         log.write(source[0..len]);
+        if (len != 0) write_at_line_start = source[len - 1] == '\n';
         architecture.setSystemCallResult(state, len);
     } else {
         fail(state);