#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);
}

You are viewing proxied material from sdf.org. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.