Import sources from 2011-03-30 iso image - sys/lib

1 files changed, 387 insertions, 0 deletions

diff --git a/sys/lib/acid/kernel b/sys/lib/acid/kernel
new file mode 100755
index 000000000..76b4490f8
--- /dev/null
+++ b/sys/lib/acid/kernel
@@ -0,0 +1,387 @@
+include("/sys/lib/acid/syscall");
+
+// print various /proc files
+defn fd() {
+	rc("cat /proc/"+itoa(pid)+"/fd");
+}
+
+defn segment() {
+	rc("cat /proc/"+itoa(pid)+"/segment");
+}
+
+defn ns() {
+	rc("cat /proc/"+itoa(pid)+"/ns");
+}
+
+defn qid(qid) {
+	complex Qid qid;
+	return itoa(qid.path\X)+"."+itoa(qid.vers\X);
+}
+
+defn path(p) {
+	complex Path p;
+	if p != 0 then {
+		return *(p.s\s);
+	} else
+		return "<null>";
+}
+
+// print Image cache contents
+// requires include("/sys/src/9/xxx/segment.acid")
+IHASHSIZE = 64;
+defn imagecacheline(h) {
+	while h != 0 do {
+		complex Image h;
+		print (h\X, " ", qid(h.qid), " type ", h.type\D, " ref ", h.ref, " next ", h.next\X, " ", cname(h.c.name), "\n");
+		h = h.hash;
+	}
+}
+
+defn imagecache() {
+	local i;
+
+	i=0; loop 1,IHASHSIZE do {
+		imagecacheline(imagealloc.free[i]);
+		i = i+1;
+	}
+}
+
+// dump channels
+defn chan(c) {
+	local d, q;
+
+	c = (Chan)c;
+	d=(Dev)(*(devtab+4*c.type));
+	q=c.qid;
+	print("chan(", c\X, "): ref=", c.ref\D, " #", d.dc\r, c.dev\D, " (", q.path, " ", q.vers\D, " ", q.type\X, ")");
+	print(" fid=", c.fid\D, " iounit=", c.iounit\D);
+	if c.ref != 0 then {
+		print(" ", cname(c.name), " mchan=", c.mchan\X);
+		if c.mchan != 0 then {
+			print(" ", cname(c.mchan.name));
+		}
+	}
+	print("\n");
+}
+
+defn chans() {
+	local c;
+
+	c = (Chan)chanalloc.list;
+	while c != 0 do {
+		if c.ref != 0 then
+			chan(c);
+		c=(Chan)c.link;
+	}
+}
+
+defn nchans() {
+	local c, n;
+	
+	n = 0;
+	c = (Chan)chanalloc.list;
+	while c != 0 do {
+		if c.ref != 0 then
+			n++;
+		c = (Chan)c.link;
+	}
+	return n;
+}
+
+defn activechanlist() {
+	local l, n;
+	
+	l = {};
+	c = (Chan)chanalloc.list;
+	while c != 0 do {
+		if c.ref != 0 then
+			l = append l,c;
+		c = (Chan)c.link;
+	}
+	return l;
+}
+
+defn difflist(a, b) {
+	local l, x;
+	
+	l = {};
+	while a != {} do {
+		x = head a;
+		if match(x, b) == -1 then
+			l = append l, x;
+		a = tail a;
+	}
+	return l;
+}
+
+_active_chan_list = {};
+defn newchans() {
+	local l, new;
+	
+	l = activechanlist();
+	if _active_chan_list != {} then
+		newerchans(_active_chan_list);
+	_active_chan_list = l;
+}
+
+defn newerchans(oldlist){
+	local new;
+	
+	new = difflist(activechanlist(), oldlist);
+	while new != {} do {
+		chan(head new);
+		new = tail new;
+	}
+}
+
+// look for channels that refer to themselves
+defn badchans() {
+	local bad, c, i, len, mtpt, p;
+	
+	c = (Chan)chanalloc.list;
+	while c != 0 do {
+		if c.ref != 0 then {
+			bad = "";
+			p = (Path)c.path;
+			if p != 0 then {
+				path(p);
+				mtpt = p.mtpt;
+				len = p.mlen;
+				i=0; loop 1,len do {
+					if mtpt[i] == c then
+						bad = bad+" mtpt self-ref";
+					i = i+1;
+				}
+			}
+			if bad != "" then
+				print("chan(", c\X, "):", bad, "\n");
+		}
+		c = (Chan)c.link;
+	}
+}
+
+// manipulate processes
+defn proctab(x) {
+	return procalloc.arena+sizeofProc*x;
+}
+
+defn proc(p) {
+	complex Proc p;
+	local s, i;
+
+	if p.state != 0 && p.pid != 0 && p.text != 0 then {	// 0 is Dead
+		s = p.psstate;
+		if s == 0 then {
+			s = "kproc";
+		} else {
+			s = *(s\s);
+		}
+		print(p\X, " ", p.pid, ": ", *(p.text\s), " ", *(p.user\s), " pc ", p.pc\X, " ", s, " (", *(statename[p.state]\s), ") ut ", p.time[0]\D, " st ", p.time[1]\D, " qpc ", p.qpc\X, "\n");
+	}
+}
+
+defn procenv(p) {
+	complex Proc p;
+	local e, v;
+
+	e = p.egrp;
+	complex Egrp e;
+	v = e.entries;
+	while v != 0 do {
+		complex Evalue v;
+		print(*(v.name\s), "=");
+		printstringn(v.value, v.len);
+		print("\n");
+		v = v.link;
+	}
+}
+
+KSTACK=4096;
+
+defn procstksize(p) {
+	complex Proc p;
+	local top, sp;
+
+	if p.state != 0 then {	// 0 is Dead
+		top = p.kstack+KSTACK;
+		sp = *p.sched;
+		print(top-sp\D, "\n");
+	}
+}
+
+defn procstk(p) {
+	complex Proc p;
+	local l;
+
+	if p.state != 0 then {	// 0 is Dead
+		l = p.sched;
+		if objtype=="386" then
+			_stk(gotolabel, *l, linkreg(0), 0);
+		else
+			_stk(*(l+4), *l, linkreg(0), 0);
+	}
+}
+
+defn procs() {
+	local i;
+
+	i=0; loop 1,conf.nproc do {
+		proc(proctab(i));
+		i = i+1;
+	}
+}
+
+defn stacks() {
+	local i, p;
+
+	i=0; loop 1,conf.nproc do {
+		p = (Proc)proctab(i);
+		if p.state != 0 then {
+			print("=========================================================\n");
+			proc(p);
+			procstk(p);
+		}
+		i = i+1;
+	}
+}
+
+defn stacksizes() {
+	local i;
+
+	i=0; loop 1,conf.nproc do {
+		procstksize(proctab(i));
+		i = i+1;
+	}
+}
+
+// segment-related
+defn procsegs(p) {
+	complex Proc p;
+	local i;
+
+	i=0; loop 1,NSEG do {
+		psegment(p.seg[i]);
+		i = i+1;
+	}
+}
+
+segtypes = { "text", "data", "bss", "stack", "shared", "physical", "shdata", "map" };
+defn psegment(s) {
+	complex Segment s;
+
+	if s != 0 then {
+		print(s\X, " ", segtypes[s.type&SG_TYPE], " ", s.base\X, "-", s.top\X, " image ", s.image\X, "\n");
+	}
+}
+
+// find physical address for an address in a given process
+defn procaddr(p, a) {
+	complex Proc p;
+	local i, s, r;
+
+	r = 0;
+	i=0; loop 1,NSEG do {
+		s = p.seg[i];
+		if s != 0 then {
+			complex Segment s;
+			if s.base <= a && a < s.top then {
+				r = segaddr(s, a);
+			}
+		}
+		i = i+1;
+	}
+	return r;
+}
+
+// find an address in a given segment
+defn segaddr(s, a) {
+	complex Segment s;
+	local pte, pg;
+
+	a = a - s.base;
+	if s.map == 0 || s.mapsize < a/PTEMAPMEM then {
+		return 0;
+	}
+
+	pte = s.map[a/PTEMAPMEM];
+	if pte == 0 then {
+		return 0;
+	}
+
+	complex Pte pte;
+	pg = pte.pages[(a%PTEMAPMEM)/BY2PG];
+	if pg == 0 then {
+		return 0;
+	}
+
+	if pg & 1 then {	// swapped out, return disk address
+		return pg&~1;
+	}
+
+	complex Page pg;
+	return (KZERO|(pg.pa+(a%BY2PG)))\X;
+}
+
+defn kzero() {
+	return main - (main & 0x0FFFFFFF);
+}
+
+// PC only
+PTEMAPMEM = (1024*1024);
+BY2PG = 4096;
+PTEPERTAB = (PTEMAPMEM/BY2PG);
+defn up() {
+	local mach;
+
+	MACHADDR = KZERO+0x4000;
+	mach = MACHADDR;
+	complex Mach mach;
+	return mach.externup;
+}
+
+defn intrcount() {
+	local p, pp, t, i, j;
+
+	p = intrtimes;
+	i=0;
+	loop 1,256 do {
+		pp = p[i];
+		i=i+1;
+		if pp != 0 then {
+			j=0;
+			t=0;
+			loop 1,1000 do {
+				t = t+pp[j];
+				j=j+1;
+			}
+			print(itoa(i, "%5d"), " ", itoa(t, "%11d"), "\n");
+		}
+	}
+}
+
+print("/sys/lib/acid/kernel");
+
+defn needacid(s){
+	print("\trc(\"cd /sys/src/9/", kdir, "; mk ", s, ".acid\")\n");
+	print("\tinclude(\"/sys/src/9/", kdir, "/", s, ".acid\")\n");
+}
+
+defn kinit() {
+if (map()[2]) != {} then {	// map has more than two elements -> active proc
+	kdir = "unknown";
+	KZERO = kzero();
+	
+	if objtype == "386" then {
+		map({"*data", KZERO, 0xffffffff, KZERO});
+		kdir="pc";
+	}
+	if (objtype == "mips" || objtype == "mips2") then {
+		kdir = "ch";
+	}
+	if objtype == "alpha" then {
+		map({"*data", KZERO, 0xffffffff, KZERO});
+		kdir = "alpha";
+	}
+	needacid("proc");
+}
+}