diff -rupN --exclude='ide*' linux-2.4.20.orig/include/linux/mm.h linux-2.4.20/include/linux/mm.h
--- linux-2.4.20.orig/include/linux/mm.h	2004-02-10 11:43:10.000000000 +0200
+++ linux-2.4.20/include/linux/mm.h	2004-03-01 13:44:45.000000000 +0200
@@ -468,7 +468,8 @@ extern void clear_page_tables(struct mm_
 extern int fail_writepage(struct page *);
 struct page * shmem_nopage(struct vm_area_struct * vma, unsigned long address, int unused);
 struct file *shmem_file_setup(char * name, loff_t size);
-int shmem_getpage(struct inode * inode, unsigned long idx, struct page **ptr);
+struct page *shmem_getpage_locked(struct inode *inode, unsigned long idx);
+struct page *shmem_getpage_unlocked(struct inode *inode, unsigned long idx);
 extern void shmem_lock(struct file * file, int lock);
 extern int shmem_zero_setup(struct vm_area_struct *);
 
diff -rupN --exclude='ide*' linux-2.4.20.orig/include/linux/shmem_fs.h linux-2.4.20/include/linux/shmem_fs.h
--- linux-2.4.20.orig/include/linux/shmem_fs.h	2004-02-10 18:39:17.000000000 +0200
+++ linux-2.4.20/include/linux/shmem_fs.h	2004-02-23 12:40:28.000000000 +0200
@@ -7,6 +7,9 @@
 
 #define SHMEM_NR_DIRECT 16
 
+#define SHMEM_MOUNT_IOPEN	  0x8000	/* Allow access via iopen */
+#define SHMEM_MOUNT_IOPEN_NOPRIV  0x10000	/* Make iopen world-readable */
+
 /*
  * A swap entry has to fit into a "unsigned long", as
  * the entry is hidden in the "index" field of the
@@ -38,6 +41,9 @@ struct shmem_inode_info {
 };
 
 struct shmem_sb_info {
+	struct dentry *iopen;
+	unsigned long options;
+	unsigned long root_ino;
 	unsigned long max_blocks;   /* How many blocks are allowed */
 	unsigned long free_blocks;  /* How many are left for allocation */
 	unsigned long max_inodes;   /* How many inodes are allowed */
@@ -59,11 +65,9 @@ shmem_xattr_find(struct inode *inode, co
 extern ssize_t
 shmem_xattr_set(struct inode *inode, const char *name,
 		const void *value, u16 valuelen, int flags);
-		
 extern ssize_t
 shmem_xattr_get(struct inode *inode, const char *name,
 		void *value, size_t valuelen);
-		
 extern int
 shmem_xattr_delete(struct inode *inode, struct shmem_xattr *xattr);
 
diff -rupN --exclude='ide*' linux-2.4.20.orig/mm/shmem.c linux-2.4.20/mm/shmem.c
--- linux-2.4.20.orig/mm/shmem.c	2004-02-10 18:44:05.000000000 +0200
+++ linux-2.4.20/mm/shmem.c	2004-03-01 14:37:21.000000000 +0200
@@ -36,29 +36,45 @@
 #define TMPFS_MAGIC	0x01021994
 
 #define ENTRIES_PER_PAGE (PAGE_CACHE_SIZE/sizeof(unsigned long))
+
 #define BLOCKS_PER_PAGE  (PAGE_CACHE_SIZE/512)
 
-#define SHMEM_MAX_INDEX  (SHMEM_NR_DIRECT + ENTRIES_PER_PAGE * (ENTRIES_PER_PAGE/2) * (ENTRIES_PER_PAGE+1))
+#define SHMEM_MAX_INDEX  (SHMEM_NR_DIRECT + ENTRIES_PER_PAGE * \
+			  (ENTRIES_PER_PAGE/2) * (ENTRIES_PER_PAGE+1))
+
 #define SHMEM_MAX_BYTES  ((unsigned long long)SHMEM_MAX_INDEX << PAGE_CACHE_SHIFT)
 #define VM_ACCT(size)    (((size) + PAGE_CACHE_SIZE - 1) >> PAGE_SHIFT)
 
 /* Pretend that each entry is of this size in directory's i_size */
-#define BOGO_DIRENT_SIZE 20
-
+#define BOGO_DIRENT_SIZE (20)
 #define SHMEM_SB(sb) (&sb->u.shmem_sb)
 
+#define SHMEM_IOPEN_INO 	2
+#define SHMEM_IOPEN_NAME_LEN	32
+
+#define ASSERT(cond)                                                    \
+do {									\
+	if (!(cond)) {							\
+		printk (KERN_EMERG					\
+			"Assertion failure in %s() at %s:%d: \"%s\"\n",	\
+			__FUNCTION__, __FILE__, __LINE__, # cond);	\
+		BUG();							\
+	}								\
+} while (0)
+
 static struct super_operations shmem_ops;
+static struct vm_operations_struct shmem_vm_ops;
 static struct address_space_operations shmem_aops;
 static struct file_operations shmem_file_operations;
 static struct inode_operations shmem_inode_operations;
 static struct inode_operations shmem_dir_inode_operations;
-static struct vm_operations_struct shmem_vm_ops;
 
 LIST_HEAD (shmem_inodes);
 static spinlock_t shmem_ilock = SPIN_LOCK_UNLOCKED;
 atomic_t shmem_nrpages = ATOMIC_INIT(0); /* Not used right now */
 
-static struct page *shmem_getpage_locked(struct shmem_inode_info *, struct inode *, unsigned long);
+struct page *shmem_getpage_locked(struct inode *inode, unsigned long idx);
+struct page *shmem_getpage_unlocked(struct inode *inode, unsigned long idx);
 
 #ifdef CONFIG_TMPFS
 static struct inode_operations shmem_symlink_inode_operations;
@@ -327,7 +343,7 @@ shmem_getxattr(struct dentry *dentry, co
  * inode attributes list.*/
 static int
 shmem_setxattr(struct dentry *dentry, const char *name,
-               void *value, size_t valuelen, int flags)
+               const void *value, size_t valuelen, int flags)
 {
         int error;
         struct inode *inode = dentry->d_inode;
@@ -404,8 +420,8 @@ shmem_listxattr(struct dentry *dentry, c
  * @inode: inode to recalc
  * @swap:  additional swap pages freed externally
  *
- * We have to calculate the free blocks since the mm can drop pages
- * behind our back
+ * We have to calculate the free blocks since the mm can drop pages behind our
+ * back
  *
  * But we know that normally
  * inodes->i_blocks/BLOCKS_PER_PAGE == 
@@ -441,24 +457,23 @@ static void shmem_recalc_inode(struct in
  * @page:  optional page to add to the structure. Has to be preset to
  *         all zeros
  *
- * If there is no space allocated yet it will return -ENOMEM when
- * page == 0 else it will use the page for the needed block.
+ * If there is no space allocated yet it will return -ENOMEM when page == 0 else
+ * it will use the page for the needed block.
  *
  * returns -EFBIG if the index is too big.
  *
  *
  * The swap vector is organized the following way:
  *
- * There are SHMEM_NR_DIRECT entries directly stored in the
- * shmem_inode_info structure. So small files do not need an addional
- * allocation.
- *
- * For pages with index > SHMEM_NR_DIRECT there is the pointer
- * i_indirect which points to a page which holds in the first half
- * doubly indirect blocks, in the second half triple indirect blocks:
+ * There are SHMEM_NR_DIRECT entries directly stored in the shmem_inode_info
+ * structure. So small files do not need an addional allocation.
+ *
+ * For pages with index > SHMEM_NR_DIRECT there is the pointer i_indirect which
+ * points to a page which holds in the first half doubly indirect blocks, in the
+ * second half triple indirect blocks:
  *
- * For an artificial ENTRIES_PER_PAGE = 4 this would lead to the
- * following layout (for SHMEM_NR_DIRECT == 16):
+ * For an artificial ENTRIES_PER_PAGE = 4 this would lead to the following
+ * layout (for SHMEM_NR_DIRECT == 16):
  *
  * i_indirect -> dir --> 16-19
  * 	      |	     +-> 20-23
@@ -473,7 +488,9 @@ static void shmem_recalc_inode(struct in
  * 	      	       +-> 48-51
  * 	      	       +-> 52-55
  */
-static swp_entry_t * shmem_swp_entry (struct shmem_inode_info *info, unsigned long index, unsigned long page) 
+static swp_entry_t *
+shmem_swp_entry (struct shmem_inode_info *info, unsigned long index,
+		 unsigned long page) 
 {
 	unsigned long offset;
 	void **dir;
@@ -520,7 +537,8 @@ static swp_entry_t * shmem_swp_entry (st
  * @info:	info structure for the inode
  * @index:	index of the page to find
  */
-static inline swp_entry_t * shmem_alloc_entry (struct shmem_inode_info *info, unsigned long index)
+static inline swp_entry_t *
+shmem_alloc_entry(struct shmem_inode_info *info, unsigned long index)
 {
 	unsigned long page = 0;
 	swp_entry_t * res;
@@ -545,7 +563,8 @@ static inline swp_entry_t * shmem_alloc_
  * @dir:   pointer to the directory
  * @count: number of entries to scan
  */
-static int shmem_free_swp(swp_entry_t *dir, unsigned int count)
+static int
+shmem_free_swp(swp_entry_t *dir, unsigned int count)
 {
 	swp_entry_t *ptr, entry;
 	int freed = 0;
@@ -573,7 +592,9 @@ static int shmem_free_swp(swp_entry_t *d
  */
 
 static inline unsigned long 
-shmem_truncate_direct(swp_entry_t *** dir, unsigned long start, unsigned long len) {
+shmem_truncate_direct(swp_entry_t ***dir, unsigned long start,
+		      unsigned long len)
+{
 	swp_entry_t **last, **ptr;
 	unsigned long off, freed = 0;
  
@@ -639,7 +660,8 @@ shmem_truncate_indirect(struct shmem_ino
 			BUG();
 
 		baseidx = max & ~(ENTRIES_PER_PAGE*ENTRIES_PER_PAGE-1);
-		base = (swp_entry_t ***) info->i_indirect + ENTRIES_PER_PAGE/2 + baseidx/ENTRIES_PER_PAGE/ENTRIES_PER_PAGE ;
+		base = (swp_entry_t ***) info->i_indirect + ENTRIES_PER_PAGE/2 +
+			baseidx/ENTRIES_PER_PAGE/ENTRIES_PER_PAGE ;
 		len = max - baseidx + 1;
 		baseidx += ENTRIES_PER_PAGE*ENTRIES_PER_PAGE/2+SHMEM_NR_DIRECT;
 	}
@@ -654,7 +676,8 @@ shmem_truncate_indirect(struct shmem_ino
 	return shmem_truncate_direct(base, start, len);
 }
 
-static void shmem_truncate (struct inode * inode)
+static void
+shmem_truncate(struct inode *inode)
 {
 	unsigned long index;
 	unsigned long partial;
@@ -668,16 +691,16 @@ static void shmem_truncate (struct inode
 	partial = inode->i_size & ~PAGE_CACHE_MASK;
 
 	if (partial) {
-		swp_entry_t *entry = shmem_swp_entry(info, index-1, 0);
 		struct page *page;
-		/*
-		 * This check is racy: it's faintly possible that page
-		 * was assigned to swap during truncate_inode_pages,
-		 * and now assigned to file; but better than nothing.
+		swp_entry_t *entry = shmem_swp_entry(info, index - 1, 0);
+		
+		/* This check is racy: it's faintly possible that page was
+		 * assigned to swap during truncate_inode_pages, and now
+		 * assigned to file; but better than nothing.
 		 */
 		if (!IS_ERR(entry) && entry->val) {
 			spin_unlock(&info->lock);
-			page = shmem_getpage_locked(info, inode, index-1);
+			page = shmem_getpage_locked(inode, index - 1);
 			if (!IS_ERR(page)) {
 				memclear_highpage_flush(page, partial,
 					PAGE_CACHE_SIZE - partial);
@@ -697,8 +720,166 @@ static void shmem_truncate (struct inode
 	up(&info->sem);
 }
 
-static void shmem_delete_inode(struct inode * inode)
+static struct inode *
+shmem_find_inode(struct super_block *sb, long int ino)
+{
+	struct list_head *p;
+	struct inode *inode = NULL;
+	struct shmem_inode_info *info;
+
+	spin_lock (&shmem_ilock);
+	list_for_each(p, &shmem_inodes) {
+		info = list_entry(p, struct shmem_inode_info, list);
+		
+		if (info->inode->i_ino == ino && 
+		    info->inode->i_sb == sb) 
+		{
+			inode = info->inode;
+			break;
+		}
+	}
+	
+	spin_unlock (&shmem_ilock);
+	
+	if (inode)
+		igrab(inode);
+		
+	return inode;
+}
+
+#define switch_fields(x,y) do {   \
+	__typeof__ (x) __tmp = x; \
+	x = y; y = __tmp; } while (0)
+
+static inline void
+switch_names(struct dentry *dentry, struct dentry *target)
+{
+	const unsigned char *old_name, *new_name;
+
+	memcpy(dentry->d_iname, target->d_iname, 
+	       DNAME_INLINE_LEN);
+	
+	old_name = target->d_name.name;
+	new_name = dentry->d_name.name;
+	
+	if (old_name == target->d_iname)
+		old_name = dentry->d_iname;
+	
+	if (new_name == dentry->d_iname)
+		new_name = target->d_iname;
+	
+	target->d_name.name = new_name;
+	dentry->d_name.name = old_name;
+}
+
+static struct dentry *
+shmem_iopen_lookup(struct inode *dir, 
+		   struct dentry *dentry)
+{
+	struct inode *inode;
+	unsigned long ino;
+	struct list_head *lp;
+	struct dentry *alternate;
+	char buf[SHMEM_IOPEN_NAME_LEN];
+	struct shmem_sb_info *sbinfo = SHMEM_SB(dir->i_sb);
+
+	if (dentry->d_name.len >= SHMEM_IOPEN_NAME_LEN)
+		return ERR_PTR(-ENAMETOOLONG);
+
+	memcpy(buf, dentry->d_name.name, dentry->d_name.len);
+	buf[dentry->d_name.len] = 0;
+
+	if (strcmp(buf, ".") == 0)
+		ino = dir->i_ino;
+	else if (strcmp(buf, "..") == 0)
+		ino = sbinfo->root_ino;
+	else
+		ino = simple_strtoul(buf, 0, 0);
+
+	if (ino < sbinfo->root_ino)
+		return ERR_PTR(-ENOENT);
+
+	if (!(inode = shmem_find_inode(dir->i_sb, ino)))
+		return ERR_PTR(-ENOENT);
+
+	ASSERT(list_empty(&dentry->d_alias));
+	ASSERT(list_empty(&dentry->d_hash));
+
+	/* preferrably return a connected dentry */
+	spin_lock(&dcache_lock);
+	list_for_each(lp, &inode->i_dentry) {
+		alternate = list_entry(lp, struct dentry, d_alias);
+		ASSERT(!(alternate->d_flags & DCACHE_NFSD_DISCONNECTED));
+	}
+
+	if (!list_empty(&inode->i_dentry)) {
+		alternate = list_entry(inode->i_dentry.next,
+				       struct dentry, d_alias);
+		dget_locked(alternate);
+		alternate->d_vfs_flags |= DCACHE_REFERENCED;
+		iput(inode);
+		spin_unlock(&dcache_lock);
+		return alternate;
+	}
+	dentry->d_flags |= DCACHE_NFSD_DISCONNECTED;
+
+	/* d_add(), but don't drop dcache_lock before adding dentry to inode */
+	list_add(&dentry->d_alias, &inode->i_dentry);
+	dentry->d_inode = inode;
+
+	__d_rehash(dentry, 0);
+	spin_unlock(&dcache_lock);
+
+	return NULL;
+}
+
+struct dentry *
+shmem_iopen_unalias(struct dentry *dentry, struct inode *inode)
+{
+	struct dentry *tmp, *goal = NULL;
+	struct list_head *lp;
+
+	list_for_each(lp, &inode->i_dentry) {
+		tmp = list_entry(lp, struct dentry, d_alias);
+		if (tmp->d_flags & DCACHE_NFSD_DISCONNECTED) {
+			ASSERT(tmp->d_alias.next == &inode->i_dentry);
+			ASSERT(tmp->d_alias.prev == &inode->i_dentry);
+			goal = tmp;
+			dget_locked(goal);
+			break;
+		}
+	}
+
+	if (!goal)
+		return NULL;
+
+	goal->d_flags &= ~DCACHE_NFSD_DISCONNECTED;
+	list_del_init(&goal->d_hash);
+
+	list_del(&goal->d_child);
+	list_del(&dentry->d_child);
+
+	switch_names(goal, dentry);
+	switch_fields(goal->d_parent, dentry->d_parent);
+	switch_fields(goal->d_name.len, dentry->d_name.len);
+	switch_fields(goal->d_name.hash, dentry->d_name.hash);
+
+	list_add(&goal->d_child, &goal->d_parent->d_subdirs);
+	list_add(&dentry->d_child, &dentry->d_parent->d_subdirs);
+	__d_rehash(goal, 0);
+
+	return goal;
+}
+
+static struct inode_operations iopen_inode_operations = {
+	lookup:		shmem_iopen_lookup,
+};
+
+static void
+shmem_delete_inode(struct inode *inode)
 {
+	struct dentry *dentry;
+	
 #ifdef CONFIG_TMPFS_XATTR
 	struct list_head *tmp, *p;
 	struct shmem_xattr *xattr;
@@ -706,16 +887,30 @@ static void shmem_delete_inode(struct in
 #endif
 	struct shmem_sb_info *sbinfo = SHMEM_SB(inode->i_sb);
 
-	if (inode->i_op->truncate == shmem_truncate) {
+	if (inode->i_ino != SHMEM_IOPEN_INO) {
+		/* eliminating iopen alias */
+		spin_lock(&dcache_lock);
+		if (!list_empty(&inode->i_dentry)) {
+			dentry = list_entry(inode->i_dentry.next,
+					    struct dentry, d_alias);
+			shmem_iopen_unalias(dentry, inode);
+		}
+		spin_unlock(&dcache_lock);
+
 		spin_lock (&shmem_ilock);
 		list_del (&SHMEM_I(inode)->list);
 		spin_unlock (&shmem_ilock);
-		inode->i_size = 0;
-		shmem_truncate (inode);
+	
+		if (inode->i_op->truncate == shmem_truncate) {
+			inode->i_size = 0;
+			shmem_truncate (inode);
+		}
+	
+		spin_lock (&sbinfo->stat_lock);
+		sbinfo->free_inodes++;
+		spin_unlock (&sbinfo->stat_lock);
 	}
-	spin_lock (&sbinfo->stat_lock);
-	sbinfo->free_inodes++;
-	spin_unlock (&sbinfo->stat_lock);
+	
 #ifdef CONFIG_TMPFS_XATTR
         list_for_each_safe(p, tmp, &info->xattrs) {
                 xattr = list_entry(p, struct shmem_xattr, list);
@@ -725,7 +920,8 @@ static void shmem_delete_inode(struct in
 	clear_inode(inode);
 }
 
-static inline int shmem_find_swp(swp_entry_t entry, swp_entry_t *ptr, swp_entry_t *eptr)
+static inline int
+shmem_find_swp(swp_entry_t entry, swp_entry_t *ptr, swp_entry_t *eptr)
 {
 	swp_entry_t *test;
 
@@ -736,7 +932,9 @@ static inline int shmem_find_swp(swp_ent
 	return -1;
 }
 
-static int shmem_unuse_inode(struct shmem_inode_info *info, swp_entry_t entry, struct page *page)
+static int
+shmem_unuse_inode(struct shmem_inode_info *info, swp_entry_t entry,
+		  struct page *page)
 {
 	swp_entry_t *ptr;
 	unsigned long idx;
@@ -875,9 +1073,11 @@ getswap:
  * still need to guard against racing with shm_writepage(), which might
  * be trying to move the page to the swap cache as we run.
  */
-static struct page * shmem_getpage_locked(struct shmem_inode_info *info, struct inode * inode, unsigned long idx)
+struct page *
+shmem_getpage_locked(struct inode *inode, unsigned long idx)
 {
 	struct address_space * mapping = inode->i_mapping;
+	struct shmem_inode_info *info = SHMEM_I(inode);
 	struct shmem_sb_info *sbinfo;
 	struct page * page;
 	swp_entry_t *entry;
@@ -941,7 +1141,8 @@ repeat:
 		swap_free(*entry);
 		*entry = (swp_entry_t) {0};
 		delete_from_swap_cache(page);
-		flags = page->flags & ~((1 << PG_uptodate) | (1 << PG_error) | (1 << PG_referenced) | (1 << PG_arch_1));
+		flags = page->flags & ~((1 << PG_uptodate) | (1 << PG_error) |
+					(1 << PG_referenced) | (1 << PG_arch_1));
 		page->flags = flags | (1 << PG_dirty);
 		add_to_page_cache_locked(page, mapping, idx);
 		info->swapped--;
@@ -985,46 +1186,53 @@ wait_retry:
 	goto repeat;
 }
 
-int shmem_getpage(struct inode * inode, unsigned long idx, struct page **ptr)
+struct page *
+shmem_getpage_unlocked(struct inode *inode, unsigned long idx)
 {
+	struct page *page;
 	struct shmem_inode_info *info = SHMEM_I(inode);
-	int error;
 
-	down (&info->sem);
-	*ptr = ERR_PTR(-EFAULT);
-	if (inode->i_size <= (loff_t) idx * PAGE_CACHE_SIZE)
+	down(&info->sem);
+	page = ERR_PTR(-EFAULT);
+	
+	if (inode->i_size <= (loff_t)idx * PAGE_CACHE_SIZE)
 		goto failed;
 
-	*ptr = shmem_getpage_locked(info, inode, idx);
-	if (IS_ERR (*ptr))
+	page = shmem_getpage_locked(inode, idx);
+	
+	if (IS_ERR(page))
 		goto failed;
 
-	UnlockPage(*ptr);
-	up (&info->sem);
-	return 0;
+	UnlockPage(page);
+	up(&info->sem);
+	return page;
 failed:
-	up (&info->sem);
-	error = PTR_ERR(*ptr);
-	*ptr = NOPAGE_SIGBUS;
-	if (error == -ENOMEM)
-		*ptr = NOPAGE_OOM;
-	return error;
+	up(&info->sem);
+
+	if (PTR_ERR(page) == -ENOMEM)
+		return NOPAGE_OOM;
+	
+	return page;
 }
 
-struct page * shmem_nopage(struct vm_area_struct * vma, unsigned long address, int unused)
+struct page *
+shmem_nopage(struct vm_area_struct *vma, 
+	     unsigned long address, int unused)
 {
-	struct page * page;
 	unsigned int idx;
+	struct page * page;
 	struct inode * inode = vma->vm_file->f_dentry->d_inode;
 
-	idx = (address - vma->vm_start) >> PAGE_CACHE_SHIFT;
-	idx += vma->vm_pgoff;
+	idx = ((address - vma->vm_start) >> PAGE_CACHE_SHIFT) +
+		vma->vm_pgoff;
 
-	if (shmem_getpage(inode, idx, &page))
+	page = shmem_getpage_unlocked(inode, idx);
+	
+	if (IS_ERR(page))
 		return page;
 
 	flush_page_to_ram(page);
-	return(page);
+	return page;
 }
 
 void shmem_lock(struct file * file, int lock)
@@ -1037,7 +1245,8 @@ void shmem_lock(struct file * file, int 
 	up(&info->sem);
 }
 
-static int shmem_mmap(struct file * file, struct vm_area_struct * vma)
+static int
+shmem_mmap(struct file * file, struct vm_area_struct * vma)
 {
 	struct vm_operations_struct * ops;
 	struct inode *inode = file->f_dentry->d_inode;
@@ -1050,39 +1259,53 @@ static int shmem_mmap(struct file * file
 	return 0;
 }
 
-struct inode *shmem_get_inode(struct super_block *sb, int mode, int dev)
+static void
+shmem_fill_inode(struct inode *inode, int mode, int dev)
 {
-	struct inode * inode;
 	struct shmem_inode_info *info;
-	struct shmem_sb_info *sbinfo = SHMEM_SB(sb);
+	
+	info = SHMEM_I(inode);
+	info->inode = inode;
+	spin_lock_init (&info->lock);
+	sema_init (&info->sem, 1);
 
-	spin_lock (&sbinfo->stat_lock);
-	if (!sbinfo->free_inodes) {
-		spin_unlock (&sbinfo->stat_lock);
-		return NULL;
-	}
-	sbinfo->free_inodes--;
-	spin_unlock (&sbinfo->stat_lock);
+#ifdef CONFIG_TMPFS_XATTR
+	INIT_LIST_HEAD(&info->xattrs);
+	info->xtail = &info->xattrs;
+#endif
 
-	inode = new_inode(sb);
-	if (inode) {
+	inode->i_blocks = 0;
+	inode->i_rdev = NODEV;
+	inode->i_atime = CURRENT_TIME;
+	inode->i_ctime = CURRENT_TIME;
+	inode->i_mtime = CURRENT_TIME;
+	inode->i_blksize = PAGE_CACHE_SIZE;
+	
+	/* handling speciall iopen inode. */
+	if (inode->i_ino == SHMEM_IOPEN_INO) {
+		struct shmem_sb_info *sbinfo = SHMEM_SB(inode->i_sb);
+		
+		inode->i_mode = S_IFDIR | S_IRUSR | S_IXUSR;
+	
+		if (sbinfo->options & SHMEM_MOUNT_IOPEN_NOPRIV)
+			inode->i_mode |= 0777;
+		
+		inode->i_uid = 0;
+		inode->i_gid = 0;
+		inode->i_nlink = 1;
+		inode->i_size = 2 * BOGO_DIRENT_SIZE;
+		inode->i_version = 1;
+		inode->i_generation = 0;
+
+		inode->i_op = &iopen_inode_operations;
+		inode->i_fop = &dcache_dir_ops;
+		inode->i_mapping->a_ops = 0;
+	} else {
 		inode->i_mode = mode;
 		inode->i_uid = current->fsuid;
 		inode->i_gid = current->fsgid;
-		inode->i_blksize = PAGE_CACHE_SIZE;
-		inode->i_blocks = 0;
-		inode->i_rdev = NODEV;
 		inode->i_mapping->a_ops = &shmem_aops;
-		inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
-		info = SHMEM_I(inode);
-		info->inode = inode;
-		spin_lock_init (&info->lock);
-		sema_init (&info->sem, 1);
 
-#ifdef CONFIG_TMPFS_XATTR
-		INIT_LIST_HEAD(&info->xattrs);
-		info->xtail = &info->xattrs;
-#endif
 		switch (mode & S_IFMT) {
 		default:
 			init_special_inode(inode, mode, dev);
@@ -1090,9 +1313,6 @@ struct inode *shmem_get_inode(struct sup
 		case S_IFREG:
 			inode->i_op = &shmem_inode_operations;
 			inode->i_fop = &shmem_file_operations;
-			spin_lock (&shmem_ilock);
-			list_add_tail(&info->list, &shmem_inodes);
-			spin_unlock (&shmem_ilock);
 			break;
 		case S_IFDIR:
 			inode->i_nlink++;
@@ -1104,12 +1324,59 @@ struct inode *shmem_get_inode(struct sup
 		case S_IFLNK:
 			break;
 		}
+		
+		spin_lock (&shmem_ilock);
+		list_add_tail(&info->list, &shmem_inodes);
+		spin_unlock (&shmem_ilock);
+	}
+}
+
+struct inode *
+shmem_get_inode(struct super_block *sb, 
+		int mode, int dev, int root)
+{
+	struct inode *inode;
+	struct shmem_sb_info *sbinfo = SHMEM_SB(sb);
+
+	spin_lock (&sbinfo->stat_lock);
+	if (!sbinfo->free_inodes) {
+		spin_unlock (&sbinfo->stat_lock);
+		return NULL;
+	}
+	sbinfo->free_inodes--;
+	spin_unlock (&sbinfo->stat_lock);
+
+	if ((inode = new_inode(sb))) {
+		shmem_fill_inode(inode, mode, dev);
+		if (root)
+			sbinfo->root_ino = inode->i_ino;
 	}
+	
 	return inode;
 }
 
-static int shmem_set_size(struct shmem_sb_info *info,
-			  unsigned long max_blocks, unsigned long max_inodes)
+void shmem_read_inode(struct inode *inode)
+{
+	struct shmem_sb_info *sbinfo;
+
+	if (inode->i_ino != SHMEM_IOPEN_INO)
+		return;
+		
+	sbinfo = SHMEM_SB(inode->i_sb);
+	
+	spin_lock (&sbinfo->stat_lock);
+	if (!sbinfo->free_inodes) {
+		spin_unlock (&sbinfo->stat_lock);
+		return;
+	}
+	sbinfo->free_inodes--;
+	spin_unlock (&sbinfo->stat_lock);
+	shmem_fill_inode(inode, 0, 0);
+}
+
+static int
+shmem_set_size(struct shmem_sb_info *info, unsigned long max_blocks, 
+	       unsigned long max_inodes)
 {
 	int error;
 	unsigned long blocks, inodes;
@@ -1192,7 +1459,6 @@ shmem_file_write(struct file *file,const
 
 	while (count) {
 		unsigned long bytes, index, offset;
-		char *kaddr;
 
 		/*
 		 * Try to find the page in the cache. If it isn't there,
@@ -1201,9 +1467,9 @@ shmem_file_write(struct file *file,const
 		offset = (pos & (PAGE_CACHE_SIZE -1)); /* Within page */
 		index = pos >> PAGE_CACHE_SHIFT;
 		bytes = PAGE_CACHE_SIZE - offset;
-		if (bytes > count) {
+
+		if (bytes > count)
 			bytes = count;
-		}
 
 		/*
 		 * Bring in the user page that we will copy from _first_.
@@ -1218,7 +1484,7 @@ shmem_file_write(struct file *file,const
 
 		info = SHMEM_I(inode);
 		down (&info->sem);
-		page = shmem_getpage_locked(info, inode, index);
+		page = shmem_getpage_locked(inode, index);
 		up (&info->sem);
 
 		status = PTR_ERR(page);
@@ -1226,17 +1492,19 @@ shmem_file_write(struct file *file,const
 			break;
 
 		/* We have exclusive IO access to the page.. */
-		if (!PageLocked(page)) {
+		if (!PageLocked(page))
 			PAGE_BUG(page);
-		}
 
-		kaddr = kmap(page);
-		status = copy_from_user(kaddr+offset, buf, bytes);
+		status = copy_from_user(kmap(page) + offset,
+					buf, bytes);
+		
 		kunmap(page);
+
 		if (status)
 			goto fail_write;
 
 		flush_dcache_page(page);
+		
 		if (bytes > 0) {
 			SetPageDirty(page);
 			written += bytes;
@@ -1266,7 +1534,8 @@ fail_write:
 	goto unlock;
 }
 
-static void do_shmem_file_read(struct file * filp, loff_t *ppos, read_descriptor_t * desc)
+static void
+do_shmem_file_read(struct file * filp, loff_t *ppos, read_descriptor_t * desc)
 {
 	struct inode *inode = filp->f_dentry->d_inode;
 	struct address_space *mapping = inode->i_mapping;
@@ -1292,15 +1561,18 @@ static void do_shmem_file_read(struct fi
 
 		nr = nr - offset;
 
-		if ((desc->error = shmem_getpage(inode, index, &page)))
+		page = shmem_getpage_unlocked(inode, index);
+
+		if (IS_ERR(page)) {
+			desc->error = PTR_ERR(page);
 			break;
+		}
 
 		if (mapping->i_mmap_shared != NULL)
 			flush_dcache_page(page);
 
-		/*
-		 * Ok, we have the page, and it's up-to-date, so
-		 * now we can copy it to user space...
+		/* Ok, we have the page, and it's up-to-date, so now we can copy
+		 * it to user space...
 		 *
 		 * The actor routine returns how many bytes were actually used..
 		 * NOTE! This may not be the same as how much of a user buffer
@@ -1309,6 +1581,8 @@ static void do_shmem_file_read(struct fi
 		 * pointers and the remaining count).
 		 */
 		nr = file_read_actor(desc, page, offset, nr);
+
+		/* updating counters */
 		offset += nr;
 		index += offset >> PAGE_CACHE_SHIFT;
 		offset &= ~PAGE_CACHE_MASK;
@@ -1320,7 +1594,8 @@ static void do_shmem_file_read(struct fi
 	UPDATE_ATIME(inode);
 }
 
-static ssize_t shmem_file_read(struct file * filp, char * buf, size_t count, loff_t *ppos)
+static ssize_t
+shmem_file_read(struct file * filp, char * buf, size_t count, loff_t *ppos)
 {
 	ssize_t retval;
 
@@ -1345,7 +1620,8 @@ static ssize_t shmem_file_read(struct fi
 	return retval;
 }
 
-static int shmem_statfs(struct super_block *sb, struct statfs *buf)
+static int
+shmem_statfs(struct super_block *sb, struct statfs *buf)
 {
 	struct shmem_sb_info *sbinfo = SHMEM_SB(sb);
 
@@ -1361,22 +1637,62 @@ static int shmem_statfs(struct super_blo
 	return 0;
 }
 
-/*
- * Lookup the data. This is trivial - if the dentry didn't already
- * exist, we know it is negative.
- */
-static struct dentry * shmem_lookup(struct inode *dir, struct dentry *dentry)
+static int
+match_dentry(struct dentry *dentry, const char *name)
+{
+	int len = strlen(name);
+	
+	if (dentry->d_name.len != len)
+		return 0;
+		
+	if (strncmp(dentry->d_name.name, name, len))
+		return 0;
+		
+	return 1;
+}
+
+static int
+shmem_iopen_check(struct inode *dir, struct dentry *dentry)
+{
+	struct inode *inode;
+	struct shmem_sb_info *sbinfo = SHMEM_SB(dir->i_sb);
+
+	if (dir->i_ino != sbinfo->root_ino ||
+	    !(sbinfo->options & SHMEM_MOUNT_IOPEN) ||
+	    !match_dentry(dentry, "__iopen__"))
+	{
+		return 0;
+	}
+
+	if (!(inode = iget(dir->i_sb, SHMEM_IOPEN_INO)))
+		return 0;
+		
+	d_add(dentry, inode);
+	
+	spin_lock (&sbinfo->stat_lock);
+	sbinfo->iopen = dentry;
+	spin_unlock (&sbinfo->stat_lock);
+	
+	dget(dentry);
+	return 1;
+}
+
+static struct dentry *
+shmem_lookup(struct inode *dir, struct dentry *dentry)
 {
-	d_add(dentry, NULL);
+	if (!shmem_iopen_check(dir, dentry))
+		d_add(dentry, NULL);
+	
 	return NULL;
 }
 
 /*
  * File creation. Allocate an inode, and we're done..
  */
-static int shmem_mknod(struct inode *dir, struct dentry *dentry, int mode, int dev)
+static int
+shmem_mknod(struct inode *dir, struct dentry *dentry, int mode, int dev)
 {
-	struct inode * inode = shmem_get_inode(dir->i_sb, mode, dev);
+	struct inode *inode = shmem_get_inode(dir->i_sb, mode, dev, 0);
 	int error = -ENOSPC;
 
 	if (inode) {
@@ -1386,20 +1702,24 @@ static int shmem_mknod(struct inode *dir
 		dget(dentry); /* Extra count - pin the dentry in core */
 		error = 0;
 	}
+	
 	return error;
 }
 
-static int shmem_mkdir(struct inode * dir, struct dentry * dentry, int mode)
+static int
+shmem_mkdir(struct inode * dir, struct dentry * dentry, int mode)
 {
 	int error;
 
 	if ((error = shmem_mknod(dir, dentry, mode | S_IFDIR, 0)))
 		return error;
+		
 	dir->i_nlink++;
 	return 0;
 }
 
-static int shmem_create(struct inode *dir, struct dentry *dentry, int mode)
+static int
+shmem_create(struct inode *dir, struct dentry *dentry, int mode)
 {
 	return shmem_mknod(dir, dentry, mode | S_IFREG, 0);
 }
@@ -1407,7 +1727,8 @@ static int shmem_create(struct inode *di
 /*
  * Link a file..
  */
-static int shmem_link(struct dentry *old_dentry, struct inode * dir, struct dentry * dentry)
+static int
+shmem_link(struct dentry *old_dentry, struct inode * dir, struct dentry * dentry)
 {
 	struct inode *inode = old_dentry->d_inode;
 
@@ -1429,13 +1750,11 @@ static inline int shmem_positive(struct 
 }
 
 /*
- * Check that a directory is empty (this works
- * for regular files too, they'll just always be
- * considered empty..).
+ * Check that a directory is empty (this works for regular files too, they'll
+ * just always be considered empty..).
  *
- * Note that an empty directory can still have
- * children, they just all have to be negative..
- */
+ * Note that an empty directory can still have children, they just all have to
+ * be negative.. */
 static int shmem_empty(struct dentry *dentry)
 {
 	struct list_head *list;
@@ -1456,18 +1775,22 @@ static int shmem_empty(struct dentry *de
 	return 1;
 }
 
-static int shmem_unlink(struct inode * dir, struct dentry *dentry)
+static int
+shmem_unlink(struct inode *dir, struct dentry *dentry)
 {
 	struct inode *inode = dentry->d_inode;
 
 	dir->i_size -= BOGO_DIRENT_SIZE;
 	inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME;
 	inode->i_nlink--;
-	dput(dentry);	/* Undo the count from "create" - this does all the work */
+	
+	/* undo the count from "create" - this does all the work. */
+	dput(dentry);
 	return 0;
 }
 
-static int shmem_rmdir(struct inode * dir, struct dentry *dentry)
+static int
+shmem_rmdir(struct inode *dir, struct dentry *dentry)
 {
 	if (!shmem_empty(dentry))
 		return -ENOTEMPTY;
@@ -1477,12 +1800,13 @@ static int shmem_rmdir(struct inode * di
 }
 
 /*
- * The VFS layer already does all the dentry stuff for rename,
- * we just have to decrement the usage count for the target if
- * it exists so that the VFS layer correctly free's it when it
- * gets overwritten.
+ * The VFS layer already does all the dentry stuff for rename, we just have to
+ * decrement the usage count for the target if it exists so that the VFS layer
+ * correctly free's it when it gets overwritten.
  */
-static int shmem_rename(struct inode * old_dir, struct dentry *old_dentry, struct inode * new_dir,struct dentry *new_dentry)
+static int
+shmem_rename(struct inode *old_dir, struct dentry *old_dentry,
+	     struct inode *new_dir, struct dentry *new_dentry)
 {
 	struct inode *inode = old_dentry->d_inode;
 	int they_are_dirs = S_ISDIR(inode->i_mode);
@@ -1507,19 +1831,20 @@ static int shmem_rename(struct inode * o
 	return 0;
 }
 
-static int shmem_symlink(struct inode * dir, struct dentry *dentry, const char * symname)
+static int
+shmem_symlink(struct inode *dir, struct dentry *dentry,
+	      const char *symname)
 {
 	int len;
-	struct inode *inode;
 	struct page *page;
-	char *kaddr;
-	struct shmem_inode_info * info;
+	struct inode *inode;
+	struct shmem_inode_info *info;
 
 	len = strlen(symname) + 1;
 	if (len > PAGE_CACHE_SIZE)
 		return -ENAMETOOLONG;
 
-	inode = shmem_get_inode(dir->i_sb, S_IFLNK|S_IRWXUGO, 0);
+	inode = shmem_get_inode(dir->i_sb, S_IFLNK|S_IRWXUGO, 0, 0);
 	if (!inode)
 		return -ENOSPC;
 
@@ -1531,7 +1856,7 @@ static int shmem_symlink(struct inode * 
 		inode->i_op = &shmem_symlink_inline_operations;
 	} else {
 		down(&info->sem);
-		page = shmem_getpage_locked(info, inode, 0);
+		page = shmem_getpage_locked(inode, 0);
 		if (IS_ERR(page)) {
 			up(&info->sem);
 			iput(inode);
@@ -1541,8 +1866,7 @@ static int shmem_symlink(struct inode * 
 		spin_lock (&shmem_ilock);
 		list_add_tail(&info->list, &shmem_inodes);
 		spin_unlock (&shmem_ilock);
-		kaddr = kmap(page);
-		memcpy(kaddr, symname, len);
+		memcpy(kmap(page), symname, len);
 		kunmap(page);
 		SetPageDirty(page);
 		UnlockPage(page);
@@ -1556,40 +1880,52 @@ static int shmem_symlink(struct inode * 
 	return 0;
 }
 
-static int shmem_readlink_inline(struct dentry *dentry, char *buffer, int buflen)
+static int
+shmem_readlink_inline(struct dentry *dentry, char *buffer, int buflen)
 {
-	return vfs_readlink(dentry,buffer,buflen, (const char *)SHMEM_I(dentry->d_inode));
+	return vfs_readlink(dentry,buffer, buflen,
+			    (const char *)SHMEM_I(dentry->d_inode));
 }
 
-static int shmem_follow_link_inline(struct dentry *dentry, struct nameidata *nd)
+static int
+shmem_follow_link_inline(struct dentry *dentry, struct nameidata *nd)
 {
 	return vfs_follow_link(nd, (const char *)SHMEM_I(dentry->d_inode));
 }
 
-static int shmem_readlink(struct dentry *dentry, char *buffer, int buflen)
+static int
+shmem_readlink(struct dentry *dentry, char *buffer, int buflen)
 {
-	struct page * page;
-	int res = shmem_getpage(dentry->d_inode, 0, &page);
+	int res;
+	struct page *page;
+
+	page = shmem_getpage_unlocked(dentry->d_inode, 0);
 
-	if (res)
-		return res;
+	if (IS_ERR(page))
+		return PTR_ERR(page);
 
 	res = vfs_readlink(dentry,buffer,buflen, kmap(page));
 	kunmap(page);
 	page_cache_release(page);
+	
 	return res;
 }
 
-static int shmem_follow_link(struct dentry *dentry, struct nameidata *nd)
+static int
+shmem_follow_link(struct dentry *dentry, struct nameidata *nd)
 {
 	struct page * page;
-	int res = shmem_getpage(dentry->d_inode, 0, &page);
-	if (res)
-		return res;
+	int res;
+
+	page = shmem_getpage_unlocked(dentry->d_inode, 0);
+
+	if (IS_ERR(page))
+		return PTR_ERR(page);
 
 	res = vfs_follow_link(nd, kmap(page));
 	kunmap(page);
 	page_cache_release(page);
+
 	return res;
 }
 
@@ -1610,7 +1946,10 @@ static struct inode_operations shmem_sym
 #endif
 };
 
-static int shmem_parse_options(char *options, int *mode, uid_t *uid, gid_t *gid, unsigned long * blocks, unsigned long *inodes)
+static int
+shmem_parse_options(char *options, int *mode, uid_t *uid, gid_t *gid, 
+		    unsigned long *blocks, unsigned long *inodes, 
+		    unsigned long *opts)
 {
 	char *this_char, *value, *rest;
 
@@ -1620,11 +1959,6 @@ static int shmem_parse_options(char *opt
 	for ( ; this_char; this_char = strtok(NULL,",")) {
 		if ((value = strchr(this_char,'=')) != NULL) {
 			*value++ = 0;
-		} else {
-			printk(KERN_ERR 
-			    "tmpfs: No value for mount option '%s'\n", 
-			    this_char);
-			return 1;
 		}
 
 		if (!strcmp(this_char,"size")) {
@@ -1659,6 +1993,17 @@ static int shmem_parse_options(char *opt
 			*gid = simple_strtoul(value,&rest,0);
 			if (*rest)
 				goto bad_val;
+		} else if (!strcmp(this_char, "iopen")) {
+			*opts |= SHMEM_MOUNT_IOPEN;
+			*opts &= ~SHMEM_MOUNT_IOPEN_NOPRIV;
+		}
+		else if (!strcmp(this_char, "noiopen")) {
+			*opts &= ~SHMEM_MOUNT_IOPEN;
+			*opts &= ~SHMEM_MOUNT_IOPEN_NOPRIV;
+		}
+		else if (!strcmp (this_char, "iopen_nopriv")) {
+			*opts |= SHMEM_MOUNT_IOPEN;
+			*opts |= SHMEM_MOUNT_IOPEN_NOPRIV;
 		} else {
 			printk(KERN_ERR "tmpfs: Bad mount option %s\n",
 			       this_char);
@@ -1674,14 +2019,19 @@ bad_val:
 
 }
 
-static int shmem_remount_fs (struct super_block *sb, int *flags, char *data)
+static int
+shmem_remount_fs(struct super_block *sb, int *flags, char *data)
 {
 	struct shmem_sb_info *sbinfo = &sb->u.shmem_sb;
 	unsigned long max_blocks = sbinfo->max_blocks;
 	unsigned long max_inodes = sbinfo->max_inodes;
 
-	if (shmem_parse_options (data, NULL, NULL, NULL, &max_blocks, &max_inodes))
+	if (shmem_parse_options (data, NULL, NULL, NULL, &max_blocks, 
+				 &max_inodes, &sbinfo->options))
+	{
 		return -EINVAL;
+	}
+		
 	return shmem_set_size(sbinfo, max_blocks, max_inodes);
 }
 
@@ -1691,7 +2041,8 @@ int shmem_sync_file(struct file * file, 
 }
 #endif
 
-static struct super_block *shmem_read_super(struct super_block * sb, void * data, int silent)
+static struct super_block *
+shmem_read_super(struct super_block * sb, void * data, int silent)
 {
 	struct inode * inode;
 	struct dentry * root;
@@ -1710,11 +2061,15 @@ static struct super_block *shmem_read_su
 	blocks = inodes = si.totalram / 2;
 
 #ifdef CONFIG_TMPFS
-	if (shmem_parse_options (data, &mode, &uid, &gid, &blocks, &inodes))
+	if (shmem_parse_options (data, &mode, &uid, &gid, &blocks, 
+				 &inodes, &sbinfo->options))
+	{
 		return NULL;
+	}
 #endif
 
 	spin_lock_init (&sbinfo->stat_lock);
+	sbinfo->iopen = NULL;
 	sbinfo->max_blocks = blocks;
 	sbinfo->free_blocks = blocks;
 	sbinfo->max_inodes = inodes;
@@ -1724,7 +2079,7 @@ static struct super_block *shmem_read_su
 	sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
 	sb->s_magic = TMPFS_MAGIC;
 	sb->s_op = &shmem_ops;
-	inode = shmem_get_inode(sb, S_IFDIR | mode, 0);
+	inode = shmem_get_inode(sb, S_IFDIR | mode, 0, 1);
 	if (!inode)
 		return NULL;
 
@@ -1739,7 +2094,19 @@ static struct super_block *shmem_read_su
 	return sb;
 }
 
+void shmem_put_super(struct super_block *sb)
+{
+	struct dentry *iopen;
+	struct shmem_sb_info *sbinfo = SHMEM_SB(sb);
 
+	spin_lock(&sbinfo->stat_lock);
+	iopen = sbinfo->iopen;
+	sbinfo->iopen = NULL;
+	spin_unlock(&sbinfo->stat_lock);
+
+	if (iopen)
+		dput(iopen);
+}
 
 static struct address_space_operations shmem_aops = {
 	writepage:	shmem_writepage,
@@ -1790,11 +2157,13 @@ static struct super_operations shmem_ops
 	remount_fs:	shmem_remount_fs,
 #endif
 	delete_inode:	shmem_delete_inode,
-	put_inode:	force_delete,	
+	read_inode:	shmem_read_inode,
+	put_inode:	force_delete,
+	put_super:	shmem_put_super,
 };
 
 static struct vm_operations_struct shmem_vm_ops = {
-	nopage:	shmem_nopage,
+	nopage:		shmem_nopage,
 };
 
 #ifdef CONFIG_TMPFS
@@ -1885,7 +2254,7 @@ struct file *shmem_file_setup(char * nam
 		goto put_dentry;
 
 	error = -ENOSPC;
-	inode = shmem_get_inode(root->d_sb, S_IFREG | S_IRWXUGO, 0);
+	inode = shmem_get_inode(root->d_sb, S_IFREG | S_IRWXUGO, 0, 0);
 	if (!inode) 
 		goto close_file;
 
@@ -1921,15 +2290,17 @@ int shmem_zero_setup(struct vm_area_stru
 
 	if (vma->vm_file)
 		fput (vma->vm_file);
+	
 	vma->vm_file = file;
 	vma->vm_ops = &shmem_vm_ops;
 	return 0;
 }
 
 EXPORT_SYMBOL(shmem_file_setup);
-EXPORT_SYMBOL(shmem_getpage);
 EXPORT_SYMBOL(shmem_xattr_find);
 EXPORT_SYMBOL(shmem_xattr_set);
 EXPORT_SYMBOL(shmem_xattr_get);
 EXPORT_SYMBOL(shmem_xattr_delete);
 EXPORT_SYMBOL(shmem_xattr_remove);
+EXPORT_SYMBOL(shmem_getpage_locked);
+EXPORT_SYMBOL(shmem_getpage_unlocked);