Subversion Repositories planix.SVN

typedef struct Alarms	Alarms;

typedef struct Block	Block;

typedef struct Chan	Chan;

typedef struct Cmdbuf	Cmdbuf;

typedef struct Cmdtab	Cmdtab;

typedef struct Confmem	Confmem;

typedef struct Dev	Dev;

typedef struct Dirtab	Dirtab;

typedef struct Edf	Edf;

typedef struct Egrp	Egrp;

typedef struct Evalue	Evalue;

typedef struct Execvals	Execvals;

typedef struct Fgrp	Fgrp;

typedef struct DevConf	DevConf;

typedef struct Image	Image;

typedef struct Log	Log;

typedef struct Logflag	Logflag;

typedef struct Mntcache Mntcache;

typedef struct Mount	Mount;

typedef struct Mntrpc	Mntrpc;

typedef struct Mntwalk	Mntwalk;

typedef struct Mnt	Mnt;

typedef struct Mhead	Mhead;

typedef struct Note	Note;

typedef struct Page	Page;

typedef struct Path	Path;

typedef struct Palloc	Palloc;

typedef struct Pallocmem	Pallocmem;

typedef struct Perf	Perf;

typedef struct PhysUart	PhysUart;

typedef struct Pgrp	Pgrp;

typedef struct Physseg	Physseg;

typedef struct Proc	Proc;

typedef struct Pte	Pte;

typedef struct QLock	QLock;

typedef struct Queue	Queue;

typedef struct Ref	Ref;

typedef struct Rendez	Rendez;

typedef struct Rgrp	Rgrp;

typedef struct RWlock	RWlock;

typedef struct Sargs	Sargs;

typedef struct Schedq	Schedq;

typedef struct Segment	Segment;

typedef struct Sema	Sema;

typedef struct Timer	Timer;

typedef struct Timers	Timers;

typedef struct Uart	Uart;

typedef struct Waitq	Waitq;

typedef struct Walkqid	Walkqid;

typedef struct Watchdog	Watchdog;

typedef struct Watermark	Watermark;

typedef int    Devgen(Chan*, char*, Dirtab*, int, int, Dir*);

#pragma incomplete DevConf

#pragma incomplete Edf

#pragma incomplete Mntcache

#pragma incomplete Mntrpc

#pragma incomplete Queue

#pragma incomplete Timers

#include <fcall.h>

#define HOWMANY(x, y)	(((x)+((y)-1))/(y))

#define ROUNDUP(x, y)	(HOWMANY((x), (y))*(y))	/* ceiling */

#define ROUNDDN(x, y)	(((x)/(y))*(y))		/* floor */

#define	ROUND(s, sz)	(((s)+(sz-1))&~(sz-1))

#define	PGROUND(s)	ROUNDUP(s, BY2PG)

#define MIN(a, b)	((a) < (b)? (a): (b))

#define MAX(a, b)	((a) > (b)? (a): (b))

/*

 * For multi-bit fields use FIELD(v, o, w) where 'v' is the value

 * of the bit-field of width 'w' with LSb at bit offset 'o'.

 */

#define FIELD(v, o, w)	(((v) & ((1<<(w))-1))<<(o))

#define FCLR(d, o, w)	((d) & ~(((1<<(w))-1)<<(o)))

#define FEXT(d, o, w)	(((d)>>(o)) & ((1<<(w))-1))

#define FINS(d, o, w, v) (FCLR((d), (o), (w))|FIELD((v), (o), (w)))

#define FSET(d, o, w)	((d)|(((1<<(w))-1)<<(o)))

#define FMASK(o, w)	(((1<<(w))-1)<<(o))

/* let each port override any of these */

#ifndef KMESGSIZE

#define KMESGSIZE (16*1024)

#endif

#ifndef PCICONSSIZE

#define PCICONSSIZE (16*1024)

#endif

#ifndef STAGESIZE

#define STAGESIZE 64

#endif

#ifndef MAXBY2PG

#define MAXBY2PG BY2PG		/* rounding for UTZERO in executables */

#endif

struct Ref

{

	Lock;

	long	ref;

};

struct Rendez

{

	Lock;

	Proc	*p;

};

struct QLock

{

	Lock	use;		/* to access Qlock structure */

	Proc	*head;		/* next process waiting for object */

	Proc	*tail;		/* last process waiting for object */

	int	locked;		/* flag */

	uintptr	qpc;		/* pc of the holder */

};

struct RWlock

