/* This file manages the inode table. There are procedures to allocate and
* deallocate inodes, acquire, erase, and release them, and read and write
* them from the disk.
*/
/* Methods:
* get_inode: search inode table for a given inode; if not there, read it
* read_inode: read a disk block and extract an inode
* v1_copy_inode copy from disk inode (V1.x) to in-memory inode struct
* v2_copy_inode copy from disk inode (V2.x) to in-memory inode structs
* put_inode indicate that an inode is no longer needed in memory
* dup_inode: indicate that someone else is using an inode table entry
*/
#include "fs.h"
#include "block.h"
#include "file.h"
#include "fproc.h"
#include "inode.h"
#include "super.h"
inode_t inode[NR_INODES];
static void v1_copy_inode(inode_t *rip, d1_inode_t *dip, int normal);
static void v2_copy_inode(inode_t *rip, d2_inode_t *dip, int normal);
inode_t *get_inode(int numb)
{
/* Find a slot in the inode table, load the specified inode into it, and
* return a pointer to the slot.
*/
register inode_t *rip, *xp;
/* Search the inode table both for numb and a free slot. */
xp = NIL_INODE;
for (rip = &inode[0]; rip < &inode[NR_INODES]; rip++) {
if (rip->i_count > 0) { /* only check used slots for numb */
if (rip->i_num == numb) {
/* This is the inode that we are looking for. */
rip->i_count++;
return rip; /* numb found */
}
}
else {
xp = rip; /* remember this free slot for later */
}
}
/* Inode we want is not currently in use. Did we find a free slot? */
if (xp == NIL_INODE) { /* inode table completely full */
err_code = FS_ENFILE;
return NIL_INODE;
}
/* A free inode slot has been located. Load the inode into it. */
xp->i_num = numb;
xp->i_count = 1;
read_inode(xp);
return xp;
}
void read_inode(register inode_t *rip)
{
/* An entry in the inode table is to be copied from the disk. */
register block_t *bp;
register super_block_t *sp;
d1_inode_t *dip1;
d2_inode_t *dip2;
block_num_t b, offset;
/* Get the block where the inode resides. */
sp = get_super(); /* get pointer to super block */
rip->i_sp = sp; /* inode must contain super block pointer */
offset = sp->s_imap_blocks + sp->s_zmap_blocks + 2;
b = (block_num_t)(rip->i_num - 1)/sp->s_inodes_per_block + offset;
bp = get_block(b);
dip1 = bp->b.b__v1_ino + (rip->i_num - 1) % V1_INODES_PER_BLOCK;
dip2 = bp->b.b__v2_ino + (rip->i_num - 1) % V2_INODES_PER_BLOCK;
/* Copy inode to the in-core table, swapping bytes if need be. */
if (sp->s_version == V1) {
v1_copy_inode(rip, dip1, sp->s_native);
}
else {
v2_copy_inode(rip, dip2, sp->s_native);
}
}
void v1_copy_inode(inode_t *rip, d1_inode_t *dip, int normal)
{
/* The V1.x IBM disk, the V1.x 68000 disk, and the V2 disk (same for IBM and
* 68000) all have different inode layouts. When an inode is read or written
* this routine handles the conversions so that the information in the inode
* table is independent of the disk structure from which the inode came.
* This routine copies from V1 disks.
*/
int i;
/* Some check is made for valid number of inode. */
if (rip == NIL_INODE || dip == NULL)
return;
/* Copy V1.x inode to the in-memory table, swapping bytes if need be. */
rip->i_mode = conv2(normal, dip->d1_mode);
rip->i_size = conv4(normal, dip->d1_size);
rip->i_nlinks = (nlink_t)dip->d1_nlinks; /* 1 char */
rip->i_ndzones = V1_NR_DZONES;
rip->i_nindirs = V1_INDIRECTS;
for (i = 0; i < V1_NR_TZONES; i++)
rip->i_zone[i] = conv2(normal, dip->d1_zone[i]);
}
void v2_copy_inode(inode_t *rip, d2_inode_t *dip, int normal)
{
/* Same as old_icopy, but to/from V2 disk layout. */
int i;
/* Some check is made for valid number of inode. */
if (rip == NIL_INODE || dip == NULL)
return;
/* Copy V2.x inode to the in-core table, swapping bytes if need be. */
rip->i_mode = conv2(normal, dip->d2_mode);
rip->i_size = conv4(normal, dip->d2_size);
rip->i_nlinks = conv2(normal, dip->d2_nlinks);
rip->i_ndzones = V2_NR_DZONES;
rip->i_nindirs = V2_INDIRECTS;
for (i = 0; i < V2_NR_TZONES; i++)
rip->i_zone[i] = conv4(normal, dip->d2_zone[i]);
}
void put_inode(inode_t *rip)
{
/* The caller is no longer using this inode. */
if (rip == NIL_INODE)
return;
rip->i_count--;
}
void dup_inode(inode_t *rip)
{
/* This routine is a simplified form of get_inode() for the case where
* the inode pointer is already known.
*/
if (rip == NIL_INODE)
return;
rip->i_count++;
}