minix/servers/pfs/inode.c

/* 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.
 *
 * The entry points into this file are
 *   get_inode:	   search inode table for a given inode; if not there,
 *                 read it
 *   put_inode:	   indicate that an inode is no longer needed in memory
 *   alloc_inode:  allocate a new, unused inode
 *   wipe_inode:   erase some fields of a newly allocated inode
 *   free_inode:   mark an inode as available for a new file
 *   update_times: update atime, ctime, and mtime
 *   find_inode:   retrieve pointer to inode in inode cache
 *
 */

#include "fs.h"
#include "buf.h"
#include "inode.h"
#include <minix/vfsif.h>

FORWARD _PROTOTYPE( int addhash_inode, (struct inode *node)		); 
FORWARD _PROTOTYPE( int unhash_inode, (struct inode *node) 		);


/*===========================================================================*
 *				fs_putnode				     *
 *===========================================================================*/
PUBLIC int fs_putnode()
{
/* Find the inode specified by the request message and decrease its counter.*/

  struct inode *rip;
  int count;
  dev_t dev;
  ino_t inum;
  
  rip = find_inode(fs_m_in.REQ_INODE_NR);

  if(!rip) {
	  printf("%s:%d put_inode: inode #%d dev: %d not found\n", __FILE__,
		 __LINE__, fs_m_in.REQ_INODE_NR, fs_m_in.REQ_DEV);
	  panic("fs_putnode failed");
  }

  count = fs_m_in.REQ_COUNT;
  if (count <= 0) {
	printf("%s:%d put_inode: bad value for count: %d\n", __FILE__,
	       __LINE__, count);
	panic("fs_putnode failed");
  } else if(count > rip->i_count) {
	printf("%s:%d put_inode: count too high: %d > %d\n", __FILE__,
	       __LINE__, count, rip->i_count);
	panic("fs_putnode failed");
  }

  /* Decrease reference counter, but keep one reference; it will be consumed by
   * put_inode(). */ 
  rip->i_count -= count - 1;
  dev = rip->i_dev;
  inum = rip->i_num;
  put_inode(rip);
  if (rip->i_count == 0) put_block(dev, inum);
  return(OK);
}


/*===========================================================================*
 *				init_inode_cache			     *
 *===========================================================================*/
PUBLIC void init_inode_cache()
{
  struct inode *rip;
  struct inodelist *rlp;

  /* init free/unused list */
  TAILQ_INIT(&unused_inodes);
  
  /* init hash lists */
  for (rlp = &hash_inodes[0]; rlp < &hash_inodes[INODE_HASH_SIZE]; ++rlp) 
      LIST_INIT(rlp);

  /* add free inodes to unused/free list */
  for (rip = &inode[0]; rip < &inode[NR_INODES]; ++rip) {
      rip->i_num = 0;
      TAILQ_INSERT_HEAD(&unused_inodes, rip, i_unused);
  }

  /* Reserve the first inode (bit 0) to prevent it from being allocated later*/
  if (alloc_bit() != NO_BIT) printf("PFS could not reserve NO_BIT\n");
  busy = 0; /* This bit does not make the server 'in use/busy'. */
}


/*===========================================================================*
 *				addhash_inode   			     *
 *===========================================================================*/
PRIVATE int addhash_inode(struct inode *node) 
{
  int hashi = node->i_num & INODE_HASH_MASK;
  
  /* insert into hash table */
  LIST_INSERT_HEAD(&hash_inodes[hashi], node, i_hash);
  return(OK);
}


/*===========================================================================*
 *				unhash_inode      			     *
 *===========================================================================*/
PRIVATE int unhash_inode(struct inode *node) 
{
  /* remove from hash table */
  LIST_REMOVE(node, i_hash);
  return(OK);
}


/*===========================================================================*
 *				get_inode				     *
 *===========================================================================*/
PUBLIC struct inode *get_inode(
  dev_t dev,		/* device on which inode resides */
  int numb		/* inode number (ANSI: may not be unshort) */
)
{
/* Find the inode in the hash table. If it is not there, get a free inode
 * load it from the disk if it's necessary and put on the hash list 
 */
  register struct inode *rip;
  int hashi;

  hashi = numb & INODE_HASH_MASK;

  /* Search inode in the hash table */
  LIST_FOREACH(rip, &hash_inodes[hashi], i_hash) {
	if (rip->i_num == numb && rip->i_dev == dev) {
		/* If unused, remove it from the unused/free list */
		if (rip->i_count == 0) {
			TAILQ_REMOVE(&unused_inodes, rip, i_unused);
		}
		++rip->i_count;

		return(rip);
	}
  }

  /* Inode is not on the hash, get a free one */
  if (TAILQ_EMPTY(&unused_inodes)) {
      err_code = ENFILE;
      return(NULL);
  }
  rip = TAILQ_FIRST(&unused_inodes);

  /* If not free unhash it */
  if (rip->i_num != 0) unhash_inode(rip);
  
  /* Inode is not unused any more */
  TAILQ_REMOVE(&unused_inodes, rip, i_unused);

  /* Load the inode. */
  rip->i_dev = dev;
  rip->i_num = numb;
  rip->i_count = 1;
  rip->i_update = 0;		/* all the times are initially up-to-date */

  /* Add to hash */
  addhash_inode(rip);

  
  return(rip);
}


