Subversion Repositories planix.SVN

#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);

}