/*
 * 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];
}