--- linux/fs/inode.c	2018/04/24 18:04:59	1.1.1.6
+++ linux/fs/inode.c	2018/04/24 18:12:11	1.1.1.11
@@ -1,23 +1,19 @@
 /*
  *  linux/fs/inode.c
  *
- *  (C) 1991  Linus Torvalds
+ *  Copyright (C) 1991, 1992  Linus Torvalds
  */
 
-#include <string.h>
-#include <sys/stat.h>
-
+#include <linux/stat.h>
 #include <linux/sched.h>
-#include <linux/minix_fs.h>
 #include <linux/kernel.h>
 #include <linux/mm.h>
+#include <linux/string.h>
+
 #include <asm/system.h>
 
 struct inode inode_table[NR_INODE]={{0,},};
 
-extern void minix_read_inode(struct inode * inode);
-extern void minix_write_inode(struct inode * inode);
-
 static inline void wait_on_inode(struct inode * inode)
 {
 	cli();
@@ -43,25 +39,39 @@ static inline void unlock_inode(struct i
 
 static void write_inode(struct inode * inode)
 {
-	lock_inode(inode);
-	if (!inode->i_dirt || !inode->i_dev) {
-		unlock_inode(inode);
+	if (!inode->i_dirt)
 		return;
-	}
-	minix_write_inode(inode);
+	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);
-	minix_read_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)
 {
-	return minix_bmap(inode,block);
+	if (inode->i_op && inode->i_op->bmap)
+		return inode->i_op->bmap(inode,block);
+	return 0;
 }
 
 void invalidate_inodes(int dev)
@@ -90,7 +100,7 @@ void sync_inodes(void)
 	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);
 	}
 }
@@ -100,36 +110,34 @@ 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);
 		wake_up(&inode->i_wait2);
-		if (--inode->i_count)
-			return;
-		free_page(inode->i_size);
-		inode->i_count=0;
-		inode->i_dirt=0;
-		inode->i_pipe=0;
-		return;
 	}
-	if (!inode->i_dev) {
+repeat:
+	if (inode->i_count>1) {
 		inode->i_count--;
 		return;
 	}
-	if (S_ISBLK(inode->i_mode)) {
-		sync_dev(inode->i_rdev);
-		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_nlink) {
-		minix_truncate(inode);
-		minix_free_inode(inode);
-		return;
+		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 */
@@ -180,12 +188,13 @@ struct inode * get_pipe_inode(void)
 
 	if (!(inode = get_empty_inode()))
 		return NULL;
-	if (!(inode->i_size=get_free_page())) {
+	if (!(inode->i_size = get_free_page(GFP_USER))) {
 		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;
 }
@@ -243,6 +252,7 @@ struct inode * iget(int dev,int nr)
 	}
 	inode->i_dev = dev;
 	inode->i_ino = nr;
+	inode->i_flags = inode->i_sb->s_flags;
 	read_inode(inode);
 	return inode;
 }