/*
 * Copyright (c) 2013, Coraid, Inc.
 * All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of Coraid nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 * 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL CORAID BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/*
 * Adapted by Brian L. Stuart from:
 *
 * vblade — virtual aoe target
 * copyright © 2007—2013 erik quanstrom
 */

#include <u.h>
#include <libc.h>
#include <thread.h>
#include <ip.h>			/* irony */
#include <fis.h>
#include <fcall.h>
#include <9p.h>

enum {
	Eaddrlen	= 6,		/* only defined in kernel */
};
#include "aoe.h"

#include "dat.h"

enum {
	Fclone,
	Fdata,
	Flast,

	Nether	= 8,
	Nvblade	= 16,
	Nmask	= 10,
	Nmaxout= 128,
	Maxpkt	= 10000,
	Conflen	= 1024,
};

typedef	struct	Vblade	Vblade;

struct Vblade {
	vlong	maxlba;
	uint	nmask;
	Lock	mlk;
	uchar	*mask;
	int	shelf;
	int	slot;
	int	clen;
	char	*config;
};

static	Vblade	vblade[Nvblade];
static	int	nblade;

static	char	*ethertab[Nether] = {
	"#l0/ether0",
};
static	int	etheridx = 1;
static	int	efdtab[Nether*Flast];
static	uchar	pkttab[Nether][Maxpkt];
static	uchar	bctab[Nether][Maxpkt];
static	int	mtutab[Nether];
static Ioproc *ioprocs[Nether];

static int
getmtu(char *p)
{
	char buf[50];
	int fd, mtu;

	snprint(buf, sizeof buf, "%s/mtu", p);
	if((fd = open(buf, OREAD)) == -1)
		return 2;
	if(read(fd, buf, 36) < 0)
		return 2;
	close(fd);
	buf[36] = 0;
	mtu = strtoul(buf+12, 0, 0)-Aoehsz-Aoeatasz;
	return mtu>>9;
}

static int
aoeopen(Ioproc *io, char *e, int fds[])
{
	char buf[128], ctl[13];
	int n;

	snprint(buf, sizeof buf, "%s/clone", e);
	if((fds[Fclone] = ioopen(io, buf, ORDWR)) == -1)
		return -1;
	memset(ctl, 0, sizeof ctl);
	if(ioread(io, fds[Fclone], ctl, sizeof ctl - 1) < 0)
		return -1;
	n = atoi(ctl);
	snprint(buf, sizeof buf, "connect %d", Aoetype);
	if(iowrite(io, fds[Fclone], buf, strlen(buf)) != strlen(buf))
		return -1;
	snprint(buf, sizeof buf, "%s/%d/data", e, n);
	fds[Fdata] = ioopen(io, buf, ORDWR);
	return fds[Fdata];
}

static void
replyhdr(Aoehdr *h, Vblade *vblade)
{
	uchar	ea[Eaddrlen];

	memmove(ea, h->dst, Eaddrlen);
	memmove(h->dst, h->src, Eaddrlen);
	memmove(h->src, ea, Eaddrlen);

	hnputs(h->major, vblade->shelf);
	h->minor = vblade->slot;
	h->verflag |= AFrsp;
}

static int
servebad(uchar *pkt, Vblade*, int)
{
	Aoehdr *h;

	h = (Aoehdr*)pkt;
	h->verflag |= AFerr;
	h->error = AEcmd;

	return Aoehsz;
}

static uchar nilea[Eaddrlen];

/*
static void
savemask(Vblade *vb)
{
	uvlong qpath, meta;

	qpath = ((uvlong)TLun << 60) | (vb->shelf << 8) | vb->slot;
	meta = q2m(-1, qpath, 0);
	if(meta == 0)
		return;
	setmetaint(meta, "nmask", nil, vb->nmask);
	if(vb->mask)
		setmetablob(meta, "mask", nil, vb->mask, vb->nmask * Eaddrlen, 0);
	else
		setmetastr(meta, "mask", nil, "", 0);
}
*/

