nexoniarz/SchOS
nexoniarz/SchOS
Watch
1
0
Fork
You've already forked SchOS
 0
Code Issues Pull requests Projects Releases 1 Packages Wiki Activity Actions

debugger: the kernel can be asked a question

Browse source 
docs/plan/debugger.md, milestones D0, D1 and D2. What they replace is the
ninety-second loop -- add a cprintf, rebuild, boot, read the serial log --
which answers exactly the one question you thought of before the rebuild.

The rule the shape follows: **it observes, it does not control.** No
stepping, no software breakpoints, no stopping the world. Half the bugs
this kernel produces are timing -- an interrupt storm, a level-triggered
line nobody acknowledges, a driver that faults only on its second start --
and every one of them disappears when you halt the machine to look. And
the layering rule, which is the circularity rule the display already has:
a debugger that needs lwIP cannot debug lwIP.

D0 -- symbols. tools/ksyms.pl turns the first link pass into a table the
second pass carries. Two passes is enough because .ksym is placed after
.text and .rodata, so carrying the table cannot move anything recorded in
it; the build lists both passes' text symbols and refuses to link if they
ever disagree, because a symbol table that is subtly wrong gives confident
false answers. ksym.c reads it through weak symbols, so pass one -- which
has no table -- still links. A crash chain now reads panic+0x5f <-
proc_sysrq_cmd+0x99 <- ... <- syscall+0xf6.

D1 -- a log that outlives the kernel. Every character through consputc()
lands in a byte ring with a timestamp per line, readable as /proc/kmsg.
It sits in a region carved before the page allocator gets anything, with a
magic header, so a kernel finds the previous kernel's log still there --
including the whole PSOGM report. panic.c's own comment said "there is no
core dump and no log to go back to"; that is no longer true.

  The obvious place for it is the top of RAM beside the DMA arena. That
  was the first attempt and the magic came back as ASCII on the reboot,
  because the top of usable memory is exactly where the firmware makes its
  own allocations. It lives above the kernel image instead, which is a
  stable address across boots of the same build.

D2 -- the introspection registry. A subsystem publishes its state with one
line at the bottom of the file that owns the data:

  dbg_register("dma", dma_dump, "the DMA arena's free extents");

Seven views -- dma, mem, proc, vma, claims, pci, sock -- reachable three
ways: sysrq 'g' (always, no process and no filesystem), /dev/dbg (echo a
line, cat the answer), and schdbg. The protocol is lines of text because
the same bytes have to work where nothing can allocate or frame a record,
and because a protocol you cannot drive by hand is one you cannot debug.
struct sbuf moved out of kernel/dev/procfs.c into include/sbuf.h rather
than being written a second time.

Several views exist because of a specific bug. `vma` is the table that
decides whether exit() frees a page, and the DMA ownership bug that made
this worth building was a block that was never in it.

Also fixed, found by building with clang for the first time in a while:
struct iovec was defined in both posix.h and socket.h, and every file that
included both was a redefinition. GCC 15 defaults to C23, which permits an
identical struct redeclaration, so the gcc path never noticed -- while
clang defaults to gnu17 and rejected it, breaking the one toolchain
shell.nix exists to provide and the UEFI loader requires. Both are now
guarded.

D3 (`whose <addr>`, the cross-subsystem ownership query) and D4 (hardware
watchpoints on DR0-DR3) are not built and are described honestly as
missing in the architecture doc's "What it does not do".

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01VQ7Qx8E1q1M1bbCq8QLHS2
This commit is contained in:
Nexoniarz 2026-09-14 00:58:45 +02:00
commit 1dd4ba0186
35 changed files with 2296 additions and 83 deletions
Download patch file Download diff file Expand all files Collapse all files

3
kernel/arch/x86_64/e820.c
View file

