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 "stats.h"

/*

 *  read the inode blocks and make sure they

 *  haven't been trashed.

 *

 *  make the in-core table of qid to inode mappings.

 *	N.B. this is just an array. we need a linear search to find

 *	     a particular inode. this could be done faster.

 *

 *  nab is the first inode block.

 */

int

iinit(Icache *ic, int f, int psize, char* name)

{

	Ibuf *b;

	Imap *m;

	ulong ino;

	Bbuf *bb;

	Dinode *bi;

	/*

	 *  get basic sizes and allocation info from disk

	 */

	if(dinit(ic, f, psize, name) < 0)

		return -1;

	/*

	 *  read first inode block to get number of inodes

	 */

	bb = bcread(ic, ic->nab);

	if(bb == 0){

		fprint(2, "iinit: can't read disk\n");

		return -1;

	}

	bi = (Dinode*)bb->data;

	if(bi->nino==0 || bi->nino>2048){

		fprint(2, "iinit: bad nino\n");

		return -1;

	}

	ic->nino = bi->nino;

	/*

	 *  set up sizing constants

	 */

	ic->i2b = (ic->bsize - sizeof(Dihdr))/sizeof(Inode);

	ic->nib = (ic->nino + ic->i2b - 1)/ic->i2b;

	/*

	 *  allocate the in-core qid/inode map, build it's lru

	 */

	if(ic->map)

		free(ic->map);

	ic->map = malloc(sizeof(Imap)*ic->nino);

	if(ic->map == 0){

		fprint(2, "iinit: can't alloc map\n");

		return -1;

	}

	lruinit(&ic->mlru);

	for(m = ic->map; m < &ic->map[ic->nino]; m++){

		m->inuse = 0;

		m->b = 0;

		lruadd(&ic->mlru, m);

	}

	/*

	 *  mark all cache buffers as empty, put them on the lru list

	 */

	lruinit(&ic->blru);

	for(b = ic->ib; b < &ic->ib[Nicache]; b++){

		b->inuse = 0;

		lruadd(&ic->blru, b);

	}

	/*

	 *  Read all inodes and

	 *  build the in-core qid/inode map

	 */

	for(ino = 0; ino < ic->nino; ino++){

		b = iread(ic, ino);

		if(b == 0){

			fprint(2, "iinit: can't read inode %ld\n", ino);

			return -1;

		}

		if(b->inode.inuse){

			m = &ic->map[ino];

			m->inuse = 1;

			m->qid = b->inode.qid;

			lruref(&ic->mlru, m);

		}

	}

	return 0;

}

/*

 *  format the inode blocks

 */

int

iformat(Icache *ic, int f, ulong nino, char *name, int bsize, int psize)

{

	int nib;

	ulong bno, i2b, i;

	Bbuf *bb;

	Dinode *bi;

	/*

	 *  first format disk allocation

	 */

	if(dformat(ic, f, name, bsize, psize) < 0)

		return -1;

	fprint(2, "formatting inodes\n");

	i2b = (bsize - sizeof(Dihdr))/sizeof(Inode);

	nib = (nino + i2b - 1)/i2b;

	for(bno = ic->nab; bno < ic->nab + nib; bno++){

		if(dalloc(ic, 0) == Notabno){

			fprint(2, "iformat: balloc failed\n");

			return -1;

		}

		bb = bcalloc(ic, bno);

		if(bb == 0){

			fprint(2, "iformat: bcalloc failed\n");

			return -1;

		}

		bi = (Dinode*)bb->data;

		bi->magic = Imagic;

		bi->nino = nino;

		for(i = 0; i < i2b; i++)

			bi->inode[i].inuse = 0;

		bcmark(ic, bb);

	}

	bcsync(ic);

	return iinit(ic, f, psize, name);

}

/*

 *  allocate a cache buffer, use least recently used

 */

Ibuf*

ialloc(Icache *ic, ulong ino)

{

	Imap *m;

	Ibuf *b;

	b = (Ibuf*)ic->blru.lnext;

	if(b->inuse)

		ic->map[b->ino].b = 0;

	b->ino = ino;

	b->inuse = 1;

	m = &ic->map[ino];

	m->b = b;

	return b;

}

/*

 *  free a cache buffer

 */

void

ifree(Icache *ic, Ibuf *b)

{

	b->inuse = 0;

	if(b->inuse)

		ic->map[b->ino].b = 0;

	lruderef(&ic->blru, b);

}

/*

 *  get an inode into the cache.  if no inode exists for this qid, create one

 *  from an unused qid/inode map.

 */

Ibuf *

iget(Icache *ic, Qid qid)

