/*
* linux/fs/inode.c
*
* (C) 1991 Linus Torvalds
*/

#include <string.h>		// ַͷļҪһЩйַǶ뺯
#include <sys/stat.h>		// ļ״̬ͷļļļϵͳ״̬ṹstat{}ͳ

#include <linux/sched.h>	// ȳͷļṹtask_structʼ0 ݣ
// һЩйúͻȡǶʽຯ䡣
#include <linux/kernel.h>	// ںͷļһЩں˳úԭζ塣
#include <linux/mm.h>		// ڴͷļҳСһЩҳͷźԭ͡
#include <asm/system.h>		// ϵͳͷļû޸/жŵȵǶʽꡣ

struct m_inode inode_table[NR_INODE] = { {0,}, };	// ڴi ڵNR_INODE=32 

static void read_inode (struct m_inode *inode);
static void write_inode (struct m_inode *inode);

//// ȴָi ڵá
// i ڵѱ򽫵ǰΪжϵĵȴ״ֱ̬i ڵ
static inline void
wait_on_inode (struct m_inode *inode)
{
  cli ();
  while (inode->i_lock)
    sleep_on (&inode->i_wait);
  sti ();
}

//// ָi ڵָi ڵ㣩
// i ڵѱ򽫵ǰΪжϵĵȴ״ֱ̬i ڵȻ
static inline void
lock_inode (struct m_inode *inode)
{
  cli ();
  while (inode->i_lock)
    sleep_on (&inode->i_wait);
  inode->i_lock = 1;		// ־
  sti ();
}

//// ָi ڵ
// λi ڵ־ȷػѵȴi ڵĽ̡
static inline void
unlock_inode (struct m_inode *inode)
{
  inode->i_lock = 0;
  wake_up (&inode->i_wait);
}

//// ͷڴ豸dev i ڵ㡣
// ɨڴеi ڵ飬ָ豸ʹõi ڵͷ֮
void
invalidate_inodes (int dev)
{
  int i;
  struct m_inode *inode;

  inode = 0 + inode_table;	// ָָi ڵָ
  for (i = 0; i < NR_INODE; i++, inode++)
    {				// ɨi ڵָеi ڵ㡣
      wait_on_inode (inode);	// ȴi ڵã
      if (inode->i_dev == dev)
	{			// ָ豸i ڵ㣬
	  if (inode->i_count)	// Ϊ0ʾ棻
	    printk ("inode in use on removed disk\n\r");
	  inode->i_dev = inode->i_dirt = 0;	// ͷŸi ڵ(豸Ϊ0 )
	}
    }
}

//// ͬi ڵ㡣
// ͬڴ豸ϵi ڵϢ
void
sync_inodes (void)
{
  int i;
  struct m_inode *inode;

  inode = 0 + inode_table;	// ָָi ڵָ
  for (i = 0; i < NR_INODE; i++, inode++)
    {				// ɨi ڵָ顣
      wait_on_inode (inode);	// ȴi ڵã
      if (inode->i_dirt && !inode->i_pipe)	// i ڵ޸Ҳǹܵڵ㣬
	write_inode (inode);	// д̡
    }
}

