zig fmt

system/kernel/architecture/x86_64/cpu.zig

@@ -490,8 +490,7 @@ pub fn saveInterrupts() u64 {
         \\cli
         : [f] "=r" (flags),
         :
-        : .{ .memory = true }
-    );
+        : .{ .memory = true });
     return flags;
 }
 

system/kernel/architecture/x86_64/idt.zig

@@ -78,22 +78,22 @@ fn defaultFault(_: *const CpuState) noreturn {
 
 /// Names for the 32 defined exception vectors, for readable output.
 const names = [_][]const u8{
-    "divide error",             "debug",
-    "NMI",                      "breakpoint",
-    "overflow",                 "bound range exceeded",
-    "invalid opcode",           "device not available",
-    "double fault",             "coprocessor segment overrun",
-    "invalid TSS",              "segment not present",
-    "stack-segment fault",      "general protection fault",
-    "page fault",               "reserved (15)",
-    "x87 floating-point",       "alignment check",
-    "machine check",            "SIMD floating-point",
-    "virtualization",           "control protection",
-    "reserved (22)",            "reserved (23)",
-    "reserved (24)",            "reserved (25)",
-    "reserved (26)",            "reserved (27)",
-    "hypervisor injection",     "VMM communication",
-    "security exception",       "reserved (31)",
+    "divide error",         "debug",
+    "NMI",                  "breakpoint",
+    "overflow",             "bound range exceeded",
+    "invalid opcode",       "device not available",
+    "double fault",         "coprocessor segment overrun",
+    "invalid TSS",          "segment not present",
+    "stack-segment fault",  "general protection fault",
+    "page fault",           "reserved (15)",
+    "x87 floating-point",   "alignment check",
+    "machine check",        "SIMD floating-point",
+    "virtualization",       "control protection",
+    "reserved (22)",        "reserved (23)",
+    "reserved (24)",        "reserved (25)",
+    "reserved (26)",        "reserved (27)",
+    "hypervisor injection", "VMM communication",
+    "security exception",   "reserved (31)",
 };
 
 pub fn vectorName(vector: u64) []const u8 {

system/kernel/architecture/x86_64/paging.zig

@@ -166,8 +166,7 @@ pub fn init(allocFrame: *const fn () ?u64, freeFrame: *const fn (u64) void, boot
     asm volatile ("mov %[pml4], %%cr3"
         :
         : [pml4] "r" (pml4),
-        : .{ .memory = true }
-    );
+        : .{ .memory = true });
     on_own_tables = true; // now on the kernel's physmap (covers all RAM)
     init_done = true; // the kernel half is fixed from here
 }
@@ -409,6 +408,5 @@ fn invalidate(virtual: u64) void {
         \\invlpg (%%rax)
         :
         : [v] "r" (virtual),
-        : .{ .rax = true, .memory = true }
-    );
+        : .{ .rax = true, .memory = true });
 }

system/kernel/console.zig

@@ -154,5 +154,3 @@ pub const Console = struct {
         while (x < self.fb.width) : (x += 1) destination[x] = source[x];
     }
 };
-
-

system/kernel/kernel.zig

@@ -87,7 +87,7 @@ fn kmain(boot_information: *const BootInformation) noreturn {
     log.print("  pitch      : {d} bytes\n", .{fb.pitch});
     log.print("  format     : {s}\n", .{@tagName(fb.format)});
     log.print("  framebuffer: 0x{x:0>16}\n", .{fb.base});
-    log.print (" footprint  : {d} MiB\n", .{(fb.pitch * fb.height) / (1024 * 1024)});
+    log.print(" footprint  : {d} MiB\n", .{(fb.pitch * fb.height) / (1024 * 1024)});
 
     // Summarise the physical memory the loader handed us. The array is danos's
     // own MemoryRegion, so this is a plain slice — no firmware layout in sight.

system/kernel/process.zig

@@ -1082,4 +1082,4 @@ pub fn spawnProcessSupervised(image: []const u8, priority: u3, argv: []const []c
 /// a spin count, and time short delays.
 fn systemClock(state: *architecture.CpuState) void {
     architecture.setSystemCallResult(state, architecture.nanos());
-}
+}

system/kernel/tests.zig

@@ -2023,7 +2023,10 @@ fn faultNull() void {
     // access). `allowzero` skips the same null check on the cast. The write then
     // hits the unmapped page 0 and takes a real hardware #PF.
     var address: u64 = 0;
-    address = asm ("" : [ret] "=r" (-> u64) : [in] "0" (address));
+    address = asm (""
+        : [ret] "=r" (-> u64),
+        : [in] "0" (address),
+    );
     const p: *allowzero volatile u64 = @ptrFromInt(address);
     p.* = 1;
 }
@@ -2049,8 +2052,7 @@ fn faultDoubleFault() void {
         \\ud2
         :
         : [sp] "r" (bad_sp),
-        : .{ .memory = true }
-    );
+        : .{ .memory = true });
     bad_sp += 0;
 }
 
@@ -2069,8 +2071,7 @@ fn apDoubleFaultTask() void {
         \\ud2
         :
         : [sp] "r" (bad_sp),
-        : .{ .memory = true }
-    );
+        : .{ .memory = true });
     bad_sp += 0;
 }