## diffname mpc/devsac.c 1999/0608
## diff -e /dev/null /n/emeliedump/1999/0608/sys/src/brazil/mpc/devsac.c
0a
#include "u.h"
#include "../port/lib.h"
#include "mem.h"
#include "dat.h"
#include "fns.h"
#include "io.h"

/*
 * Rather than reading /adm/users, which is a lot of work for
 * a toy program, we assume all groups have the form
 *	NNN:user:user:
 * meaning that each user is the leader of his own group.
 */

enum
{
	OPERM	= 0x3,		/* mask of all permission types in open mode */
	Nram	= 512,
};

typedef struct SacPath SacPath;
typedef struct Sac Sac;
typedef struct SacHeader SacHeader;
typedef struct SacDir SacDir;

enum {
	Magic = 0x5acf5,
};

struct SacDir
{
	char	name[NAMELEN];
	char	uid[NAMELEN];
	char	gid[NAMELEN];
	uchar	qid[4];
	uchar	mode[4];
	uchar	atime[4];
	uchar	mtime[4];
	uchar	length[8];
	uchar	blocks[8];
};

struct SacHeader
{
	uchar	magic[4];
	uchar	length[8];
	uchar	blocksize[4];
	uchar	md5[16];
};


struct Sac
{
	SacDir;
	SacPath *path;
};

struct SacPath
{
	Ref;
	SacPath *up;
	vlong blocks;
	int entry;
};

enum
{
	Pexec =		1,
	Pwrite = 	2,
	Pread = 	4,
	Pother = 	1,
	Pgroup = 	8,
	Powner =	64,
};

uchar *data = SACMEM;
int blocksize;
Sac root;

void	sacstat(SacDir*, char*);
void	io(void);
void	usage(void);
ulong	getl(void *p);
vlong	getv(void *p);
void	init(char*);
Sac	*saccpy(Sac *s);
Sac *saclookup(Sac *s, char *name);
int sacdirread(Sac *s, char *p, long off, long cnt);
void loadblock(void *buf, uchar *offset, int blocksize);
void sacfree(Sac*);

void
devinit(void)
{
	SacHeader *hdr;
	hdr = (SacHeader*)data;
	if(getl(hdr->magic) != Magic) {
print("devsac: bad magic");
		return;
	}
	blocksize = getl(hdr->blocksize);
	root.SacDir = *(SacDir*)(data + sizeof(SacHeader));
}

static Chan*
sacattach(char* spec)
{
	Chan *c;
	int dev;

	dev = atoi(spec);
	if(dev != 0)
		error("bad specification");

	// check if init found sac file system in memory
	if(blocksize == 0)
		error("devsac: bad magic");

	c = devattach('C', spec);
	c->qid = (Qid){getl(root.qid), 0};
	c->dev = dev;
	c->aux = saccpy(&root);
	return c;
}

Chan*
sacclone(Chan *c, Chan *nc)
{
	nc = devclone(c, nc);
	nc->aux = saccpy(c->aux);
	return nc;
}

int
devwalk(Chan *c, char *name, Dirtab *tab, int ntab, Devgen *gen)
{
	Sac *sac;

	isdir(c);
	sac = c->aux;
	if(strcmp(name, ".") == 0)
		return 1;
	sac = saclookup(sac, name);
	if(sac == nil) {
		strncpy(up->error, Enonexist, NAMELEN);
		return 0;
	}
	c->aux = sac;
	c->qid = (Qid){getl(sac->qid), 0};
	op = c->path;
	c->path = ptenter(&syspt, op, name);
	decref(op);
	return 1;
}

char *
ropen(Fid *f)
{
	int mode, trunc;

	if(f->open)
		return Eisopen;
	if(f->busy == 0)
		return Enotexist;
	mode = rhdr.mode;
	if(f->qid.path & CHDIR){
		if(mode != OREAD)
			return Eperm;
		thdr.qid = f->qid;
		return 0;
	}
	if(mode & ORCLOSE)
		return Erdonly;
	trunc = mode & OTRUNC;
	mode &= OPERM;
	if(mode==OWRITE || mode==ORDWR || trunc)
		return Erdonly;
	if(mode==OREAD)
		if(!perm(f, f->sac, Pread))
			return Eperm;
	if(mode==OEXEC)
		if(!perm(f, f->sac, Pexec))
			return Eperm;
	thdr.qid = f->qid;
	f->open = 1;
	return 0;
}