{

	Lock	use;

	Proc	*head;		/* list of waiting processes */

	Proc	*tail;

	ulong	wpc;		/* pc of writer */

	Proc	*wproc;		/* writing proc */

	int	readers;	/* number of readers */

	int	writer;		/* number of writers */

};

struct Alarms

{

	QLock;

	Proc	*head;

};

struct Sargs

{

	ulong	args[MAXSYSARG];

};

/*

 * Access types in namec & channel flags

 */

enum

{

	Aaccess,			/* as in stat, wstat */

	Abind,				/* for left-hand-side of bind */

	Atodir,				/* as in chdir */

	Aopen,				/* for i/o */

	Amount,				/* to be mounted or mounted upon */

	Acreate,			/* is to be created */

	Aremove,			/* will be removed by caller */

	COPEN	= 0x0001,		/* for i/o */

	CMSG	= 0x0002,		/* the message channel for a mount */

/*rsc	CCREATE	= 0x0004,		/* permits creation if c->mnt */

	CCEXEC	= 0x0008,		/* close on exec */

	CFREE	= 0x0010,		/* not in use */

	CRCLOSE	= 0x0020,		/* remove on close */

	CCACHE	= 0x0080,		/* client cache */

};

/* flag values */

enum

{

	BINTR	=	(1<<0),

	BFREE	=	(1<<1),

	Bipck	=	(1<<2),		/* ip checksum */

	Budpck	=	(1<<3),		/* udp checksum */

	Btcpck	=	(1<<4),		/* tcp checksum */

	Bpktck	=	(1<<5),		/* packet checksum */

};

struct Block

{

	long	ref;

	Block*	next;

	Block*	list;

	uchar*	rp;			/* first unconsumed byte */

	uchar*	wp;			/* first empty byte */

	uchar*	lim;			/* 1 past the end of the buffer */

	uchar*	base;			/* start of the buffer */

	void	(*free)(Block*);

	ushort	flag;

	ushort	checksum;		/* IP checksum of complete packet (minus media header) */

	ulong	magic;

};

#define BLEN(s)	((s)->wp - (s)->rp)

#define BALLOC(s) ((s)->lim - (s)->base)

struct Chan

{

	Ref;				/* the Lock in this Ref is also Chan's lock */

	Chan*	next;			/* allocation */

	Chan*	link;

	vlong	offset;			/* in fd */

	vlong	devoffset;		/* in underlying device; see read */

	ushort	type;

	ulong	dev;

	ushort	mode;			/* read/write */

	ushort	flag;

	Qid	qid;

	int	fid;			/* for devmnt */

	ulong	iounit;			/* chunk size for i/o; 0==default */

	Mhead*	umh;			/* mount point that derived Chan; used in unionread */

	Chan*	umc;			/* channel in union; held for union read */

	QLock	umqlock;		/* serialize unionreads */

	int	uri;			/* union read index */

	int	dri;			/* devdirread index */

	uchar*	dirrock;		/* directory entry rock for translations */

	int	nrock;

	int	mrock;

	QLock	rockqlock;

	int	ismtpt;

	Mntcache*mcp;			/* Mount cache pointer */

	Mnt*	mux;			/* Mnt for clients using me for messages */

	union {

		void*	aux;

		Qid	pgrpid;		/* for #p/notepg */

		ulong	mid;		/* for ns in devproc */

	};

	Chan*	mchan;			/* channel to mounted server */

	Qid	mqid;			/* qid of root of mount point */

	Path*	path;

};

struct Path

{

	Ref;

	char	*s;

	Chan	**mtpt;			/* mtpt history */

	int	len;			/* strlen(s) */

	int	alen;			/* allocated length of s */

	int	mlen;			/* number of path elements */

	int	malen;			/* allocated length of mtpt */

};

struct Dev

{

	int	dc;

	char*	name;

	void	(*reset)(void);

	void	(*init)(void);

	void	(*shutdown)(void);

	Chan*	(*attach)(char*);

	Walkqid*(*walk)(Chan*, Chan*, char**, int);

	int	(*stat)(Chan*, uchar*, int);

	Chan*	(*open)(Chan*, int);

	void	(*create)(Chan*, char*, int, ulong);

	void	(*close)(Chan*);

	long	(*read)(Chan*, void*, long, vlong);

	Block*	(*bread)(Chan*, long, ulong);

	long	(*write)(Chan*, void*, long, vlong);