@ -143,6 +143,9 @@ e820_init(void)
// physically contiguous, so the region that set `top` must be able to hold
// it. Picking the largest region makes this true on any machine worth
// booting; checking says so out loud if it ever is not.
//
// The kernel log is *not* up here -- it sits just above the kernel image,
// where the firmware does not allocate. See klog_init()'s caller.
if (largest < DMA_ARENA_BYTES) {
cprintf("e820: largest usable region is %d MB, too small for the %d MB "
"DMA arena\n", (int)(largest / (1024 * 1024)),

10
kernel/arch/x86_64/trap.c
View file

@ -111,8 +111,14 @@ trap(struct trapframe *tf)
}
if(myproc() == 0 || (tf->cs&3) == 0){
cprintf("unexpected trap %d from cpu %d rip %p (cr2=0x%p) err=0x%p\n",
tf->trapno, cpunum(), tf->rip, rcr2(), tf->err);
// The rip is named where it can be. This is a kernel address, so
// ksym_lookup() has something to say about it -- and the whole reason
// docs/plan/debugger.md puts D0 first is that "rip ffff8000001294c2"
// costs an objdump session and "rip in dma_alloc+0x8c" does not.
char where[72];
ksym_fmt(where, sizeof(where), tf->rip);
cprintf("unexpected trap %d from cpu %d rip %p <%s> (cr2=0x%p) err=0x%p\n",
tf->trapno, cpunum(), tf->rip, where, rcr2(), tf->err);
if (myproc())
cprintf("proc id: %d\n", myproc()->pid);
if (tf->trapno == T_GPFLT) {

6
kernel/core/console.c
View file

@ -1,6 +1,7 @@
#include <stdarg.h>
#include "types.h"
#include "defs.h"
#include "klog.h"
#include "vt.h"
#include "kbd.h" /* KEY_VT_SWITCH -- the terminal-switch chords */
#include "gfx.h"
@ -205,6 +206,11 @@ consputc(int c)
for(;;) hlt();
}
// Every kernel message passes through here, which is what makes this the
// one hook the log needs: cprintf, panic's report, a driver's complaint at
// three in the morning. See include/klog.h.
klog_putc(c);
if (c == BACKSPACE) {
uartputc('\b'); uartputc(' '); uartputc('\b');
if (!cons_serial_only)

57
kernel/core/dma.c
View file

@ -7,6 +7,8 @@
#include "mmu.h"
#include "spinlock.h"
#include "dma.h"
#include "sbuf.h"
#include "dbg.h"
#define DMA_GRAIN 64 // one cache line; also xHCI's ring alignment
#define NEXTENT 64 // free extents we can track
@ -30,6 +32,59 @@ roundup(uint64 v, uint64 to)
return (v + to - 1) & ~(to - 1);
}
// What the arena is holding, extent by extent.
//
// This is the view that would have ended the H2 investigation in one line. The
// bug was that a 4 MB block was on this free list *and* on kalloc's at the same
// time, and the only way to see it at the time was to read two allocators and
// reason about PHYSTOP. Printing the list is not clever; not being able to
// print it was the problem.
static void
dma_dump(struct sbuf *out, const char *arg)
{
(void)arg;
acquire(&arena.lock);
sb_puts(out, "arena 0x");
sb_puthex(out, arena.lo, 16);
sb_puts(out, "-0x");
sb_puthex(out, arena.hi, 16);
sb_puts(out, " (virtual; physical is this minus KERNBASE)\n");
sb_puts(out, " ");
sb_putu(out, arena.total / 1024);
sb_puts(out, " KB total, ");
{
uint64 free = 0;
for (int i = 0; i < arena.n; i++)
free += arena.free[i].len;
sb_putu(out, free / 1024);
sb_puts(out, " KB free in ");
sb_putu(out, arena.n);
sb_puts(out, " extent(s), ");
sb_putu(out, (arena.total - free) / 1024);
sb_puts(out, " KB out\n");
}
sb_puts(out, "\n # base phys bytes\n");
for (int i = 0; i < arena.n; i++) {
sb_puts(out, " ");
sb_putu_pad(out, i, 2);
sb_puts(out, " 0x");
sb_puthex(out, arena.free[i].base, 16);
sb_puts(out, " 0x");
sb_puthex(out, arena.free[i].base - (addr_t)KERNBASE, 16);
sb_puts(out, " ");
sb_putu_pad(out, arena.free[i].len, 10);
sb_putc(out, '\n');
}
if (arena.n == NEXTENT)
sb_puts(out, "\n the extent table is FULL -- a free here leaks rather "
"than corrupting the list\n");
release(&arena.lock);
}
void
dma_init(void *vstart, void *vend)
{
@ -42,6 +97,8 @@ dma_init(void *vstart, void *vend)
arena.free[0].len = arena.hi - arena.lo;
arena.n = 1;
arena.total = arena.free[0].len;
dbg_register("dma", dma_dump, "the DMA arena's free extents");
}
// Remove free[i], shifting the tail down.

37
kernel/core/kalloc.c
View file

@ -8,6 +8,8 @@
#include "memlayout.h"
#include "mmu.h"
#include "spinlock.h"
#include "sbuf.h"
#include "dbg.h"
void freerange(void *vstart, void *vend);
extern char end[]; // first address after kernel loaded from ELF file
@ -80,10 +82,45 @@ kinit1(void *vstart, void *vend)
}
}
// The page allocator, from the outside.
//
// Counting the free list is O(the free list), which on a gigabyte is a quarter
// of a million links. That is fine for a command someone typed and would not
// be fine anywhere else, so it lives here and nowhere near a hot path -- and
// the walk is bounded, because the one time you most want to run this is when
// you suspect the list is a loop.
static void
mem_dump(struct sbuf *out, const char *arg)
{
(void)arg;
struct run *r;
uint64 n = 0;
int looped = 0;
if (kmem.use_lock)
acquire(&kmem.lock);
for (r = kmem.freelist; r; r = r->next) {
if (++n > (PHYSTOP / PGSIZE) + 16) { looped = 1; break; }
}
if (kmem.use_lock)
release(&kmem.lock);
sb_puts(out, "window 0x");
sb_puthex(out, (addr_t)end, 16);
sb_puts(out, " upward; PHYSTOP is 0x");
sb_puthex(out, (addr_t)PHYSTOP, 16);
sb_putc(out, '\n');
sb_kv(out, "free ", n, "pages");
sb_kv(out, " ", n * PGSIZE / 1024, "KB");
if (looped)
sb_puts(out, "\n the free list did not end -- it has a CYCLE in it\n");
}
void
kinit2()
{
kmem.use_lock = 1;
dbg_register("mem", mem_dump, "the page allocator's free list");
}
void

267
kernel/core/klog.c Normal file
View file

