xref: /plan9/sys/src/cmd/aux/flashfs/request.c (revision 9a747e4fd48b9f4522c70c07e8f882a15030f964)

#include <u.h>
#include <libc.h>
#include <auth.h>
#include <fcall.h>
#include <thread.h>
#include <9p.h>
#include "flashfs.h"

static	Srv	flashsrv;

typedef struct	State	State;

struct State
{
	Entry	*e;
	Dirr	*r;
};

#define	writeable(e)	((e)->mode & 0222)

static State *
state(Entry *e)
{
	State *s;

	s = emalloc9p(sizeof(State));
	s->e = e;
	s->r = nil;
	return s;
}

static void
destroy(Fid *f)
{
	State *s;

	s = f->aux;
	if(s == nil)		/* Tauth fids have no state */
		return;

	f->aux = nil;
	if(s->e)
		edestroy(s->e);
	if(s->r)
		edirclose(s->r);
	free(s);
}

static void
trace(Req *)
{
	edump();
}

/** T_ **/

static void
flattach(Req *r)
{
	root->ref++;
	r->ofcall.qid = eqid(root);
	r->fid->qid = r->ofcall.qid;
	r->fid->aux = state(root);
	respond(r, nil);
}

static void
flopen(Req *r)
{
	Jrec j;
	int m, p;
	Entry *e;
	State *s;
	char *err;

	s = r->fid->aux;
	e = s->e;
	m = e->mode;
	m = (m | (m >> 3) | (m >> 6)) & 7;
	switch(r->ifcall.mode & 3) {
	case OREAD:
		p = AREAD;
		break;
	case OWRITE:
		p = AWRITE;
		break;
	case ORDWR:
		p = AREAD|AWRITE;
		break;
	case OEXEC:
		p = AEXEC;
		break;
	default:
		p = 0;
		break;
	}

	if((p & m) != p) {
		respond(r, Eperm);
		return;
	}

	if(readonly && (p & AWRITE) != 0) {
		respond(r, Erofs);
		return;
	}

	r->ofcall.qid = eqid(e);
	if(r->ofcall.qid.type & QTDIR) {
		if((p & AWRITE) != 0) {
			respond(r, Eisdir);
			return;
		}
		s->r = ediropen(s->e);
	}
	else if(r->ifcall.mode & OTRUNC) {
		err = need(Ntrunc);
		if(err != nil) {
			respond(r, err);
			return;
		}
		j.type = FT_trunc;
		j.tnum = e->fnum;
		j.mtime = now();
		etrunc(e, 0, j.mtime);
		j.fnum = e->fnum;
		j.parent = e->parent->fnum;
		j.mode = e->mode;
		strcpy(j.name, e->name);
		put(&j, 1);
	}

	respond(r, nil);
}

static void
flcreate(Req *r)
{
	Jrec j;
	State *s;
	char *err;
	Entry *e, *f;

	if(readonly) {
		respond(r, Erofs);
		return;
	}

	s = r->fid->aux;
	e = s->e;
	if((e->mode & DMDIR) == 0) {
		respond(r, Eisdir);
		return;
	}

	if(!writeable(e)) {
		respond(r, Eperm);
		return;
	}

	if(strlen(r->ifcall.name) > MAXNSIZE) {
		respond(r, "filename too long");
		return;
	}

	err = need(Ncreate);
	if(err != nil) {
		respond(r, err);
		return;
	}

	j.type = FT_create;
	j.mtime = now();
	j.parent = e->fnum;
	j.mode = r->ifcall.perm;
	strcpy(j.name, r->ifcall.name);

	f = ecreate(e, r->ifcall.name, 0, r->ifcall.perm, j.mtime, &err);
	if(f == nil) {
		respond(r, err);
		return;
	}

	j.fnum = f->fnum;
	put(&j, 1);
	s->e = f;
	r->ofcall.qid = eqid(f);
	respond(r, nil);
}

static void
flread(Req *r)
{
	Entry *e;
	State *s;

	s = r->fid->aux;
	e = s->e;

	if(e->mode & DMDIR)
		r->ofcall.count = edirread(s->r, r->ofcall.data, r->ifcall.count);
	else
		r->ofcall.count = eread(e, eparity, r->ofcall.data, r->ifcall.count, r->ifcall.offset);

	respond(r, nil);
}