	long	(*bwrite)(Chan*, Block*, ulong);

	void	(*remove)(Chan*);

	int	(*wstat)(Chan*, uchar*, int);

	void	(*power)(int);	/* power mgt: power(1) => on, power (0) => off */

	int	(*config)(int, char*, DevConf*);	/* returns nil on error */

	/* not initialised */

	int	attached;				/* debugging */

};

struct Dirtab

{

	char	name[KNAMELEN];

	Qid	qid;

	vlong	length;

	long	perm;

};

struct Walkqid

{

	Chan	*clone;

	int	nqid;

	Qid	qid[1];

};

enum

{

	NSMAX	=	1000,

	NSLOG	=	7,

	NSCACHE	=	(1<<NSLOG),

};

struct Mntwalk				/* state for /proc/#/ns */

{

	int	cddone;

	Mhead*	mh;

	Mount*	cm;

};

struct Mount

{

	ulong	mountid;

	Mount*	next;

	Mhead*	head;

	Mount*	copy;

	Mount*	order;

	Chan*	to;			/* channel replacing channel */

	int	mflag;

	char	*spec;

};

struct Mhead

{

	Ref;

	RWlock	lock;

	Chan*	from;			/* channel mounted upon */

	Mount*	mount;			/* what's mounted upon it */

	Mhead*	hash;			/* Hash chain */

};

struct Mnt

{

	Lock;

	/* references are counted using c->ref; channels on this mount point incref(c->mchan) == Mnt.c */

	Chan	*c;		/* Channel to file service */

	Proc	*rip;		/* Reader in progress */

	Mntrpc	*queue;		/* Queue of pending requests on this channel */

	ulong	id;		/* Multiplexer id for channel check */

	Mnt	*list;		/* Free list */

	int	flags;		/* cache */

	int	msize;		/* data + IOHDRSZ */

	char	*version;	/* 9P version */

	Queue	*q;		/* input queue */

};

enum

{

	NUser,				/* note provided externally */

	NExit,				/* deliver note quietly */

	NDebug,				/* print debug message */

};

struct Note

{

	char	msg[ERRMAX];

	int	flag;			/* whether system posted it */

};

enum

{

	PG_NOFLUSH	= 0,

	PG_TXTFLUSH	= 1,		/* flush dcache and invalidate icache */

	PG_DATFLUSH	= 2,		/* flush both i & d caches (UNUSED) */

	PG_NEWCOL	= 3,		/* page has been recolored */

	PG_MOD		= 0x01,		/* software modified bit */

	PG_REF		= 0x02,		/* software referenced bit */

};

struct Page

{

	Lock;

	ulong	pa;			/* Physical address in memory */

	ulong	va;			/* Virtual address for user */

	ulong	daddr;			/* Disc address on swap */

	ulong	gen;			/* Generation counter for swap */

	ushort	ref;			/* Reference count */

	char	modref;			/* Simulated modify/reference bits */

	char	color;			/* Cache coloring */

	char	cachectl[MAXMACH];	/* Cache flushing control for putmmu */

	Image	*image;			/* Associated text or swap image */

	Page	*next;			/* Lru free list */

	Page	*prev;

	Page	*hash;			/* Image hash chains */

};

struct Swapalloc

{

	Lock;				/* Free map lock */

	int	free;			/* currently free swap pages */

	uchar*	swmap;			/* Base of swap map in memory */

	uchar*	alloc;			/* Round robin allocator */

	uchar*	last;			/* Speed swap allocation */

	uchar*	top;			/* Top of swap map */

	Rendez	r;			/* Pager kproc idle sleep */

	ulong	highwater;		/* Pager start threshold */

	ulong	headroom;		/* Space pager frees under highwater */

}swapalloc;

struct Image

{

	Ref;

	Chan	*c;			/* channel to text file */

	Qid 	qid;			/* Qid for page cache coherence */

	Qid	mqid;

	Chan	*mchan;

	ushort	type;			/* Device type of owning channel */

	Segment *s;			/* TEXT segment for image if running */

	Image	*hash;			/* Qid hash chains */

	Image	*next;			/* Free list */

	int	notext;			/* no file associated */

};

struct Pte

{

	Page	*pages[PTEPERTAB];	/* Page map for this chunk of pte */

	Page	**first;		/* First used entry */

	Page	**last;			/* Last used entry */

};

/* Segment types */

enum

{

	SG_TYPE		= 07,		/* Mask type of segment */

	SG_TEXT		= 00,