char *
rcreate(Fid *f)
{
	if(f->open)
		return Eisopen;
	if(f->busy == 0)
		return Enotexist;
	return Erdonly;
}

char*
rread(Fid *f)
{
	Sac *sac;
	char *buf, *buf2;
	long off;
	int n, cnt, i, j;
	uchar *blocks;
	vlong length;

	if(f->busy == 0)
		return Enotexist;
	sac = f->sac;
	thdr.count = 0;
	off = rhdr.offset;
	buf = thdr.data;
	cnt = rhdr.count;
	if(f->qid.path & CHDIR){
		cnt = (rhdr.count/DIRLEN)*DIRLEN;
		if(off%DIRLEN)
			return "i/o error";
		thdr.count = sacdirread(sac, buf, off, cnt);
		return 0;
	}
	length = getv(sac->length);
	if(off >= length) {
		rhdr.count = 0;
		return 0;
	}
	if(cnt > length-off)
		cnt = length-off;
	thdr.count = cnt;
	if(cnt == 0)
		return 0;
	blocks = data + getv(sac->blocks);
	buf2 = malloc(blocksize);
	while(cnt > 0) {
		i = off/blocksize;
		loadblock(buf2, blocks+i*8, blocksize);
		j = off-i*blocksize;
		n = blocksize-j;
		if(n > cnt)
			n = cnt;
		memmove(buf, buf2+j, n);
		cnt -= n;
		off += n;
	}
	free(buf2);
	return 0;
}

char*
sacwrite(Fid *f)
{
	if(f->busy == 0)
		return Enotexist;
	return Erdonly;
}

char *
rclunk(Fid *f)
{
	f->busy = 0;
	f->open = 0;
	free(f->user);
	sacfree(f->sac);
	return 0;
}

char *
rremove(Fid *f)
{
	f->busy = 0;
	f->open = 0;
	free(f->user);
	sacfree(f->sac);
	return Erdonly;
}

char *
rstat(Fid *f)
{
	if(f->busy == 0)
		return Enotexist;
	sacstat(f->sac, thdr.stat);
	return 0;
}

char *
rwstat(Fid *f)
{
	if(f->busy == 0)
		return Enotexist;
	return Erdonly;
}

Sac*
saccpy(Sac *s)
{
	Sac *ss;
	
	ss = malloc(sizeof(Sac));
	*ss = *s;
	if(ss->path)
		incref(ss->path);
	return ss;
}

SacPath *
sacpathalloc(SacPath *p, vlong blocks, int entry)
{
	SacPath *pp = malloc(sizeof(SacPath));
	pp->ref = 1;
	pp->blocks = blocks;
	pp->entry = entry;
	pp->up = p;
	return pp;
}

static void
sacpathfree(SacPath *p)
{
	if(p == nil)
		return;
	if(decref(p) > 0)
		return;
	sacpathfree(p->up);
	free(p);
}


void
sacfree(Sac *s)
{
	sacpathfree(s->path);
	free(s);
}

void
sacstat(SacDir *s, char *buf)
{
	Dir dir;

	memmove(dir.name, s->name, NAMELEN);
	dir.qid = (Qid){getl(s->qid), 0};
	dir.mode = getl(s->mode);
	dir.length = getv(s->length);
	if(dir.mode &CHDIR)
		dir.length *= DIRLEN;
	strcpy(dir.uid, s->uid);
	strcpy(dir.gid, s->gid);
	dir.atime = getl(s->atime);
	dir.mtime = getl(s->mtime);
	convD2M(&dir, buf);
}

void
loadblock(void *buf, uchar *offset, int blocksize)
{
	vlong block, n;

	block = getv(offset);
	if(block < 0) {
		block = -block;
		n = getv(offset+8);
		if(n < 0)
			n = -n;
		n -= block;
//fprint(2, "blocksize = %d, block = %lld n = %lld\n", blocksize, block, n);
		if(unsac(buf, data+block, blocksize, n)<0)
			panic("unsac failed!");
	} else {
		memmove(buf, data+block, blocksize);
	}
}