@ -0,0 +1,267 @@
// SPDX-License-Identifier: Apache-2.0
//
// The kernel log that outlives the kernel. See include/klog.h.
//
// Two properties are worth reading the code for, because both are easy to
// write and easy to get subtly wrong:
//
// **It takes no lock.** klog_putc() runs inside consputc(), which runs with
// cons.lock held on the ordinary path and with interrupts off and every other
// CPU spinning on the panic path. A lock here would add a way for the logger
// to deadlock the thing it exists to report on, which is the one failure it
// must not have. The cost is that two CPUs printing at once can interleave
// characters -- which is already true of the console itself, so the log is no
// worse than the screen it mirrors.
//
// **It buffers before it exists.** The region is carved after e820_init(), so
// everything printed before that -- the loader's handover, the memory map
// itself -- has nowhere to go yet. Dropping it would mean the log is blank for
// exactly the part of the boot that is hardest to debug any other way, so
// early output goes into a small static array and is flushed into the ring the
// moment there is one.
#include "types.h"
#include "defs.h"
#include "memlayout.h"
#include "klog.h"
// consputc()'s cursor-movement escape, from kernel/core/console.c.
#define BACKSPACE 0x100
static struct klog_hdr *klog;
static int recovered; // the buffer held a previous boot when we found it
static uint64 prev_bytes; // how much of it that was
// Early output, before there is a ring to put it in. One page is enough for
// the handful of lines between the first cprintf and klog_init(); anything
// past it is dropped rather than overwritten, because the *first* lines of a
// boot that died early are the ones worth having.
static char early[4096];
static int nearly;
static int early_lost;
// Line state, kept here rather than derived, so a timestamp is emitted once
// per line and not once per write.
static int at_line_start = 1;
// Over the fields that do not move while a kernel is running -- deliberately
// not over head and mark.
//
// Those two change on every character written, and a sum that covered them
// would have to be recomputed on every character too: eight multiplies per
// byte of log, for a check whose entire job is to notice that some *other*
// program used this memory between two boots. head and mark are validated by
// range instead, which catches the same thing without the cost.
//
// Not a CRC either, for the same reason of proportion: this does not need to
// detect a clever corruption, and dragging kernel/fs/schfs's crc32c into core
// to do it would be a dependency in the wrong direction.
static uint32
checksum(const struct klog_hdr *h)
{
uint32 s = 0x9e3779b9u;
s = s * 31 + h->magic;
s = s * 31 + h->version;
s = s * 31 + h->size;
return s;
}
static int
looks_valid(const struct klog_hdr *h, uint64 bytes)
{
if (h->magic != KLOG_MAGIC || h->version != KLOG_VERSION)
return 0;
if (h->size != bytes - sizeof(struct klog_hdr))
return 0;
if (h->sum != checksum(h))
return 0;
// head and mark are outside the sum, so they are checked for sense instead:
// a boot cannot have ended before it started, and nothing this kernel does
// writes a quarter of a petabyte to a log.
if (h->mark > h->head)
return 0;
if (h->head > (1ULL << 48))
return 0;
return 1;
}
static void
raw_putc(char c)
{
klog->data[klog->head % klog->size] = c;
klog->head++;
}
static void
raw_puts(const char *s)
{
while (*s)
raw_putc(*s++);
}
// "[ 2.84] ", from the timer tick. Written by hand because the only
// formatter in the kernel is cprintf, and cprintf is what calls this.
static void
stamp(void)
{
uint t = ticks;
uint sec = t / 100;
uint cs = t % 100;
char b[16];
int i = 0, j;
raw_putc('[');
if (sec == 0) {
b[i++] = '0';
} else {
while (sec && i < 12) { b[i++] = '0' + (sec % 10); sec /= 10; }
}
for (j = i; j < 6; j++)
raw_putc(' ');
while (i-- > 0)
raw_putc(b[i]);
raw_putc('.');
raw_putc('0' + (cs / 10));
raw_putc('0' + (cs % 10));
raw_putc(']');
raw_putc(' ');
}
void
klog_putc(int c)
{
char ch = (char)c;
// Carriage returns and the console's backspace are cursor movement, not
// content. A log full of them reads as corruption.
if (ch == '\r' || c == BACKSPACE || ch == 0)
return;
if (!klog) {
if (nearly < (int)sizeof(early))
early[nearly++] = ch;
else
early_lost = 1;
return;
}
if (at_line_start && ch != '\n')
stamp();
raw_putc(ch);
at_line_start = (ch == '\n');
}
void
klog_init(void *base, uint64 bytes)
{
struct klog_hdr *h = (struct klog_hdr *)base;
if (bytes <= sizeof(struct klog_hdr))
return;
if (looks_valid(h, bytes)) {
recovered = 1;
prev_bytes = h->head - h->mark; // what the *last* boot wrote
} else {
// Either the first boot on this machine or a region something else has
// been using. Either way the contents cannot be trusted, and printing
// somebody else's bytes as if they were a log would be worse than
// printing nothing.
h->magic = KLOG_MAGIC;
h->version = KLOG_VERSION;
h->size = (uint32)(bytes - sizeof(struct klog_hdr));
h->boot = 0;
h->head = 0;
recovered = 0;
prev_bytes = 0;
}
h->mark = h->head;
h->boot++;
h->sum = checksum(h);
klog = h;
// A divider in the log itself rather than a flag a reader has to know about:
// whoever ends up reading this will be reading text, possibly by eye, and a
// line that says where one boot ends is worth more than a field that has to
// be interpreted.
at_line_start = 1;
raw_puts("\n--- boot ");
{
char b[12];
int i = 0;
uint32 n = h->boot;
if (n == 0) b[i++] = '0';
while (n) { b[i++] = '0' + (n % 10); n /= 10; }
while (i-- > 0) raw_putc(b[i]);
}
raw_puts(" ---\n");
for (int i = 0; i < nearly; i++) {
char ch = early[i];
if (ch == '\r' || ch == 0)
continue;
if (at_line_start && ch != '\n')
stamp();
raw_putc(ch);
at_line_start = (ch == '\n');
}
if (early_lost)
raw_puts("klog: early output overflowed and some was dropped\n");
nearly = 0;
h->sum = checksum(h);
// Said out loud on every boot, because "the log survived" and "the log was
// silently started over" look identical in a file that begins with a boot
// divider either way.
if (recovered)
cprintf("klog: %d KB at %p, %d bytes carried over from the previous boot\n",
(int)(bytes / 1024), (uint64)base, (int)prev_bytes);
else
cprintf("klog: %d KB at %p, nothing recoverable was there\n",
(int)(bytes / 1024), (uint64)base);
}
// How many bytes the ring currently holds, oldest first.
uint64
klog_len(void)
{
if (!klog)
return 0;
return klog->head < klog->size ? klog->head : klog->size;
}
uint64 klog_prev_bytes(void) { return prev_bytes; }
int klog_recovered(void) { return recovered; }
// Read at a byte offset into the log, where 0 is the oldest byte still held.
//
// Serving straight out of the ring rather than rendering into a scratch buffer
// the way every other /proc file does, because this file is 128 KB and that
// pattern regenerates the whole thing on every read into a stack array. See
// procread() in kernel/dev/procfs.c.
int
klog_read(uint64 off, char *dst, int n)
{
uint64 have, first;
int i;
if (!klog || n <= 0)
return 0;
have = klog_len();
if (off >= have)
return 0; // EOF
if ((uint64)n > have - off)
n = (int)(have - off);
first = klog->head - have; // logical position of the oldest byte
for (i = 0; i < n; i++)
dst[i] = klog->data[(first + off + i) % klog->size];
return n;
}

128
kernel/core/ksym.c Normal file
View file

@ -0,0 +1,128 @@
// SPDX-License-Identifier: Apache-2.0
//
// Naming an address.
//
// docs/plan/debugger.md milestone D0. It is the least clever thing on that
// plan and the one everything else is worth more with: a call chain of six
// hex numbers has to be resolved by hand against a disassembly that may not
// be the build that was running, and the resolving is done at exactly the
// moment when you least want a second task.
//
// The table is built by tools/ksyms.pl from the *first* of two link passes and
// linked into the second. kernel/kernel.ld puts .ksym after .text and .rodata,
// so carrying the table cannot move the addresses recorded in it; the Makefile
// checks that rather than trusting it, by listing the text symbols of both
// passes and refusing to build if they differ.
#include "types.h"
#include "defs.h"
// Weak, and the reason is worth stating: the first link pass has no table --
// it is the input to the program that writes one. An undefined weak symbol
// links as zero, so that pass resolves these to nothing and still links. The
// same property means a kernel built with the generator removed boots fine and
// simply cannot name anything, which is a much better failure than a build
// that stops.
extern const uint32 ksym_count __attribute__((weak));
extern const uint64 ksym_base __attribute__((weak));
extern const uint64 ksym_textend __attribute__((weak));
extern const uint32 ksym_addr[] __attribute__((weak));
extern const uint32 ksym_nameoff[] __attribute__((weak));
extern const char ksym_names[] __attribute__((weak));
int
ksym_ready(void)
{
return &ksym_count != 0 && ksym_count > 0;
}
// The greatest symbol at or below addr.
//
// Returns 0 for anything outside the kernel's text, which includes every
// userspace address -- naming a user rip with a kernel symbol would be worse
// than printing the number, because it would look like an answer.
const char *
ksym_lookup(uint64 addr, uint64 *off)
{
if (!ksym_ready())
return 0;
if (addr < ksym_base || addr >= ksym_textend)
return 0;
uint32 want = (uint32)(addr - ksym_base);
// Binary search for the last entry <= want, in the half-open form so the
// indices stay unsigned and nothing has to go below zero. ksym_addr[0] is 0
// by construction -- the base *is* the first symbol -- so the invariant
// "ksym_addr[lo] <= want" holds on entry and there is no empty case.
uint32 lo = 0, hi = ksym_count;
while (hi - lo > 1) {
uint32 mid = lo + (hi - lo) / 2;
if (ksym_addr[mid] <= want)
lo = mid;
else
hi = mid;
}
if (off)
*off = want - ksym_addr[lo];
return &ksym_names[ksym_nameoff[lo]];
}
static int
put(char *buf, int cap, int n, const char *s)
{
while (*s && n < cap - 1)
buf[n++] = *s++;
return n;
}
static int
puthex(char *buf, int cap, int n, uint64 v)
{
static const char h[] = "0123456789abcdef";
char tmp[17];
int i = 0;
if (v == 0)
return put(buf, cap, n, "0");
while (v && i < 16) { tmp[i++] = h[v & 0xF]; v >>= 4; }
while (i-- > 0 && n < cap - 1)
buf[n++] = tmp[i];
return n;
}
// "sched+0x2a", or the bare address when there is nothing to say.
//
// Writes into a caller's buffer rather than printing, because both callers
// that matter are in panic context: one is building a line for the crash
// screen and the other is building the QR payload. Neither can call cprintf.
int
ksym_fmt(char *buf, int cap, uint64 addr)
{
uint64 off = 0;
const char *name;
int n = 0;
if (cap <= 1) {
if (cap == 1)
buf[0] = 0;
return 0;
}
name = ksym_lookup(addr, &off);
if (!name) {
n = put(buf, cap, n, "0x");
n = puthex(buf, cap, n, addr);
buf[n] = 0;
return n;
}
n = put(buf, cap, n, name);
if (off) {
n = put(buf, cap, n, "+0x");
n = puthex(buf, cap, n, off);
}
buf[n] = 0;
return n;
}