	SG_DATA		= 01,

	SG_BSS		= 02,

	SG_STACK	= 03,

	SG_SHARED	= 04,

	SG_PHYSICAL	= 05,

	SG_RONLY	= 0040,		/* Segment is read only */

	SG_CEXEC	= 0100,		/* Detach at exec */

};

#define PG_ONSWAP	1

#define onswap(s)	(((ulong)s)&PG_ONSWAP)

#define pagedout(s)	(((ulong)s)==0 || onswap(s))

#define swapaddr(s)	(((ulong)s)&~PG_ONSWAP)

#define SEGMAXSIZE	(SEGMAPSIZE*PTEMAPMEM)

struct Physseg

{

	ulong	attr;			/* Segment attributes */

	char	*name;			/* Attach name */

	ulong	pa;			/* Physical address */

	ulong	size;			/* Maximum segment size in pages */

	Page	*(*pgalloc)(Segment*, ulong);	/* Allocation if we need it */

	void	(*pgfree)(Page*);

};

struct Sema

{

	Rendez;

	long	*addr;

	int	waiting;

	Sema	*next;

	Sema	*prev;

};

struct Segment

{

	Ref;

	QLock	lk;

	ushort	steal;		/* Page stealer lock */

	ushort	type;		/* segment type */

	ulong	base;		/* virtual base */

	ulong	top;		/* virtual top */

	ulong	size;		/* size in pages */

	ulong	fstart;		/* start address in file for demand load */

	ulong	flen;		/* length of segment in file */

	int	flushme;	/* maintain icache for this segment */

	Image	*image;		/* text in file attached to this segment */

	Physseg *pseg;

	ulong*	profile;	/* Tick profile area */

	Pte	**map;

	int	mapsize;

	Pte	*ssegmap[SSEGMAPSIZE];

	Lock	semalock;

	Sema	sema;

	ulong	mark;		/* portcountrefs */

};

enum

{

	RENDLOG	=	5,

	RENDHASH =	1<<RENDLOG,	/* Hash to lookup rendezvous tags */

	MNTLOG	=	5,

	MNTHASH =	1<<MNTLOG,	/* Hash to walk mount table */

	NFD =		100,		/* per process file descriptors */

	PGHLOG  =	9,

	PGHSIZE	=	1<<PGHLOG,	/* Page hash for image lookup */

};

#define REND(p,s)	((p)->rendhash[(s)&((1<<RENDLOG)-1)])

#define MOUNTH(p,qid)	((p)->mnthash[(qid).path&((1<<MNTLOG)-1)])

struct Pgrp

{

	Ref;				/* also used as a lock when mounting */

	int	noattach;

	ulong	pgrpid;

	QLock	debug;			/* single access via devproc.c */

	RWlock	ns;			/* Namespace n read/one write lock */

	Mhead	*mnthash[MNTHASH];

};

struct Rgrp

{

	Ref;				/* the Ref's lock is also the Rgrp's lock */

	Proc	*rendhash[RENDHASH];	/* Rendezvous tag hash */

};

struct Egrp

{

	Ref;

	RWlock;

	Evalue	**ent;

	int	nent;

	int	ment;

	ulong	path;	/* qid.path of next Evalue to be allocated */

	ulong	vers;	/* of Egrp */

};

struct Evalue

{

	char	*name;

	char	*value;

	int	len;

	Evalue	*link;

	Qid	qid;

};

struct Fgrp

{

	Ref;

	Chan	**fd;

	int	nfd;			/* number allocated */

	int	maxfd;			/* highest fd in use */

	int	exceed;			/* debugging */

};

enum

{

	DELTAFD	= 20		/* incremental increase in Fgrp.fd's */

};

struct Pallocmem

{

	ulong base;

	ulong npage;

};

struct Palloc

{

	Lock;

	Pallocmem	mem[4];

	Page	*head;			/* most recently used */

	Page	*tail;			/* least recently used */

	ulong	freecount;		/* how many pages on free list now */

	Page	*pages;			/* array of all pages */

	ulong	user;			/* how many user pages */

	Page	*hash[PGHSIZE];

	Lock	hashlock;

	Rendez	r;			/* Sleep for free mem */

	QLock	pwait;			/* Queue of procs waiting for memory */

};

struct Waitq

{

	Waitmsg	w;

	Waitq	*next;

};

/*

 * fasttick timer interrupts

 */

enum {

	/* Mode */

	Trelative,	/* timer programmed in ns from now */