static int
servemask(uchar *pkt, Vblade *vb, int mtu)
{
	int i, j, r, e;
	uchar mx[Nmask*Eaddrlen], *mtab[Nmask], *p;
	Aoem *m;
	Aoemd *d;

	m = (Aoem*)(pkt + Aoehsz);
	if(m->mcnt > (mtu - Aoehsz - Aoemsz)/Aoemdsz)
		return -1;

	if(!canlock(&vb->mlk))
		return -1;		/* drop */

	switch(m->mcmd){
	default:
		unlock(&vb->mlk);
		return servebad(pkt, vb, mtu);
	case Medit:
		memcpy(mx, vb->mask, vb->nmask*Eaddrlen);
		j = 0;
		for(i = 0; i < vb->nmask; i++){
			p = mx + i*Eaddrlen;
			if(memcmp(p, nilea, Eaddrlen) != 0)
				mtab[j++] = p;
		}
		e = 0;
		p = pkt + Aoehsz + Aoemsz;
		for(i = 0; i < m->mcnt && e == 0; i++){
			d = (Aoemd*)(p + i*Aoemdsz);
			switch(d->dcmd){
			default:
				e = MEunk;
				break;
			case MDnop:
				break;
			case MDadd:
				for(i = 0; i < j; i++)
					if(memcmp(d->ea, mtab[j], Eaddrlen) == 0)
						continue;
				if(j == Nmask)
					e = MEfull;
				else
					memcpy(mtab[j++], d->ea, Eaddrlen);
				break;
			case MDdel:
				for(i = 0; i < j; i++)
					if(memcmp(d->ea, mtab[j], Eaddrlen) == 0)
						break;
				if(i < j){
					for(; i < j; i++)
						mtab[i] = mtab[i+1];
					j--;
				}
				break;
			}
		}

		if(e != 0){
			m->merr = e;
			r = Aoehsz + Aoemsz;
			break;
		}

		p = malloc(j*Eaddrlen);
		if(p == nil){
			r = -1;
			break;
		}

		for(i = 0; i < j; i++)
			memcpy(p+i*Eaddrlen, mtab[i], Eaddrlen);
		free(vb->mask);
		vb->nmask = j;
		vb->mask = p;
	case Mread:
		m->mcnt = vb->nmask;
		m->merr = 0;
		p = pkt + Aoehsz + Aoemsz;
		for(i = 0; i < m->mcnt; i++){
			d = (Aoemd*)(p + i*Aoemdsz);
			d->dres = 0;
			d->dcmd = MDnop;
			memcpy(d->ea, vb->mask + i*Eaddrlen, Eaddrlen);
		}
		r = Aoehsz + Aoemsz + m->mcnt * Aoemdsz;
		break;
	}

	unlock(&vb->mlk);
	return r;
}

static void
saveconfig(Vblade *vb)
{
	uvlong qpath, meta;

	qpath = ((uvlong)TLun << 60) | (vb->shelf << 8) | vb->slot;
	meta = q2m(-1, qpath, 0);
	if(meta == 0)
		return;
	if(vb->config)
		setmetastr(meta, "config", nil, vb->config, 0);
	else
		setmetastr(meta, "config", nil, "", 0);
}

static int
serveconfig(uchar *pkt, Vblade *vb, int mtu)
{
	char *cfg;
	int cmd, reqlen, len;
	Aoehdr *h;
	Aoecfg *q;

	h = (Aoehdr*)pkt;
	q = (Aoecfg*)(pkt + Aoehsz);

	if(memcmp(h->src, h->dst, Eaddrlen) == 0)
		return -1;

	reqlen = nhgets(q->cslen);
	len = vb->clen;
	cmd = q->verccmd&0xf;
	cfg = (char*)(pkt + Aoehsz + Aoecfgsz);

	switch(cmd){
	case AQCtest:
		if(reqlen != len)
			return -1;
	case AQCprefix:
		if(reqlen > len)
			return -1;
		if(memcmp(vb->config, cfg, reqlen) != 0)
			return -1;
	case AQCread:
		break;
	case AQCset:
		if(len && len != reqlen || memcmp(vb->config, cfg, reqlen) != 0){
			h->verflag |= AFerr;
			h->error = AEcfg;
			break;
		}
	case AQCfset:
		if(reqlen > Conflen){
			h->verflag |= AFerr;
			h->error = AEarg;
			break;
		}
		free(vb->config);
		vb->config = θmalloc(reqlen + 1);
		memmove(vb->config, cfg, reqlen);
		vb->clen = len = reqlen;
		saveconfig(vb);
		break;
	default:
		h->verflag |= AFerr;
		h->error = AEarg;
		break;
	}

	if(vb->config)
		memmove(cfg, vb->config, len);
	hnputs(q->cslen, len);
	hnputs(q->bufcnt, Nmaxout);
	q->scnt = mtu;
	hnputs(q->fwver, 2323);
	q->verccmd = Aoever<<4 | cmd;

	return len;
}