Sac*
sacparent(Sac *s)
{
	uchar *blocks;
	SacDir *buf;
	int per, i;
	SacPath *p;

	p = s->path;
	if(p == nil || p->up == nil) {
		pathfree(p);
		*s = root;
		return s;
	}
	p = p->up;

//fprint(2, "sacparent = %lld %d\n", p->blocks, p->entry);
	blocks = data + p->blocks;
	per = blocksize/sizeof(SacDir);
	i = p->entry/per;
	buf = malloc(per*sizeof(SacDir));
	loadblock(buf, blocks + i*8, per*sizeof(SacDir));
	s->SacDir = buf[p->entry-i*per];
//fprint(2, "sacparent = %s\n", s->name);
	free(buf);
	incref(p);
	pathfree(s->path);
	s->path = p;
	return s;
}

int
sacdirread(Sac *s, char *p, long off, long cnt)
{
	uchar *blocks;
	SacDir *buf;
	int iblock, per, i, j, ndir;

	blocks = data + getv(s->blocks);
	per = blocksize/sizeof(SacDir);
	ndir = getv(s->length);
	off /= DIRLEN;
	cnt /= DIRLEN;
	if(off >= ndir)
		return 0;
	if(cnt > ndir-off)
		cnt = ndir-off;
	iblock = -1;
	buf = malloc(per*sizeof(SacDir));
	for(i=off; i<off+cnt; i++) {
		j = i/per;
		if(j != iblock) {
			loadblock(buf, blocks + j*8, per*sizeof(SacDir));
			iblock = j;
		}
		j *= per;
		sacstat(buf+i-j, p);
		p += DIRLEN;
	}
	free(buf);
	return cnt*DIRLEN;
}

Sac*
saclookup(Sac *s, char *name)
{
	int ndir;
	int top, bot, i, j, k, per;
	uchar *blocks;
	SacDir *buf;
	int iblock;
	SacDir *sd;
	
	if(strcmp(name, "..") == 0)
		return sacparent(s);
	blocks = data + getv(s->blocks);
	per = blocksize/sizeof(SacDir);
	ndir = getv(s->length);
	buf = malloc(per*sizeof(SacDir));
	iblock = -1;

	if(1) {
		// linear search
		for(i=0; i<ndir; i++) {
			j = i/per;
			if(j != iblock) {
				loadblock(buf, blocks + j*8, per*sizeof(SacDir));
				iblock = j;
			}
			j *= per;
			sd = buf+i-j;
			k = strcmp(name, sd->name);
			if(k == 0) {
//print("walk %s %lld %d\n", name, getv(s->blocks), i);
				s->path = sacpathalloc(s->path, getv(s->blocks), i);
				s->SacDir = *sd;
				free(buf);
				return s;
			}
		}
		free(buf);
		return 0;
	}

	// binary search
	top = ndir;
	bot = 0;
	while(bot != top){
if(bot>top)
sysfatal("binary serach failed: %d %d\n", bot, top);
		i = (bot+top)>>1;
		j = i/per;
		if(j != iblock) {
			loadblock(buf, blocks + j*8, per*sizeof(SacDir));
			iblock = j;
		}
		j *= per;
		sd = buf+i-j;
		k = strcmp(name, sd->name);
		if(k == 0) {
			s->path = sacpathalloc(s->path, getv(s->blocks), i);
			s->SacDir = *sd;
			free(buf);
		}
		if(k < 0) {
			top = i;
			sd = buf;
			if(strcmp(name, sd->name) < 0)
				top = j;
		} else {
			bot = i+1;
			if(ndir-j < per)
				i = ndir-j;
			else
				i = per;
			sd = buf+i-1;
			if(strcmp(name, sd->name) > 0)
				bot = j+i;
		}
	}
	return 0;
}

Fid *
newfid(int fid)
{
	Fid *f, *ff;

	ff = 0;
	for(f = fids; f; f = f->next)
		if(f->fid == fid)
			return f;
		else if(!ff && !f->busy)
			ff = f;
	if(ff){
		ff->fid = fid;
		return ff;
	}
	f = malloc(sizeof *f);
//fprint(2, "newfid\n");
	memset(f, 0 , sizeof(Fid));
	f->fid = fid;
	f->next = fids;
	fids = f;
	return f;
}