	Tperiodic,	/* periodic timer, period in ns */

};

struct Timer

{

	/* Public interface */

	int	tmode;		/* See above */

	vlong	tns;		/* meaning defined by mode */

	void	(*tf)(Ureg*, Timer*);

	void	*ta;

	/* Internal */

	Lock;

	Timers	*tt;		/* Timers queue this timer runs on */

	Tval	tticks;		/* tns converted to ticks */

	Tval	twhen;		/* ns represented in fastticks */

	Timer	*tnext;

};

enum

{

	RFNAMEG		= (1<<0),

	RFENVG		= (1<<1),

	RFFDG		= (1<<2),

	RFNOTEG		= (1<<3),

	RFPROC		= (1<<4),

	RFMEM		= (1<<5),

	RFNOWAIT	= (1<<6),

	RFCNAMEG	= (1<<10),

	RFCENVG		= (1<<11),

	RFCFDG		= (1<<12),

	RFREND		= (1<<13),

	RFNOMNT		= (1<<14),

};

/*

 *  process memory segments - NSEG always last !

 */

enum

{

	SSEG, TSEG, DSEG, BSEG, ESEG, LSEG, SEG1, SEG2, SEG3, SEG4, NSEG

};

enum

{

	Dead = 0,		/* Process states */

	Moribund,

	Ready,

	Scheding,

	Running,

	Queueing,

	QueueingR,

	QueueingW,

	Wakeme,

	Broken,

	Stopped,

	Rendezvous,

	Waitrelease,

	Proc_stopme = 1, 	/* devproc requests */

	Proc_exitme,

	Proc_traceme,

	Proc_exitbig,

	Proc_tracesyscall,

	TUser = 0, 		/* Proc.time */

	TSys,

	TReal,

	TCUser,

	TCSys,

	TCReal,

	NERR = 64,

	NNOTE = 5,

	Npriq		= 20,		/* number of scheduler priority levels */

	Nrq		= Npriq+2,	/* number of priority levels including real time */

	PriRelease	= Npriq,	/* released edf processes */

	PriEdf		= Npriq+1,	/* active edf processes */

	PriNormal	= 10,		/* base priority for normal processes */

	PriExtra	= Npriq-1,	/* edf processes at high best-effort pri */

	PriKproc	= 13,		/* base priority for kernel processes */

	PriRoot		= 13,		/* base priority for root processes */

};

struct Schedq

{

	Lock;

	Proc*	head;

	Proc*	tail;

	int	n;

};

struct Proc

{

	Label	sched;		/* known to l.s */

	char	*kstack;	/* known to l.s */

	Mach	*mach;		/* machine running this proc */

	char	*text;

	char	*user;

	char	*args;

	int	nargs;		/* number of bytes of args */

	Proc	*rnext;		/* next process in run queue */

	Proc	*qnext;		/* next process on queue for a QLock */

	QLock	*qlock;		/* addr of qlock being queued for DEBUG */

	int	state;

	char	*psstate;	/* What /proc/#/status reports */

	Segment	*seg[NSEG];

	QLock	seglock;	/* locked whenever seg[] changes */

	ulong	pid;

	ulong	noteid;		/* Equivalent of note group */

	Proc	*pidhash;	/* next proc in pid hash */

	Lock	exl;		/* Lock count and waitq */

	Waitq	*waitq;		/* Exited processes wait children */

	int	nchild;		/* Number of living children */

	int	nwait;		/* Number of uncollected wait records */

	QLock	qwaitr;

	Rendez	waitr;		/* Place to hang out in wait */

	Proc	*parent;

	Pgrp	*pgrp;		/* Process group for namespace */

	Egrp 	*egrp;		/* Environment group */

	Fgrp	*fgrp;		/* File descriptor group */

	Rgrp	*rgrp;		/* Rendez group */

	Fgrp	*closingfgrp;	/* used during teardown */

	ulong	parentpid;

	ulong	time[6];	/* User, Sys, Real; child U, S, R */

	uvlong	kentry;		/* Kernel entry time stamp (for profiling) */

	/*

	 * pcycles: cycles spent in this process (updated on procsave/restore)

	 * when this is the current proc and we're in the kernel

	 * (procrestores outnumber procsaves by one)

	 * the number of cycles spent in the proc is pcycles + cycles()

	 * when this is not the current process or we're in user mode

	 * (procrestores and procsaves balance), it is pcycles.

	 */

