Subversion Repositories planix.SVN

#include <u.h>

#include <libc.h>

#include <bio.h>

#include <mach.h>

#include "snap.h"

/* research 16-bit crc.  good enough. */

static ulong

sumr(ulong sum, void *buf, int n)

{

	uchar *s, *send;

	if(buf == 0)

		return sum;

	for(s=buf, send=s+n; s<send; s++)

		if(sum & 1)

			sum = 0xffff & ((sum>>1)+*s+0x8000);

		else

			sum = 0xffff & ((sum>>1)+*s);

	return sum;

}

static int npage;

static Page *pgtab[1<<10];

Page*

datapage(char *p, long len)

{

	Page *pg;

	char *q, *ep;

	long	sum;

	int iszero;

	if(len > Pagesize) {

		fprint(2, "datapage cannot handle pages > 1024\n");

		exits("datapage");

	}

	sum = sumr(0, p, len) & (nelem(pgtab)-1);

	if(sum == 0) {

		iszero = 1;

		for(q=p, ep=p+len; q<ep; q++)

			if(*q != 0) {

				iszero = 0;

				break;

			}

	} else

		iszero = 0;

	for(pg = pgtab[sum]; pg; pg=pg->link)

		if(pg->len == len && memcmp(pg->data, p, len) == 0)

			break;

	if(pg)

		return pg;

	pg = emalloc(sizeof(*pg)+len);

	pg->data = (char*)&pg[1];

	pg->type = 0;

	pg->len = len;

	memmove(pg->data, p, len);

	pg->link = pgtab[sum];

	pgtab[sum] = pg;

	if(iszero) {

		pg->type = 'z';

		pg->written = 1;

	}

	++npage;

	return pg;

}

static Data*

readsection(long pid, char *sec)

{

	char buf[8192];

	int n, fd;

	int hdr, tot;

	Data *d = nil;

	snprint(buf, sizeof buf, "/proc/%ld/%s", pid, sec);

	if((fd = open(buf, OREAD)) < 0)

		return nil;

	tot = 0;

	hdr = (int)((Data*)0)->data;

	while((n = read(fd, buf, sizeof buf)) > 0) {

		d = erealloc(d, tot+n+hdr);

		memmove(d->data+tot, buf, n);

		tot += n;

	}

	close(fd);

	if(d == nil)

		return nil;

	d->len = tot;

	return d;

}

static Seg*

readseg(int fd, vlong off, ulong len, char *name)

{

	char buf[Pagesize];

	Page **pg;

	int npg;

	Seg *s;

	ulong i;

	int n;

	s = emalloc(sizeof(*s));

	s->name = estrdup(name);

	if(seek(fd, off, 0) < 0) {

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

		goto Die;

	}

	pg = nil;

	npg = 0;

	for(i=0; i<len; ) {

		n = Pagesize;

		if(n > len-i)

			n = len-i;

		if((n = readn(fd, buf, n)) <= 0)

			break;

		pg = erealloc(pg, sizeof(*pg)*(npg+1));

		pg[npg++] = datapage(buf, n);

		i += n;

		if(n != Pagesize)	/* any short read, planned or otherwise */

			break;

	}

	if(i==0 && len!=0)

		goto Die;

	s->offset = off;

	s->len = i;

	s->pg = pg;

	s->npg = npg;

	return s;

Die:

	free(s->name);

	free(s);

	return nil;

}

/* discover the stack pointer of the given process */

ulong

stackptr(Proc *proc, int fd)

