Research V6 development

[unix-history] / usr / sys / ken / alloc.c

#
/*
*/

#include "../param.h"
#include "../systm.h"
#include "../filsys.h"
#include "../conf.h"
#include "../buf.h"
#include "../inode.h"
#include "../user.h"

/*
* iinit is called once (from main)
* very early in initialization.
* It reads the root's super block
* and initializes the current date
* from the last modified date.
*
* panic: iinit -- cannot read the super
* block. Usually because of an IO error.
*/
iinit()
{
       register *cp, *bp;

       (*bdevsw[rootdev.d_major].d_open)(rootdev, 1);
       bp = bread(rootdev, 1);
       cp = getblk(NODEV);
       if(u.u_error)
               panic("iinit");
       bcopy(bp->b_addr, cp->b_addr, 256);
       brelse(bp);
       mount[0].m_bufp = cp;
       mount[0].m_dev = rootdev;
       cp = cp->b_addr;
       cp->s_flock = 0;
       cp->s_ilock = 0;
       cp->s_ronly = 0;
       time[0] = cp->s_time[0];
       time[1] = cp->s_time[1];
}

/*
* alloc will obtain the next available
* free disk block from the free list of
* the specified device.
* The super block has up to 100 remembered
* free blocks; the last of these is read to
* obtain 100 more . . .
*
* no space on dev x/y -- when
* the free list is exhausted.
*/
alloc(dev)
{
       int bno;
       register *bp, *ip, *fp;

       fp = getfs(dev);
       while(fp->s_flock)
               sleep(&fp->s_flock, PINOD);
       do {
               if(fp->s_nfree <= 0)
                       goto nospace;
               bno = fp->s_free[--fp->s_nfree];
               if(bno == 0)
                       goto nospace;
       } while (badblock(fp, bno, dev));
       if(fp->s_nfree <= 0) {
               fp->s_flock++;
               bp = bread(dev, bno);
               ip = bp->b_addr;
               fp->s_nfree = *ip++;
               bcopy(ip, fp->s_free, 100);
               brelse(bp);
               fp->s_flock = 0;
               wakeup(&fp->s_flock);
       }
       bp = getblk(dev, bno);
       clrbuf(bp);
       fp->s_fmod = 1;
       return(bp);

nospace:
       fp->s_nfree = 0;
       prdev("no space", dev);
       u.u_error = ENOSPC;
       return(NULL);
}

/*
* place the specified disk block
* back on the free list of the
* specified device.
*/
free(dev, bno)
{
       register *fp, *bp, *ip;

       fp = getfs(dev);
       fp->s_fmod = 1;
       while(fp->s_flock)
               sleep(&fp->s_flock, PINOD);
       if (badblock(fp, bno, dev))
               return;
       if(fp->s_nfree <= 0) {
               fp->s_nfree = 1;
               fp->s_free[0] = 0;
       }
       if(fp->s_nfree >= 100) {
               fp->s_flock++;
               bp = getblk(dev, bno);
               ip = bp->b_addr;
               *ip++ = fp->s_nfree;
               bcopy(fp->s_free, ip, 100);
               fp->s_nfree = 0;
               bwrite(bp);
               fp->s_flock = 0;
               wakeup(&fp->s_flock);
       }
       fp->s_free[fp->s_nfree++] = bno;
       fp->s_fmod = 1;
}

/*
* Check that a block number is in the
* range between the I list and the size
* of the device.
* This is used mainly to check that a
* garbage file system has not been mounted.
*
* bad block on dev x/y -- not in range
*/
badblock(afp, abn, dev)
{
       register struct filsys *fp;
       register char *bn;

       fp = afp;
       bn = abn;
       if (bn < fp->s_isize+2 || bn >= fp->s_fsize) {
               prdev("bad block", dev);
               return(1);
       }
       return(0);
}