static ushort ident[256] = {
	[47] 0x8000,
	[49] 0x0200,
	[50] 0x4000,
	[83] 0x5400,
	[84] 0x4000,
	[86] 0x1400,
	[87] 0x4000,
	[93] 0x400b,
};

static void
idmoveto(char *a, int idx, int len, char *s)
{
	char *p;

	p = a+idx*2;
	for(; len > 0; len -= 2) {
		if(*s == 0)
			p[1] = ' ';
		else
			p[1] = *s++;
		if (*s == 0)
			p[0] = ' ';
		else
			p[0] = *s++;
		p += 2;
	}
}

static void
lbamoveto(char *p, int idx, int n, vlong lba)
{
	int i;

	p += idx*2;
	for(i = 0; i < n; i++)
		*p++ = lba>>i*8;
}

enum {
	Crd		= 0x20,
	Crdext		= 0x24,
	Cwr		= 0x30,
	Cwrext		= 0x34,
	Cid		= 0xec,
};

static uvlong
getlba(uchar *p)
{
	uvlong v;

	v = p[0];
	v |= p[1]<<8;
	v |= p[2]<<16;
	v |= p[3]<<24;
	v |= (uvlong)p[4]<<32;
	v |= (uvlong)p[5]<<40;
	return v;
}

static void
putlba(uchar *p, vlong lba)
{
	p[0] = lba;
	p[1] = lba>>8;
	p[2] = lba>>16;
	p[3] = lba>>24;
	p[4] = lba>>32;
	p[5] = lba>>40;
}

static int
serveata(uchar *pkt, Vblade *vb, int mtu)
{
	char *buf;
	int rbytes, bytes, len;
	vlong lba, off, qpath;
	Aoehdr *h;
	Aoeata *a;

	h = (Aoehdr*)pkt;
	a = (Aoeata*)(pkt + Aoehsz);

	buf = (char*)(pkt + Aoehsz + Aoeatasz);
	lba = getlba(a->lba);
	len = a->scnt<<9;
	off = lba<<9;

	if(a->scnt > mtu || a->scnt == 0){
		h->verflag |= AFerr;
		h->error = AEarg;
		a->cmdstat = ASdrdy|ASerr;
		return 0;
	}
	
	if(a->cmdstat != Cid)
	if(lba+a->scnt > vb->maxlba){
		a->errfeat = Eidnf;
		a->cmdstat = ASdrdy|ASerr;
		return 0;
	}

	if(a->cmdstat&0xf0 == 0x20)
		lba &= 0xfffffff;
	switch(a->cmdstat){
	default:
		a->errfeat = Eabrt;
		a->cmdstat = ASdrdy|ASerr;
		return 0;
	case Cid:
		memmove(buf, ident, sizeof ident);
		idmoveto(buf, 27, 40, "Plan 9 Vblade");
		idmoveto(buf, 10, 20, "serial#");
		idmoveto(buf, 23, 8, "2");
		lbamoveto(buf, 60, 4, vb->maxlba);
		lbamoveto(buf, 100, 8, vb->maxlba);
		a->cmdstat = ASdrdy;
		return 512;
		break;
	case Crd:
	case Crdext:
		qpath = ((uvlong)TLun << 60) | (vb->shelf << 8) | vb->slot;
		bytes = θpread(-1, qpath, buf, len, off);
		rbytes = bytes;
		break;
	case Cwr:
	case Cwrext:
		qpath = ((uvlong)TLun << 60) | (vb->shelf << 8) | vb->slot;
		bytes = θpwrite(qpath, buf, len, off, 0);
		rbytes  = 0;
		break;
	}
	if(bytes != len){
		a->errfeat = Eabrt;
		a->cmdstat = ASdf|ASerr;
		putlba(a->lba, lba+(len-bytes)>>9);
		return 0;
	}

	putlba(a->lba, lba+a->scnt);
	a->scnt = 0;
	a->errfeat = 0;
	a->cmdstat = ASdrdy;

	return rbytes;
}

