Subversion Repositories planix.SVN

include("/sys/src/libthread/sched.acid");

defn labpc(l)

{

	if objtype == "386" then

		return longjmp;

	return *(l+4);

}

defn labsp(l)

{

	return *l;

}

defn labstk(l)

{

	_stk(labpc(l), labsp(l), 0, 0);

}

defn lablstk(l)

{

	_stk(labpc(l), labsp(l), 0, 1);

}

defn altfmt(A){

	local i, s, yes;

	complex Alt A;

	s = "alt(";

	s = s + "tag(*" + itoa(A.tag, "%x") + "=" + itoa(*A.tag, "%x") + ") ";

	i = 0;

	yes = 0;

	while A.op != CHANEND && A.op != CHANNOBLK do{

		if A.op != CHANNOP then{

			if yes then s = s + " ";

			s = s + itoa(i, "%d");

			s = s + ":";

			if A.op == CHANSND then s = s + "send";

			if A.op == CHANRCV then s = s + "recv";

			s = s + "(channel(";

			s = s + itoa(A.c, "%x");

			s = s + "))";

			yes = 1;

		}

		i = i + 1;

		A = (Alt)(A + sizeofAlt);

	}

	if A.op==CHANNOBLK then{

		if yes then s = s + " ";

		s = s + "noblock";

	}

	s = s + ")";

	return s;

}

defn alt(A){

	print(altfmt(A), "\n");

}

threadignsrc = {

	"^/sys/src/libc",

	"^/sys/src/libthread",

};

defn fnname(a){

	local sym, s;

	s = symbols;

	while s do {

		sym = head s;

		if sym[2] == a then

			return sym[0];

		s = tail s;

	}

	if a == {} then

		return "{}";

	return itoa(a\X, "%x");

}

stkignorelist = {};

defn stkignore(s){

	append stkignorelist, s;

}

defn threadstkline(T){

	local ostk, stk, frame, pc, pc0, file, lastpc0, s, sym, i, stop;

	if T.state == Running then{

		pc = *PC;

		stk = strace(*PC, *SP, linkreg(0));

	}else{

		pc = labpc(T.sched);

		stk = strace(labpc(T.sched), labsp(T.sched), 0);

	}

	firstpc = pc;

	lastpc0 = 0;

	pc0 = 0;

	stop = 0;

	ostk = stk;

	while stk && !stop do {

		file = pcfile(pc);

		if !regexp("^/sys/src/libc/", file)

		&& !regexp("^/sys/src/libthread/", file) 

		&& match(file, stkignore)==-1 then

			stop = 1;

		else if stk[0][1] == 0xfefefefe then {

			pc = ostk[0][1];

			pc0 = ostk[1][0];

			stop = 1;

		}else{

			lastpc0 = pc0;

			frame = head stk;

			stk = tail stk;

			nextframe = head stk;

			pc = frame[1];

			pc0 = nextframe[0];

		}

	}

	file = pcfile(pc);

	s = file+":"+itoa(pcline(pc), "%d");

	if pc0 != 0 then 

		s = s + " "+fnname(pc0);

	return s;

}

defn threadfmt(T){

	complex Thread T;

	local A, yes, i, P, s;

	P = (Proc)T.proc;

	s = "t=(Thread)"+itoa(T, "%-10x")+" ";

	if T.state == Running then

		s = s + "Running    ";

	else if T.state == Ready then

		s = s + "Ready      ";

	else if T.state == Rendezvous then

		s = s + "Rendez     ";

	else

		s = s + "Bad state "+itoa(T.state, "%x")+" ";

	A = (Alt)T.alt;

	if 1 then

		s = s + threadstkline(T);

	else if T.chan == Chanalt then

		s = s + altfmt(T.alt);

	else if T.chan == Chansend then

		s = s + "send(Channel("+itoa(A.c, "%x")+"))";

	else if T.chan == Chanrecv then

		s = s + "recv(Channel("+itoa(A.c, "%x")+"))";

	else

		s = s + threadstkline(T);

	if T.moribund == 1 then

		s = s + " Moribund";

	if T.cmdname != 0 then

		s = s + " ["+*(T.cmdname\s)+"]";

	return s;

}

defn thread(T){

	print(threadfmt(T), "\n");

}

defn pthreads(P){

	complex Proc P;

	local T, Tq, mainpid;

	mainpid = pid;

	setproc(P.pid);

	Tq = (Tqueue)P.threads;

	T = (Thread)Tq.$head;

	while T != 0 do{

		print("\t");

		thread(T);

		T = T.nextt;

	}

	setproc(mainpid);

}

