Subversion Repositories planix.SVN

#include <u.h>

#include <libc.h>

#include <auth.h>

#include <fcall.h>

#include "dat.h"

#include "fns.h"

/*

 * We used to use 100 i/o buffers of size 2kb (Sectorsize).

 * Unfortunately, reading 2kb at a time often hopping around

 * the disk doesn't let us get near the disk bandwidth.

 *

 * Based on a trace of iobuf address accesses taken while

 * tarring up a Plan 9 distribution CD, we now use 16 128kb

 * buffers.  This works for ISO9660 because data is required

 * to be laid out contiguously; effectively we're doing agressive

 * readahead.  Because the buffers are so big and the typical 

 * disk accesses so concentrated, it's okay that we have so few

 * of them.

 *

 * If this is used to access multiple discs at once, it's not clear

 * how gracefully the scheme degrades, but I'm not convinced

 * it's worth worrying about.		-rsc

 */

/* trying a larger value to get greater throughput - geoff */

#define	BUFPERCLUST	256 /* sectors/cluster; was 64, 64*Sectorsize = 128kb */

#define	NCLUST		16

int nclust = NCLUST;

static Ioclust*	iohead;

static Ioclust*	iotail;

static Ioclust*	getclust(Xdata*, vlong);

static void	putclust(Ioclust*);

static void	xread(Ioclust*);

void

iobuf_init(void)

{

	int i, j, n;

	Ioclust *c;

	Iobuf *b;

	uchar *mem;

	n = nclust*sizeof(Ioclust) +

		nclust*BUFPERCLUST*(sizeof(Iobuf)+Sectorsize);

	mem = sbrk(n);

	if(mem == (void*)-1)

		panic(0, "iobuf_init");

	memset(mem, 0, n);

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

		c = (Ioclust*)mem;

		mem += sizeof(Ioclust);

		c->addr = -1;

		c->prev = iotail;

		if(iotail)

			iotail->next = c;

		iotail = c;

		if(iohead == nil)

			iohead = c;

		c->buf = (Iobuf*)mem;

		mem += BUFPERCLUST*sizeof(Iobuf);

		c->iobuf = mem;

		mem += BUFPERCLUST*Sectorsize;

		for(j=0; j<BUFPERCLUST; j++){

			b = &c->buf[j];

			b->clust = c;

			b->addr = -1;

			b->iobuf = c->iobuf+j*Sectorsize;

		}

	}

}

void

purgebuf(Xdata *dev)

{

	Ioclust *p;

	for(p=iohead; p!=nil; p=p->next)

		if(p->dev == dev){

			p->addr = -1;

			p->busy = 0;

		}

}

static Ioclust*

getclust(Xdata *dev, vlong addr)

{

	Ioclust *c, *f;

	f = nil;

	for(c=iohead; c; c=c->next){

		if(!c->busy)

			f = c;

		if(c->addr == addr && c->dev == dev){

			c->busy++;

			return c;

		}

	}

	if(f == nil)

		panic(0, "out of buffers");

	f->addr = addr;

	f->dev = dev;

	f->busy++;

	if(waserror()){

		f->addr = -1;	/* stop caching */

		putclust(f);

		nexterror();

	}

	xread(f);

	poperror();

	return f;

}

static void

putclust(Ioclust *c)

{

	if(c->busy <= 0)

		panic(0, "putbuf");

	c->busy--;

	/* Link onto head for LRU */

	if(c == iohead)

		return;

	c->prev->next = c->next;

	if(c->next)

		c->next->prev = c->prev;

	else

		iotail = c->prev;

	c->prev = nil;

	c->next = iohead;

	iohead->prev = c;

	iohead = c;

}

Iobuf*

getbuf(Xdata *dev, uvlong addr)

{

	int off;

	Ioclust *c;

	off = addr%BUFPERCLUST;

	c = getclust(dev, addr - off);

	if(c->nbuf < off){

		c->busy--;

		error("short read or I/O error");

	}

	return &c->buf[off];

}

void

putbuf(Iobuf *b)

{

	putclust(b->clust);

}

static void

xread(Ioclust *c)

{

	int n;

	Xdata *dev;

	dev = c->dev;

	seek(dev->dev, (vlong)c->addr * Sectorsize, 0);

	n = readn(dev->dev, c->iobuf, BUFPERCLUST*Sectorsize);

	if(n < Sectorsize)

		error("short read or I/O error");

	c->nbuf = n/Sectorsize;

}