/*===========================================================================*
 *				find_inode        			     *
 *===========================================================================*/
PUBLIC struct inode *find_inode(numb)
int numb;			/* inode number (ANSI: may not be unshort) */
{
/* Find the inode specified by the inode and device number.
 */
  struct inode *rip;
  int hashi;

  hashi = numb & INODE_HASH_MASK;

  /* Search inode in the hash table */
  LIST_FOREACH(rip, &hash_inodes[hashi], i_hash) {
      if (rip->i_count > 0 && rip->i_num == numb) {
          return(rip);
      }
  }
  
  return(NULL);
}


/*===========================================================================*
 *				put_inode				     *
 *===========================================================================*/
PUBLIC void put_inode(rip)
register struct inode *rip;	/* pointer to inode to be released */
{
/* The caller is no longer using this inode.  If no one else is using it either
 * write it back to the disk immediately.  If it has no links, truncate it and
 * return it to the pool of available inodes.
 */

  if (rip == NULL) return;	/* checking here is easier than in caller */

  if (rip->i_count < 1)
	panic("put_inode: i_count already below 1: %d", rip->i_count);

  if (--rip->i_count == 0) {	/* i_count == 0 means no one is using it now */
	if (rip->i_nlinks == 0) {
		/* i_nlinks == 0 means free the inode. */
		truncate_inode(rip, 0);	/* return all the disk blocks */
		rip->i_mode = I_NOT_ALLOC;	/* clear I_TYPE field */
		free_inode(rip);
	} else {
		truncate_inode(rip, 0);
	}

	if (rip->i_nlinks == 0) {
		/* free, put at the front of the LRU list */
		unhash_inode(rip);
		rip->i_num = 0;
		rip->i_dev = NO_DEV;
		rip->i_rdev = NO_DEV;
		TAILQ_INSERT_HEAD(&unused_inodes, rip, i_unused);
	} else {
		/* unused, put at the back of the LRU (cache it) */
		TAILQ_INSERT_TAIL(&unused_inodes, rip, i_unused);
	}
  }
}


/*===========================================================================*
 *				alloc_inode				     *
 *===========================================================================*/
PUBLIC struct inode *alloc_inode(dev_t dev, mode_t bits)
{
/* Allocate a free inode on 'dev', and return a pointer to it. */

  register struct inode *rip;
  bit_t b;
  ino_t i_num;

  b = alloc_bit();
  if (b == NO_BIT) {
  	err_code = ENOSPC;
  	printf("PipeFS is out of inodes\n");
  	return(NULL);
  }
  i_num = (ino_t) b;
  

  /* Try to acquire a slot in the inode table. */
  if ((rip = get_inode(dev, i_num)) == NULL) {
	/* No inode table slots available.  Free the inode if just allocated.*/
	if (dev == NO_DEV) free_bit(b);
  } else {
	/* An inode slot is available. */

	rip->i_mode = bits;		/* set up RWX bits */
	rip->i_nlinks = 0;		/* initial no links */
	rip->i_uid = caller_uid;	/* file's uid is owner's */
	rip->i_gid = caller_gid;	/* ditto group id */

	/* Fields not cleared already are cleared in wipe_inode().  They have
	 * been put there because truncate() needs to clear the same fields if
	 * the file happens to be open while being truncated.  It saves space
	 * not to repeat the code twice.
	 */
	wipe_inode(rip);
  }

  return(rip);
}


/*===========================================================================*
 *				wipe_inode				     *
 *===========================================================================*/
PUBLIC void wipe_inode(rip)
register struct inode *rip;	/* the inode to be erased */
{
/* Erase some fields in the inode.  This function is called from alloc_inode()
 * when a new inode is to be allocated, and from truncate(), when an existing
 * inode is to be truncated.
 */

  rip->i_size = 0;
  rip->i_update = ATIME | CTIME | MTIME;	/* update all times later */
}


/*===========================================================================*
 *				free_inode				     *
 *===========================================================================*/
PUBLIC void free_inode(rip)
struct inode *rip;
{
/* Return an inode to the pool of unallocated inodes. */

  bit_t b;

  if (rip->i_num <= 0 || rip->i_num >= NR_INODES) return;
  b = rip->i_num;
  free_bit(b);
}


/*===========================================================================*
 *				update_times				     *
 *===========================================================================*/
PUBLIC void update_times(rip)
register struct inode *rip;	/* pointer to inode to be read/written */
{
/* Various system calls are required by the standard to update atime, ctime,
 * or mtime.  Since updating a time requires sending a message to the clock
 * task--an expensive business--the times are marked for update by setting
 * bits in i_update.  When a stat, fstat, or sync is done, or an inode is 
 * released, update_times() may be called to actually fill in the times.
 */

  time_t cur_time;

  cur_time = clock_time();
  if (rip->i_update & ATIME) rip->i_atime = cur_time;
  if (rip->i_update & CTIME) rip->i_ctime = cur_time;
  if (rip->i_update & MTIME) rip->i_mtime = cur_time;
  rip->i_update = 0;		/* they are all up-to-date now */
}