//// ļݿӳ䵽̿Ĵ(block λͼbmap - block map)
// inode C ļi ڵ㣻block C ļеݿţcreate - ־
// ־λڶӦ߼鲻ʱ´̿顣
// block ݿӦ豸ϵ߼ţ̿ţ
static int
_bmap (struct m_inode *inode, int block, int create)
{
  struct buffer_head *bh;
  int i;

// С0
  if (block < 0)
    panic ("_bmap: block<0");
// Ŵֱӿ + ӿ + μӿļϵͳʾΧ
  if (block >= 7 + 512 + 512 * 512)
    panic ("_bmap: block>big");
// ÿС7ʹֱӿʾ
  if (block < 7)
    {
// ־λi ڵжӦÿ߼飨ΣֶΪ0Ӧ豸һ
// 飨߼飬飩߼ţ̿ţ߼ֶСȻi ڵ޸ʱ䣬
// i ڵ޸ı־󷵻߼š
      if (create && !inode->i_zone[block])
	if (inode->i_zone[block] = new_block (inode->i_dev))
	  {
	    inode->i_ctime = CURRENT_TIME;
	    inode->i_dirt = 1;
	  }
      return inode->i_zone[block];
    }
// ÿ>=7С7+512˵һμӿ顣һμӿд
  block -= 7;
  if (block < 512)
    {
// ǴҸi ڵжӦӿֶΪ0ļ״ʹüӿ飬
// һ̿ڴżӿϢʵʴ̿ӿֶСȻi ڵ
// ޸ı־޸ʱ䡣
      if (create && !inode->i_zone[7])
	if (inode->i_zone[7] = new_block (inode->i_dev))
	  {
	    inode->i_dirt = 1;
	    inode->i_ctime = CURRENT_TIME;
	  }
// ʱi ڵӿֶΪ0̿ʧܣ0 ˳
      if (!inode->i_zone[7])
	return 0;
// ȡ豸ϵһμӿ顣
      if (!(bh = bread (inode->i_dev, inode->i_zone[7])))
	return 0;
// ȡüӿϵblock е߼ţ̿ţ
      i = ((unsigned short *) (bh->b_data))[block];
// ǴҼӿĵblock е߼Ϊ0 Ļһ̿飨߼飩
// ӿеĵblock ڸ߼šȻλӿ޸ı־
      if (create && !i)
	if (i = new_block (inode->i_dev))
	  {
	    ((unsigned short *) (bh->b_data))[block] = i;
	    bh->b_dirt = 1;
	  }
// ͷŸüӿ飬شĶӦblock ߼Ŀš
      brelse (bh);
      return i;
    }
// еˣݿǶμӿ飬һμӿơǶԶμӿĴ
// block ټȥӿɵĿ(512)
  block -= 512;
// ´i ڵĶμӿֶΪ0һ̿ڴŶμӿһ
// Ϣʵʴ̿μӿֶС֮i ڵ޸ıƺ޸ʱ䡣
  if (create && !inode->i_zone[8])
    if (inode->i_zone[8] = new_block (inode->i_dev))
      {
	inode->i_dirt = 1;
	inode->i_ctime = CURRENT_TIME;
      }
// ʱi ڵμӿֶΪ0̿ʧܣ0 ˳
  if (!inode->i_zone[8])
    return 0;
// ȡöμӿһ顣
  if (!(bh = bread (inode->i_dev, inode->i_zone[8])))
    return 0;
// ȡöμӿһϵ(block/512)е߼š
  i = ((unsigned short *) bh->b_data)[block >> 9];
// ǴҶμӿһϵ(block/512)е߼Ϊ0 Ļһ
// 飨߼飩ΪμӿĶ飬öμӿһе(block/512)ڸö
// ĿšȻλμӿһ޸ı־ͷŶμӿһ顣
  if (create && !i)
    if (i = new_block (inode->i_dev))
      {
	((unsigned short *) (bh->b_data))[block >> 9] = i;
	bh->b_dirt = 1;
      }
  brelse (bh);
// μӿĶΪ0ʾ̿ʧܣ0 ˳
  if (!i)
    return 0;
// ȡμӿĶ顣
  if (!(bh = bread (inode->i_dev, i)))
    return 0;
// ȡöϵblock е߼š(511 Ϊ޶block ֵ511)
  i = ((unsigned short *) bh->b_data)[block & 511];
// ǴҶĵblock е߼Ϊ0 Ļһ̿飨߼飩Ϊ
// մϢĿ顣öеĵblock ڸ߼(i)Ȼλ
// ޸ı־
  if (create && !i)
    if (i = new_block (inode->i_dev))
      {
	((unsigned short *) (bh->b_data))[block & 511] = i;
	bh->b_dirt = 1;
      }
// ͷŸöμӿĶ飬شĶӦblock ߼Ŀš
  brelse (bh);
  return i;
}

//// i ڵϢȡļݿblock 豸϶Ӧ߼š
int
bmap (struct m_inode *inode, int block)
{
  return _bmap (inode, block, 0);
}

//// ļݿblock 豸϶Ӧ߼飬豸϶Ӧ߼š
int
create_block (struct m_inode *inode, int block)
{
  return _bmap (inode, block, 1);
}