static void
flwrite(Req *r)
{
	Jrec j;
	uchar *a;
	Entry *e;
	State *s;
	Extent *x;
	char *err;
	ulong c, n, o, mtime;

	c = r->ifcall.count;
	o = r->ifcall.offset;
	a = (uchar *)r->ifcall.data;

	if(c == 0) {
		respond(r, nil);
		return;
	}

	if(o + c >= MAXFSIZE) {
		respond(r, "file too big");
		return;
	}

	if(used + c > limit) {
		respond(r, "filesystem full");
		return;
	}

	r->ofcall.count = c;
	s = r->fid->aux;
	e = s->e;
	mtime = now();

	for(;;) {
		n = c;
		if(n > maxwrite)
			n = maxwrite;

		err = need(Nwrite + n);
		if(err != nil) {
			respond(r, err);
			return;
		}

		x = emalloc9p(sizeof(Extent));
		x->size = n;
		x->off = o;
		ewrite(e, x, eparity, mtime);
		j.type = FT_WRITE;
		j.fnum = e->fnum;
		j.size = n;
		j.offset = o;
		j.mtime = mtime;
		putw(&j, 1, x, a);
		c -= n;

		if(c == 0)
			break;

		o += n;
		a += n;
	}

	respond(r, nil);
}

static void
flremove(Req *r)
{
	Jrec j;
	State *s;
	Entry *e;
	char *d, *err;

	if(readonly) {
		respond(r, Erofs);
		return;
	}

	s = r->fid->aux;
	e = s->e;
	if(writeable(e->parent)) {
		err = need(Nremove);
		if(err != nil) {
			respond(r, err);
			return;
		}

		d = eremove(e);
		if(d == nil) {
			j.type = FT_REMOVE;
			j.fnum = e->fnum;
			put(&j, 0);
		}
		respond(r, d);
	}
	else
		respond(r, Eperm);
}

static void
flstat(Req *r)
{
	State *s;

	s = r->fid->aux;
	estat(s->e, &r->d, 1);
	respond(r, nil);
}

static void
flwstat(Req *r)
{
	int m;
	Jrec j;
	State *s;
	Entry *e;
	char *err;

	s = r->fid->aux;
	e = s->e;

	if(readonly) {
		respond(r, Erofs);
		return;
	}

	if(e->fnum == 0) {
		respond(r, Eperm);
		return;
	}

	m = r->d.mode & 0777;
	if(m != (e->mode & 0777)) {
		err = need(Nchmod);
		if(err != nil) {
			respond(r, err);
			return;
		}

		echmod(e, m, 0);
		j.type = FT_chmod;
		j.mode = m;
		j.fnum = e->fnum;
		j.mnum = e->mnum;
		put(&j, 0);
	}
	respond(r, nil);
}

static void
flwalk(Req *r)
{
	int i;
	State *s;
	char *err;
	Entry *e, *f;

	if(r->ifcall.fid != r->ifcall.newfid)
		r->newfid->aux = state(nil);

	s = r->fid->aux;
	e = s->e;
	f = e;
	e->ref++;
	err = nil;
	for(i = 0; i < r->ifcall.nwname; i++) {
		f = ewalk(e, r->ifcall.wname[i], &err);
		if(f) {
			r->ofcall.wqid[i] = eqid(f);
			e = f;
		}
		else {
			e->ref--;
			break;
		}
	}
	r->ofcall.nwqid = i;
	if (i) err = nil;

	if(f) {
		if(r->ifcall.fid != r->ifcall.newfid) {
			s = r->newfid->aux;
			s->e = f;
			r->newfid->qid = eqid(f);
		}
		else {
			s = r->fid->aux;
			s->e->ref--;
			s->e = f;
			r->fid->qid = eqid(f);
		}
	}
	respond(r, err);
}

void
serve(char *mount)
{
	flashsrv.attach = flattach;
	flashsrv.open = flopen;
	flashsrv.create = flcreate;
	flashsrv.read = flread;
	flashsrv.write = flwrite;
	flashsrv.remove = flremove;
	flashsrv.stat = flstat;
	flashsrv.wstat = flwstat;
	flashsrv.walk = flwalk;

	flashsrv.destroyfid = destroy;
	flashsrv.destroyreq = trace;
	postmountsrv(&flashsrv, "brzr", mount, MREPL|MCREATE);
}