static int
myea(Ioproc *io, uchar ea[6], char *p)
{
	char buf[50];
	int fd;

	snprint(buf, sizeof buf, "%s/addr", p);
	if((fd = ioopen(io, buf, OREAD)) == -1)
		return -1;
	if(ioread(io, fd, buf, 12) < 12)
		return -1;
	ioclose(io, fd);
	return parseether(ea, buf);
}

static int
bcastpkt(uchar *pkt, uint shelf, uint slot, int i)
{
	Aoehdr *h;

	h = (Aoehdr*)pkt;
	myea(ioprocs[i], h->dst, ethertab[i]);
	memset(h->src, 0xff, Eaddrlen);
	hnputs(h->type, Aoetype);
	hnputs(h->major, shelf);
	h->minor = slot;
	h->cmd = ACconfig;
	*(u32int*)h->tag = 0;
	return Aoehsz + Aoecfgsz;
}

static int
osdgetattr(Aoeosd *o, int len, uvlong pid, uvlong oid)
{
	MVal x;
	uchar *inbuf, *outbuf, *end;
	char *name, *strval;
	uvlong meta;
	int n, nn, typ, tot;

	name = smprint("%016ullx:%016ullx", pid, oid);
	meta = q2m(-1, p2q(-1, name, 0), 0);
	free(name);
	if(meta == 0) {
		o->oflag = 0x40;
		return 0;
	}
	len -= 20;
	inbuf = θmalloc(len);
	memmove(inbuf, o->oaddr, len);
	end = inbuf + len;
	outbuf = o->opid;
	tot = 0;
	while(inbuf < end) {
		name = (char *)inbuf;			/* the compiler's obsession with signed and unsigned is annoying */
		nn = strlen(name);
		inbuf += nn + 1;
		typ = getmeta(-1, meta, name, &x);
		switch(typ) {
/*
		case MTshort:
			if(tot + nn + 4 >= 8192)
				goto done;
			tot += nn + 4;
			strcpy((char *)outbuf, name);
			outbuf += nn + 1;
			*outbuf++ = 'h';
			hnputs(outbuf, *((ushort *)x));
			outbuf += 2;
			break;
		case MTlong:
			if(tot + nn + 6 >= 8192)
				goto done;
			tot += nn + 6;
			strcpy((char *)outbuf, name);
			outbuf += nn + 1;
			*outbuf++ = 'l';
			hnputl(outbuf, *((ulong *)x));
			outbuf += 4;
			break;
*/
		case MTint:
			if(tot + nn + 10 >= 8192)
				goto done;
			tot += nn + 10;
			strcpy((char *)outbuf, name);
			outbuf += nn + 1;
			*outbuf++ = 'v';
			hnputv(outbuf, x.val);
			outbuf += 8;
			break;
		case MTistring:
			n = strlen(x.str) + 1;
			if(tot + nn + n + 3 >= 8192)
				goto done;
			tot += nn + n + 3;
			strcpy((char *)outbuf, name);
			outbuf += nn + 1;
			*outbuf++ = 's';
			strcpy((char *)outbuf, x.str);
			outbuf += n;
			break;
		case MTstring:
			strval = getblob(-1, x.val, &n);
			if(tot + nn + n + 3 >= 8192)
				goto done;
			tot += nn + n + 3;
			strcpy((char *)outbuf, name);
			outbuf += nn + 1;
			*outbuf++ = 's';
			strcpy((char *)outbuf, strval);
			free(strval);
			outbuf += n;
			break;
		case MTblob:
			strval = getblob(-1, x.val, &n);
			if(tot + nn + n + 4 >= 8192)
				goto done;
			tot += nn + n + 4;
			strcpy((char *)outbuf, name);
			outbuf += nn + 1;
			*outbuf++ = 'b';
			hnputs(outbuf, n);
			outbuf += 2;
			memmove(outbuf, strval, n);
			free(strval);
			outbuf += n;
			break;
		}
	}
done:
	brelease(meta);
	return tot;
}