void
io(void)
{
	char *err;
	int n;

	for(;;){
		/*
		 * reading from a pipe or a network device
		 * will give an error after a few eof reads
		 * however, we cannot tell the difference
		 * between a zero-length read and an interrupt
		 * on the processes writing to us,
		 * so we wait for the error
		 */
		n = read(mfd[0], mdata, sizeof mdata);
		if(n == 0)
			continue;
		if(n < 0)
			error("mount read");
		if(convM2S(mdata, &rhdr, n) == 0)
			continue;

		if(debug)
			fprint(2, "sacfs:<-%F\n", &rhdr);

		thdr.data = mdata + MAXMSG;
		if(!fcalls[rhdr.type])
			err = "bad fcall type";
		else
			err = (*fcalls[rhdr.type])(newfid(rhdr.fid));
		if(err){
			thdr.type = Rerror;
			strncpy(thdr.ename, err, ERRLEN);
		}else{
			thdr.type = rhdr.type + 1;
			thdr.fid = rhdr.fid;
		}
		thdr.tag = rhdr.tag;
		if(debug)
			fprint(2, "ramfs:->%F\n", &thdr);/**/
		n = convS2M(&thdr, mdata);
		if(write(mfd[1], mdata, n) != n)
			error("mount write");
	}
}

int
perm(Fid *f, Sac *s, int p)
{
	ulong perm = getl(s->mode);
	if((p*Pother) & perm)
		return 1;
	if(strcmp(f->user, s->gid)==0 && ((p*Pgroup) & perm))
		return 1;
	if(strcmp(f->user, s->uid)==0 && ((p*Powner) & perm))
		return 1;
	return 0;
}