21
kernel/core/main.c
View file

@ -9,6 +9,9 @@
#include "x86.h"
#include "irq.h"
#include "dma.h"
#include "klog.h"
static void *klog_base; // the persistent log, just above the kernel image
static void startothers(void);
static void mpmain(void) __attribute__((noreturn));
@ -83,7 +86,23 @@ kmain(uint32 fb_addr)
// Before anything touches PHYSTOP, which is now a variable read from the
// firmware's memory map rather than a constant asserting 224 MB exists.
e820_init();
kinit1(end, P2V(PHYSTOP - DMA_ARENA_BYTES));
// The log region: the page after the kernel image, and the page allocator is
// started above it rather than at `end`.
//
// Low memory, deliberately, and it took a measurement to learn why. The
// obvious place is the top of RAM beside the DMA arena -- and on a reboot
// the magic came back as ASCII, because that is exactly where the firmware
// puts its own allocations before it hands the machine over. The bytes below
// the kernel image are the ones the loader has already committed to leaving
// alone, and `end` is the same address on every boot of the same build,
// which is the property a region has to have to be found again.
//
// No hole has to be punched in the allocator for this: kinit1's lower bound
// is a parameter, so moving it up by KLOG_BYTES is the whole of it.
klog_base = (void *)PGROUNDUP((addr_t)end);
klog_init(klog_base, KLOG_BYTES);
kinit1((char *)klog_base + KLOG_BYTES, P2V(PHYSTOP - DMA_ARENA_BYTES));
if (boot_verbose) cprintf("verbose boot: kinit1 done\n");
dma_init(P2V(PHYSTOP - DMA_ARENA_BYTES), P2V(PHYSTOP));
if (boot_verbose) cprintf("verbose boot: dma_init done\n");

26
kernel/core/panic.c
View file

@ -414,7 +414,19 @@ trace_line(char *buf, int cap, int i, addr_t pc)
char *p = put_str(buf, e, " #");
p = put_dec(p, e, (uint64)i);
p = put_str(p, e, i < 10 ? " " : " ");
put_hex(p, e, (uint64)pc, 16);
p = put_hex(p, e, (uint64)pc, 16);
// And the name, when the kernel is carrying a symbol table. This is the
// difference between a crash screen you photograph and then decode against
// a disassembly, and one you can read. See kernel/core/ksym.c.
if (ksym_ready()) {
char name[64];
if (ksym_lookup((uint64)pc, 0)) {
ksym_fmt(name, sizeof(name), (uint64)pc);
p = put_str(p, e, " ");
put_str(p, e, name);
}
}
}
/* ------------------------------------------------------------------ */
@ -520,10 +532,16 @@ report_serial(char *reason, addr_t *pcs, int npcs)
}
cprintf("\n Call chain\n");
for (int i = 0; i < npcs && pcs[i]; i++)
cprintf(" #%d %p\n", i, pcs[i]);
for (int i = 0; i < npcs && pcs[i]; i++) {
char name[64];
ksym_fmt(name, sizeof(name), (uint64)pcs[i]);
cprintf(" #%d %p %s\n", i, pcs[i], name);
}
cprintf("\n Resolve with: addr2line -e build/kernel/kernel <address>\n");
if (!ksym_ready())
cprintf("\n Resolve with: addr2line -e build/kernel/kernel <address>\n");
else
cprintf("\n For a line number: addr2line -e build/kernel/kernel <address>\n");
cprintf(" Reason: %s\n", reason);
cprintf(" System halted.\n");
}

82
kernel/core/sbuf.c Normal file
View file

@ -0,0 +1,82 @@
// SPDX-License-Identifier: Apache-2.0
//
// The bounded string builder. See include/sbuf.h for what it is and why it
// moved out of kernel/dev/procfs.c.
#include "types.h"
#include "sbuf.h"
void
sb_putc(struct sbuf *sb, char c)
{
if (sb->len < sb->cap - 1)
sb->p[sb->len++] = c;
}
void
sb_puts(struct sbuf *sb, const char *s)
{
while (*s)
sb_putc(sb, *s++);
}
void
sb_pad(struct sbuf *sb, const char *s, int width)
{
int n = 0;
while (s[n]) {
sb_putc(sb, s[n]);
n++;
}
while (n++ < width)
sb_putc(sb, ' ');
}
void
sb_puthex4(struct sbuf *sb, uint32 v)
{
static const char hex[] = "0123456789abcdef";
for (int i = 3; i >= 0; i--)
sb_putc(sb, hex[(v >> (i * 4)) & 0xF]);
}
void
sb_puthex(struct sbuf *sb, uint64 v, int digits)
{
static const char hex[] = "0123456789abcdef";
for (int i = digits - 1; i >= 0; i--)
sb_putc(sb, hex[(v >> (i * 4)) & 0xF]);
}
void
sb_putu(struct sbuf *sb, uint64 v)
{
char tmp[24];
int i = 0;
if (v == 0) { sb_putc(sb, '0'); return; }
while (v && i < (int)sizeof(tmp)) { tmp[i++] = '0' + (v % 10); v /= 10; }
while (i--) sb_putc(sb, tmp[i]);
}
void
sb_putu_pad(struct sbuf *sb, uint64 v, int width)
{
char tmp[24];
int i = 0, n;
if (v == 0) { tmp[i++] = '0'; }
while (v && i < (int)sizeof(tmp)) { tmp[i++] = '0' + (v % 10); v /= 10; }
for (n = i; n < width; n++)
sb_putc(sb, ' ');
while (i--)
sb_putc(sb, tmp[i]);
}
void
sb_kv(struct sbuf *sb, const char *label, uint64 v, const char *unit)
{
sb_puts(sb, label);
sb_putu(sb, v);
if (unit && *unit) { sb_putc(sb, ' '); sb_puts(sb, unit); }
sb_putc(sb, '\n');
}

3
kernel/dev/cdev.c
View file