static int
osdsetattr(Aoeosd *o, int len, uvlong pid, uvlong oid)
{
	uchar *buf, *end;
	char *name;
	uvlong meta;
	int n;

	name = smprint("%016ullx:%016ullx", pid, oid);
	meta = q2m(-1, p2q(-1, name, 0), 0);
	free(name);
	if(meta == 0) {
		o->oflag = 0x40;
		return 0;
	}
	buf = o->oaddr;
	end = buf + len;
	while(buf < end) {
		name = (char *)buf;			/* the compiler's obsession with signed and unsigned is annoying */
		buf += strlen(name) + 1;
		switch(*buf) {
		case 'h':
			setmetaint(meta, name, nil, nhgets(buf + 1));
			buf += 3;
			break;
		case 'l':
			setmetaint(meta, name, nil, nhgetl(buf + 1));
			buf += 5;
			break;
		case 'v':
			setmetaint(meta, name, nil, nhgetv(buf + 1));
			buf += 9;
			break;
		case 's':
			setmetastr(meta, name, nil, (char *)(buf + 1), 0);
			buf += strlen((char *)(buf + 1)) + 2;
			break;
		case 'b':
			n = *((ushort *)(buf + 1));
			setmetablob(meta, name, nil, buf + 3, n, 0);
			buf += n + 1;
			break;
		}
	}
	return 0;
}

