* the VFS.
*
* Special notes:
- * >> sb->u.generic_sbp points to the yaffs_Device associated with this superblock
+ * >> 2.4: sb->u.generic_sbp points to the yaffs_Device associated with this superblock
+ * >> 2.6: sb->s_fs_info points to the yaffs_Device associated with this superblock
* >> inode->u.generic_ip points to the associated yaffs_Object.
*
*
*/
-const char *yaffs_fs_c_version = "$Id: yaffs_fs.c,v 1.1 2004-12-17 04:39:04 charles Exp $";
+const char *yaffs_fs_c_version = "$Id: yaffs_fs.c,v 1.8 2005-07-18 23:16:04 charles Exp $";
extern const char *yaffs_guts_c_version;
+
#include <linux/config.h>
#include <linux/kernel.h>
#include <linux/module.h>
#endif
-
#include <asm/uaccess.h>
#include "yportenv.h"
-//unsigned yaffs_traceMask = YAFFS_TRACE_ALWAYS | YAFFS_TRACE_BAD_BLOCKS;
-unsigned yaffs_traceMask = 0xFFFFFFFF;
+unsigned yaffs_traceMask = YAFFS_TRACE_ALWAYS | YAFFS_TRACE_BAD_BLOCKS;
+//unsigned yaffs_traceMask = 0xFFFFFFFF;
#ifdef CONFIG_YAFFS_RAM_ENABLED
{
T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_lookup found %d\n",obj->objectId));
- inode = yaffs_get_inode(dir->i_sb, obj->st_mode,0,obj);
+ inode = yaffs_get_inode(dir->i_sb, obj->yst_mode,0,obj);
if(inode)
{
yaffs_GrossLock(obj->myDev);
- nWritten = yaffs_WriteDataToFile(obj,buffer,page->index << PAGE_CACHE_SHIFT,nBytes);
+ nWritten = yaffs_WriteDataToFile(obj,buffer,page->index << PAGE_CACHE_SHIFT,nBytes,0);
yaffs_GrossUnlock(obj->myDev);
if (inode && obj)
{
inode->i_ino = obj->objectId;
- inode->i_mode = obj->st_mode;
- inode->i_uid = obj->st_uid;
- inode->i_gid = obj->st_gid;
+ inode->i_mode = obj->yst_mode;
+ 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->st_rdev);
- inode->i_atime.tv_sec = (time_t)(obj->st_atime);
+ inode->i_rdev = old_decode_dev(obj->yst_rdev);
+ inode->i_atime.tv_sec = (time_t)(obj->yst_atime);
inode->i_atime.tv_nsec = 0;
- inode->i_mtime.tv_sec = (time_t)obj->st_mtime;
+ inode->i_mtime.tv_sec = (time_t)obj->yst_mtime;
inode->i_mtime.tv_nsec =0;
- inode->i_ctime.tv_sec = (time_t)obj->st_ctime;
+ inode->i_ctime.tv_sec = (time_t)obj->yst_ctime;
inode->i_ctime.tv_nsec = 0;
#else
- inode->i_rdev = obj->st_rdev;
- inode->i_atime = obj->st_atime;
- inode->i_mtime = obj->st_mtime;
- inode->i_ctime = obj->st_ctime;
+ inode->i_rdev = obj->yst_rdev;
+ inode->i_atime = obj->yst_atime;
+ inode->i_mtime = obj->yst_mtime;
+ inode->i_ctime = obj->yst_ctime;
#endif
inode->i_size = yaffs_GetObjectFileLength(obj);
inode->i_blocks = (inode->i_size + 511) >> 9;
T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_FillInode mode %x uid %d gid %d size %d count %d\n",
inode->i_mode, inode->i_uid, inode->i_gid, (int)inode->i_size, atomic_read(&inode->i_count)));
- switch (obj->st_mode & S_IFMT)
+ switch (obj->yst_mode & S_IFMT)
{
default: // fifo, device or socket
- init_special_inode(inode, obj->st_mode,(dev_t)(obj->st_rdev));
- break;
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
+ init_special_inode(inode, obj->yst_mode,old_decode_dev(obj->yst_rdev));
+#else
+ init_special_inode(inode, obj->yst_mode,(dev_t)(obj->yst_rdev));
+#endif break;
case S_IFREG: // file
inode->i_op = &yaffs_file_inode_operations;
inode->i_fop = &yaffs_file_operations;
T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_file_write about to write writing %d bytes to object %d at %d\n",n,obj->objectId,ipos));
}
- nWritten = yaffs_WriteDataToFile(obj,buf,ipos,n);
+ nWritten = yaffs_WriteDataToFile(obj,buf,ipos,n,0);
T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_file_write writing %d bytes, %d written at %d\n",n,nWritten,ipos));
if(nWritten > 0)
default:
// Special (socket, fifo, device...)
T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_mknod: making special\n"));
- obj = yaffs_MknodSpecial(parent,dentry->d_name.name,mode,current->uid, current->gid,rdev);
- break;
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
+ obj = yaffs_MknodSpecial(parent,dentry->d_name.name,mode,current->uid, current->gid,old_encode_dev(rdev));
+#else
+ obj = yaffs_MknodSpecial(parent,dentry->d_name.name,mode,current->uid, current->gid,rdev);
+#endif break;
case S_IFREG: // file
T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_mknod: making file\n"));
obj = yaffs_MknodFile(parent,dentry->d_name.name,mode,current->uid, current->gid);
struct inode* inode;
- inode = yaffs_get_inode(dir->i_sb, obj->st_mode, 0, obj);
+ inode = yaffs_get_inode(dir->i_sb, obj->yst_mode, 0, obj);
d_instantiate(dentry, inode);
T(YAFFS_TRACE_OS,(KERN_DEBUG"symlink created OK\n"));
return 0;
error = -EPERM;
}
yaffs_GrossUnlock(dev);
- inode_setattr(inode,attr);
+ error = inode_setattr(inode,attr);
}
return error;
}
static int yaffs_statfs(struct super_block *sb, struct statfs *buf)
#endif
{
+
+
yaffs_Device *dev = yaffs_SuperToDevice(sb);
T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_statfs\n"));
yaffs_GrossLock(dev);
+
buf->f_type = YAFFS_MAGIC;
buf->f_bsize = sb->s_blocksize;
buf->f_namelen = 255;
- buf->f_blocks = (dev->endBlock - dev->startBlock + 1) * YAFFS_CHUNKS_PER_BLOCK/
- (sb->s_blocksize/YAFFS_BYTES_PER_CHUNK);
+ if(sb->s_blocksize > dev->nBytesPerChunk)
+ {
+
+ buf->f_blocks = (dev->endBlock - dev->startBlock + 1) * dev->nChunksPerBlock/
+ (sb->s_blocksize/dev->nBytesPerChunk);
+ buf->f_bfree = yaffs_GetNumberOfFreeChunks(dev)/
+ (sb->s_blocksize/dev->nBytesPerChunk);
+ }
+ else
+ {
+
+ buf->f_blocks = (dev->endBlock - dev->startBlock + 1) * dev->nChunksPerBlock *
+ (dev->nBytesPerChunk/sb->s_blocksize);
+ buf->f_bfree = yaffs_GetNumberOfFreeChunks(dev) *
+ (dev->nBytesPerChunk/sb->s_blocksize);
+ }
buf->f_files = 0;
buf->f_ffree = 0;
- buf->f_bfree = yaffs_GetNumberOfFreeChunks(dev)/
- (sb->s_blocksize/YAFFS_BYTES_PER_CHUNK);
buf->f_bavail = buf->f_bfree;
yaffs_GrossUnlock(dev);
#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)
{
// Deep shit could not allocate device structure
dev->genericDevice = NULL; // Not used for RAM emulation.
nBlocks = YAFFS_RAM_EMULATION_SIZE / (YAFFS_CHUNKS_PER_BLOCK * YAFFS_BYTES_PER_CHUNK);
- dev->startBlock = 1; // Don't use block 0
+ dev->startBlock = 0;
dev->endBlock = nBlocks - 1;
dev->nChunksPerBlock = YAFFS_CHUNKS_PER_BLOCK;
dev->nBytesPerChunk = YAFFS_BYTES_PER_CHUNK;
dev->nChunksPerBlock = nandemul2k_GetChunksPerBlock();
dev->nBytesPerChunk = nandemul2k_GetBytesPerChunk();;
nBlocks = nandemul2k_GetNumberOfBlocks();
- dev->startBlock = 1; // Don't use block 0
+ dev->startBlock = 0;
dev->endBlock = nBlocks - 1;
}
else
// Set up the memory size parameters....
nBlocks = mtd->size / (YAFFS_CHUNKS_PER_BLOCK * YAFFS_BYTES_PER_CHUNK);
- dev->startBlock = 1; // Don't use block 0
+ dev->startBlock = 0;
dev->endBlock = nBlocks - 1;
dev->nChunksPerBlock = YAFFS_CHUNKS_PER_BLOCK;
dev->nBytesPerChunk = YAFFS_BYTES_PER_CHUNK;
dev->nBytesPerChunk = mtd->oobblock;
dev->nChunksPerBlock = mtd->erasesize / mtd->oobblock;
nBlocks = mtd->size / mtd->erasesize;
- dev->startBlock = 1; // Don't use block 0
+ dev->startBlock = 0;
dev->endBlock = nBlocks - 1;
}
else
.owner = THIS_MODULE,
.name = "yaffs",
.get_sb = yaffs_read_super,
-// .kill_sb = kill_block_super,
- .kill_sb = kill_litter_super,
+ .kill_sb = kill_block_super,
+// .kill_sb = kill_litter_super,
.fs_flags = FS_REQUIRES_DEV,
};
#else
.owner = THIS_MODULE,
.name = "yaffs2",
.get_sb = yaffs2_read_super,
-// .kill_sb = kill_block_super,
- .kill_sb = kill_litter_super,
+ .kill_sb = kill_block_super,
+// .kill_sb = kill_litter_super,
.fs_flags = FS_REQUIRES_DEV,
};
#else
.owner = THIS_MODULE,
.name = "yaffsram",
.get_sb = yaffs_ram_read_super,
-// .kill_sb = kill_block_super,
- .kill_sb = kill_litter_super,
- .fs_flags = FS_SINGLE,
+ .kill_sb = kill_block_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)
.owner = THIS_MODULE,
.name = "yaffs2ram",
.get_sb = yaffs2_ram_read_super,
-// .kill_sb = kill_block_super,
- .kill_sb = kill_litter_super,
- .fs_flags = FS_SINGLE,
+ .kill_sb = kill_block_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)
MODULE_AUTHOR("Charles Manning, Aleph One Ltd., 2002,2003,2004");
MODULE_LICENSE("GPL");
+
projects / yaffs2.git / blobdiff