@ -118,4 +118,7 @@ struct devsw devsw[] = {
// that do not live in the kernel. Registers arrive through mmap and
// everything else through ioctl; see include/pciuser.h.
[9] = { pciuser_read, pciuser_write },
// /dev/dbg (major 10) -- ask the kernel a question. Write a line, read the
// answer; see include/dbg.h and docs/plan/debugger.md.
[10] = { dbg_read, dbg_write },
};

243
kernel/dev/dbg.c Normal file
View file

@ -0,0 +1,243 @@
// SPDX-License-Identifier: Apache-2.0
//
// /dev/dbg -- asking the kernel a question. See include/dbg.h.
//
// The device is a conversation: write a line, read the answer.
//
// # echo dma > /dev/dbg && cat /dev/dbg
//
// That shape is chosen so the debugger is usable with the tools already on the
// machine, before `schdbg` is built and on a system where it will not start.
// docs/plan/debugger.md argues the case at length; the short version is that a
// protocol you cannot drive by hand is a protocol you cannot debug.
//
// One conversation at a time, deliberately. The answer buffer is global and
// the lock is held only while it is being filled, so two programs asking at
// once get one answer each, in some order, and neither gets half of the
// other's. Making it per-open would mean a struct file hook for something that
// has exactly one user.
#include "types.h"
#include "defs.h"
#include "param.h"
#include "spinlock.h"
#include "sleeplock.h"
#include "fs.h"
#include "file.h"
#include "errno.h"
#include "sbuf.h"
#include "dbg.h"
#define NVIEW 24
#define DBGBUF (16 * 1024)
struct view {
const char *name;
dbg_view_fn fn;
const char *what;
};
static struct view views[NVIEW];
static int nview;
// Static, and 16 KB of it. A view of every process on a 64-slot table is the
// largest thing here and comes to a few kilobytes; the alternative -- kalloc
// on every read -- would put an allocation on the path of the tool you reach
// for when the allocator is what you are investigating.
static char dbgbuf[DBGBUF];
static int dbglen;
static struct spinlock dbglock;
static int dbginit;
void
dbg_register(const char *name, dbg_view_fn fn, const char *what)
{
if (nview >= NVIEW || !name || !fn)
return;
views[nview].name = name;
views[nview].fn = fn;
views[nview].what = what ? what : "";
nview++;
}
static int
streq(const char *a, const char *b)
{
while (*a && *b && *a == *b) { a++; b++; }
return *a == 0 && *b == 0;
}
static void
do_help(struct sbuf *out)
{
sb_puts(out, "views this kernel publishes:\n");
for (int i = 0; i < nview; i++) {
sb_puts(out, " ");
sb_pad(out, views[i].name, 10);
sb_puts(out, views[i].what);
sb_putc(out, '\n');
}
sb_puts(out, "\n all every view above\n");
sb_puts(out, " help this\n");
}
static void
do_all(struct sbuf *out)
{
for (int i = 0; i < nview; i++) {
sb_puts(out, "=== ");
sb_puts(out, views[i].name);
sb_puts(out, " ===\n");
views[i].fn(out, "");
sb_putc(out, '\n');
}
}
int
dbg_command(const char *line, struct sbuf *out)
{
char word[32], arg[64];
int n = 0;
while (*line == ' ' || *line == '\t')
line++;
while (*line && *line != '\n' && *line != ' ' && n < (int)sizeof(word) - 1)
word[n++] = *line++;
word[n] = 0;
while (*line == ' ' || *line == '\t')
line++;
n = 0;
while (*line && *line != '\n' && n < (int)sizeof(arg) - 1)
arg[n++] = *line++;
while (n > 0 && (arg[n-1] == ' ' || arg[n-1] == '\r'))
n--;
arg[n] = 0;
if (word[0] == 0 || streq(word, "help")) {
do_help(out);
return out->len;
}
if (streq(word, "all")) {
do_all(out);
return out->len;
}
for (int i = 0; i < nview; i++) {
if (streq(word, views[i].name)) {
views[i].fn(out, arg);
return out->len;
}
}
sb_puts(out, "no view called '");
sb_puts(out, word);
sb_puts(out, "'. try: help\n");
return out->len;
}
// Fill dbgbuf, and say so if the answer did not fit.
//
// sb_* silently drops what will not fit, which is the right behaviour for a
// builder that must not fail -- but a table that stops in the middle of a row
// with no explanation reads as a kernel that is broken rather than as a buffer
// that is full. The last 64 bytes are held back to have somewhere to say it.
static int
fill(const char *cmd)
{
struct sbuf sb;
sb.p = dbgbuf; sb.len = 0; sb.cap = DBGBUF - 64;
if (cmd)
dbg_command(cmd, &sb);
else
do_all(&sb);
if (sb.len >= sb.cap - 1) {
sb.cap = DBGBUF;
sb_puts(&sb, "\n-- truncated: the answer is larger than the buffer. "
"ask for one view at a time.\n");
}
dbgbuf[sb.len] = 0;
return sb.len;
}
void
dbg_dump_all(void)
{
if (!dbginit) { initlock(&dbglock, "dbg"); dbginit = 1; }
acquire(&dbglock);
dbglen = fill(0);
// Printed inside the lock so a second sysrq cannot interleave with this one.
// cprintf takes cons.lock, which is never held by anything that wants
// dbglock, so the order is fixed and there is no cycle.
cprintf("%s", dbgbuf);
release(&dbglock);
}
// --- the device -------------------------------------------------------------
// A command. The answer replaces whatever was there.
//
// **The answer is read from offset zero.** That matters because writing to a
// descriptor advances its offset, so a program that writes and then reads on
// the same descriptor starts reading as many bytes into the answer as its
// command was long -- which is exactly the bug this comment exists to stop
// being written again. `cat` is unaffected because it opens the file fresh;
// cmd/schdbg seeks back to zero. See lseek() there.
int
dbg_write(struct inode *ip, uint64 off, char *src, int n)
{
char line[128];
int i;
(void)ip; (void)off;
if (n <= 0)
return 0;
if (n > (int)sizeof(line) - 1)
n = (int)sizeof(line) - 1;
for (i = 0; i < n; i++)
line[i] = src[i];
line[n] = 0;
if (!dbginit) { initlock(&dbglock, "dbg"); dbginit = 1; }
acquire(&dbglock);
dbglen = fill(line);
release(&dbglock);
return n; // the whole line was consumed either way
}
int
dbg_read(struct inode *ip, uint64 off, char *dst, int n)
{
int i, avail;
(void)ip;
if (!dbginit) { initlock(&dbglock, "dbg"); dbginit = 1; }
acquire(&dbglock);
if (dbglen == 0) {
// Nothing asked yet. Answering with the help text rather than with EOF,
// because `cat /dev/dbg` on its own is what someone does first and an
// empty file teaches them nothing.
struct sbuf sb = { dbgbuf, 0, DBGBUF };
do_help(&sb);
dbglen = sb.len;
}
if (off >= (uint64)dbglen) {
release(&dbglock);
return 0; // EOF
}
avail = dbglen - (int)off;
if (n > avail)
n = avail;
for (i = 0; i < n; i++)
dst[i] = dbgbuf[off + i];
release(&dbglock);
return n;
}

