X-Git-Url: http://www.aleph1.co.uk/gitweb/?p=yaffs2.git;a=blobdiff_plain;f=yaffs_fs.c;h=e4ea466b54365b4512502743c4437d36d2c098b5;hp=3f8cf2a9f14be85a1912c7a948f1be580b76ea27;hb=9625e7b16224f286bb177324f2c1283b9db08286;hpb=e528916d3c9c87aa1547b1cc2536389ef5efbcb3

diff --git a/yaffs_fs.c b/yaffs_fs.c
index 3f8cf2a..e4ea466 100644
--- a/yaffs_fs.c
+++ b/yaffs_fs.c
@@ -30,7 +30,7 @@
  */
 
 
-const char *yaffs_fs_c_version = "$Id: yaffs_fs.c,v 1.23 2005-08-01 20:52:35 luc Exp $";
+const char *yaffs_fs_c_version = "$Id: yaffs_fs.c,v 1.28 2005-08-09 03:52:23 charles Exp $";
 extern const char *yaffs_guts_c_version;
 
 
@@ -78,16 +78,6 @@ unsigned yaffs_traceMask = YAFFS_TRACE_ALWAYS | YAFFS_TRACE_BAD_BLOCKS;
 //unsigned yaffs_traceMask = 0xFFFFFFFF;
 
 
-#ifdef CONFIG_YAFFS_RAM_ENABLED
-#include "yaffs_nandemul.h" 
-// 2 MB of RAM for emulation
-#define YAFFS_RAM_EMULATION_SIZE  0x200000
-#endif //CONFIG_YAFFS_RAM_ENABLED
-
-#if CONFIG_YAFFS2_RAM_ENABLED
-#include "yaffs_nandemul2k.h"
-#endif
-
 #ifdef CONFIG_YAFFS_YAFFS1
 #include <linux/mtd/mtd.h>
 #include "yaffs_mtdif.h"