defn threads(){

	local P;

	P = (Proc)_threadpq.$head;

	while P != 0 do{

		if P != (Proc)_threadpq.$head then print("\n");

		lproc(P);

		P = P.next;

	}

}

defn stacks(){

	local P, mainpid;

	mainpid = pid;

	P = (Proc)_threadpq.$head;

	while P != 0 do{

		proc(P);

	//	setproc(P.pid);

	//	if P.thread==0 then{

	//		print("=== thread scheduler stack\n");

	//		stk();

	//	}

	//	print("threadstks(", P\X, ")\n");

		threadstks(P);

		P = P.next;

		print("\n");

	}

	setproc(mainpid);

}

defn stacksizes(){

	local P, T, Tq, top, sp, mainpid;

	mainpid = pid;

	P = (Proc)_threadpq.$head;

	while P != 0 do{

		P = (Proc)P;

		Tq = (Tqueue)P.threads;

		T = (Thread)Tq.$head;

		while T != 0 do{

			top = T.stk+T.stksize;

			if T.state==Running then {

				sp = *SP;

			}else{

				sp = *(T.sched);

			}

			sp = *(T.sched);

			print(top-sp\D, " / ", T.stksize\D, "\n");

			T = T.nextt;

		}

		P = P.next;

	}

	setproc(mainpid);

}

defn lproc(P){

	proc(P);

	pthreads(P);

}

defn threadstks(P){

	complex Proc P;

	local T, Tq, mainpid, pref, ign;

	mainpid = pid;

	pref = stkprefix;

	stkprefix = pref+"\t\t";

	ign = stkignore;

	stkignore = {

		"^/sys/src/libthread/",

		"^/sys/src/libc/(386|arm|alpha|sparc|power|mips)/"

	};

	setproc(P.pid);

	Tq = (Tqueue)P.threads;

	T = (Thread)Tq.$head;

	while T != 0 do{

	//	print("=============================\n");

	//	print("  thread(", T\X, ")\n");

		print("\t");

		thread(T);

		threadstk(T);

		T = T.nextt;

		print("\n");

	}

	setproc(mainpid);

	stkprefix = pref;

	stkignore = ign;

}

defn proc(P){

	complex Proc P;

	print("p=(Proc)", itoa(P, "%-10x"), " pid ", P.pid\D, " ");

	if P.thread==0 then

		print(" Sched");

	else

		print(" Running");

	print("\n");

}

defn procs(){

	local P;

	P = (Proc)_threadpq.$head;

	while P != 0 do{

		proc(P);

		P = P.next;

	}

}

defn threadlstk(T){

	complex Thread T;

	local P, mainpid;

	P = (Proc)T.proc;

	mainpid = pid;

	setproc(P.pid);

	if T.state == Running then{

		lstk();

	} else {

		lablstk(T.sched);

	}

	setproc(mainpid);

}

defn threadstk(T){

	complex Thread T;

	local P, mainpid;

	P = (Proc)T.proc;

	mainpid = pid;

	setproc(P.pid);

	if T.state == Running then{

		stk();

	} else {

		labstk(T.sched);

	}

	setproc(mainpid);

}

defn tqueue(Q) {

	complex Tqueue Q;

	while Q != 0 do {

		print(Q.$head\X, " ");

		Q = *(Q.$tail);

	}

	print("#\n");

}

defn channel(C) {

	complex Channel C;

	local i, p;

	print("channel ", C\X);

	if C.freed then {

		print(" (moribund)");

	}

	print("\n");

	print("\telementsize=", C.e\D, " buffersize=", C.s, "\n");

	if C.s then {

		print("\t", C.n\D, " values in channel:\n");

		print("\t");

		p = C.v+C.e*(C.f%C.s);

		loop 1,C.n do {

			if C.e==4 then {

				print((*p)\X, " ");

			}else {

				print("data(", (*p)\X, ") ");

			}

			p = p+C.e;

			if p == C.v+C.s*C.e then {

				p = C.v;

			}

		}

	}

	print("\n");

	print(C.nentry\D, " queue slots:\n");

	i=0;

	loop 1,C.nentry do {

		if C.qentry[i] then

			print("\t", altfmt(C.qentry[i]), "\n");

		else

			print("\t<empty>\n");

		i=i+1;

	}

}

print("/sys/lib/acid/thread");