46
kernel/dev/pci.c
View file

@ -21,6 +21,8 @@
#include "fs.h"
#include "file.h"
#include "pci.h"
#include "sbuf.h"
#include "dbg.h"
#include "device.h"
static struct pci_dev devs[NPCI];
@ -497,10 +499,54 @@ pci_info(char *buf, int cap)
return len;
}
// The same lines /proc/pci carries, plus the command register, which is the
// bit that says whether a device can still reach memory. pciuser.c clears bus
// mastering when a userspace driver dies -- see "Taking it back" in
// docs/architecture/devices.md -- and "did that actually happen" is a question
// worth being able to ask without a userspace program.
static void
pci_dump(struct sbuf *out, const char *arg)
{
(void)arg;
sb_puts(out, " bdf vendor:device class "
"cmd bm io mem driver\n");
for (int i = 0; i < ndevs; i++) {
struct pci_dev *d = &devs[i];
uint32 cmd = pci_read32(d->bus, d->slot, d->func, PCI_COMMAND) & 0xFFFF;
sb_puts(out, " ");
sb_puthex(out, d->bus, 2); sb_putc(out, ':');
sb_puthex(out, d->slot, 2); sb_putc(out, '.');
sb_puthex(out, d->func, 1);
sb_puts(out, " ");
sb_puthex4(out, d->vendor); sb_putc(out, ':');
sb_puthex4(out, d->device);
sb_puts(out, " ");
sb_pad(out, class_name(d->class, d->subclass), 25);
sb_puthex4(out, cmd);
sb_puts(out, (cmd & PCI_CMD_BUS_MASTER) ? " on " : " -- ");
sb_puts(out, (cmd & PCI_CMD_IO) ? " on " : " -- ");
sb_puts(out, (cmd & PCI_CMD_MEMORY) ? " on " : " -- ");
sb_puts(out, " ");
{
int pid = pciuser_owner_pid(i);
if (pid) {
sb_puts(out, "userspace pid ");
sb_putu(out, pid);
} else {
sb_puts(out, d->driver ? d->driver : "-");
}
}
sb_putc(out, '\n');
}
}
void
pci_init(void)
{
ndevs = 0;
dbg_register("pci", pci_dump, "the bus, with each device's command register");
// If there is no host bridge at 0:0.0 there is no PCI, and every config
// read will come back 0xFFFFFFFF. Saying so once beats 8192 silent probes.

114
kernel/dev/pciuser.c
View file

@ -29,6 +29,8 @@
#include "uaccess.h"
#include "irq.h"
#include "pciuser.h"
#include "sbuf.h"
#include "dbg.h"
int mappages(pml4e_t *pgdir, void *va, uint64 size, uint64 pa, int perm);
// Who holds each device, or 0. Indexed the same way pci_get() is, because the
@ -89,10 +91,122 @@ pciuser_irq_handler(void *arg)
wakeup(&irqdev);
}
// The pid holding a device, or 0. For kernel/dev/pci.c's `pci` view, which
// otherwise prints "-" in the driver column for a device that is very much
// being driven -- just not from in here.
int
pciuser_owner_pid(int idx)
{
int pid = 0;
if (idx < 0 || idx >= NPCI)
return 0;
acquire(&pciuser_lock);
if (owner[idx])
pid = owner[idx]->pid;
release(&pciuser_lock);
return pid;
}
// Who is holding what, and what memory they were given for it.
//
// The three things that go wrong with a userspace driver are all here: a
// device claimed by a process that no longer exists, DMA handed out and never
// returned, and an interrupt line left masked with nobody reading it. Each was
// found the hard way, and each used to need a rebuild to see.
static void
pciuser_dump(struct sbuf *out, const char *arg)
{
(void)arg;
int held = 0, blocks = 0;
uint64 bytes = 0;
acquire(&pciuser_lock);
sb_puts(out, "claims\n");
for (int i = 0; i < NPCI && i < pci_count(); i++) {
const struct pci_dev *d;
if (!owner[i])
continue;
held++;
d = pci_get(i);
sb_puts(out, " index ");
sb_putu_pad(out, i, 2);
sb_puts(out, " ");
if (d) {
sb_puthex(out, d->bus, 2); sb_putc(out, ':');
sb_puthex(out, d->slot, 2); sb_putc(out, '.');
sb_puthex(out, d->func, 1);
sb_puts(out, " ");
sb_puthex4(out, d->vendor); sb_putc(out, ':');
sb_puthex4(out, d->device);
}
sb_puts(out, " held by pid ");
sb_putu(out, owner[i]->pid);
sb_puts(out, " (");
sb_puts(out, owner[i]->name);
sb_puts(out, ")\n");
}
if (!held)
sb_puts(out, " (nothing is claimed)\n");
sb_puts(out, "\ndma handed out\n");
for (int i = 0; i < PCIUSER_MAXDMA; i++) {
if (!dmablk[i].proc)
continue;
blocks++;
bytes += dmablk[i].size;
sb_puts(out, " slot ");
sb_putu_pad(out, i, 2);
sb_puts(out, " 0x");
sb_puthex(out, (addr_t)dmablk[i].kva, 16);
sb_puts(out, " phys 0x");
sb_puthex(out, dma_phys(dmablk[i].kva), 16);
sb_putu_pad(out, dmablk[i].size, 10);
sb_puts(out, " pid ");
sb_putu(out, dmablk[i].proc->pid);
sb_puts(out, " (");
sb_puts(out, dmablk[i].proc->name);
sb_puts(out, ")\n");
}
if (!blocks)
sb_puts(out, " (none)\n");
else {
sb_puts(out, " ");
sb_putu(out, blocks);
sb_puts(out, " block(s), ");
sb_putu(out, bytes / 1024);
sb_puts(out, " KB of ");
sb_putu(out, PCIUSER_MAXDMA);
sb_puts(out, " slots\n");
}
sb_puts(out, "\ninterrupts\n");
if (!irqdev.proc) {
sb_puts(out, " (no line is delivered to userspace)\n");
} else {
sb_puts(out, " irq ");
sb_putu(out, irqdev.irq);
sb_puts(out, " pid ");
sb_putu(out, irqdev.proc->pid);
sb_puts(out, " taken ");
sb_putu(out, irqdev.count);
sb_puts(out, ", seen ");
sb_putu(out, irqdev.seen);
sb_puts(out, irqdev.masked ? ", MASKED" : ", unmasked");
if (irqdev.count != irqdev.seen)
sb_puts(out, " -- the driver is behind");
sb_putc(out, '\n');
}
release(&pciuser_lock);
}
void
pciuser_init(void)
{
initlock(&pciuser_lock, "pciuser");
dbg_register("claims", pciuser_dump,
"devices, DMA and interrupts held by userspace drivers");
}
// Does `phys` fall inside a memory BAR of a device this process has claimed?

93
kernel/dev/procfs.c
View file

