Subversion Repositories planix.SVN

/*

 * stubs to make bootstrap kernels link, copies of a few functions

 * to avoid including system calls yet have access to i/o functions,

 * and some convenience routines.

 */

#include	"u.h"

#include	"../port/lib.h"

#include	"mem.h"

#include	"dat.h"

#include	"fns.h"

#include	"../port/error.h"

void (*proctrace)(Proc*, int, vlong);

/* devmnt.c */

void

muxclose(Mnt *)

{

}

Chan*

mntauth(Chan *, char *)

{

	return nil;

}

long

mntversion(Chan *, char *, int, int)

{

	return 0;

}

/* swap.c */

Image swapimage;

void

putswap(Page *)

{

}

void

dupswap(Page *)

{

}

void

kickpager(void)

{

}

int

swapcount(ulong)

{

	return 0;

}

void

pagersummary(void)

{

}

void

setswapchan(Chan *)

{

}

/* devenv.c */

void

closeegrp(Egrp *)

{

}

void

ksetenv(char *, char *, int)

{

}

/* devproc.c */

Segment*

data2txt(Segment *s)

{

	Segment *ps;

	ps = newseg(SG_TEXT, s->base, s->size);

	ps->image = s->image;

	incref(ps->image);

	ps->fstart = s->fstart;

	ps->flen = s->flen;

	ps->flushme = 1;

	return ps;

}

/* sysproc.c */

int

return0(void*)

{

	return 0;

}

/* syscallfmt.c */

void

syscallfmt(int, ulong, va_list)

{

}

void

sysretfmt(int, va_list, long, uvlong, uvlong)

{

}

/* sysfile.c */

int

newfd(Chan *)

{

	return -1;

}

void

validstat(uchar *s, int n)

{

	int m;

	char buf[64];

	if(statcheck(s, n) < 0)

		error(Ebadstat);

	/* verify that name entry is acceptable */

	s += STATFIXLEN - 4*BIT16SZ;	/* location of first string */

	/*

	 * s now points at count for first string.

	 * if it's too long, let the server decide; this is

	 * only for his protection anyway. otherwise

	 * we'd have to allocate and waserror.

	 */

	m = GBIT16(s);

	s += BIT16SZ;

	if(m+1 > sizeof buf)

		return;

	memmove(buf, s, m);

	buf[m] = '\0';

	/* name could be '/' */

	if(strcmp(buf, "/") != 0)

		validname(buf, 0);

}

Chan*

fdtochan(int fd, int mode, int chkmnt, int iref)

{

	Chan *c;

	Fgrp *f;

	c = 0;

	f = up->fgrp;

	lock(f);

	if(fd<0 || f->nfd<=fd || (c = f->fd[fd])==0) {

		unlock(f);

		error(Ebadfd);

	}

	if(iref)

		incref(c);

	unlock(f);

	if(chkmnt && (c->flag&CMSG)) {

		if(iref)

			cclose(c);

		error(Ebadusefd);

	}

	if(mode<0 || c->mode==ORDWR)

		return c;

	if((mode&OTRUNC) && c->mode==OREAD) {

		if(iref)

			cclose(c);

		error(Ebadusefd);

	}

	if((mode&~OTRUNC) != c->mode) {

		if(iref)

			cclose(c);

		error(Ebadusefd);

	}

	return c;

}

int

openmode(ulong o)

{

	o &= ~(OTRUNC|OCEXEC|ORCLOSE);

	if(o > OEXEC)

		error(Ebadarg);

	if(o == OEXEC)

		return OREAD;

	return o;

}

int

bind(char *old, char *new, int flag)

{

	int ret;

	Chan *c0, *c1;

	if((flag&~MMASK) || (flag&MORDER)==(MBEFORE|MAFTER))

		error(Ebadarg);

	c0 = namec(old, Abind, 0, 0);

	if(waserror()){

		cclose(c0);

		return -1;

	}

	c1 = namec(new, Amount, 0, 0);

	if(waserror()){

		cclose(c1);

		nexterror();

	}

	ret = cmount(&c0, c1, flag, nil);

	poperror();

	cclose(c1);

	poperror();

	cclose(c0);

	return ret;

}

long

unmount(char *name, char *old)

{

	Chan *cmount, *cmounted;

	cmounted = 0;

	cmount = namec(old, Amount, 0, 0);

	if(waserror()) {

		cclose(cmount);

		if(cmounted)

			cclose(cmounted);

		return -1;

	}

	if(name)

		/*

		 * This has to be namec(..., Aopen, ...) because

		 * if name is something like /srv/cs or /fd/0,

		 * opening it is the only way to get at the real

		 * Chan underneath.

		 */

		cmounted = namec(name, Aopen, OREAD, 0);

	cunmount(cmount, cmounted);

	poperror();

	cclose(cmount);

	if(cmounted)

		cclose(cmounted);

	return 0;

}

long

chdir(char *dir)

{

	Chan *c;

	if (waserror())

		return -1;

	c = namec(dir, Atodir, 0, 0);

	if (up->dot)

		cclose(up->dot);

	up->dot = c;

	poperror();

	return 0;

}

Chan *

namecopen(char *name, int mode)

{

	Chan *c;

	if (waserror())

		return nil;

	c = namec(name, Aopen, mode, 0);

	poperror();

	return c;

}

Chan *

enamecopen(char *name, int mode)

{

	Chan *c;

	c = namecopen(name, mode);

	if (c == nil)

		panic("can't open %s", name);

	return c;

}

Chan *

nameccreate(char *name, int mode)

{

	Chan *c;

	if (waserror())

		return nil;

	c = namec(name, Acreate, mode, 0);

	poperror();

	return c;

}

Chan *

enameccreate(char *name, int mode)

{

	Chan *c;

	c = nameccreate(name, mode);

	if (c == nil)

		panic("can't create %s", name);

	return c;

}

int

myreadn(Chan *c, void *vp, long n)

{

	char *p = vp;

	long nn;

	while(n > 0) {

		nn = devtab[c->type]->read(c, p, n, c->offset);

		if(nn == 0)

			break;

		c->offset += nn;

		p += nn;

		n -= nn;

	}

	return p - (char *)vp;

}

int

readfile(char *file, void *buf, int len)

{

	int n;

	Chan *cc;

	cc = nil;

	if (waserror()) {

		if (cc)

			cclose(cc);

		return -1;

	}

	cc = namecopen(file, OREAD);

	if (cc == nil)

		error("no such file");

	n = myreadn(cc, buf, len);

	poperror();

	cclose(cc);

	return n;

}

static int

dumpfile(char *file)

{

	int n;

	char *buf;

	buf = smalloc(Maxfile + 1);

	n = readfile(file, buf, Maxfile);

	if (n < 0)

		return -1;

	buf[n] = 0;

	print("%s (%d bytes):\n", file, n);

	print("%s\n", buf);

	free(buf);

	return 0;

}

/* main.c */

void

fpx87restore(FPsave*)

{

}

void

fpx87save(FPsave*)

{

}

void

fpssesave(FPsave *)

{

}

void

fpsserestore(FPsave *)

{

}

ulong

l2be(long l)

{

	uchar *cp;

	cp = (uchar*)&l;

	return (cp[0]<<24) | (cp[1]<<16) | (cp[2]<<8) | cp[3];

}