Subversion Repositories planix.SVN

#include <u.h>

#include <libc.h>

#include "cformat.h"

#include "lru.h"

#include "bcache.h"

#include "disk.h"

#include "inode.h"

#include "file.h"

/*

 *  merge data with that which already exists in a block

 *

 *  we allow only one range per block, always use the new

 *  data if the ranges don't overlap.

 */

void

fmerge(Dptr *p, char *to, char *from, int start, int len)

{

	int end;

	end = start + len;

	memmove(to+start, from, end-start);

	/*

	 *  if ranges do not overlap...

	 */

	if(start>p->end || p->start>end){

		/*

		 *  just use the new data

		 */

		p->start = start;

		p->end = end;

	} else {

		/*

		 *  merge ranges

		 */

		if(start < p->start)

			p->start = start;

		if(end > p->end)

			p->end = end;

	}

}

/*

 *  write a block (or less) of data onto a disk, follow it with any necessary

 *  pointer writes.

 *

 *	N.B. ordering is everything

 */

int

fbwrite(Icache *ic, Ibuf *b, char *a, ulong off, int len)

{

	int wrinode;

	ulong fbno;

	Bbuf *dbb;	/* data block */

	Bbuf *ibb;	/* indirect block */

	Dptr *p;

	Dptr t;

	fbno = off / ic->bsize;

	p = &b->inode.ptr;

	ibb = 0;

	wrinode = 0;

	/*

	 *  are there any pages for this inode?

	 */

	if(p->bno == Notabno){

		wrinode = 1;

		goto dowrite;

	}

	/*

 	 *  is it an indirect block?

	 */

	if(p->bno & Indbno){

		ibb = bcread(ic, p->bno);

		if(ibb == 0)

			return -1;

		p = (Dptr*)ibb->data;

		p += fbno % ic->p2b;

		goto dowrite;

	}

	/*

 	 *  is it the wrong direct block?

	 */

	if((p->fbno%ic->p2b) != (fbno%ic->p2b)){

		/*

		 *  yes, make an indirect block

		 */

		t = *p;

		dpalloc(ic, p);

		if(p->bno == Notabno){

			*p = t;

			return -1;

		}

		ibb = bcalloc(ic, p->bno);

		if(ibb == 0){

			*p = t;

			return -1;

		}

		p = (Dptr*)ibb->data;

		p += t.fbno % ic->p2b;

		*p = t;

		p = (Dptr*)ibb->data;

		p += fbno % ic->p2b;

	}

	wrinode = 1;

dowrite:

	/*

	 *  get the data block into the block cache

	 */

	if(p->bno == Notabno){

		/*

		 *  create a new block

		 */

		dalloc(ic, p);

		if(p->bno == Notabno)

			return -1;		/* no blocks left (maybe) */

		dbb = bcalloc(ic, p->bno);

	} else {

		/*

		 *  use what's there

		 */

		dbb = bcread(ic, p->bno);

	}

	if(dbb == 0)

		return -1;

	/*

	 *  merge in the new data

	 */

	if(p->fbno != fbno){

		p->start = p->end = 0;

		p->fbno = fbno;

	}

	fmerge(p, dbb->data, a, off % ic->bsize, len);

	/*

	 *  write changed blocks back in the

	 *  correct order

	 */

	bcmark(ic, dbb);

	if(ibb)

		bcmark(ic, ibb);

	if(wrinode)

		if(iwrite(ic, b) < 0)

			return -1;

	return len;

}

/*

 *  write `n' bytes to the cache

 *

 *  return number of bytes written

 */

long

fwrite(Icache *ic, Ibuf *b, char *a, ulong off, long n)

{

	int len;

	long sofar;

	for(sofar = 0; sofar < n; sofar += len){

		len = ic->bsize - ((off+sofar)%ic->bsize);

		if(len > n - sofar)

			len = n - sofar;

		if(fbwrite(ic, b, a+sofar, off+sofar, len) < 0)

			return sofar;

	}

	return sofar;

}

/*

 *  get a pointer to the next valid data at or after `off'

 */

Dptr *

fpget(Icache *ic, Ibuf *b, ulong off)

{

	ulong fbno;

	long doff;

	Bbuf *ibb;	/* indirect block */

	Dptr *p, *p0, *pf;

	fbno = off / ic->bsize;

	p = &b->inode.ptr;

	/*

	 *  are there any pages for this inode?

	 */

	if(p->bno == Notabno)

		return 0;

	/*

 	 *  if it's a direct block, life is easy?

	 */

	if(!(p->bno & Indbno)){

		/*

		 *  a direct block, return p if it's at least past what we want

		 */

		if(p->fbno > fbno)

			return p;

		if(p->fbno < fbno)

			return 0;

		doff = off % ic->bsize;

		if(doff>=p->start && doff<p->end)

			return p;

		else

			return 0;

	}

	/*

	 *  read the indirect block

	 */

	ibb = bcread(ic, p->bno);

	if(ibb == 0)

		return 0;

	/*

	 *  find the next valid pointer

	 */

	p0 = (Dptr*)ibb->data;

	pf = p0 + (fbno % ic->p2b);

	if(pf->bno!=Notabno && pf->fbno==fbno){

		doff = off % ic->bsize;

		if(doff<pf->end)

			return pf;

	}

	for(p = pf+1; p < p0 + ic->p2b; p++){

		fbno++;

		if(p->fbno==fbno && p->bno!=Notabno && p->start<p->end)

			return p;

	}

	for(p = p0; p < pf; p++){

		fbno++;

		if(p->fbno==fbno && p->bno!=Notabno && p->start<p->end)

			return p;

	}

	return 0;

}

/*

 *  read `n' bytes from the cache.

 *

 *  if we hit a gap and we've read something,

 *  return number of bytes read so far.

 *

 *  if we start with a gap, return minus the number of bytes

 *  to the next data.

 *

 *  if there are no bytes cached, return 0.

 */

long

fread(Icache *ic, Ibuf *b, char *a, ulong off, long n)

{

	int len, start;

	long sofar, gap;

	Dptr *p;

	Bbuf *bb;

	for(sofar = 0; sofar < n; sofar += len, off += len){

		/*

		 *  get pointer to next data

		 */

		len = n - sofar;

		p = fpget(ic, b, off);

		/*

		 *  if no more data, return what we have so far

		 */

		if(p == 0)

			return sofar;

		/*

		 *  if there's a gap, return the size of the gap

		 */

		gap = (ic->bsize*p->fbno + p->start) - off;

		if(gap>0)

			if(sofar == 0)

				return -gap;

			else

				return sofar;

		/*

		 *  return what we have

		 */

		bb = bcread(ic, p->bno);

		if(bb == 0)

			return sofar;

		start = p->start - gap;

		if(p->end - start < len)

			len = p->end - start;

		memmove(a + sofar, bb->data + start, len);

	}

	return sofar;

}