ulong
getl(void *p)
{
	uchar *a = p;

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

vlong
getv(void *p)
{
	uchar *a = p;
	ulong l0, l1;
	vlong v;

	l0 = (a[0]<<24) | (a[1]<<16) | (a[2]<<8) | a[3];
	a += 4;
	l1 = (a[0]<<24) | (a[1]<<16) | (a[2]<<8) | a[3];
	
	v = l0;
	v <<= 32;
	v |= l1;
	return v;
}

Dev sacdevtab = {
	'C',
	"sac",

	devreset,
	sacinit,
	sacattach,
	sacclone,
	sacwalk,
	sacstat,
	sacopen,
	devcreate,
	sacclose,
	sacread,
	devbread,
	sacwrite,
	devbwrite,
	devremove,
	devwstat,
};
.
## diffname mpc/devsac.c 1999/0609
## diff -e /n/emeliedump/1999/0608/sys/src/brazil/mpc/devsac.c /n/emeliedump/1999/0609/sys/src/brazil/mpc/devsac.c
611c
static vlong
.
518,603c
static ulong
.
514a
	free(buf);
.
499,513d
497a
			return s;
.
495c
print("walk %s %lld %d\n", name, getv(s->blocks), i);
		s->path = sacpathalloc(s->path, getv(s->blocks), i);
.
456,485c
	// linear search
	for(i=0; i<ndir; i++) {
.
442c
	int i, j, k, per;
.
438c
static Sac*
.
431c
		sacdir(c, buf+i-j, p);
.
412a
print("sacdirread %d %d\n", off, cnt);
	s = c->aux;
.
411a
	Sac *s;
.
406,407c
static int
sacdirread(Chan *c, char *p, long off, long cnt)
.
401c
	sacpathfree(s->path);
.
398c
print("sacparent = %s\n", s->name);
.
391c
print("sacparent = %lld %d\n", p->blocks, p->entry);
.
385c
		sacpathfree(p);
.
375c
static Sac*
.
370a
print("memmove: blocksize = %d\n", blocksize);
.
367c
print("blocksize = %d, block = %lld n = %lld\n", blocksize, block, n);
.
355c
static void
.
351a
	dir.type = devtab[c->type]->dc;
	dir.dev = c->dev;
.
337,338c
static void
sacdir(Chan *c, SacDir *s, char *buf)
.
330c
static void
.
307c
static SacPath *
.
300a
print("saccpy = %ux\n", ss);
.
295c
static Sac*
.
290,292c
	sacdir(c, c->aux, db);
.
287,288c
static void
sacstat(Chan *c, char *db)
.
278,285d
271,275c
	Sac *sac = c->aux;
print("close %ux\n", sac);
	c->aux = nil;
	sacfree(sac);
.
268,269c
static void
sacclose(Chan* c)
.
253,264c
	error(Eperm);
.
250,251c
static long
sacwrite(Chan *, void *, long, vlong)
.
247c
	return n;
.
239,244c
		nn = blocksize-j;
		if(nn > cnt)
			nn = cnt;
		memmove(buf, buf2+j, nn);
		cnt -= nn;
		off += nn;
.
232a
	n = cnt;
.
230d
227d
224,225c
	if(off >= length)
.
222a
print("data read\n");
	sac = c->aux;
.
219,221c
			error("i/o error");
		return sacdirread(c, buf, off, cnt);
.
209,217c
	buf = a;
	cnt = n;
	if(c->qid.path & CHDIR){
		cnt = (cnt/DIRLEN)*DIRLEN;
.
204,205c
	int nn, cnt, i, j;
.
199,200c

static long
sacread(Chan *c, void *a, long n, vlong off)
.
189,196c
	t = access[omode&3];
	if((t & mode) != t)
			error(Eperm);
	c->offset = 0;
	c->mode = openmode(omode);
	c->flag |= COPEN;
	return c;
.
161,187c
	sac = c->aux;
	mode = getl(sac->mode);
	if(strcmp(up->user, sac->uid) == 0)
		mode = mode;
	else if(strcmp(up->user, sac->gid) == 0)
		mode = mode<<3;
	else
		mode = mode<<6;
.
159c
	ulong t, mode;
	Sac *sac;
	static int access[] = { 0400, 0200, 0600, 0100 };
.
156,157c
static Chan*
sacopen(Chan *c, int omode)
.
150a
print("op=%ux name = %s\n", op, name);
.
142a
	sac = c->aux;
.
140,141c
	if(name[0]=='.' && name[1]==0)
.
138a
print("sacwalk\n");
.
137a
	Path *op;
.
134,135c
static int
sacwalk(Chan *c, char *name)
.
126c
static Chan*
.
101a
print("blocksize = %d\n", blocksize);
.
98c
print("devsac: bad magic\n");
.
95a
print("sacinit\n");
.
92,93c
static void
sacinit(void)
.
80,90c
static void	sacdir(Chan *, SacDir*, char*);
static ulong	getl(void *p);
static vlong	getv(void *p);
static Sac	*saccpy(Sac *s);
static Sac *saclookup(Sac *s, char *name);
static int sacdirread(Chan *, char *p, long off, long cnt);
static void loadblock(void *buf, uchar *offset, int blocksize);
static void sacfree(Sac*);
.
76,78c
static uchar *data = SACMEM;
static int blocksize;
static Sac root;
.
6a
#include "../port/error.h"
.
## diffname mpc/devsac.c 1999/0610
## diff -e /n/emeliedump/1999/0609/sys/src/brazil/mpc/devsac.c /n/emeliedump/1999/0610/sys/src/brazil/mpc/devsac.c
431d
375d
359d
352d
331d
327d
258d
240d
223a
		buf += nn;
.
203a
//print("sacread: %s %llx %d\n", sac->name, off, n);
.
202d
153d
140c
//print("walk %s\n", name);

.
101d
## diffname mpc/devsac.c 1999/0727
## diff -e /n/emeliedump/1999/0610/sys/src/brazil/mpc/devsac.c /n/emeliedump/1999/0727/sys/src/brazil/mpc/devsac.c
152,154d
137d
## diffname mpc/devsac.c 1999/0806
## diff -e /n/emeliedump/1999/0727/sys/src/brazil/mpc/devsac.c /n/emeliedump/1999/0806/sys/src/brazil/mpc/devsac.c
322a
		memmove(cache[j].data, buf, blocksize);
		cache[j].age = cacheage;
		cache[j].block = block;
.
316a
		cacheage++;
		// age has wraped
		if(cacheage == 0) {
			for(i=0; i<CacheSize; i++)
				cache[i].age = 0;
		}
		j = 0;
		age = cache[0].age;
		for(i=0; i<CacheSize; i++) {
			if(cache[i].age < age) {
				age = cache[i].age;
				j = i;
			}
			if(cache[i].block != block)
				continue;
			memmove(buf, cache[i].data, blocksize);
			cache[i].age = cacheage;
			return;
		}

.
312a
	ulong age;
	int i, j;
.
101a
	p = malloc(CacheSize*blocksize);
	if(p == nil)
		error("allocating cache");
	for(i=0; i<CacheSize; i++) {
		cache[i].data = p;
		p += blocksize;
	}
.
93a
	uchar *p;
	int i;

.
79a
static Cache cache[CacheSize];
static ulong cacheage;
.
66a
struct Cache
{
	long block;
	ulong age;
	uchar *data;
};

.
25a
typedef struct Cache Cache;
.
19a
	CacheSize = 20,
.
## diffname mpc/devsac.c 1999/0807
## diff -e /n/emeliedump/1999/0806/sys/src/brazil/mpc/devsac.c /n/emeliedump/1999/0807/sys/src/brazil/mpc/devsac.c
482,498d
466c
		s->path = sacpathalloc(s->path, getl(s->blocks), i, ndir);
.
459c
			n = per;
			if(n > ndir-j*per)
				n = ndir-j*per;
			loadblock(buf, blocks + j*OffsetSize, n*sizeof(SacDir));
.
451c
	ndir = getl(s->length);
.
449c
	blocks = data + getl(s->blocks);
.
441c
	int i, j, k, n, per;
.
426c
			n = per;
			if(n > ndir-j*per)
				n = ndir-j*per;
			loadblock(buf, blocks + j*OffsetSize, n*sizeof(SacDir));
.
414c
	ndir = getl(s->length);
.
412c
	blocks = data + getl(s->blocks);
.
408c
	int iblock, per, i, j, n, ndir;
.
394c
	loadblock(buf, blocks + i*OffsetSize, n*sizeof(SacDir));
.
392a
	n = per;
	if(n > p->nentry-i*per)
		n = p->nentry-i*per;
.
379c
	int per, i, n;
.
360c
		n = getl(offset+OffsetSize);
.
337c
	block = getl(offset);
.
333c
	long block, n;
.
321,322c
	memmove(dir.uid, s->uid, NAMELEN);
	memmove(dir.gid, s->gid, NAMELEN);
.
318c
	dir.length = getl(s->length);
.
286a
	pp->nentry = nentry;
.
281c
sacpathalloc(SacPath *p, long blocks, int entry, int nentry)
.
234c
		nn -= j;
.
232c
		nn = blocksize;
		if(nn > length-i*blocksize)
			nn = length-i*blocksize;
		loadblock(buf2, blocks+i*OffsetSize, nn);
.
228c
	blocks = data + getl(sac->blocks);
.
219,220c
	length = getl(sac->length);
.
208c
	long length;
	long off = voff;
.
202c
sacread(Chan *c, void *a, long n, vlong voff)
.
94d
66a
	int nentry;
.
65c
	long blocks;
.
20a
	OffsetSize = 4,		/* size in bytes of an offset */
.
## diffname mpc/devsac.c 1999/1231
## diff -e /n/emeliedump/1999/0807/sys/src/brazil/mpc/devsac.c /n/emeliedump/1999/1231/sys/src/9/mpc/devsac.c
164a
	if(name[0]=='.' && name[1]=='.' && name[2]==0)
		return 1;
.
## diffname mpc/devsac.c 2000/0516
## diff -e /n/emeliedump/1999/1231/sys/src/9/mpc/devsac.c /n/emeliedump/2000/0516/sys/src/9/mpc/devsac.c
109a
	s = getconf("flash");
	if(s == nil) {
		print("devsac: no flash file system\n");
		return;
	}

	p = (uchar*)strtoul(s, 0, 0);
	if(p == 0) {
		print("devsac: bad address for flash file system\n");
		return;
	}
	data = tarlookup(p, sacfs, &i);
	if(data == 0) {
		print("devsac: could not find file: %s\n", sacfs);
		return;
	}
.
106a
	char *s;
.
88c
static char *sacfs = "fs.sac";
static uchar *data;
.
9,15d
## diffname mpc/devsac.c 2000/1208
## diff -e /n/emeliedump/2000/0516/sys/src/9/mpc/devsac.c /n/emeliedump/2000/1208/sys/src/9/mpc/devsac.c
176,177d
## diffname mpc/devsac.c 2001/0527 # deleted
## diff -e /n/emeliedump/2000/1208/sys/src/9/mpc/devsac.c /n/emeliedump/2001/0527/sys/src/9/mpc/devsac.c
1,528d