--- linux/fs/inode.c	2018/04/24 18:01:53	1.1.1.3
+++ linux/fs/inode.c	2018/04/24 18:10:35	1.1.1.10
@@ -4,20 +4,17 @@
  *  (C) 1991  Linus Torvalds
  */
 
-#include <string.h>
-#include <sys/stat.h>
-
+#include <linux/string.h>
+#include <linux/stat.h>
 #include <linux/sched.h>
 #include <linux/kernel.h>
 #include <linux/mm.h>
-#include <asm/system.h>
 
-struct m_inode inode_table[NR_INODE]={{0,},};
+#include <asm/system.h>
 
-static void read_inode(struct m_inode * inode);
-static void write_inode(struct m_inode * inode);
+struct inode inode_table[NR_INODE]={{0,},};
 
-static inline void wait_on_inode(struct m_inode * inode)
+static inline void wait_on_inode(struct inode * inode)
 {
 	cli();
 	while (inode->i_lock)
@@ -25,7 +22,7 @@ static inline void wait_on_inode(struct
 	sti();
 }
 
-static inline void lock_inode(struct m_inode * inode)
+static inline void lock_inode(struct inode * inode)
 {
 	cli();
 	while (inode->i_lock)
@@ -34,23 +31,62 @@ static inline void lock_inode(struct m_i
 	sti();
 }
 
-static inline void unlock_inode(struct m_inode * inode)
+static inline void unlock_inode(struct inode * inode)
 {
 	inode->i_lock=0;
 	wake_up(&inode->i_wait);
 }
 
+static void write_inode(struct inode * inode)
+{
+	if (!inode->i_dirt)
+		return;
+	inode->i_dirt = 0;
+	lock_inode(inode);
+	if (inode->i_dev && inode->i_sb &&
+	    inode->i_sb->s_op && inode->i_sb->s_op->write_inode)
+		inode->i_sb->s_op->write_inode(inode);
+	unlock_inode(inode);
+}
+
+static void read_inode(struct inode * inode)
+{
+	lock_inode(inode);
+	if (inode->i_sb && inode->i_sb->s_op && inode->i_sb->s_op->read_inode)
+		inode->i_sb->s_op->read_inode(inode);
+	unlock_inode(inode);
+}
+
+/*
+ * bmap is needed for demand-loading and paging: if this function
+ * doesn't exist for a filesystem, then those things are impossible:
+ * executables cannot be run from the filesystem etc...
+ *
+ * This isn't as bad as it sounds: the read-routines might still work,
+ * so the filesystem would be otherwise ok (for example, you might have
+ * a DOS filesystem, which doesn't lend itself to bmap very well, but
+ * you could still transfer files to/from the filesystem)
+ */
+int bmap(struct inode * inode, int block)
+{
+	if (inode->i_op && inode->i_op->bmap)
+		return inode->i_op->bmap(inode,block);
+	return 0;
+}
+
 void invalidate_inodes(int dev)
 {
 	int i;
-	struct m_inode * inode;
+	struct inode * inode;
 
 	inode = 0+inode_table;
 	for(i=0 ; i<NR_INODE ; i++,inode++) {
 		wait_on_inode(inode);
 		if (inode->i_dev == dev) {
-			if (inode->i_count)
+			if (inode->i_count) {
 				printk("inode in use on removed disk\n\r");
+				continue;
+			}
 			inode->i_dev = inode->i_dirt = 0;
 		}
 	}
@@ -59,128 +95,49 @@ void invalidate_inodes(int dev)
 void sync_inodes(void)
 {
 	int i;
-	struct m_inode * inode;
+	struct inode * inode;
 
 	inode = 0+inode_table;
 	for(i=0 ; i<NR_INODE ; i++,inode++) {
 		wait_on_inode(inode);
-		if (inode->i_dirt && !inode->i_pipe)
+		if (inode->i_dirt)
 			write_inode(inode);
 	}
 }
 
-static int _bmap(struct m_inode * inode,int block,int create)
-{
-	struct buffer_head * bh;
-	int i;
-
-	if (block<0)
-		panic("_bmap: block<0");
-	if (block >= 7+512+512*512)
-		panic("_bmap: block>big");
-	if (block<7) {
-		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];
-	}
-	block -= 7;
-	if (block<512) {
-		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;
-			}
-		if (!inode->i_zone[7])
-			return 0;
-		if (!(bh = bread(inode->i_dev,inode->i_zone[7])))
-			return 0;
-		i = ((unsigned short *) (bh->b_data))[block];
-		if (create && !i)
-			if (i=new_block(inode->i_dev)) {
-				((unsigned short *) (bh->b_data))[block]=i;
-				bh->b_dirt=1;
-			}
-		brelse(bh);
-		return i;
-	}
-	block -= 512;
-	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;
-		}
-	if (!inode->i_zone[8])
-		return 0;
-	if (!(bh=bread(inode->i_dev,inode->i_zone[8])))
-		return 0;
-	i = ((unsigned short *)bh->b_data)[block>>9];
-	if (create && !i)
-		if (i=new_block(inode->i_dev)) {
-			((unsigned short *) (bh->b_data))[block>>9]=i;
-			bh->b_dirt=1;
-		}
-	brelse(bh);
-	if (!i)
-		return 0;
-	if (!(bh=bread(inode->i_dev,i)))
-		return 0;
-	i = ((unsigned short *)bh->b_data)[block&511];
-	if (create && !i)
-		if (i=new_block(inode->i_dev)) {
-			((unsigned short *) (bh->b_data))[block&511]=i;
-			bh->b_dirt=1;
-		}
-	brelse(bh);
-	return i;
-}
-
-int bmap(struct m_inode * inode,int block)
-{
-	return _bmap(inode,block,0);
-}
-
-int create_block(struct m_inode * inode, int block)
-{
-	return _bmap(inode,block,1);
-}
-		
-void iput(struct m_inode * inode)
+void iput(struct inode * inode)
 {
 	if (!inode)
 		return;
 	wait_on_inode(inode);
-	if (!inode->i_count)
-		panic("iput: trying to free free inode");
+	if (!inode->i_count) {
+		printk("iput: trying to free free inode\n");
+		printk("device %04x, inode %d, mode=%07o\n",inode->i_rdev,
+			inode->i_ino,inode->i_mode);
+		return;
+	}
 	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;
+		wake_up(&inode->i_wait2);
 	}