//// ͷһi ڵ(д豸)
void
iput (struct m_inode *inode)
{
  if (!inode)
    return;
  wait_on_inode (inode);	// ȴinode ڵ(Ļ)
  if (!inode->i_count)
    panic ("iput: trying to free free inode");
// ǹܵi ڵ㣬ѵȴùܵḶ̌ô1򷵻ءͷ
// ܵռõڴҳ棬λýڵüֵ޸ı־͹ܵ־ء
// pipe ڵ㣬inode->i_size ڴҳַμget_pipe_inode()228234 С
  if (inode->i_pipe)
    {
      wake_up (&inode->i_wait);
      if (--inode->i_count)
	return;
      free_page (inode->i_size);
      inode->i_count = 0;
      inode->i_dirt = 0;
      inode->i_pipe = 0;
      return;
    }
// i ڵӦ豸=0򽫴˽ڵüݼ1ء
  if (!inode->i_dev)
    {
      inode->i_count--;
      return;
    }
// ǿ豸ļi ڵ㣬ʱ߼ֶ0 豸ţˢ¸豸ȴi ڵ
  if (S_ISBLK (inode->i_mode))
    {
      sync_dev (inode->i_zone[0]);
      wait_on_inode (inode);
    }
repeat:
// i ڵü1ݼ1
  if (inode->i_count > 1)
    {
      inode->i_count--;
      return;
    }
// i ڵΪ0ͷŸi ڵ߼飬ͷŸi ڵ㡣
  if (!inode->i_nlinks)
    {
      truncate (inode);
      free_inode (inode);
      return;
    }
// i ڵ޸ģ¸i ڵ㣬ȴi ڵ
  if (inode->i_dirt)
    {
      write_inode (inode);	/* we can sleep - so do again */
      wait_on_inode (inode);
      goto repeat;
    }
// i ڵüݼ1
  inode->i_count--;
  return;
}

//// i ڵ(inode_table)лȡһi ڵ
// Ѱücount Ϊ0 i ڵ㣬д̺㣬ָ롣
struct m_inode *
get_empty_inode (void)
{
  struct m_inode *inode;
  static struct m_inode *last_inode = inode_table;	// last_inode ָi ڵһ
  int i;

  do
    {
// ɨi ڵ
      inode = NULL;
      for (i = NR_INODE; i; i--)
	{
// last_inode Ѿָi ڵ1 ָ֮i ڵʼ
	  if (++last_inode >= inode_table + NR_INODE)
	    last_inode = inode_table;
// last_inode ָi ڵļֵΪ0˵ҵi ڵinode ָ
// i ڵ㡣i ڵ޸ı־־Ϊ0ǿʹøi ڵ㣬˳ѭ
	  if (!last_inode->i_count)
	    {
	      inode = last_inode;
	      if (!inode->i_dirt && !inode->i_lock)
		break;
	    }
	}
// ûҵi ڵ(inode=NULL)i ڵӡʹã
      if (!inode)
	{
	  for (i = 0; i < NR_INODE; i++)
	    printk ("%04x: %6d\t", inode_table[i].i_dev,
		    inode_table[i].i_num);
	  panic ("No free inodes in mem");
	}
// ȴi ڵֱĻ
      wait_on_inode (inode);
// i ڵ޸ı־λĻ򽫸i ڵˢ£ȴi ڵ
      while (inode->i_dirt)
	{
	  write_inode (inode);
	  wait_on_inode (inode);
	}
    }
  while (inode->i_count);	// i ڵֱռõĻѰҿi ڵ㡣
// ҵi ڵ򽫸i ڵ㣬ñ־Ϊ1ظi ڵָ롣
  memset (inode, 0, sizeof (*inode));
  inode->i_count = 1;
  return inode;
}

//// ȡܵڵ㡣Ϊi ڵָ루NULL ʧܣ
// ɨi ڵѰһi ڵȻȡһҳڴ湩ܵʹá
// Ȼ󽫵õi ڵüΪ2(ߺд)ʼܵͷβi ڵĹܵͱʾ
struct m_inode *
get_pipe_inode (void)
{
  struct m_inode *inode;

  if (!(inode = get_empty_inode ()))	// Ҳi ڵ򷵻NULL
    return NULL;
  if (!(inode->i_size = get_free_page ()))
    {				// ڵi_size ֶָ򻺳
      inode->i_count = 0;	// ûпڴ棬
      return NULL;		// ͷŸi ڵ㣬NULL
    }
  inode->i_count = 2;		/* sum of readers/writers *//* /дܼ */
  PIPE_HEAD (*inode) = PIPE_TAIL (*inode) = 0;	// λܵͷβָ롣
  inode->i_pipe = 1;		// ýڵΪܵʹõı־
  return inode;			// i ڵָ롣
}

