Plan 9 from Bell Labs’s /usr/web/sources/contrib/quanstro/root/sys/src/fs/port/portfns.h

Copyright © 2021 Plan 9 Foundation.
Distributed under the MIT License.
Download the Plan 9 distribution.

void	accessdir(Iobuf*, Dentry*, int, int);
void	addfree(Device*, Off, Superb*);
void	arpstart(void);
void	apcinit(void);
void	arginit(void);
void	atexit(void (*)(void*), void*);
char*	authaname(Auth*);
void	authinit(void);
void	authfree(Auth*);
Auth*	authnew(char*, char*);
int	authread(File*, uchar*, int);
int	authuid(Auth*);
char*	authuname(Auth*);
int	authwrite(File*, uchar*, int);
Off	byteio(Device*, int, uvlong, ulong, void*);
void	cdiag(char*, int);
Device*	config(void);
void	cpuidentify(void);
int	rawchar(int);
Off	bufalloc(Device*, int, long, int);
void	buffree(Device*, Off, int, Truncstate *);
int	byuid(void*, void*);
int	canlock(Lock*);
int	canqlock(QLock*);
int	cecgetc(void);
void	cecinit(void);
void	cecputs(char*, int);
void	cfsdump(Filsys*);
Chan*	chaninit(int, int, int);
void	cmd_check(int, char*[]);
void	cmd_devcopy(int, char*[]);
void	cmd_users(int, char*[]);
void	cmd_newuser(int, char*[]);
void	cmd_netdb(int, char*[]);
void	cmd_passwd(int, char*[]);
void	cmd_printconf(int, char*[]);
void	cmd_rawcopy(int, char*[]);
void	cmd_writeconf(int, char*[]);
int	checkname(char*);
int	checktag(Iobuf*, int, Off);
void	clock(Timet, ulong);
void	clockinit(void);
void	clockreload(Timet);
void	devcopyproc(void);
Device*	devstr(char*);
void	dotrace(int);
int	conschar(void);
void	consinit(void (*)(char*, int));
void	consreset(void);
void	consstart(int);
int	(*consgetc)(void);
void	(*consputc)(int);
void	(*consputs)(char*, int);
void	consserve(void);
int	conslock(void);
int	con_attach(int, char*, char*);
int	con_clone(int, int);
int	con_create(int, char*, int, int, long, int);
int	con_clri(int);
int	con_fstat(int);
int	con_open(int, int);
int	con_read(int, char*, Off, int);
int	con_remove(int);
void	con_rintr(int);
int	con_session(void);
int	con_walk(int, char*);
int	con_write(int, char*, Off, int);
int	cwgrow(Device*, Superb*, int);
int	cwfree(Device*, Off);
void	cwinit(Device*);
Off	cwraddr(Device*);
int	cwread(Device*, Off, void*);
void	cwream(Device*, int);
void	cwrecover(Device*);
Off	cwsaddr(Device*);
Devsize	cwsize(Device*);
int	cwwrite(Device*, Off, void*);
void	datestr(char*, Timet);
Off	dbufread(Iobuf*, Dentry*, Off, Off, int);
void	delay(int);
int	devcmpr(Device*, Device*);
void	devream(Device*, int);
void	devrecover(Device*);
void	devinit(Device*);
int	devread(Device*, Off, void*);
int	devsecsize(Device*);
Devsize	devsize(Device*);
int	devwrite(Device*, Off, void*);
Iobuf*	dnodebuf(Iobuf*, Dentry*, Off, int, int);
Iobuf*	dnodebuf1(Iobuf*, Dentry*, Off, int, int);
void	dofilter(Filter*);
int	doremove(File*);
void	dtrunc(Iobuf*, Dentry*, int);
int	dtrunclen(Iobuf *p, Dentry *, Off newsize, int uid);
int	dumpblock(Device*);
void	dumpregs(Ureg*);
void	dumpstack(User*);
void	exit(void);
Float	famd(Float, int, int, int);
ulong	fdf(Float, int);
void	fileinit(Chan*);
File*	filep(Chan*, ulong, int);
void	firmware(void);
int	fname(char*);
void	formatinit(void);
void	freefp(File*);
void	freewp(Wpath*);
Filsys*	fsstr(char*);
Devsize	fwormsize(Device*);
void	fwormream(Device*, int);
void	fworminit(Device*);
int	fwormread(Device*, Off, void*);
int	fwormwrite(Device*, Off, void*);
char*	getauthlist(void);
Iobuf*	getbuf(Device*, Off, int);
char*	getwd(char*, char*);
int	getc(void);
ulong	getcallerpc(void*);
Dentry*	getdir(Iobuf*, int);
Chan*	getlcp(uchar*, long);
Off	getraddr(Device*);
void	getstring(char*, int, int);
void	gotolabel(Label*);
void	hexdump(void*, int);
int	iaccess(File*, Dentry*, int);
void*	ialloc(ulong, int);
void	ilock(Lock*);
void	iunlock(Lock*);
Off	indfetch(Device*, Off, Off, Off , int, int, int);
int	ingroup(int, int);
int	inh(int, uchar*);
void	init0(void);
void	iobufinit(void);
void*	iobufmap(Iobuf*);
void	iobufunmap(Iobuf*);
int	iobufql(QLock*);
int	jukeread(Device*, Off, void*);
int	jukewrite(Device*, Off, void*);
void	jukeinit(Device*);
void	jukerecover(Device*);
Off	jukesaddr(Device*);
Devsize	jukesize(Device*);
void	kbdchar(int);
void	lights(int, int);
void	launchinit(void);
void	localconfinit(void);
int	leadgroup(int, int);
void	lock(Lock*);
void	lockinit(void);
void	machinit(void);
Msgbuf*	mballoc(int, Chan*, int);
void	mballocpool(int, int, int, int, void (*)(Msgbuf*));
void	mbinit(void);
void	mbfree(Msgbuf*);
ulong	meminit(void);
Iobuf*	movebuf(Iobuf*);
void	mcatinit(Device*);
int	mcatread(Device*, Off, void*);
Devsize	mcatsize(Device*);
int	mcatwrite(Device*, Off, void*);
void	mirrinit(Device*);
int	mirrread(Device*, Off, void*);
Devsize	mirrsize(Device*);
int	mirrwrite(Device*, Off, void*);
void	mkqid(Qid*, Dentry*, int);
int	mkqidcmp(Qid*, Dentry*);
void	mkqid9p1(Qid9p1*, Qid*);
void	mkqid9p2(Qid*, Qid9p1*, int);
void	mlevinit(Device*);
int	mlevread(Device*, Off, void*);
Devsize	mlevsize(Device*);
int	mlevwrite(Device*, Off, void*);
void	mwormream(Device*, int);
int	nametokey(char*, char*);
File*	newfp(void);
User*	newproc(void);
Queue*	newqueue(int);
Wpath*	newwp(void);
Auth*	newauth(void);
int	nvrcheck(void);
int	nvread(int, void*, int);
char*	nvrgetconfig(void);
int	nvrsetconfig(char*);
int	nvwrite(int, void*, int);
int	walkto(char*);
int	no(void*);
vlong	number(char*, int, int);
void	online(void);
void	otherinit(void);
void	panic(char*, ...);
void	partinit(Device*);
int	partread(Device*, Off, void*);
void	partream(Device*, int);
Devsize	partsize(Device*);
int	partwrite(Device*, Off, void*);
void	prdate(void);
void	preread(Device*, Off);
void	prflush(void);
void	printlocks(User*);
int	prime(vlong);
void	printinit(void);
void	procinit(void);
void	profinit(void);
void	putbuf(Iobuf*);
void	putstrn(char *str, int n);
Off	qidpathgen(Device*);
void	qlock(QLock*);
void	qunlock(QLock*);
void	rahead(void);
void	raheadsort(void);
void	ready(User*);
void	rawcopyproc(void);
void	ream(Filsys*);
void*	recv(Queue*, int);
void	rlock(RWlock*);
void	rootream(Device*, Off);
int	roread(Device*, Off, void*);
void	roinit(Device*);
int	rowrite(Device*, Off, void*);
Timet	rtc2sec(Rtc *);
void	runlock(RWlock*);
User*	runproc(void);
void	sched(void);
void	schedinit(void);
int	scsiio(Device*, int, uchar*, int, void*, int);
void	sec2rtc(Timet, Rtc *);
void	send(Queue*, void*);
void	serve(void);
int	serve9p(Msgbuf*);
int	setlabel(Label*);
void	settag(Iobuf*, int, long);
void	settime(Timet);
void	sleep(Rendez*, int(*)(void*), void*);
void	sntpinit(void);
int	splhi(void);
int	spllo(void);
void	splx(int);
int	strtouid(char*);
int	strtoipflag(char*);
Off	superaddr(Device*);
void	superream(Device*, Off);
void	swab(void*, int);
void	swabinit(Device*);
Off	swabraddr(Device*);
int	swabread(Device *, Off, void*);
void	swabream(Device*,int);
void	swabrecover(Device*);
Devsize	swabsize(Device*);
Off	swabsuper(Device*);
int	swabwrite(Device*, Off, void*);
void	sync(char*);
int	syncblock(void);
long	syscall(Ureg*);
void	sysinit(void);
int	Tfmt(Fmt*);
Timet	time(void);
Timet	nextime(Timet, int, int);
Tlock*	tlocked(Iobuf*, Dentry*);
void	tsleep(Rendez*, int(*)(void*), void*, int);
void	touser(void);
Timet	toytime(void);
Timet	rtctime(void);
void	setrtc(Timet);
void	uidtostr(char*, int, int);
Uid*	uidpstr(char*);
void	unlock(Lock*);
void	userinit(void(*)(void), void*, char*);
void	vecinit(void);
void	wakeup(Rendez*);
void	wbflush(void);
void	wlock(RWlock*);
void	wormcopy(void);
void	wormprobe(void);
void	synccopy(void);
#define waitmsec(ms)	tsleep(&u->tsleep, no, 0, ms)
int	wormread(Device*, Off, void*);
Devsize	wormsize(Device*);
Devsize	wormsizeside(Device *, int side);
void	wormsidestarts(Device *dev, int side, Sidestarts *stp);
int	wormwrite(Device*, Off, void*);
void	wreninit(Device*);
int	wrenread(Device*, Off, void*);
Devsize	wrensize(Device*);
int	wrenwrite(Device*, Off, void*);
void	wunlock(RWlock*);
void 	cmd_exec(char*);
void	cmd_install(char*, char*, void (*)(int, char*[]));
ulong	flag_install(char*, char*);

int	chartoea(uchar*, char*);
int	chartoip(uchar*, char*);
int	isvalidip(uchar*);

int	nhgets(uchar*);
long	nhgetl(uchar*);
void	hnputs(uchar*, int);
void	hnputl(uchar*, long);

vlong	strtoll(char *, char **, int);
uvlong	strtoull(char *, char **, int);
ulong	strtoul(char*, char**, int);

Bell Labs OSI certified Powered by Plan 9

(Return to Plan 9 Home Page)

Copyright © 2021 Plan 9 Foundation. All Rights Reserved.
Comments to