-	if (!inode->i_dev) {
+repeat:
+	if (inode->i_count>1) {
 		inode->i_count--;
 		return;
 	}
-	if (S_ISBLK(inode->i_mode)) {
-		sync_dev(inode->i_zone[0]);
-		wait_on_inode(inode);
+	if (inode->i_pipe) {
+		free_page(inode->i_size);
+		inode->i_size = 0;
 	}
-repeat:
-	if (inode->i_count>1) {
+	if (!inode->i_dev) {
 		inode->i_count--;
 		return;
 	}
-	if (!inode->i_nlinks) {
-		truncate(inode);
-		free_inode(inode);
-		return;
+	if (!inode->i_nlink) {
+		if (inode->i_sb && inode->i_sb->s_op && inode->i_sb->s_op->put_inode) {
+			inode->i_sb->s_op->put_inode(inode);
+			return;
+		}
 	}
 	if (inode->i_dirt) {
 		write_inode(inode);	/* we can sleep - so do again */
@@ -191,10 +148,10 @@ repeat:
 	return;
 }
 
-struct m_inode * get_empty_inode(void)
+struct inode * get_empty_inode(void)
 {
-	struct m_inode * inode;
-	static struct m_inode * last_inode = inode_table;
+	struct inode * inode;
+	static struct inode * last_inode = inode_table;
 	int i;
 
 	do {
@@ -210,8 +167,8 @@ struct m_inode * get_empty_inode(void)
 		}
 		if (!inode) {
 			for (i=0 ; i<NR_INODE ; i++)
-				printk("%04x: %6d\t",inode_table[i].i_dev,
-					inode_table[i].i_num);
+				printk("(%04x: %d (%o)) ",inode_table[i].i_dev,
+					inode_table[i].i_ino,inode_table[i].i_mode);
 			panic("No free inodes in mem");
 		}
 		wait_on_inode(inode);
@@ -225,37 +182,38 @@ struct m_inode * get_empty_inode(void)
 	return inode;
 }
 
-struct m_inode * get_pipe_inode(void)
+struct inode * get_pipe_inode(void)
 {
-	struct m_inode * inode;
+	struct inode * inode;
 
 	if (!(inode = get_empty_inode()))
 		return NULL;
-	if (!(inode->i_size=get_free_page())) {
+	if (!(inode->i_size = get_free_page())) {
 		inode->i_count = 0;
 		return NULL;
 	}
 	inode->i_count = 2;	/* sum of readers/writers */
 	PIPE_HEAD(*inode) = PIPE_TAIL(*inode) = 0;
+	PIPE_READERS(*inode) = PIPE_WRITERS(*inode) = 1;
 	inode->i_pipe = 1;
 	return inode;
 }
 
-struct m_inode * iget(int dev,int nr)
+struct inode * iget(int dev,int nr)
 {
-	struct m_inode * inode, * empty;
+	struct inode * inode, * empty;
 
 	if (!dev)
 		panic("iget with dev==0");
 	empty = get_empty_inode();
 	inode = inode_table;
 	while (inode < NR_INODE+inode_table) {
-		if (inode->i_dev != dev || inode->i_num != nr) {
+		if (inode->i_dev != dev || inode->i_ino != nr) {
 			inode++;
 			continue;
 		}
 		wait_on_inode(inode);
-		if (inode->i_dev != dev || inode->i_num != nr) {
+		if (inode->i_dev != dev || inode->i_ino != nr) {
 			inode = inode_table;
 			continue;
 		}
@@ -264,7 +222,7 @@ struct m_inode * iget(int dev,int nr)
 			int i;
 
 			for (i = 0 ; i<NR_SUPER ; i++)
-				if (super_block[i].s_imount==inode)
+				if (super_block[i].s_covered==inode)
 					break;
 			if (i >= NR_SUPER) {
 				printk("Mounted inode hasn't got sb\n");
@@ -273,10 +231,12 @@ struct m_inode * iget(int dev,int nr)
 				return inode;
 			}
 			iput(inode);
-			dev = super_block[i].s_dev;
-			nr = ROOT_INO;
-			inode = inode_table;
-			continue;
+			if (!(inode = super_block[i].s_mounted))
+				printk("iget: mounted dev has no rootinode\n");
+			else {
+				inode->i_count++;
+				wait_on_inode(inode);
+			}
 		}
 		if (empty)
 			iput(empty);
@@ -284,55 +244,14 @@ struct m_inode * iget(int dev,int nr)
 	}
 	if (!empty)
 		return (NULL);
-	inode=empty;
+	inode = empty;
+	if (!(inode->i_sb = get_super(dev))) {
+		printk("iget: gouldn't get super-block\n\t");
+		iput(inode);
+		return NULL;
+	}
 	inode->i_dev = dev;
-	inode->i_num = nr;
+	inode->i_ino = nr;
 	read_inode(inode);
 	return inode;
 }
-
-static void read_inode(struct m_inode * inode)
-{
-	struct super_block * sb;
-	struct buffer_head * bh;
-	int block;
-
-	lock_inode(inode);
-	if (!(sb=get_super(inode->i_dev)))
-		panic("trying to read inode without dev");
-	block = 2 + sb->s_imap_blocks + sb->s_zmap_blocks +
-		(inode->i_num-1)/INODES_PER_BLOCK;
-	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];
-	brelse(bh);
-	unlock_inode(inode);
-}
-
-static void write_inode(struct m_inode * inode)
-{
-	struct super_block * sb;
-	struct buffer_head * bh;
-	int block;
-
-	lock_inode(inode);
-	if (!inode->i_dirt || !inode->i_dev) {
-		unlock_inode(inode);
-		return;
-	}
-	if (!(sb=get_super(inode->i_dev)))
-		panic("trying to write inode without device");
-	block = 2 + sb->s_imap_blocks + sb->s_zmap_blocks +
-		(inode->i_num-1)/INODES_PER_BLOCK;
-	if (!(bh=bread(inode->i_dev,block)))
-		panic("unable to read i-node block");
-	((struct d_inode *)bh->b_data)
-		[(inode->i_num-1)%INODES_PER_BLOCK] =
-			*(struct d_inode *)inode;
-	bh->b_dirt=1;
-	inode->i_dirt=0;
-	brelse(bh);
-	unlock_inode(inode);
-}