static int
serveosd(Ioproc *io, uchar *pkt, int fd, int)
{
	Qid nqid;
	Aoehdr *ah;
	Aoeosd *o;
	uchar *buf;
	char *name;
	uvlong x;
	uvlong pid, oid, addr, meta, pmeta, dirblk, pqpath;
	int n, len, rlen;

	ah = (Aoehdr *)pkt;
	o = (Aoeosd *)(pkt + Aoehsz);
	len = nhgets(o->olen);
	/* for some commands, the pid, oid, or addr may be junk */
	pid = nhgetv(o->opid);
	oid = nhgetv(o->ooid);
	addr = nhgetv(o->oaddr);

	rlen = 0;
	o->oflag = 0;
fprint(2, "OSD request: %016ullx:%016ullx len:%d cmd:%x addr:%ulld\n", pid, oid, len, o->ocmd, addr);
	switch(o->ocmd) {
	case AOCformat:
		name = smprint("0000000000000000:0000000000000000");
		nqid.path = p2q(-1, name, 1);
		nqid.vers = 0;
		nqid.type = QTFILE;
		meta = q2m(-1, nqid.path, 1);
		setmetastr(meta, "name", nil, name, 0);
		setmetaint(meta, "pid", nil, 0);
		setmetaint(meta, "oid", nil, 0);
		setmetaint(meta, "qpath", nil, nqid.path);
		setmetaint(meta, "qvers", nil, nqid.vers);
		setmetaint(meta, "qtype", nil, nqid.type);
		setmetaint(meta, "child", nil, 0);
		setqhash(nqid.path, meta);
		free(name);
		savesuper();
		break;
	case AOCcreate:
		name = smprint("%016ullx:0000000000000000", pid);
		pqpath = p2q(-1, name, 0);
		pmeta = q2m(-1, pqpath, 0);
		free(name);
		if(pmeta == 0) {
			o->oflag = 0x40;
			break;
		}
		name = smprint("%016ullx:%016ullx", pid, oid);
		nqid.path = p2q(-1, name, 1);
		nqid.vers = 0;
		nqid.type = QTFILE;
		meta = q2m(-1, nqid.path, 1);
		if(meta == 0) {
			o->oflag = 0x40;
			free(name);
			break;
		}
		setmetastr(meta, "name", nil, name, 0);
		setmetaint(meta, "pid", nil, pid);
		setmetaint(meta, "oid", nil, oid);
		setmetaint(meta, "qpath", nil, nqid.path);
		setmetaint(meta, "qvers", nil, nqid.vers);
		setmetaint(meta, "qtype", nil, nqid.type);
		setmetaint(meta, "length", nil, 0);
		setmetaint(meta, "parent", nil, pqpath);
		getmetaint(-1, pmeta, "child", &x);
		setmetaint(meta, "sib", nil, x);
		setmetaint(pmeta, "child", nil, nqid.path);
		dirblk = allocblock();
		if(dirblk != 0) {
			cbclean(dirblk);
			cbwrite(dirblk);
			brelease(dirblk);
		}
		setmetaint(meta, "index", nil, dirblk);
		setqhash(nqid.path, meta);
		free(name);
		savesuper();
		break;
	case AOClist:
		name = smprint("%016ullx:%016ullx", pid, oid);
		pqpath = p2q(-1, name, 0);
		meta = q2m(-1, pqpath, 0);
		getmetaint(-1, meta, "child", &pqpath);
		buf = o->opid;
		while(len > 0 && pqpath != 0) {
			meta = q2m(-1, pqpath, 0);
			if(meta == 0)
				break;
			if(pid == 0)
				getmetaint(-1, meta, "pid", &x);
			else
				getmetaint(-1, meta, "oid", &x);
			hnputv(buf, x);
			buf += 8;
			len -= 8;
			getmetaint(-1, meta, "sib", &pqpath);
		}
		rlen = len = buf - o->opid;
		hnputs(o->olen, len);
		break;
	case AOCread:
		name = smprint("%016ullx:%016ullx", pid, oid);
		pqpath = p2q(-1, name, 0);
		buf = o->opid;
		len = θpread(-1, pqpath, buf, len, addr);
		rlen = len;
		free(name);
		break;
	case AOCwrite:
		name = smprint("%016ullx:%016ullx", pid, oid);
		pqpath = p2q(-1, name, 0);
		buf = o->oaddr + 8;
		len = θpwrite(pqpath, buf, len, addr, 1);
		free(name);
		break;
	case AOCappend:
		name = smprint("%016ullx:%016ullx", pid, oid);
		pqpath = p2q(-1, name, 0);
		buf = o->oaddr + 8;
		len = θpwrite(pqpath, buf, len, 0, 2);
		free(name);
		break;
	case AOCflush:
		resetmeta();
		csync();
		break;
	case AOCremove:
		name = smprint("%016ullx:%016ullx", pid, oid);
		meta = q2m(-1, p2q(-1, name, 0), 0);
		if(meta == 0) {
			o->oflag = 0x40;
			free(name);
			break;
		}
		getmetaint(-1, meta, "qpath", &x);
		rmdlist(meta, x);
		rmq(x, meta);
		rmp(name);
		free(name);
		break;
	case AOCpcreate:
		name = smprint("0000000000000000:0000000000000000");
		pqpath = p2q(-1, name, 0);
		pmeta = q2m(-1, pqpath, 0);
		free(name);
		if(pmeta == 0) {
			o->oflag = 0x40;
			break;
		}
		name = smprint("%016ullx:0000000000000000", pid);
		nqid.path = p2q(-1, name, 1);
		nqid.vers = 0;
		nqid.type = QTFILE;
		meta = q2m(-1, nqid.path, 1);
		if(meta == 0) {
			o->oflag = 0x40;
			free(name);
			break;
		}
		setmetastr(meta, "name", nil, name, 0);
		setmetaint(meta, "pid", nil, pid);
		setmetaint(meta, "oid", nil, 0);
		setmetaint(meta, "qpath", nil, nqid.path);
		setmetaint(meta, "qvers", nil, nqid.vers);
		setmetaint(meta, "qtype", nil, nqid.type);
		setmetaint(meta, "parent", nil, pqpath);
		setmetaint(meta, "child", nil, 0);
		getmetaint(-1, pmeta, "child", &x);
		setmetaint(meta, "sib", nil, x);
		setmetaint(pmeta, "child", nil, nqid.path);
		setqhash(nqid.path, meta);
		free(name);
		savesuper();
		break;
	case AOCpremove:
		name = smprint("%016ullx:0000000000000000", pid);
		meta = q2m(-1, p2q(-1, name, 0), 0);
		if(meta == 0) {
			o->oflag = 0x40;
			free(name);
			break;
		}
		getmetaint(-1, meta, "child", &x);
		if(x == 0) {
			rmdlist(meta, x);
			rmq(x, meta);
			freeblock(meta);
			rmp(name);
		}
		else {
			o->oflag |= 0x40;
		}
		free(name);
		break;
	case AOCgetattr:
		rlen = len = osdgetattr(o, len, pid, oid);
		break;
	case AOCsetattr:
		rlen = len = osdsetattr(o, len, pid, oid);
		break;
	case AOCccreate:
	case AOCcremove:
	case AOCclist:
	default:
		o->oflag = 0x40;
		break;
	}
	memmove(ah->dst, ah->src, Eaddrlen);
	ah->verflag |= AFrsp;
	if(o->oflag & 0x40) {
		ah->verflag |= AFerr;
		ah->error = AEarg;
	}
	o->oflag |= 0x80;
	hnputs(o->olen, len);
	n = rlen + 4 + sizeof(Aoehdr);
	if(n < 60)
		n = 60;
	if(iowrite(io, fd, pkt, n) != n) {
		fprint(2, "response write failed: %r\n");
		return -1;
	}
	return 0;
}

