ref: 81c9ede53f6f9ebd67e7134e664c98e08b9fcca6
dir: /sys/src/cmd/cfs/inode.c/
#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 %zd\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);
}