*/
-const char *yaffs_fs_c_version = "$Id: yaffs_fs.c,v 1.21 2005-08-01 20:49:38 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;
//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"
#define yaffs_InodeToObject(iptr) ((yaffs_Object *)((iptr)->u.generic_ip))
#define yaffs_DentryToObject(dptr) yaffs_InodeToObject((dptr)->d_inode)
-//NCB #define yaffs_SuperToDevice(sb) ((yaffs_Device *)sb->u.generic_sbp)
-//#if defined(CONFIG_KERNEL_2_5)
#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
#define yaffs_SuperToDevice(sb) ((yaffs_Device *)sb->s_fs_info)
#else
static void yaffs_put_super(struct super_block *sb);
-#if 0
-static ssize_t yaffs_file_read(struct file *f, char *buf, size_t n, loff_t *pos);
-#endif
-
static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n, loff_t *pos);
static int yaffs_file_flush(struct file* file);
static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir);
-//#if defined(CONFIG_KERNEL_2_5) /* Added NCB 185-8-2003 */
#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
static int yaffs_create(struct inode *dir, struct dentry *dentry, int mode, struct nameidata *n);
static struct dentry * yaffs_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *n);
static int yaffs_symlink(struct inode * dir, struct dentry *dentry, const char * symname);
static int yaffs_mkdir(struct inode * dir, struct dentry * dentry, int mode);
-//#if defined(CONFIG_KERNEL_2_5)
#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t dev);
#else
static int yaffs_rename(struct inode * old_dir, struct dentry *old_dentry, struct inode * new_dir,struct dentry *new_dentry);
static int yaffs_setattr(struct dentry *dentry, struct iattr *attr);
-//#if defined(CONFIG_KERNEL_2_5) /* Added NCB 185-8-2003 */
#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
static int yaffs_statfs(struct super_block *sb, struct kstatfs *buf);
#else
/*
* Lookup is used to find objects in the fs
*/
-//#if defined(CONFIG_KERNEL_2_5) /* Added NCB 185-8-2003 */
#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
static struct dentry * yaffs_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *n)
#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;
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 */
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);
inode->i_uid = obj->yst_uid;
inode->i_gid = obj->yst_gid;
inode->i_blksize = inode->i_sb->s_blocksize;
-//#if defined(CONFIG_KERNEL_2_5)
#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
inode->i_rdev = old_decode_dev(obj->yst_rdev);
/*
* File creation. Allocate an inode, and we're done..
*/
-//#if defined(CONFIG_KERNEL_2_5)
#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t rdev)
#else
return retVal;
}
-//#if defined(CONFIG_KERNEL_2_5) /* Added NCB 185-8-2003 */
#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
static int yaffs_create(struct inode *dir, struct dentry *dentry, int mode, struct nameidata *n)
#else
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);
return error;
}
-//#if defined(CONFIG_KERNEL_2_5) /* Added NCB 185-8-2003 */
#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
static int yaffs_statfs(struct super_block *sb, struct kstatfs *buf)
#else
#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;
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 ||
-#ifndef CONFIG_YAFFS_USE_OLD_MTD
- !mtd->write_ecc ||
- !mtd->read_ecc ||
-#endif
- !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 ||
-#ifndef CONFIG_YAFFS_USE_OLD_MTD
- !mtd->write_ecc ||
- !mtd->read_ecc ||
-#endif
- !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 defined(CONFIG_KERNEL_2_5)
#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);
#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)
return get_sb_bdev(fs, flags, dev_name, data, yaffs_internal_read_super_mtd);
}
-/* changes NCB 2.5.70 */
-//static DECLARE_FSTYPE(yaffs_fs_type, "yaffs", yaffs_read_super, FS_REQUIRES_DEV);
static struct file_system_type yaffs_fs_type = {
.owner = THIS_MODULE,
.name = "yaffs",
.get_sb = yaffs_read_super,
.kill_sb = kill_block_super,
-// .kill_sb = kill_litter_super,
.fs_flags = FS_REQUIRES_DEV,
};
#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);
#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)
return get_sb_bdev(fs, flags, dev_name, data, yaffs2_internal_read_super_mtd);
}
-/* changes NCB 2.5.70 */
-//static DECLARE_FSTYPE(yaffs_fs_type, "yaffs", yaffs_read_super, FS_REQUIRES_DEV);
static struct file_system_type yaffs2_fs_type = {
.owner = THIS_MODULE,
.name = "yaffs2",
.get_sb = yaffs2_read_super,
.kill_sb = kill_block_super,
-// .kill_sb = kill_litter_super,
.fs_flags = FS_REQUIRES_DEV,
};
#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);
#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;
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
{
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
projects / yaffs2.git / blobdiff