@ -17,6 +17,7 @@
#include "types.h"
#include "defs.h"
#include "klog.h"
#include "irq.h"
#include "x86.h"
#include "device.h"
@ -34,77 +35,14 @@
#include "errno.h"
#include "fsstat.h"
#include "schfs.h"
#include "sbuf.h"
#include "dbg.h"
#define PROC_BUFSZ 2048
// --- tiny formatting helpers (no snprintf in the kernel) -------------------
struct sbuf {
char *p;
int len;
int cap;
};
static void
sb_putc(struct sbuf *sb, char c)
{
if (sb->len < sb->cap - 1)
sb->p[sb->len++] = c;
}
static void
sb_puts(struct sbuf *sb, const char *s)
{
while (*s)
sb_putc(sb, *s++);
}
// A string in a fixed-width column, space-padded. cprintf has no width
// specifier and neither does this buffer, so tables build their own columns.
// Over-long values are allowed to run past their column rather than be
// truncated: a misaligned row is easier to read than a mangled name.
static void
sb_pad(struct sbuf *sb, const char *s, int width)
{
int n = 0;
while (s[n]) {
sb_putc(sb, s[n]);
n++;
}
while (n++ < width)
sb_putc(sb, ' ');
}
// Four lowercase hex digits, zero-padded. PCI and USB identifiers are always
// written this way, and a lookup table keyed on "8086:100e" does not match
// "8086:100E" or "8086:10e".
static void
sb_puthex4(struct sbuf *sb, uint32 v)
{
static const char hex[] = "0123456789abcdef";
for (int i = 3; i >= 0; i--)
sb_putc(sb, hex[(v >> (i * 4)) & 0xF]);
}
static void
sb_putu(struct sbuf *sb, uint64 v)
{
char tmp[24];
int i = 0;
if (v == 0) { sb_putc(sb, '0'); return; }
while (v && i < (int)sizeof(tmp)) { tmp[i++] = '0' + (v % 10); v /= 10; }
while (i--) sb_putc(sb, tmp[i]);
}
// "<label><value> <unit>\n" — the shape almost every /proc line takes.
static void
sb_kv(struct sbuf *sb, const char *label, uint64 v, const char *unit)
{
sb_puts(sb, label);
sb_putu(sb, v);
if (unit && *unit) { sb_putc(sb, ' '); sb_puts(sb, unit); }
sb_putc(sb, '\n');
}
// The formatting helpers these files are built out of now live in
// include/sbuf.h, because the debugger's introspection registry needs exactly
// the same thing and two copies would have drifted. See docs/plan/debugger.md.
// --- the files -------------------------------------------------------------
@ -403,6 +341,7 @@ gen_filesystems(struct sbuf *sb)
#define PROC_DEVICES 13
#define PROC_FSSTAT 14
#define PROC_NETIF 15
#define PROC_KMSG 17
// Render global file `id` (a PROC_* constant) into `buf`. Returns its length.
//
@ -446,6 +385,13 @@ proc_gen_global(int id, char *buf, int cap)
int
procread(struct inode *ip, uint64 off, char *dst, int n)
{
// The log is served straight out of its ring rather than regenerated into a
// scratch buffer like everything else here: it is 128 KB, and this function
// renders the whole file on every read into an array on a 4 KB kernel stack.
// See klog_read().
if (ip->minor == PROC_KMSG)
return klog_read(off, dst, n);
char buf[PROC_BUFSZ];
int len = proc_gen_global(ip->minor, buf, PROC_BUFSZ);
@ -502,6 +448,16 @@ proc_sysrq_cmd(char cmd)
cprintf("sysrq: pid 1 asked to exit -- it should come back\n");
break;
case 'g':
// Every registered view, straight to the console.
//
// This is docs/plan/debugger.md's level 0: no process, no filesystem, no
// client program. If /dev/dbg cannot be opened -- because the filesystem
// is what is broken -- this still works, and on a machine with only a
// serial line it is the whole debugger.
dbg_dump_all();
break;
case 'w': {
// Wedge the supervisor: make schinitd hang, on purpose, so PID 1's
// heartbeat timeout is exercised instead of reasoned about. There is no
@ -518,6 +474,7 @@ proc_sysrq_cmd(char cmd)
cprintf("sysrq: unknown command '%c' "
"(known: c = crash, u = dump USB, s = read the USB disk, "
"d = display self-test, t = text self-test, n = net self-test, "
"g = dump every debug view, "
"w = wedge the init supervisor, i = kill pid 1)\n",
cmd);
break;

1
kernel/fs/devfs.c
View file

@ -88,6 +88,7 @@ static const struct devnode devnodes[] = {
{ "stderr", 1, 1, D_ROOT },
{ "fb0", 2, 0, D_ROOT },
{ "pci", 9, 0, D_ROOT },
{ "dbg", 10, 0, D_ROOT },
{ "mouse", 3, 1, D_ROOT },
// Raw disks. Created whether or not a drive is present: opening one with no

28
kernel/fs/procfs.c
View file

@ -21,6 +21,7 @@
#include "types.h"
#include "defs.h"
#include "klog.h"
#include "param.h"
#include "memlayout.h"
#include "mmu.h"
@ -93,6 +94,7 @@ static const struct global_file globals[] = {
{ "devices", 13 },
{ "fsstat", 14 },
{ "netif", 15 },
{ "kmsg", 17 },
};
#define NGLOBALS ((int)(sizeof(globals) / sizeof(globals[0])))
@ -304,6 +306,32 @@ procfs_read(struct inode *ip, int user_dst, uint64 dst, uint64 off, uint n)
//
// A whole page for a 2 KB buffer is not wasteful here -- kalloc's unit is a
// page either way, and this is not a hot path.
// /proc/kmsg is 128 KB and comes out of a ring, so it does not go through
// the render-the-whole-file-then-slice path below. See klog_read().
if (INO_IS_GLOBAL(ip->inum) && (int)(ip->inum & 0xFF) == 17) {
char *k;
int got;
if (n > PGSIZE)
n = PGSIZE;
if ((k = kalloc()) == 0)
return -ENOMEM;
got = klog_read(off, k, (int)n);
if (got <= 0) {
kfree(k);
return 0;
}
r = got;
if (user_dst) {
if (copy_to_user(dst, k, got) < 0)
r = -EFAULT;
} else {
memmove((char *)dst, k, got);
}
kfree(k);
return r;
}
if ((buf = kalloc()) == 0)
return -ENOMEM;

19
kernel/kernel.ld
View file

@ -80,6 +80,25 @@ SECTIONS
*(.ldata .ldata.*)
}
/* The kernel symbol table, generated by tools/ksyms.pl between the two link
* passes. See kernel/core/ksym.c.
*
* The position is the whole trick and it is not cosmetic: everything the
* table records is a *text* address, and .ksym sits after .text and .rodata,
* so adding several tens of kilobytes here cannot move a single entry in it.
* That is what makes two passes enough -- pass one is read to build the
* table, pass two carries it, and pass two's text is identical to pass one's.
* Put this before .text and the table describes a kernel that no longer
* exists, subtly, with every address off by the size of the table.
*
* It is inside the loaded image (before edata), not in .bss, because it has
* contents. mboot_load_end is computed from edata and would otherwise not
* cover it. */
. = ALIGN(8);
.ksym : {
*(.ksym .ksym.*)
}
. = ALIGN(0x1000);
PROVIDE(edata = .);

58
kernel/net/unix.c
View file

@ -39,6 +39,8 @@
#define _KERNEL_SOCKET_INTERNALS
#include "socket.h"
#include "sbuf.h"
#include "dbg.h"
static struct {
struct spinlock lock;
@ -49,10 +51,66 @@ static struct {
// because sockclose is the one caller that cannot be moved after it.
static void scm_drain(struct socket *s);
// The socket table.
//
// Two columns here are the ones worth having: `buf`, because a peer that has
// stopped reading is invisible until its buffer is full and the writer blocks;
// and `scm`, because a descriptor sent over a socket and never received holds
// a kernel reference open, and there is no garbage collector for it -- see
// "What it does not do" in docs/architecture/networking.md.
static void
sock_dump(struct sbuf *out, const char *arg)
{
(void)arg;
struct socket *s;
int used = 0;
sb_puts(out, " slot dom state ref buf peer scm name\n");
acquire(&stab.lock);
for (s = stab.sock; s < stab.sock + NSOCK; s++) {
if (s->state == SS_FREE && s->ref == 0)
continue;
used++;
sb_putu_pad(out, (int)(s - stab.sock), 6);
sb_puts(out, " ");
sb_pad(out, s->domain == AF_UNIX ? "unix" :
s->domain == AF_INET ? "inet" :
s->domain == AF_NETLINK ? "nl" : "?", 7);
sb_pad(out, s->state == SS_FREE ? "free" :
s->state == SS_UNBOUND ? "unbound" :
s->state == SS_BOUND ? "bound" :
s->state == SS_LISTENING ? "listening" :
s->state == SS_CONNECTED ? "connected" : "?", 11);
sb_putu_pad(out, s->ref, 3);
sb_putu_pad(out, s->nwrite - s->nread, 7);
sb_puts(out, " ");
if (s->peer)
sb_putu_pad(out, (int)(s->peer - stab.sock), 4);
else
sb_puts(out, s->peer_closed ? "gone" : " -");
sb_putu_pad(out, s->nscm, 5);
sb_puts(out, " ");
if (s->name[0])
sb_puts(out, s->name);
else if (s->nqueue)
sb_putu(out, s->nqueue);
sb_putc(out, '\n');
}
release(&stab.lock);
if (!used)
sb_puts(out, " (no sockets)\n");
sb_puts(out, "\n buf is bytes written and not yet read; scm is descriptors\n"
" sent and not yet received, which nothing reclaims.\n");
}
void
sockinit(void)
{
initlock(&stab.lock, "socktab");
dbg_register("sock", sock_dump,
"the socket table, with buffered bytes and descriptors in flight");
}
// Caller holds stab.lock.

121
kernel/proc/proc.c
View file

@ -8,6 +8,8 @@
#include "proc.h"
#include "spinlock.h"
#include "sleeplock.h"
#include "sbuf.h"
#include "dbg.h"
#include "fs.h"
#include "file.h"
#include "posix.h"
@ -42,10 +44,129 @@ kstack_check_canary(const char *where)
}
}
// --- what the debugger can be told about processes --------------------------
//
// docs/plan/debugger.md, D2. These are here rather than in kernel/dev/dbg.c
// because this file owns ptable, and a view written anywhere else would need
// the lock and the struct exported to get at it. One line at the bottom of the
// file that owns the data is the whole discipline.
static const char *
state_name(enum procstate s)
{
switch (s) {
case UNUSED: return "unused";
case EMBRYO: return "embryo";
case SLEEPING: return "sleep";
case RUNNABLE: return "ready";
case RUNNING: return "run";
case ZOMBIE: return "zombie";
default: return "?";
}
}
// "4" means only pid 4. Not a general query language -- just the one filter
// that stops a table from being unreadable on a busy machine.
static int
want_pid(const char *arg)
{
int v = 0;
if (!arg || !*arg)
return 0; // no filter
while (*arg >= '0' && *arg <= '9')
v = v * 10 + (*arg++ - '0');
return v;
}
static void
proc_dump(struct sbuf *out, const char *arg)
{
struct proc *p;
int only = want_pid(arg);
sb_puts(out, " pid ppid pgid state sz(KB) mmap_next "
"name\n");
acquire(&ptable.lock);
for (p = ptable.proc; p < &ptable.proc[NPROC]; p++) {
if (p->state == UNUSED)
continue;
if (only && p->pid != only)
continue;
sb_putu_pad(out, p->pid, 5);
sb_putu_pad(out, p->parent ? p->parent->pid : 0, 6);
sb_putu_pad(out, p->pgid, 6);
sb_puts(out, " ");
sb_pad(out, state_name(p->state), 8);
sb_putu_pad(out, p->sz / 1024, 6);
sb_puts(out, " 0x");
sb_puthex(out, p->mmap_next, 16);
sb_puts(out, " ");
sb_puts(out, p->name);
if (p->killed)
sb_puts(out, " [killed]");
if (p->wedged)
sb_puts(out, " [wedged]");
sb_putc(out, '\n');
}
release(&ptable.lock);
}
// Every mapping every process holds that it does not own the pages of.
//
// This is the table that decides whether exit() frees a page or leaves it
// alone -- see proc_release_shared() in kernel/sys/sys_mem.c -- and the bug
// that made the debugger worth building was a DMA block that was never in it.
// A view of it is the cheapest possible check that the rule is being kept.
static void
vma_dump(struct sbuf *out, const char *arg)
{
struct proc *p;
int any = 0;
int only = want_pid(arg);
sb_puts(out, " pid slot va bytes "
"no_free shmid name\n");
acquire(&ptable.lock);
for (p = ptable.proc; p < &ptable.proc[NPROC]; p++) {
if (p->state == UNUSED)
continue;
if (only && p->pid != only)
continue;
for (int i = 0; i < NVMA; i++) {
if (!p->vma[i].used)
continue;
any = 1;
sb_putu_pad(out, p->pid, 5);
sb_putu_pad(out, i, 6);
sb_puts(out, " 0x");
sb_puthex(out, p->vma[i].addr, 16);
sb_putu_pad(out, p->vma[i].length, 12);
sb_puts(out, p->vma[i].no_free ? " yes " : " no ");
if (p->vma[i].shmid >= 0)
sb_putu_pad(out, p->vma[i].shmid, 5);
else
sb_puts(out, " -");
sb_puts(out, " ");
sb_puts(out, p->name);
sb_putc(out, '\n');
}
}
release(&ptable.lock);
if (!any)
sb_puts(out, only ? " (that pid holds no mappings)\n"
: " (no process is holding a mapping)\n");
}
void
pinit(void)
{
initlock(&ptable.lock, "ptable");
dbg_register("proc", proc_dump, "every process, with its state and size");
dbg_register("vma", vma_dump, "mappings a process holds but does not own");
}
static struct proc*