{

	char *q;

	Fhdr f;

	Reglist *r;

	long textoff;

	int i;

	Data *dreg;

	textoff = -1;

	for(i=0; i<proc->nseg; i++)

		if(proc->seg[i] && strcmp(proc->seg[i]->name, "Text") == 0)

			textoff = proc->seg[i]->offset;

	if(textoff == -1)

		return 0;

	seek(fd, textoff, 0);

	if(crackhdr(fd, &f) == 0)

		return 0;

	machbytype(f.type);

	for(r=mach->reglist; r->rname; r++)

		if(strcmp(r->rname, mach->sp) == 0)

			break;

	if(r == nil) {

		fprint(2, "couldn't find stack pointer register?\n");

		return 0;

	}

	if((dreg = proc->d[Pregs]) == nil)

		return 0;

	if(r->roffs+mach->szreg > dreg->len) {

		fprint(2, "SP register too far into registers?\n");

		return 0;

	}

	q = dreg->data+r->roffs;

	switch(mach->szreg) {

	case 2:	return machdata->swab(*(ushort*)q);

	case 4:	return machdata->swal(*(ulong*)q);

	case 8:	return machdata->swav(*(uvlong*)q);

	default:

		fprint(2, "register size is %d bytes?\n", mach->szreg);

		return 0;

	}

}

Proc*

snap(long pid, int usetext)

{

	Data *d;

	Proc *proc;

	Seg **s;

	char *name, *segdat, *q, *f[128+1], buf[128];

	int fd, i, stacki, nf, np;

	uvlong off, len, stackoff, stacklen;

	uvlong sp;

	proc = emalloc(sizeof(*proc));

	proc->pid = pid;

	np = 0;

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

		if(proc->d[i] = readsection(pid, pfile[i]))

			np++;

		else

			fprint(2, "warning: can't include /proc/%ld/%s\n", pid, pfile[i]);

	}

	if(np == 0)

		return nil;

	if(usetext) {

		snprint(buf, sizeof buf, "/proc/%ld/text", pid);

		if((fd = open(buf, OREAD)) >= 0) {

			werrstr("");

			if((proc->text = readseg(fd, 0, 1<<31, "textfile")) == nil)

				fprint(2, "warning: can't include %s: %r\n", buf);

			close(fd);

		} else

			fprint(2, "warning: can't include /proc/%ld/text\n", pid);

	}

	if((d=proc->d[Psegment]) == nil) {

		fprint(2, "warning: no segment table, no memory image\n");

		return proc;

	}

	segdat = emalloc(d->len+1);

	memmove(segdat, d->data, d->len);

	segdat[d->len] = 0;

	nf = getfields(segdat, f, nelem(f), 1, "\n");

	if(nf == nelem(f)) {

		nf--;

		fprint(2, "process %ld has >%d segments; only using first %d\n",

			pid, nf, nf);

	}

	if(nf <= 0) {

		fprint(2, "warning: couldn't understand segment table, no memory image\n");

		free(segdat);

		return proc;

	}

	snprint(buf, sizeof buf, "/proc/%ld/mem", pid);

	if((fd = open(buf, OREAD)) < 0) {

		fprint(2, "warning: can't include /proc/%ld/mem\n", pid);

		return proc;

	}

	s = emalloc(nf*sizeof(*s));

	stacklen = 0;

	stackoff = 0;

	stacki = 0;

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

		if(q = strchr(f[i], ' ')) 

			*q = 0;

		name = f[i];

		off = strtoull(name+10, &q, 16);

		len = strtoull(q, &q, 16) - off;

		if(strcmp(name, "Stack") == 0) {

			stackoff = off;

			stacklen = len;

			stacki = i;

		} else

			s[i] = readseg(fd, off, len, name);

	}

	proc->nseg = nf;

	proc->seg = s;

	/* stack hack: figure sp so don't need to page in the whole segment */

	if(stacklen) {

		sp = stackptr(proc, fd);

		if(stackoff <= sp && sp < stackoff+stacklen) {

			off = (sp - Pagesize) & ~(Pagesize - 1);

			if(off < stackoff)

				off = stackoff;

			len = stacklen - (off - stackoff);

		} else {	/* stack pointer not in segment.  thread library? */

			off = stackoff + stacklen - 16*1024;

			len = 16*1024;

		}

		s[stacki] = readseg(fd, off, len, "Stack");

	}

	return proc;

}