Subversion Repositories planix.SVN

#include <u.h>

#include <libc.h>

#include "cformat.h"

#include "lru.h"

#include "bcache.h"

#include "disk.h"

int	icformat(Disk*, ulong);

/*

 *  read in the disk structures,  return -1 if the format

 *  is inconsistent.

 */

int

dinit(Disk *d, int f, int psize, char *expname)

{

	ulong	i;

	uvlong	length;

	char	buf[1024];

	Bbuf	*b;

	Dalloc	*ba;

	Dir	*dir;

	/*

	 *  get disk size

	 */

	dir = dirfstat(f);

	if(dir == nil){

		perror("dinit: stat");

		return -1;

	}

	length = dir->length;

	free(dir);

	/*

	 *  read first physical block to get logical block size, # of inodes,

	 *  and # of allocation blocks

	 */

	if(seek(f, 0, 0) < 0){

		perror("dinit: seek");

		return -1;

	}

	if(read(f, buf, sizeof(buf)) != sizeof(buf)){

		perror("dinit: read");

		return -1;

	}

	ba = (Dalloc*)buf;

	if(ba->bsize <= 0){

		fprint(2, "dinit: bsize 0x%lux<= 0\n", ba->bsize);

		return -1;

	}

	if((ba->bsize % psize) != 0){

		fprint(2, "dinit: logical bsize (%lud) not multiple of physical (%ud)\n",

			ba->bsize, psize);

		return -1;

	}

	d->bsize = ba->bsize;

	d->nb = length/d->bsize;

	d->b2b = (d->bsize - sizeof(Dahdr))*8;

	d->nab = (d->nb+d->b2b-1)/d->b2b;

	d->p2b = d->bsize/sizeof(Dptr);

	strncpy(d->name, ba->name, sizeof d->name);

	if (expname != nil && strncmp(d->name, expname, sizeof d->name) != 0) {

		/* Mismatch with recorded name; fail here to force a format */

		fprint(2, "cfs: name mismatch\n");

		return -1;

	}

	/*

	 *  check allocation blocks for consistency

	 */

	if(bcinit(d, f, d->bsize) < 0){

		fprint(2, "dinit: couldn't init block cache\n");

		return -1;

	}

	for(i = 0; i < d->nab; i++){

		b = bcread(d, i);

		if(b == 0){

			perror("dinit: read");

			return -1;

		}

		ba = (Dalloc*)b->data;

		if(ba->magic != Amagic){

			fprint(2, "dinit: bad magic in alloc block %uld\n", i);

			return -1;

		}

		if(d->bsize != ba->bsize){

			fprint(2, "dinit: bad bsize in alloc block %uld\n", i);

			return -1;

		}

		if(d->nab != ba->nab){

			fprint(2, "dinit: bad nab in alloc block %uld\n", i);

			return -1;

		}

		if(strncmp(d->name, ba->name, sizeof(d->name))){

			fprint(2, "dinit: bad name in alloc block %uld\n", i);

			return -1;

		}

	}

	return 0;

}

/*

 *  format the disk as a cache

 */

int

dformat(Disk *d, int f, char *name, ulong bsize, ulong psize)

{

	int	i;

	uvlong	length;

	Bbuf	*b;

	Dalloc	*ba;

	Dir	*dir;

	Dptr	dptr;

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

	/*

	 *  calculate basic numbers

	 */

	dir = dirfstat(f);

	if(dir == nil)

		return -1;

	length = dir->length;

	d->bsize = bsize;

	if((d->bsize % psize) != 0){

		fprint(2, "cfs: logical bsize not multiple of physical\n");

		return -1;

	}

	d->nb = length/d->bsize;

	d->b2b = (d->bsize - sizeof(Dahdr))*8;

	d->nab = (d->nb+d->b2b-1)/d->b2b;

	d->p2b = d->bsize/sizeof(Dptr);

	/*

	 *  init allocation blocks

	 */

	if(bcinit(d, f, d->bsize) < 0)

		return -1;

	for(i = 0; i < d->nab; i++){

		b = bcalloc(d, i);

		if(b == 0){

			perror("cfs: bcalloc");

			return -1;

		}

		memset(b->data, 0, d->bsize);

		ba = (Dalloc*)b->data;

		ba->magic = Amagic;

		ba->bsize = d->bsize;

		ba->nab = d->nab;

		strncpy(ba->name, name, sizeof(ba->name));

		bcmark(d, b);

	}

	/*

	 *  allocate allocation blocks

	 */

	for(i = 0; i < d->nab; i++)

		if(dalloc(d, &dptr) == Notabno){

			fprint(2, "can't allocate allocation blocks\n");

			return -1;

		}

	return bcsync(d);

}

