Subversion Repositories planix.SVN

#include <u.h>

#include <libc.h>

#include <bio.h>

#include <auth.h>

#include <fcall.h>

#include <thread.h>

#include <9p.h>

#include "snap.h"

typedef struct PD PD;

struct PD {

	int isproc;

	union {

		Proc *p;

		Data *d;

	};

};

PD*

PDProc(Proc *p)

{

	PD *pd;

	pd = emalloc(sizeof(*pd));

	pd->isproc = 1;

	pd->p = p;

	return pd;

}

PD*

PDData(Data *d)

{

	PD *pd;

	pd = emalloc(sizeof(*pd));

	pd->isproc = 0;

	pd->d = d;

	return pd;

}

void

usage(void)

{

	fprint(2, "usage: snapfs [-a] [-m mtpt] file\n");

	exits("usage");

}

char*

memread(Proc *p, File *f, void *buf, long *count, vlong offset)

{

	Page *pg;

	int po;

	po = offset%Pagesize;

	if(!(pg = findpage(p, p->pid, f->name[0], offset-po)))

		return "address not mapped";

	if(*count > Pagesize-po)

		*count = Pagesize-po;

	memmove(buf, pg->data+po, *count);

	return nil;

}

char*

dataread(Data *d, void *buf, long *count, vlong offset)

{

	assert(d != nil);

	if(offset >= d->len) {

		*count = 0;

		return nil;

	}

	if(offset+*count >= d->len)

		*count = d->len - offset;

	memmove(buf, d->data+offset, *count);

	return nil;

}

void

fsread(Req *r)

{

	char *e;

	PD *pd;

	Fid *fid;

	void *data;

	vlong offset;

	long count;

	fid = r->fid;

	data = r->ofcall.data;

	offset = r->ifcall.offset;

	count = r->ifcall.count;

	pd = fid->file->aux;

	if(pd->isproc)

		e = memread(pd->p, fid->file, data, &count, offset);

	else

		e = dataread(pd->d, data, &count, offset);

	if(e == nil)

		r->ofcall.count = count;

	respond(r, e);

}

Srv fs = {

	.read = fsread,

};

File*

ecreatefile(File *a, char *b, char *c, ulong d, void *e)

{

	File *f;

	f = createfile(a, b, c, d, e);

	if(f == nil)

		sysfatal("error creating snap tree: %r");

	return f;

}

void

main(int argc, char **argv)

{

	Biobuf *b;

	Data *d;

	File *fdir, *f;

	Proc *p, *plist;

	Tree *tree;

	char *mtpt, buf[32];

	int i, mflag;

	mtpt = "/proc";

	mflag = MBEFORE;

	ARGBEGIN{

	case 'D':

		chatty9p++;

		break;

	case 'd':

		debug = 1;

		break;

	case 'a':

		mflag = MAFTER;

		break;

	case 'm':

		mtpt = ARGF();

		break;

	default:

		usage();

	}ARGEND

	if(argc != 1)

		usage();

	b = Bopen(argv[0], OREAD);

	if(b == nil) {

		fprint(2, "cannot open \"%s\": %r\n", argv[0]);

		exits("Bopen");

	}

	if((plist = readsnap(b)) == nil) {

		fprint(2, "readsnap fails\n");

		exits("readsnap");

	}

	tree = alloctree(nil, nil, DMDIR|0555, nil);

	fs.tree = tree;

	for(p=plist; p; p=p->link) {

		print("process %ld %.*s\n", p->pid, 28, p->d[Pstatus] ? p->d[Pstatus]->data : "");

		snprint(buf, sizeof buf, "%ld", p->pid);

		fdir = ecreatefile(tree->root, buf, nil, DMDIR|0555, nil);

		ecreatefile(fdir, "ctl", nil, 0777, nil);

		if(p->text)

			ecreatefile(fdir, "text", nil, 0777, PDProc(p));

		ecreatefile(fdir, "mem", nil, 0666, PDProc(p));

		for(i=0; i<Npfile; i++) {

			if(d = p->d[i]) {

				f = ecreatefile(fdir, pfile[i], nil, 0666, PDData(d));

				f->length = d->len;

			}

		}

	}

	postmountsrv(&fs, nil, mtpt, mflag);

	exits(0);

}