static int
bladereply(Vblade *v, int i, int fd, uchar *pkt)
{
	int n;
	Aoehdr *h;

	h = (Aoehdr*)pkt;
	switch(h->cmd){
	case ACata:
		n = serveata(pkt, v, mtutab[i]);
		n += Aoehsz+Aoeatasz;
		break;
	case ACconfig:
		n = serveconfig(pkt, v, mtutab[i]);
		if(n >= 0)
			n += Aoehsz+Aoecfgsz;
		break;
	case ACmask:
		n = servemask(pkt, v, mtutab[i]);
		break;
	case ACosd:
		if(v == vblade)
			return serveosd(ioprocs[i], pkt, fd, mtutab[i]);
		else
			return 0;
		break;
	default:
		n = servebad(pkt, v, mtutab[i]);
		break;
	}
	if(n == -1)
		return -1;
	replyhdr(h, v);
	if(n < 60){
		memset(pkt+n, 0, 60-n);
		n = 60;
	}
	if(iowrite(ioprocs[i], fd, h, n) != n){
		fprint(2, "vblade: write to %s failed: %r\n", ethertab[i]);
		return -1;
	}
	return 0;
}

static int
filter(Vblade *v, uchar *ea)
{
	int i;
	uchar *u;

	if(v->nmask == 0)
		return 0;

	u = v->mask;
	for(i = 0; i < v->nmask; i++)
		if(memcmp(u + i*Eaddrlen, ea, Eaddrlen) == 0)
			return 0;
	return -1;
}