{

	Imap *m, *me;

	Ibuf *b;

	/*

	 *  find map entry with same qid.path

	 */

	for(m = ic->map, me = &ic->map[ic->nino]; m < me; m++)

		if(m->inuse && m->qid.path==qid.path){

			if(m->qid.vers != qid.vers){

				/*

				 *  our info is old, forget it

				 */

				DPRINT(2, "updating old file %llud.%lud\n",

					qid.path, qid.vers);

				m->qid = qid;

				iupdate(ic, m - ic->map, qid);

			}

			break;

		}

	/*

 	 *  if an already existing inode, just get it

	 */

	if(m != me)

		return iread(ic, m - ic->map);

	/*

	 *  create a new inode, throw out the least recently used inode

	 *  if necessary

	 */

	m = (Imap*)ic->mlru.lnext;

	if(m->inuse){

		DPRINT(2, "superceding file %llud.%ld by %llud.%ld\n",

			m->qid.path, m->qid.vers, qid.path, qid.vers);

		if(iremove(ic, m - ic->map) < 0)

			return 0;

	}

	if(statson)

		cfsstat.ninsert++;

	/*

	 *  init inode and write to disk

	 */

	DPRINT(2, "new file %llud.%ld ino %ld\n",

		qid.path, qid.vers, m - ic->map);

	b = ialloc(ic, m - ic->map);

	b->inode.inuse = m->inuse = 1;

	b->inode.qid = qid;

	b->inode.length = 0x7fffffffffffffffLL;

	m->qid = qid;

	b->inode.ptr.bno = Notabno;

	iwrite(ic, b);

	return b;

}

/*

 *  read an inode into the cache

 *

 *  ASSUMPTION: the inode is valid

 */

Ibuf*

iread(Icache *ic, ulong ino)

{

	Ibuf *b;

	Imap *m;

	ulong bno;

	Bbuf *bb;

	Dinode *bi;

	/*

	 *  first see if we already have it in a cache entry

	 */

	m = &ic->map[ino];

	if(m->inuse && m->b){

		b = m->b;

		goto out;

	}

	/*

	 *  read it

	 */

	b = ialloc(ic, ino);

	bno = ic->nab + ino/ic->i2b;

	bb = bcread(ic, bno);

	if(bb == 0){

		ifree(ic, b);

		return 0;

	}

	bi = (Dinode*)bb->data;

	b->inode = bi->inode[ino % ic->i2b];

	/*

	 *  consistency check

	 */

	if(bi->nino!=ic->nino || bi->magic!=Imagic){

		fprint(2, "iread: inconsistent inode block\n");

		ifree(ic, b);

		return 0;

	}

out:

	b->inuse = 1;

	m->b = b;

	if(b->inode.inuse)

		lruref(&ic->mlru, m);

	lruref(&ic->blru, b);

	return b;

}

/*

 *  write an inode back to disk

 */

int

iwrite(Icache *ic, Ibuf *b)

{

	ulong bno;

	Bbuf *bb;

	Dinode *bi;

	bno = ic->nab + b->ino/ic->i2b;

	bb = bcread(ic, bno);

	if(bb == 0)

		return 0;

	bi = (Dinode*)bb->data;

	bi->inode[b->ino % ic->i2b] = b->inode;

	bcmark(ic, bb);

	lruref(&ic->mlru, &ic->map[b->ino]);

	lruref(&ic->blru, b);

	return 0;

}

/*

 *  Forget what we know about an inode without removing it

 *

 *	N.B: ordering of iwrite and dfree is important

 */

int

iupdate(Icache *ic, ulong ino, Qid qid)

{

	Ibuf *b;

	Imap *m;

	Dptr d;

	if(statson)

		cfsstat.nupdate++;

	b = iread(ic, ino);

	if(b == 0)

		return -1;

	/*

	 *  update inode and map

	 */

	b->inode.qid = qid;

	b->inode.length = 0x7fffffffffffffffLL;	/* Set to maximum */

	m = &ic->map[ino];

	m->qid = qid;

	/*

	 *  the free is not done if the write fails!

	 *  this is important

	 */

	d = b->inode.ptr;

	b->inode.ptr.bno = Notabno;

	if(iwrite(ic, b) < 0)

		return -1;

	dfree(ic, &d);

	return 0;

}

/*

 *  remove an inode

 *

 *	N.B: ordering of iwrite and dfree is important

 */

int

iremove(Icache *ic, ulong ino)

{

	Ibuf *b;

	Imap *m;

	if(statson)

		cfsstat.ndelete++;

	m = &ic->map[ino];

	/*

	 *  read in inode

	 */

	b = iread(ic, ino);

	if(b == 0)

		return -1;

	/*

	 *  mark it unused on disk

	 */

	b->inode.inuse = 0;

	if(iwrite(ic, b) < 0)

		return -1;

	/*

	 *  throw out it's data pages

	 */

	dfree(ic, &b->inode.ptr);

	/*

	 *  free the inode buffer

	 */

	ifree(ic, b);

	/*

	 *  make map entry least recently used

	 */

	lruderef(&ic->mlru, m);

	return 0;

}

/*

 *  increment our version number

 */

void

iinc(Icache *ic, Ibuf *b)

{

	b->inode.qid.vers++;

	ic->map[b->ino].qid = b->inode.qid;

	iwrite(ic, b);

}