//// 豸϶ȡָڵŵi ڵ㡣
// nr - i ڵš
struct m_inode *
iget (int dev, int nr)
{
  struct m_inode *inode, *empty;

  if (!dev)
    panic ("iget with dev==0");
// i ڵȡһi ڵ㡣
  empty = get_empty_inode ();
// ɨi ڵѰָڵŵi ڵ㡣ýڵô
  inode = inode_table;
  while (inode < NR_INODE + inode_table)
    {
// ǰɨi ڵ豸Ųָ豸Ż߽ڵŲָĽڵţɨ衣
      if (inode->i_dev != dev || inode->i_num != nr)
	{
	  inode++;
	  continue;
	}
// ҵָ豸źͽڵŵi ڵ㣬ȴýڵĻ
      wait_on_inode (inode);
// ڵȴýڵĽ׶Σڵܻᷢ仯ٴжϣ˱仯ٴ
// ɨi ڵ
      if (inode->i_dev != dev || inode->i_num != nr)
	{
	  inode = inode_table;
	  continue;
	}
// i ڵü1
      inode->i_count++;
      if (inode->i_mount)
	{
	  int i;

// i ڵļϵͳİװ㣬ڳѰװڴi ڵĳ顣û
// ҵʾϢͷźʼȡĿнڵ㣬ظi ڵָ롣
	  for (i = 0; i < NR_SUPER; i++)
	    if (super_block[i].s_imount == inode)
	      break;
	  if (i >= NR_SUPER)
	    {
	      printk ("Mounted inode hasn't got sb\n");
	      if (empty)
		iput (empty);
	      return inode;
	    }
// i ڵд̡Ӱװڴi ڵļϵͳĳȡ豸ţi ڵΪ1Ȼ
// ɨi ڵȡñװļϵͳĸڵ㡣
	  iput (inode);
	  dev = super_block[i].s_dev;
	  nr = ROOT_INO;
	  inode = inode_table;
	  continue;
	}
// ѾҵӦi ڵ㣬˷ʱĿнڵ㣬ظҵi ڵ㡣
      if (empty)
	iput (empty);
      return inode;
    }
// i ڵûҵָi ڵ㣬ǰĿi ڵi ڵнýڵ㡣
// Ӧ豸϶ȡi ڵϢظi ڵ㡣
  if (!empty)
    return (NULL);
  inode = empty;
  inode->i_dev = dev;
  inode->i_num = nr;
  read_inode (inode);
  return inode;
}

//// 豸϶ȡָi ڵϢڴУУ
static void
read_inode (struct m_inode *inode)
{
  struct super_block *sb;
  struct buffer_head *bh;
  int block;

// i ڵ㣬ȡýڵ豸ĳ顣
  lock_inode (inode);
  if (!(sb = get_super (inode->i_dev)))
    panic ("trying to read inode without dev");
// i ڵڵ߼ = (+) + i ڵλͼռõĿ + ߼λͼռõĿ +
// (i ڵ-1)/ÿ麬еi ڵ
  block = 2 + sb->s_imap_blocks + sb->s_zmap_blocks +
    (inode->i_num - 1) / INODES_PER_BLOCK;
// 豸϶ȡi ڵڵ߼飬inode ָָӦi ڵϢ
  if (!(bh = bread (inode->i_dev, block)))
    panic ("unable to read i-node block");
  *(struct d_inode *) inode =
    ((struct d_inode *) bh->b_data)[(inode->i_num - 1) % INODES_PER_BLOCK];
// ͷŶĻi ڵ㡣
  brelse (bh);
  unlock_inode (inode);
}

//// ָi ڵϢд豸д뻺ӦĻУˢʱдУ
static void
write_inode (struct m_inode *inode)
{
  struct super_block *sb;
  struct buffer_head *bh;
  int block;

// i ڵ㣬i ڵûб޸Ĺ߸i ڵ豸ŵ㣬i ڵ㣬
// ˳
  lock_inode (inode);
  if (!inode->i_dirt || !inode->i_dev)
    {
      unlock_inode (inode);
      return;
    }
// ȡi ڵĳ顣
  if (!(sb = get_super (inode->i_dev)))
    panic ("trying to write inode without device");
// i ڵڵ߼ = (+) + i ڵλͼռõĿ + ߼λͼռõĿ +
// (i ڵ-1)/ÿ麬еi ڵ
  block = 2 + sb->s_imap_blocks + sb->s_zmap_blocks +
    (inode->i_num - 1) / INODES_PER_BLOCK;
// 豸϶ȡi ڵڵ߼顣
  if (!(bh = bread (inode->i_dev, block)))
    panic ("unable to read i-node block");
// i ڵϢƵ߼Ӧi ڵС
  ((struct d_inode *) bh->b_data)
    [(inode->i_num - 1) % INODES_PER_BLOCK] = *(struct d_inode *) inode;
// û޸ı־i ڵ޸ı־㡣ȻͷŸúi ڵĻi ڵ㡣
  bh->b_dirt = 1;
  inode->i_dirt = 0;
  brelse (bh);
  unlock_inode (inode);
}