/*
* Allocate an unused I node
* on the specified device.
* Used with file creation.
* The algorithm keeps up to
* 100 spare I nodes in the
* super block. When this runs out,
* a linear search through the
* I list is instituted to pick
* up 100 more.
*/
ialloc(dev)
{
       register *fp, *bp, *ip;
       int i, j, k, ino;

       fp = getfs(dev);
       while(fp->s_ilock)
               sleep(&fp->s_ilock, PINOD);
loop:
       if(fp->s_ninode > 0) {
               ino = fp->s_inode[--fp->s_ninode];
               ip = iget(dev, ino);
               if (ip==NULL)
                       return(NULL);
               if(ip->i_mode == 0) {
                       for(bp = &ip->i_mode; bp < &ip->i_addr[8];)
                               *bp++ = 0;
                       fp->s_fmod = 1;
                       return(ip);
               }
               /*
                * Inode was allocated after all.
                * Look some more.
                */
               iput(ip);
               goto loop;
       }
       fp->s_ilock++;
       ino = 0;
       for(i=0; i<fp->s_isize; i++) {
               bp = bread(dev, i+2);
               ip = bp->b_addr;
               for(j=0; j<256; j=+16) {
                       ino++;
                       if(ip[j] != 0)
                               continue;
                       for(k=0; k<NINODE; k++)
                       if(dev==inode[k].i_dev && ino==inode[k].i_number)
                               goto cont;
                       fp->s_inode[fp->s_ninode++] = ino;
                       if(fp->s_ninode >= 100)
                               break;
               cont:;
               }
               brelse(bp);
               if(fp->s_ninode >= 100)
                       break;
       }
       fp->s_ilock = 0;
       wakeup(&fp->s_ilock);
       if (fp->s_ninode > 0)
               goto loop;
       prdev("Out of inodes", dev);
       u.u_error = ENOSPC;
       return(NULL);
}

/*
* Free the specified I node
* on the specified device.
* The algorithm stores up
* to 100 I nodes in the super
* block and throws away any more.
*/
ifree(dev, ino)
{
       register *fp;

       fp = getfs(dev);
       if(fp->s_ilock)
               return;
       if(fp->s_ninode >= 100)
               return;
       fp->s_inode[fp->s_ninode++] = ino;
       fp->s_fmod = 1;
}

/*
* getfs maps a device number into
* a pointer to the incore super
* block.
* The algorithm is a linear
* search through the mount table.
* A consistency check of the
* in core free-block and i-node
* counts.
*
* bad count on dev x/y -- the count
*      check failed. At this point, all
*      the counts are zeroed which will
*      almost certainly lead to "no space"
*      diagnostic
* panic: no fs -- the device is not mounted.
*      this "cannot happen"
*/
getfs(dev)
{
       register struct mount *p;
       register char *n1, *n2;

       for(p = &mount[0]; p < &mount[NMOUNT]; p++)
       if(p->m_bufp != NULL && p->m_dev == dev) {
               p = p->m_bufp->b_addr;
               n1 = p->s_nfree;
               n2 = p->s_ninode;
               if(n1 > 100 || n2 > 100) {
                       prdev("bad count", dev);
                       p->s_nfree = 0;
                       p->s_ninode = 0;
               }
               return(p);
       }
       panic("no fs");
}

/*
* update is the internal name of
* 'sync'. It goes through the disk
* queues to initiate sandbagged IO;
* goes through the I nodes to write
* modified nodes; and it goes through
* the mount table to initiate modified
* super blocks.
*/
update()
{
       register struct inode *ip;
       register struct mount *mp;
       register *bp;

       if(updlock)
               return;
       updlock++;
       for(mp = &mount[0]; mp < &mount[NMOUNT]; mp++)
               if(mp->m_bufp != NULL) {
                       ip = mp->m_bufp->b_addr;
                       if(ip->s_fmod==0 || ip->s_ilock!=0 ||
                          ip->s_flock!=0 || ip->s_ronly!=0)
                               continue;
                       bp = getblk(mp->m_dev, 1);
                       ip->s_fmod = 0;
                       ip->s_time[0] = time[0];
                       ip->s_time[1] = time[1];
                       bcopy(ip, bp->b_addr, 256);
                       bwrite(bp);
               }
       for(ip = &inode[0]; ip < &inode[NINODE]; ip++)
               if((ip->i_flag&ILOCK) == 0) {
                       ip->i_flag =| ILOCK;
                       iupdat(ip, time);
                       prele(ip);
               }
       updlock = 0;
       bflush(NODEV);
}