@@ -498,6 +488,7 @@ static int yaffs_writepage(struct page *page)
 #endif
 {
 	struct address_space *mapping = page->mapping;
+	loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
 	struct inode *inode;
 	unsigned long end_index;
 	char *buffer;
@@ -511,6 +502,14 @@ static int yaffs_writepage(struct page *page)
 	if (!inode)
 		BUG();
 
+	if (offset > inode->i_size)
+	{
+		T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_writepage at %08x, inode size = %08x!!!\n", (unsigned)(page->index << PAGE_CACHE_SHIFT), (unsigned) inode->i_size));
+		T(YAFFS_TRACE_OS,(KERN_DEBUG"                -> don't care!!\n"));
+		unlock_page(page);
+		return 0;
+	}
+
 	end_index = inode->i_size >> PAGE_CACHE_SHIFT;
 
 	/* easy case */
@@ -535,9 +534,13 @@ static int yaffs_writepage(struct page *page)
 	obj = yaffs_InodeToObject(inode);
 	yaffs_GrossLock(obj->myDev);
 
+	T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_writepage at %08x, size %08x\n", (unsigned)(page->index << PAGE_CACHE_SHIFT), nBytes));
+	T(YAFFS_TRACE_OS,(KERN_DEBUG"writepag0: obj = %05x, ino = %05x\n", (int) obj->variant.fileVariant.fileSize, (int) inode->i_size));
 
 	nWritten = yaffs_WriteDataToFile(obj,buffer,page->index << PAGE_CACHE_SHIFT,nBytes,0);
 
+	T(YAFFS_TRACE_OS,(KERN_DEBUG"writepag1: obj = %05x, ino = %05x\n", (int) obj->variant.fileVariant.fileSize, (int) inode->i_size));
+
 	yaffs_GrossUnlock(obj->myDev);
 	
 	kunmap(page);
@@ -1092,10 +1095,8 @@ static int yaffs_rename(struct inode * old_dir, struct dentry *old_dentry, struc
 	else
 	{
 	   
-		// Unlink the target if it exists
-		removed = yaffs_Unlink(yaffs_InodeToObject(new_dir),new_dentry->d_name.name);
-
-	
+	        // Now does unlinking internally using shadowing mechanism
+	        
 		retVal =  yaffs_RenameObject(yaffs_InodeToObject(old_dir),old_dentry->d_name.name,
 									yaffs_InodeToObject(new_dir),new_dentry->d_name.name);
 									
@@ -1244,13 +1245,14 @@ static void  yaffs_MTDPutSuper(struct super_block *sb)
 #endif
 
 
-static struct super_block *yaffs_internal_read_super(int yaffsVersion,int useRam, struct super_block * sb, void * data, int silent)
+static struct super_block *yaffs_internal_read_super(int yaffsVersion, struct super_block * sb, void * data, int silent)
 {
 	int nBlocks;
 	struct inode * inode = NULL;
 	struct dentry * root;
 	yaffs_Device *dev = 0;
 	char devname_buf[BDEVNAME_SIZE+1];
+	struct mtd_info *mtd;
 	int err;
 	
 	sb->s_magic = YAFFS_MAGIC;
@@ -1270,222 +1272,157 @@ static struct super_block *yaffs_internal_read_super(int yaffsVersion,int useRam
 	sb->s_blocksize = PAGE_CACHE_SIZE;
 	sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
 	T(YAFFS_TRACE_OS,("yaffs_read_super: Using yaffs%d\n",yaffsVersion));
-	T(YAFFS_TRACE_OS,("yaffs_read_super: %s block size %d\n", useRam ? "RAM" : "MTD",(int)(sb->s_blocksize)));
+	T(YAFFS_TRACE_OS,("yaffs_read_super: block size %d\n", (int)(sb->s_blocksize)));
 
 #ifdef CONFIG_YAFFS_DISABLE_WRITE_VERIFY
 	T(YAFFS_TRACE_OS,("yaffs: Write verification disabled. All guarantees null and void\n"));
 #endif
 
 
+	T(YAFFS_TRACE_ALWAYS,("yaffs: Attempting MTD mount on %u.%u, \"%s\"\n",
+	 MAJOR(sb->s_dev),MINOR(sb->s_dev), yaffs_devname(sb, devname_buf)));
+		
+	// Check it's an mtd device.....
+	if(MAJOR(sb->s_dev) != MTD_BLOCK_MAJOR)
+	{
+		return NULL; // This isn't an mtd device
+	} 
 	
-	if(useRam)
+	// Get the device
+	mtd = get_mtd_device(NULL, MINOR(sb->s_dev));
+	if (!mtd) 
 	{
+		T(YAFFS_TRACE_ALWAYS,("yaffs: MTD device #%u doesn't appear to exist\n", MINOR(sb->s_dev)));
+		return NULL;
+	}
+	
+	// Check it's NAND
+	if(mtd->type != MTD_NANDFLASH)
+	{
+		T(YAFFS_TRACE_ALWAYS,("yaffs: MTD device is not NAND it's type %d\n", mtd->type));
+		return NULL;
+	}
 
-#ifdef CONFIG_YAFFS_RAM_ENABLED
-		// Set the yaffs_Device up for ram emulation
-
-		
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
-		sb->s_fs_info =	dev = kmalloc(sizeof(yaffs_Device),GFP_KERNEL);
-#else
-		sb->u.generic_sbp = dev = kmalloc(sizeof(yaffs_Device),GFP_KERNEL);
-#endif
-
-		if(!dev)
+	T(YAFFS_TRACE_OS,(" erase %p\n",mtd->erase));
+	T(YAFFS_TRACE_OS,(" read %p\n",mtd->read));
+	T(YAFFS_TRACE_OS,(" write %p\n",mtd->write));
+	T(YAFFS_TRACE_OS,(" readoob %p\n",mtd->read_oob));
+	T(YAFFS_TRACE_OS,(" writeoob %p\n",mtd->write_oob));
+	T(YAFFS_TRACE_OS,(" block_isbad %p\n",mtd->block_isbad));
+	T(YAFFS_TRACE_OS,(" block_markbad %p\n",mtd->block_markbad));
+	T(YAFFS_TRACE_OS,(" oobblock %d\n",mtd->oobblock));
+	T(YAFFS_TRACE_OS,(" oobsize %d\n",mtd->oobsize));
+	T(YAFFS_TRACE_OS,(" erasesize %d\n",mtd->erasesize));
+	T(YAFFS_TRACE_OS,(" size %d\n",mtd->size));
+
+	if(yaffsVersion == 2)
+	{
+		// Check for version 2 style functions
+		if(!mtd->erase ||
+		   !mtd->block_isbad ||
+		   !mtd->block_markbad ||
+		   !mtd->read  ||
+		   !mtd->write ||
+		   !mtd->write_ecc ||
+		   !mtd->read_ecc ||
+		   !mtd->read_oob ||
+		   !mtd->write_oob )
 		{
-			// Deep shit could not allocate device structure
-			T(YAFFS_TRACE_OS,("yaffs_read_super: Failed trying to allocate yaffs_Device.\n"));
+			T(YAFFS_TRACE_ALWAYS,("yaffs: MTD device does not support required functions\n"));;
 			return NULL;
 		}
-
-		memset(dev,0,sizeof(yaffs_Device));
-		dev->genericDevice = NULL; // Not used for RAM emulation.
-		dev->name = sb->s_type->name;
-
-		nBlocks = YAFFS_RAM_EMULATION_SIZE / (YAFFS_CHUNKS_PER_BLOCK * YAFFS_BYTES_PER_CHUNK);
-		dev->startBlock = 0;  
-		dev->endBlock = nBlocks - 1;
-		dev->nChunksPerBlock = YAFFS_CHUNKS_PER_BLOCK;
-		dev->nBytesPerChunk = YAFFS_BYTES_PER_CHUNK;
-		dev->nReservedBlocks = 5;
-		
-		if(yaffsVersion == 2)
-		{
-			dev->writeChunkWithTagsToNAND  = nandemul2k_WriteChunkWithTagsToNAND;
-			dev->readChunkWithTagsFromNAND = nandemul2k_ReadChunkWithTagsFromNAND;
-			dev->markNANDBlockBad          = nandemul2k_MarkNANDBlockBad;
-			dev->queryNANDBlock            = nandemul2k_QueryNANDBlock;
-			dev->eraseBlockInNAND          = nandemul2k_EraseBlockInNAND;
-			dev->initialiseNAND            = nandemul2k_InitialiseNAND;
-			dev->isYaffs2 = 1;
-			dev->nChunksPerBlock = nandemul2k_GetChunksPerBlock();
-			dev->nBytesPerChunk =  nandemul2k_GetBytesPerChunk();;
-			nBlocks = nandemul2k_GetNumberOfBlocks();
-			dev->startBlock = 0;
-			dev->endBlock = nBlocks - 1;
-		}
-		else
+	
+		if(mtd->oobblock < YAFFS_MIN_YAFFS2_CHUNK_SIZE ||
+		   mtd->oobsize < YAFFS_MIN_YAFFS2_SPARE_SIZE)
 		{
-			dev->writeChunkToNAND = nandemul_WriteChunkToNAND;
-			dev->readChunkFromNAND = nandemul_ReadChunkFromNAND;
-			dev->eraseBlockInNAND = nandemul_EraseBlockInNAND;
-			dev->initialiseNAND = nandemul_InitialiseNAND;
-			dev->isYaffs2 = 0;
-		}
-#endif
-
-	}
+			T(YAFFS_TRACE_ALWAYS,("yaffs: MTD device does not support have the right page sizes\n"));
+			return NULL;
+		}		}
 	else
-	{	
-#if defined(CONFIG_YAFFS_YAFFS1) || defined(CONFIG_YAFFS_YAFFS2)
-		struct mtd_info *mtd;
-		
-		T(YAFFS_TRACE_ALWAYS,("yaffs: Attempting MTD mount on %u.%u, \"%s\"\n",
-		 MAJOR(sb->s_dev),MINOR(sb->s_dev), yaffs_devname(sb, devname_buf)));
-			
-		// Check it's an mtd device.....
-		if(MAJOR(sb->s_dev) != MTD_BLOCK_MAJOR)
-		{
-			return NULL; // This isn't an mtd device
-		} 
-		
-		// Get the device
-		mtd = get_mtd_device(NULL, MINOR(sb->s_dev));
-		if (!mtd) 
+	{
+		// Check for V1 style functions
+		if(!mtd->erase ||
+		   !mtd->read  ||
+		   !mtd->write ||
+		   !mtd->write_ecc ||
+		   !mtd->read_ecc ||
+		   !mtd->read_oob ||
+		   !mtd->write_oob )
 		{
-			T(YAFFS_TRACE_ALWAYS,("yaffs: MTD device #%u doesn't appear to exist\n", MINOR(sb->s_dev)));
+			T(YAFFS_TRACE_ALWAYS,("yaffs: MTD device does not support required functions\n"));;
 			return NULL;
 		}
-		
-		// Check it's NAND
-		if(mtd->type != MTD_NANDFLASH)
+	
+		if(mtd->oobblock != YAFFS_BYTES_PER_CHUNK ||
+		   mtd->oobsize != YAFFS_BYTES_PER_SPARE)
 		{
-			T(YAFFS_TRACE_ALWAYS,("yaffs: MTD device is not NAND it's type %d\n", mtd->type));
+			T(YAFFS_TRACE_ALWAYS,("yaffs: MTD device does not support have the right page sizes\n"));
 			return NULL;
 		}
+	}
+	   
 
-		T(YAFFS_TRACE_OS,(" erase %p\n",mtd->erase));
-		T(YAFFS_TRACE_OS,(" read %p\n",mtd->read));
-		T(YAFFS_TRACE_OS,(" write %p\n",mtd->write));
-		T(YAFFS_TRACE_OS,(" readoob %p\n",mtd->read_oob));
-		T(YAFFS_TRACE_OS,(" writeoob %p\n",mtd->write_oob));
-		T(YAFFS_TRACE_OS,(" block_isbad %p\n",mtd->block_isbad));
-		T(YAFFS_TRACE_OS,(" block_markbad %p\n",mtd->block_markbad));
-		T(YAFFS_TRACE_OS,(" oobblock %d\n",mtd->oobblock));
-		T(YAFFS_TRACE_OS,(" oobsize %d\n",mtd->oobsize));
-		T(YAFFS_TRACE_OS,(" erasesize %d\n",mtd->erasesize));
-		T(YAFFS_TRACE_OS,(" size %d\n",mtd->size));
-
-		if(yaffsVersion == 2)
-		{
-			// Check for version 2 style functions
-			if(!mtd->erase ||
-			   !mtd->block_isbad ||
-			   !mtd->block_markbad ||
-			   !mtd->read  ||
-			   !mtd->write ||
-			   !mtd->write_ecc ||
-			   !mtd->read_ecc ||
-			   !mtd->read_oob ||
-			   !mtd->write_oob )
-			{
-				T(YAFFS_TRACE_ALWAYS,("yaffs: MTD device does not support required functions\n"));;
-				return NULL;
-			}
-		
-			if(mtd->oobblock < YAFFS_MIN_YAFFS2_CHUNK_SIZE ||
-			   mtd->oobsize < YAFFS_MIN_YAFFS2_SPARE_SIZE)
-			{
-				T(YAFFS_TRACE_ALWAYS,("yaffs: MTD device does not support have the right page sizes\n"));
-				return NULL;
-			}		}
-		else
-		{
-			// Check for V1 style functions
-			if(!mtd->erase ||
-			   !mtd->read  ||
-			   !mtd->write ||
-			   !mtd->write_ecc ||
-			   !mtd->read_ecc ||
-			   !mtd->read_oob ||
-			   !mtd->write_oob )
-			{
-				T(YAFFS_TRACE_ALWAYS,("yaffs: MTD device does not support required functions\n"));;
-				return NULL;
-			}
-		
-			if(mtd->oobblock != YAFFS_BYTES_PER_CHUNK ||
-			   mtd->oobsize != YAFFS_BYTES_PER_SPARE)
-			{
-				T(YAFFS_TRACE_ALWAYS,("yaffs: MTD device does not support have the right page sizes\n"));
-				return NULL;
-			}
-		}
-		   
-
-			// OK, so if we got here, we have an MTD that's NAND and looks 
-			// like it has the right capabilities
-			// Set the yaffs_Device up for mtd
+		// OK, so if we got here, we have an MTD that's NAND and looks 
+		// like it has the right capabilities
+		// Set the yaffs_Device up for mtd
 
 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
-		sb->s_fs_info =	dev = kmalloc(sizeof(yaffs_Device),GFP_KERNEL);
+	sb->s_fs_info =	dev = kmalloc(sizeof(yaffs_Device),GFP_KERNEL);
 #else
-		sb->u.generic_sbp = dev = kmalloc(sizeof(yaffs_Device),GFP_KERNEL);
+	sb->u.generic_sbp = dev = kmalloc(sizeof(yaffs_Device),GFP_KERNEL);
 #endif
-		if(!dev)
-		{
-			// Deep shit could not allocate device structure
-			T(YAFFS_TRACE_ALWAYS,("yaffs_read_super: Failed trying to allocate yaffs_Device. \n"));
-			return NULL;
-		}
+	if(!dev)
+	{
+		// Deep shit could not allocate device structure
+		T(YAFFS_TRACE_ALWAYS,("yaffs_read_super: Failed trying to allocate yaffs_Device. \n"));
+		return NULL;
+	}
 
-		memset(dev,0,sizeof(yaffs_Device));
-		dev->genericDevice = mtd; 
-		dev->name = mtd->name;
+	memset(dev,0,sizeof(yaffs_Device));
+	dev->genericDevice = mtd; 
+	dev->name = mtd->name;
 
-		// Set up the memory size parameters....
-		
-		nBlocks = mtd->size / (YAFFS_CHUNKS_PER_BLOCK * YAFFS_BYTES_PER_CHUNK);
+	// Set up the memory size parameters....
+	
+	nBlocks = mtd->size / (YAFFS_CHUNKS_PER_BLOCK * YAFFS_BYTES_PER_CHUNK);
+	dev->startBlock = 0;
+	dev->endBlock = nBlocks - 1;
+	dev->nChunksPerBlock = YAFFS_CHUNKS_PER_BLOCK;
+	dev->nBytesPerChunk = YAFFS_BYTES_PER_CHUNK;
+	dev->nReservedBlocks = 5;
+	dev->nShortOpCaches = 10; // Enable short op caching
+	
+
+	// ... and the functions.
+	if(yaffsVersion == 2)
+	{
+		dev->writeChunkWithTagsToNAND = nandmtd2_WriteChunkWithTagsToNAND;
+		dev->readChunkWithTagsFromNAND = nandmtd2_ReadChunkWithTagsFromNAND;
+		dev->markNANDBlockBad = nandmtd2_MarkNANDBlockBad;
+		dev->queryNANDBlock = nandmtd2_QueryNANDBlock;
+		dev->spareBuffer = YMALLOC(mtd->oobsize);
+		dev->isYaffs2 = 1;
+		dev->nBytesPerChunk = mtd->oobblock;
+		dev->nChunksPerBlock = mtd->erasesize / mtd->oobblock;
+		nBlocks = mtd->size / mtd->erasesize;
 		dev->startBlock = 0;
 		dev->endBlock = nBlocks - 1;
-		dev->nChunksPerBlock = YAFFS_CHUNKS_PER_BLOCK;
-		dev->nBytesPerChunk = YAFFS_BYTES_PER_CHUNK;
-		dev->nReservedBlocks = 5;
-		dev->nShortOpCaches = 10; // Enable short op caching
-		
-
-		// ... and the functions.
-		if(yaffsVersion == 2)
-		{
-			dev->writeChunkWithTagsToNAND = nandmtd2_WriteChunkWithTagsToNAND;
-			dev->readChunkWithTagsFromNAND = nandmtd2_ReadChunkWithTagsFromNAND;
-			dev->markNANDBlockBad = nandmtd2_MarkNANDBlockBad;
-			dev->queryNANDBlock = nandmtd2_QueryNANDBlock;
-			dev->spareBuffer = YMALLOC(mtd->oobsize);
-			dev->isYaffs2 = 1;
-			dev->nBytesPerChunk = mtd->oobblock;
-			dev->nChunksPerBlock = mtd->erasesize / mtd->oobblock;
-			nBlocks = mtd->size / mtd->erasesize;
-			dev->startBlock = 0;
-			dev->endBlock = nBlocks - 1;
-		}
-		else
-		{
-			dev->writeChunkToNAND = nandmtd_WriteChunkToNAND;
-			dev->readChunkFromNAND = nandmtd_ReadChunkFromNAND;
-			dev->isYaffs2 = 0;
-		}
-		// ... and common functions
-		dev->eraseBlockInNAND = nandmtd_EraseBlockInNAND;
-		dev->initialiseNAND = nandmtd_InitialiseNAND;
-		
-		dev->putSuperFunc = yaffs_MTDPutSuper;
-		
-#ifdef CONFIG_YAFFS_USE_NANDECC
-		dev->useNANDECC = 1;
-#endif
-#endif
 	}
+	else
+	{
+		dev->writeChunkToNAND = nandmtd_WriteChunkToNAND;
+		dev->readChunkFromNAND = nandmtd_ReadChunkFromNAND;
+		dev->isYaffs2 = 0;
+	}
+	// ... and common functions
+	dev->eraseBlockInNAND = nandmtd_EraseBlockInNAND;
+	dev->initialiseNAND = nandmtd_InitialiseNAND;
+	
+	dev->putSuperFunc = yaffs_MTDPutSuper;
+	
+#ifndef CONFIG_YAFFS_DOES_ECC
+	dev->useNANDECC = 1;
+#endif
 
 	/* we assume this is protected by lock_kernel() in mount/umount */
 	list_add_tail(&dev->devList, &yaffs_dev_list);
@@ -1536,7 +1473,7 @@ static struct super_block *yaffs_internal_read_super(int yaffsVersion,int useRam
 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
 static int yaffs_internal_read_super_mtd(struct super_block * sb, void * data, int silent)
 {
-	 return yaffs_internal_read_super(1,0,sb,data,silent) ? 0 : -1;
+	 return yaffs_internal_read_super(1,sb,data,silent) ? 0 : -1;
 }
 
 static struct super_block *yaffs_read_super(struct file_system_type * fs, int flags, const char *dev_name, void *data)
@@ -1555,7 +1492,7 @@ static struct file_system_type yaffs_fs_type = {
 #else
 static struct super_block *yaffs_read_super(struct super_block * sb, void * data, int silent)
 {
-	return yaffs_internal_read_super(1,0,sb,data,silent);
+	return yaffs_internal_read_super(1,sb,data,silent);
 }
 
 static DECLARE_FSTYPE(yaffs_fs_type, "yaffs", yaffs_read_super, FS_REQUIRES_DEV);
@@ -1568,7 +1505,7 @@ static DECLARE_FSTYPE(yaffs_fs_type, "yaffs", yaffs_read_super, FS_REQUIRES_DEV)
 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
 static int yaffs2_internal_read_super_mtd(struct super_block * sb, void * data, int silent)
 {
-	 return yaffs_internal_read_super(2,0,sb,data,silent) ? 0 : -1;
+	 return yaffs_internal_read_super(2,sb,data,silent) ? 0 : -1;
 }
 
 static struct super_block *yaffs2_read_super(struct file_system_type * fs, int flags, const char *dev_name, void *data)
@@ -1587,7 +1524,7 @@ static struct file_system_type yaffs2_fs_type = {
 #else
 static struct super_block *yaffs2_read_super(struct super_block * sb, void * data, int silent)
 {
-	return yaffs_internal_read_super(2,0,sb,data,silent);
+	return yaffs_internal_read_super(2,sb,data,silent);
 }
 
 static DECLARE_FSTYPE(yaffs2_fs_type, "yaffs2", yaffs2_read_super, FS_REQUIRES_DEV);
@@ -1596,72 +1533,6 @@ static DECLARE_FSTYPE(yaffs2_fs_type, "yaffs2", yaffs2_read_super, FS_REQUIRES_D
 #endif // CONFIG_YAFFS_YAFFS2
 
 
-#ifdef CONFIG_YAFFS_RAM_ENABLED
-
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
-static int yaffs_internal_read_super_ram(struct super_block * sb, void * data, int silent)
-{
-	 return yaffs_internal_read_super(1,1,sb,data,silent) ? 0 : -1;
-}
-
-static struct super_block *yaffs_ram_read_super(struct file_system_type * fs, int flags, const char *dev_name, void *data)
-{
-
-    return get_sb_nodev(fs, flags, data, yaffs_internal_read_super_ram);
-}
-
-
-static struct file_system_type yaffs_ram_fs_type = {
-	.owner		= THIS_MODULE,
-	.name		= "yaffsram",
-	.get_sb		= yaffs_ram_read_super,
-	.kill_sb	= kill_litter_super,
-	.fs_flags	= 0 ,
-};
-#else
-static struct super_block *yaffs_ram_read_super(struct super_block * sb, void * data, int silent)
-{
-	return yaffs_internal_read_super(1,1,sb,data,silent);
-}
-
-static DECLARE_FSTYPE(yaffs_ram_fs_type, "yaffsram", yaffs_ram_read_super, FS_SINGLE);
-#endif
-
-#endif // CONFIG_YAFFS_RAM_ENABLED
-
-#ifdef CONFIG_YAFFS2_RAM_ENABLED
-
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
-static int yaffs2_internal_read_super_ram(struct super_block * sb, void * data, int silent)
-{
-	 return yaffs_internal_read_super(2,1,sb,data,silent) ? 0 : -1;
-}
-
-static struct super_block *yaffs2_ram_read_super(struct file_system_type * fs, int flags, const char *dev_name, void *data)
-{
-
-    return get_sb_nodev(fs, flags, data, yaffs2_internal_read_super_ram);
-}
-
-
-static struct file_system_type yaffs2_ram_fs_type = {
-	.owner		= THIS_MODULE,
-	.name		= "yaffs2ram",
-	.get_sb		= yaffs2_ram_read_super,
-	.kill_sb	= kill_litter_super,
-	.fs_flags	= 0 ,
-};
-#else
-static struct super_block *yaffs2_ram_read_super(struct super_block * sb, void * data, int silent)
-{
-	return yaffs_internal_read_super(2,1,sb,data,silent);
-}
-
-static DECLARE_FSTYPE(yaffs2_ram_fs_type, "yaffs2ram", yaffs2_ram_read_super, FS_SINGLE);
-#endif
-
-#endif // CONFIG_YAFFS2_RAM_ENABLED
-
 
 
 static struct proc_dir_entry *my_proc_entry;
@@ -1747,22 +1618,6 @@ static int  yaffs_proc_read(
 	return buf-page < count ? buf-page : count;
 }
 
-#ifdef CONFIG_YAFFS2_RAM_ENABLED
-static int  yaffs_proc_ram_write(
-        char *page,
-	char **start,
-	off_t offset,
-	int count,
-	int *eof,
-	void *data
-	)
-{
-
-	printk(KERN_DEBUG "yaffs write size %d\n",count);
-	return count;
-}
-#endif
-
 // Stuff to handle installation of file systems
 struct file_system_to_install
 {
@@ -1772,12 +1627,6 @@ struct file_system_to_install
 
 static struct file_system_to_install fs_to_install[] =
 {
-#ifdef CONFIG_YAFFS_RAM_ENABLED
-     { &yaffs_ram_fs_type, 0},
-#endif
-#ifdef CONFIG_YAFFS2_RAM_ENABLED
-     { &yaffs2_ram_fs_type,0},
-#endif
 #ifdef CONFIG_YAFFS_YAFFS1
      { &yaffs_fs_type,0},
 #endif