static void
serve(void *a)
{
	int i, j, popcnt, vec, n, s, efd;
	uchar *pkt, *bcpkt;
	Aoehdr *h;
	Vblade *v;

	i = (int)(uintptr)a;

	efd = efdtab[i*Flast+Fdata];
	pkt = pkttab[i];
	bcpkt = bctab[i];

	n = 60;
	h = (Aoehdr*)pkt;
	bcastpkt(pkt, 0xffff, 0xff, i);
	goto start;

	for(;;){
		n = ioread(ioprocs[i], efd, pkt, Maxpkt);
	start:
		if(shutdown)
			threadexits(nil);
		if(n < 60 || h->verflag & AFrsp)
			continue;
		s = nhgets(h->major);
		popcnt = 0;
		vec = 0;
		for(j = 0; j < nblade; j++){
			v = vblade+j;
			if(v->shelf == s || s == 0xffff)
			if(v->slot == h->minor || h->minor == 0xff)
			if(v->nmask == 0 || filter(v, h->src) == 0){
				popcnt++;
				vec |= 1<<j;
			}
		}
		if(popcnt == 0)
			continue;
		for(j = 0;; j++){
			if((vec & 1<<j) == 0)
				continue;
			if(--popcnt>0){
				memcpy(bcpkt, pkt, n);
				bladereply(vblade + j, i, efd, bcpkt);
			}else{
				bladereply(vblade + j, i, efd, pkt);
				break;
			}
		}
	}
}

static void
aoeannounce(Vblade *vb)
{
	uchar *pkt;
	int i;

	pkt = θmalloc(Maxpkt);
	for(i = 0; i < etheridx; ++i) {
		bcastpkt(pkt, 0xffff, 0xff, i);
		bladereply(vb, i, efdtab[i*Flast+Fdata], pkt);
	}
}

void
starttarget(int major, int minor, uvlong nsect)
{
	Vblade *vp;

	vp = vblade + nblade;
	vp->maxlba = nsect;
	vp->nmask = 0;
	vp->mask = nil;
	vp->shelf = major;
	vp->slot = minor;
	vp->clen = 0;
	++nblade;
	aoeannounce(vp);
}

void
rmtarget(int major, int minor)
{
	int i;

	for(i = 0; i < nblade && (vblade[i].shelf != major || vblade[i].slot != minor); ++i) ;
	if(i >= nblade)
		return;
	for(; i < nblade - 1; ++i)
		vblade[i] = vblade[i+1];
	memset(vblade + i, 0, sizeof (Vblade));
	--nblade;
}

static void
scanluns(void)
{
	uvlong x;
	uvlong qpath, meta;

	for(qpath = super.firstlun; qpath; ) {
		meta = q2m(-1, qpath, 0);
		if(meta == 0) {
			fprint(2, "No metadata for %ulld\n", qpath);
			break;
		}
		getmetaint(-1, meta, "length", &x);
		vblade[nblade].maxlba = x >> 9;
		if(getmetaint(-1, meta, "nmask", &x) == MTnone)
			vblade[nblade].nmask = 0;
		else
			vblade[nblade].nmask = x;
		if(vblade[nblade].nmask != 0) {
			if(getmeta(-1, meta, "masks", (MVal *)&x) == MTnone)
				vblade[nblade].nmask = 0;
			else
				vblade[nblade].mask = getblob(-1, x, nil);
		}
		getmetaint(-1, meta, "aoemajor", &x);
		vblade[nblade].shelf = x;
		getmetaint(-1, meta, "aoeminor", &x);
		vblade[nblade].slot = x;
		if(vblade[nblade].config = getmetastr(-1, meta, "config"))
			vblade[nblade].clen = strlen(vblade[nblade].config);
		else
			vblade[nblade].clen = 0;
		++nblade;
		getmetaint(-1, meta, "nextlun", &qpath);
	}
}

static void
launch(char *tab[], int fdtab[])
{
	int i;

	for(i = 0; tab[i]; i++){
		ioprocs[i] = ioproc();
		if(aoeopen(ioprocs[i], tab[i], fdtab+Flast*i) < 0)
			sysfatal("network open: %r");
		threadcreate(serve, (void*)(uintptr)i, 32*1024);
	}
}

void
initaoe(void)
{
	int i;

	for(i = 0; i < etheridx; i++)
		mtutab[i] = getmtu(ethertab[i]);
	scanluns();
	launch(ethertab, efdtab);
}

void
haltaoe(void)
{
	int i;

	for(i  = 0; ethertab[i]; ++i) {
		if(ioprocs[i]) {
			iointerrupt(ioprocs[i]);
			closeioproc(ioprocs[i]);
		}
	}
}