	vlong	pcycles;

	int	insyscall;

	int	fpstate;

	QLock	debug;		/* to access debugging elements of User */

	Proc	*pdbg;		/* the debugging process */

	ulong	procmode;	/* proc device default file mode */

	ulong	privatemem;	/* proc does not let anyone read mem */

	int	hang;		/* hang at next exec for debug */

	int	procctl;	/* Control for /proc debugging */

	ulong	pc;		/* DEBUG only */

	Lock	rlock;		/* sync sleep/wakeup with postnote */

	Rendez	*r;		/* rendezvous point slept on */

	Rendez	sleep;		/* place for syssleep/debug */

	int	notepending;	/* note issued but not acted on */

	int	kp;		/* true if a kernel process */

	Proc	*palarm;	/* Next alarm time */

	ulong	alarm;		/* Time of call */

	int	newtlb;		/* Pager has changed my pte's, I must flush */

	int	noswap;		/* process is not swappable */

	uintptr	rendtag;	/* Tag for rendezvous */

	uintptr	rendval;	/* Value for rendezvous */

	Proc	*rendhash;	/* Hash list for tag values */

	Timer;			/* For tsleep and real-time */

	Rendez	*trend;

	int	(*tfn)(void*);

	void	(*kpfun)(void*);

	void	*kparg;

	FPsave	fpsave;		/* address of this is known by db */

	int	scallnr;	/* sys call number - known by db */

	Sargs	s;		/* address of this is known by db */

	int	nerrlab;

	Label	errlab[NERR];

	char	*syserrstr;	/* last error from a system call, errbuf0 or 1 */

	char	*errstr;	/* reason we're unwinding the error stack, errbuf1 or 0 */

	char	errbuf0[ERRMAX];

	char	errbuf1[ERRMAX];

	char	genbuf[128];	/* buffer used e.g. for last name element from namec */

	Chan	*slash;

	Chan	*dot;

	Note	note[NNOTE];

	short	nnote;

	short	notified;	/* sysnoted is due */

	Note	lastnote;

	int	(*notify)(void*, char*);

	Lock	*lockwait;

	Lock	*lastlock;	/* debugging */

	Lock	*lastilock;	/* debugging */

	Mach	*wired;

	Mach	*mp;		/* machine this process last ran on */

	Ref	nlocks;		/* number of locks held by proc */

	ulong	delaysched;

	ulong	priority;	/* priority level */

	ulong	basepri;	/* base priority level */

	uchar	fixedpri;	/* priority level deson't change */

	ulong	cpu;		/* cpu average */

	ulong	lastupdate;

	uchar	yield;		/* non-zero if the process just did a sleep(0) */

	ulong	readytime;	/* time process came ready */

	ulong	movetime;	/* last time process switched processors */

	int	preempted;	/* true if this process hasn't finished the interrupt

				 *  that last preempted it

				 */

	Edf	*edf;		/* if non-null, real-time proc, edf contains scheduling params */

	int	trace;		/* process being traced? */

	ulong	qpc;		/* pc calling last blocking qlock */

	int	setargs;

	void	*ureg;		/* User registers for notes */

	void	*dbgreg;	/* User registers for devproc */

	Notsave;

	/*

	 *  machine specific MMU

	 */

	PMMU;

	char	*syscalltrace;	/* syscall trace */

};

enum

{

	PRINTSIZE =	256,

	MAXCRYPT = 	127,

	NUMSIZE	=	12,		/* size of formatted number */

	MB =		(1024*1024),

	/* READSTR was 1000, which is way too small for usb's ctl file */

	READSTR =	4000,		/* temporary buffer size for device reads */

};

struct Execvals {

	uvlong	entry;

	ulong	textsize;

	ulong	datasize;

};

extern	Conf	conf;

extern	char*	conffile;

extern	int	cpuserver;

extern	Dev*	devtab[];

extern	char*	eve;

extern	char	hostdomain[];

extern	uchar	initcode[];

extern	int	kbdbuttons;

extern	Queue*	kbdq;

extern	Queue*	kprintoq;

extern 	Ref	noteidalloc;

extern	int	nsyscall;

extern	Palloc	palloc;

	int	(*parseboothdr)(Chan *, ulong, Execvals *);

extern	Queue*	serialoq;

extern	char*	statename[];

extern	Image	swapimage;

extern	char*	sysname;

extern	uint	qiomaxatomic;

extern	char*	sysctab[];

	Watchdog*watchdog;