ref: f4f19cdf1a8f0d2aa5f9fce10c896201528b5347
dir: /sys/src/cmd/cfs/disk.c/
#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;
}