/*

 *  allocate a block from a bit vector page

 *

 *  a return value of Notabno means no blocks left

 */

static ulong

_balloc(Dalloc *ba, ulong max)

{

	int len;	/* number of valid words */

	ulong i;	/* bit position in long */

	ulong m;	/* 1<<i */

	ulong v;	/* old value of long */

	ulong *p, *e;

	/*

	 *  find a word with a 0 bit

	 */

	len = (max+BtoUL-1)/BtoUL;

	for(p = ba->bits, e = p + len; p < e; p++)

		if(*p != 0xFFFFFFFF)

			break;

	if(p == e)

		return Notabno;

	/*

	 *  find the first 0 bit

	 */

	v = *p;

	for(m = 1, i = 0; i < BtoUL; i++, m <<= 1)

		if((m|v) != v)

			break;

	/*

	 *  calculate block number

	 */

	i += (p - ba->bits)*BtoUL;

	if(i >= max)

		return Notabno;

	/*

	 *  set bit to 1

	 */

	*p = v | m;

	return i;

}

/*

 *  allocate a block

 *

 *  return Notabno if none left

 */

ulong

dalloc(Disk *d, Dptr *p)

{

	ulong	bno, max, rv;

	Bbuf	*b;

	Dalloc	*ba;

	max = d->nb;

	for(bno = 0; bno < d->nab; bno++){

		b = bcread(d, bno);

		ba = (Dalloc*)b->data;

		rv = _balloc(ba, max > d->b2b ? d->b2b : max);

		if(rv != Notabno){

			rv = bno*d->b2b + rv;

			if(p){

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

				p->bno = rv;

			}

			bcmark(d, b);

			return rv;

		}

		max -= d->b2b;

	}

	if(p)

		p->bno = Notabno;

	return Notabno;

}

/*

 *  allocate a block of pointers

 */

ulong

dpalloc(Disk *d, Dptr *p)

{

	Bbuf *b;

	Dptr *sp, *ep;

	if(dalloc(d, p) == Notabno)

		return Notabno;

	/*

	 *  allocate the page and invalidate all the

	 *  pointers

	 */

	b = bcalloc(d, p->bno);

	if(b == 0)

		return -1;

	sp = (Dptr*)b->data;

	for(ep = sp + d->p2b; sp < ep; sp++){

		sp->bno = Notabno;

		sp->start = sp->end = 0;

	}

	p->bno |= Indbno;

	p->start = 0;

	p->end = d->bsize;

	/*

	 *  mark the page as dirty

	 */

	bcmark(d, b);

	return 0;

}

/*

 *  free a block

 */

int

_bfree(Disk *d, ulong i)

{

	ulong bno, m;

	ulong *p;

	Bbuf *b;

	Dalloc *ba;

	/*

	 *  get correct allocation block

	 */

	bno = i/d->b2b;

	if(bno >= d->nab)

		return -1;

	b = bcread(d, bno);

	if(b == 0)

		return -1;

	ba = (Dalloc*)b->data;

	/*

	 *  change bit

	 */

	i -= bno*d->b2b;

	p = ba->bits + (i/BtoUL);

	m = 1<<(i%BtoUL);

	*p &= ~m;

	bcmark(d, b);

	return 0;

}

/*

 *  free a block (or blocks)

 */

int

dfree(Disk *d, Dptr *dp)

{

	ulong bno;

	Dptr *sp, *ep;

	Bbuf *b;

	bno = dp->bno;

	dp->bno = Notabno;

	/*

	 *  nothing to free

	 */

	if(bno == Notabno)

		return 0;

	/*

	 *  direct pointer

	 */

	if((bno & Indbno) == 0)

		return _bfree(d, bno);

	/*

	 *  first indirect page

	 */

	bno &= ~Indbno;

	_bfree(d, bno);

	/*

	 *  then all the pages it points to

	 *

	 *	DANGER: this algorithm may fail if there are more

	 *		allocation blocks than block buffers

	 */

	b = bcread(d, bno);

	if(b == 0)

		return -1;

	sp = (Dptr*)b->data;

	for(ep = sp + d->p2b; sp < ep; sp++)

		if(dfree(d, sp) < 0)

			return -1;

	return 0;

}