void		_assert(char*);
void		accounttime(void);
void		addbootfile(char*, uchar*, ulong);
Timer*		addclock0link(void (*)(void), int);
int		addconsdev(Queue*, void (*fn)(char*,int), int, int);
Path*		addelem(Path *, char *, int);
int		addkbdq(Queue*, int);
int		addphysseg(Physseg*);
void		addsummary(char *(*)(char*,char*,void*), void*);
void		addttescape(uint, void(*)(void*), void*);
void		addwatchdog(Watchdog*);
int		adec(int*);
Block*		adjustblock(Block*, int);
int		ainc(int*);
void		alarmkproc(void*);
Block*		allocb(int);
Block*		bl2mem(uchar*, Block*, int);
int		blocklen(Block*);
void		bootlinks(void);
void		callwithureg(void (*)(Ureg*));
int		canlock(Lock*);
int		canpage(Proc*);
int		canqlock(QLock*);
int		canrlock(RWlock*);
Chan*		cclone(Chan*);
void		cclose(Chan*);
void		ccloseq(Chan*);
void		cflushed(Chan*);
void		chanfree(Chan*);
void		chaninit(void);
void		checkalarms(void);
void		checkb(Block*, char*);
void		cinit(void);
void		closeegrp(Egrp*);
void		closefgrp(Fgrp*);
void		closepgrp(Pgrp*);
void		closergrp(Rgrp*);
void		cmderror(Cmdbuf*, char*);
int		cmount(Chan**, Chan*, int);
int		consactive(void);
void		(*consdebug)(void);
Block*		concatblock(Block*);
void		(*consputs)(char*, int);
void		copen(Chan*);
Block*		copyblock(Block*, int);
void		pagecpy(Page*, Page*);
void		clearseg(Segment*);
long		cread(Chan*, uchar*, long, vlong);
void		cremove(Chan*);
void		cunmount(Chan*, Chan*);
void		cupdate(Chan*, uchar*, int, vlong);
long		cwrite(Chan*, uchar*, long, vlong);
uintptr		dbgpc(Proc*);
int		decrypt(void*, void*, int);
void		delay(int);
void		delconsdevs(void);
Chan*		devattach(int, char*);
Block*		devbread(Chan*, long, vlong);
long		devbwrite(Chan*, Block*, vlong);
Chan*		devclone(Chan*);
int		devconfig(int, char *, DevConf *);
void		devcreate(Chan*, char*, int, int);
void		devdir(Chan*, Qid, char*, vlong, char*, long, Dir*);
long		devdirread(Chan*, char*, long, Dirtab*, int, Devgen*);
Devgen		devgen;
void		devinit(void);
Chan*		devopen(Chan*, int, Dirtab*, int, Devgen*);
void		devpermcheck(char*, int, int);
void		devpower(int);
void		devremove(Chan*);
void		devreset(void);
void		devshutdown(void);
long		devstat(Chan*, uchar*, long, Dirtab*, int, Devgen*);
Dev*		devtabget(int, int);
void		devtabinit(void);
void		devtabreset(void);
long		devtabread(Chan*, void*, long, vlong);
void		devtabshutdown(void);
Walkqid*	devwalk(Chan*, Chan*, char**, int, Dirtab*, int, Devgen*);
long		devwstat(Chan*, uchar*, long);
char		*dirname(uchar*, int*);
long		dirsetname(char*, int, uchar*, long, long);
void		drawactive(int);
void		drawcmap(void);
void		dumpaproc(Proc*);
void		dumpregs(Ureg*);
void		dumpstack(void);
Fgrp*		dupfgrp(Fgrp*);
Pgrp*		duppgrp(Pgrp*, Chan*);
Mount*		dupmnt(Mount*);
Path*		duppath(Path *s);
Pgrp*		duppgrp(Pgrp*, Chan*);
int		duppage(Page*);
int		eqchan(Chan*, Chan*, int);
int		emptystr(char*);
int		encrypt(void*, void*, int);
void		envcpy(Egrp*, Egrp*);
int		eqchanddq(Chan*, int, uint, Qid, int);
int		eqpath(Path *, Path *);
int		eqqid(Qid, Qid);
void		error(char*);
void		execsched(void);
void		exhausted(char*);
void		exit(int);
uvlong		fastticks(uvlong*);
uvlong		fastticks2us(uvlong);
uvlong		fastticks2ns(uvlong);
int		fault(uintptr, int);
void		fdclose(int, int);
Chan*		fdtochan(int, int, int, int);
int		fixfault(Segment*, uintptr, int, int);
void		fmtinit(void);
void		forceclosefgrp(void);
void		free(void*);
void		freeb(Block*);
void		freeblist(Block*);
int		freebroken(void);
void		freename(Name*);
void		getcolor(ulong, ulong*, ulong*, ulong*);
void		gotolabel(Label*);
char*		getconfenv(void);
int		haswaitq(void*);
long		hostdomainwrite(char*, long);
long		hostownerwrite(char*, long);
void		hzsched(void);
Block*		iallocb(int);
void		iallocdump(void*);
void		ialloclimit(ulong);
char*		iallocsummary(char*, char*, void*);
void		ilock(Lock*);
void		segmapsize(Segment*, usize);
int		segreclaim(void);
void		initseg(void);
int		iprint(char*, ...);
void		isdir(Chan*);
int		iseve(void);
int		islo(void);
Segment*	isoverlap(Proc*, uintptr, usize);
int		isphysseg(char*);
void		iunlock(Lock*);
void		ixdumpsummary(void);
int		kbdcr2nl(Queue*, int);
int		kbdgetmap(int, int*, int*, Rune*);
int		kbdputc(Queue*, int);
void		kbdputmap(ushort, ushort, Rune);
void		killbig(char*);
void		kproc(char*, void(*)(void*), void*);
void		kprocchild(Proc*, void (*)(void*), void*);
void		(*kproftimer)(uintptr);
void		ksetenv(char*, char*, int);
void		kstrcpy(char*, char*, int);
void		kstrdup(char**, char*);
long		latin1(Rune*, int);
void		linkseg(Segq*, Segment*);
#define		lock(l)	xlock((l), 0)
void		logopen(Log*);
void		logclose(Log*);
char*		logctl(Log*, int, char**, Logflag*);
void		logn(Log*, int, void*, int);
long		logread(Log*, void*, ulong, long);
void		log(Log*, int, char*, ...);
Cmdtab*		lookupcmd(Cmdbuf*, Cmdtab*, int);
Page*		lookpage(Segment*, uintptr);
#define		MS2NS(n) (((vlong)(n))*1000000LL)
void		mallocinit(void);
Block*		mem2bl(uchar*, int);
void		mfreeseg(Segment*, uintptr, uintptr);
void		microdelay(int);
uvlong		mk64fract(uvlong, uvlong);
void		mkqid(Qid*, vlong, ulong, int);
void		mmuflush(void);
void		mmuput(Proc*, Page*, uint);
void		mmurelease(Proc*);
void		mmuswitch(void);
Chan*		mntauth(Chan*, char*);
void		mntclose(Mount*);
void		mntdump(Mount*, int);
Chan*		mntlookup(Path*, int, int);
void		mntmount(Mount*, Path*, Chan*, int);
void		mntunmount(Mount*, Path*, Chan*);
usize		mntversion(Chan*, u32int, char*, usize);
int		mregfmt(Fmt*);
ulong		ms2tk(ulong);
uvlong		ms2fastticks(ulong);
void		mul64fract(uvlong*, uvlong, uvlong);
void		muxclose(Mnt*);
void*		nalloc(Nalloc*);
void		nallocdump(void*);
void		nfree(Nalloc*, Nlink*);
Chan*		namec(char*, int, int, int);
Chan*		nameop(char*, int, Namec*);
char*		nasummary(char*, char*, void*);
Chan*		newchan(void);
int		newfd(Chan*);
Mount*		newmnt(char*);
Page*		newpage(uint, int, int, uintptr);
Path*		newnpath(Name*);
Path*		newpath(char*);
Rgrp*		newrgrp(void);
Proc*		newproc(void);
Walkqid*	newwq(int);
void		nexterror(void);
int		nrand(int);
uvlong		ns2fastticks(uvlong);
int		okaddr(uintptr, long, int);
int		openmode(int);
Block*		packblock(Block*);
Block*		padblock(Block*, int);
void		pageinit(void);
void		pagememinit(uintmem, uintmem);
ulong		pagenumber(Page*);
char*		pageseprintsummary(char*, char*);
void		panic(char*, ...);
Cmdbuf*		parsecmd(char *a, int n);
void		pathclose(Path*);
char*		pathlast(Path *p);
ulong		perfticks(void);
void		pexit(char*, int);
void		pgrpcpy(Pgrp*, Pgrp*);
void		pgrpnote(ulong, char*, long, int);
void		prefaultseg(Segment *s);
int		psindex(int);
#define		poperror()		up->nerrlab--
int		postnote(Proc*, int, char*, int);
int		pprint(char*, ...);
int		preempted(void);
int		prefixpath(Path *, Path *);
void		prflush(void);
void		printinit(void);
void		psinit(void);
ulong		procalarm(ulong);
void		procctl(Proc*);
int		procfdprint(Chan*, int, int, char*, int);
void		procflushseg(Segment*);
void		procpriority(Proc*, int, int);
void		procrestore(Proc*);
void		procsave(Proc*);
Proc*		psincref(int);
void		psdecref(Proc*);
void		(*proctrace)(Proc*, int, vlong, vlong);
void		procwired(Proc*, int);
Pte*		ptealloc(void);
int		pullblock(Block**, int);
Block*		pullupblock(Block*, int);
Block*		pullupqueue(Queue*, int);
void		detachseg(Segment*);
void		putpage(Page*);
void		putseg(Segment*);
void		putstrn(char*, int);
int		pwait(Waitmsg*);
void		qaddlist(Queue*, Block*);
Block*		qbread(Queue*, int);
long		qbwrite(Queue*, Block*);
Queue*		qbypass(void (*)(void*, Block*), void*);
int		qcanread(Queue*);
void		qclose(Queue*);
int		qconsume(Queue*, void*, int);
Block*		qcopy(Queue*, int, ulong);
int		qdiscard(Queue*, int);
void		qflush(Queue*);
void		qfree(Queue*);
int		qfull(Queue*);
Block*		qget(Queue*);
void		qhangup(Queue*, char*);
int		qisclosed(Queue*);
int		qiwrite(Queue*, void*, int);
int		qlen(Queue*);
void		qlock(QLock*);
Queue*		qopen(int, int, void (*)(void*), void*);
int		qpass(Queue*, Block*);
int		qpassnolim(Queue*, Block*);
int		qproduce(Queue*, void*, int);
void		qputback(Queue*, Block*);
long		qread(Queue*, void*, int);
Block*		qremove(Queue*);
void		qreopen(Queue*);
void		qsetlimit(Queue*, int);
void		qunlock(QLock*);
int		qwindow(Queue*);
int		qwrite(Queue*, void*, int);
void		qnoblock(Queue*, int);
int		rand(void);
void		randominit(void);
ulong		randomread(void*, ulong);
void		rdb(void);
int		readnum(ulong, char*, ulong, ulong, int);
long		readstr(long, char*, long, char*);
void		ready(Proc*);
void		rebootcmd(int, char**);
void		reboot(void*, void*, long);
void		relocateseg(Segment*, uintptr, uintptr);
void		renameuser(char*, char*);
void		resched(char*);
void		resrcwait(char*);
int		return0(void*);
void		rlock(RWlock*);
long		rtctime(void);
void		runlock(RWlock*);
Proc*		runproc(void);
void		sched(void);
void		schedinit(void);
long		seconds(void);
void		segclock(uintptr);
void		segpage(Segment*, Page*);
Segment*	segvictim(Segq*);
Page**		segwalk(Segment*, uintptr, int);
int		setcolor(ulong, ulong, ulong, ulong);
void		setkernur(Ureg*, Proc*);
int		setlabel(Label*);
void		setregisters(Ureg*, char*, char*, int);
void		setsched(void);
Mount*		setslash(Mount*, Chan*);
void		sleep(Rendez*, int (*)(void*), void*);
void*		smalloc(ulong);
char*		srvname(Chan*);
void		syscallfmt(int, va_list list);
void		sysretfmt(int, va_list, Ar0*, uvlong, uvlong);
void		sysrforkchild(Proc*, Proc*);
void		timeradd(Timer*);
void		timerdel(Timer*);
void		timersinit(void);
void		timerintr(Ureg*, vlong);
void		timerset(uvlong);
ulong		tk2ms(ulong);
#define		TK2MS(x) ((x)*(1000/HZ))
uvlong		tod2fastticks(vlong);
vlong		todget(vlong*);
void		todsetfreq(vlong);
void		todinit(void);
void		todset(vlong, vlong, int);
void		tsleep(Rendez*, int (*)(void*), void*, long);
Block*		trimblock(Block*, int, int);
Uart*		uartconsole(int, char*);
int		uartctl(Uart*, char*);
int		uartgetc(void);
void		uartkick(void*);
void		uartputc(int);
void		uartputs(char*, int);
void		uartrecv(Uart*, char);
int		uartstageoutput(Uart*);
void		unbreak(Proc*);
Segment*	unlinkseg(Segq*, Segment*);
#define		unlock(l)	xunlock((l), 0)
void		updatedot(void);
void		usedseg(Segq*, Segment*);
void		userinit(void);
uintptr		userpc(Ureg*);
long		userwrite(char*, long);
void*		validaddr(void*, long, int);
void		validname(char*, int);
Name*		validnamedup(char*, int);
void		validstat(uchar*, usize);
void*		vmemchr(void*, int, int);
Proc*		wakeup(Rendez*);
Chan*		walk(Chan*, char**, int);
Chan*		walklater(Chan*, Path*);
Chan*		walked(Chan*);
void		wlock(RWlock*);
void		wunlock(RWlock*);
void		yield(void);
Segment*	data2txt(Segment*);
void		forkseg(Proc*, int, int);
Segment*	newseg(int, uintptr, uintptr, Chan*, uint);
Segment*	seg(Proc*, uintptr, int);
void		hnputv(void*, uvlong);
void		hnputl(void*, uint);
void		hnputs(void*, ushort);
uvlong		nhgetv(void*);
uint		nhgetl(void*);
ushort		nhgets(void*);
#define		noschedlock(l)	xlock((l), 1)
#define		noschedunlock(l)	xunlock((l), 1)
int		xlock(Lock*, int);
void		xunlock(Lock*, int);
void		wqfree(Walkqid*);
ulong		µs(void);

#pragma varargck	argpos	iprint		1
#pragma varargck	argpos	panic		1
#pragma varargck	argpos	pprint		1