* 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.2 2005-03-16 04:00:36 charles Exp $";
+const char *yaffs_fs_c_version = "$Id: yaffs_fs.c,v 1.10 2005-07-26 20:23:30 charles Exp $";
extern const char *yaffs_guts_c_version;
static void yaffs_clear_inode(struct inode *);
static int yaffs_readpage(struct file *file, struct page * page);
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
+static int yaffs_writepage(struct page *page, struct writeback_control *wbc);
+#else
static int yaffs_writepage(struct page *page);
+#endif
static int yaffs_prepare_write(struct file *f, struct page *pg, unsigned offset, unsigned to);
static int yaffs_commit_write(struct file *f, struct page *pg, unsigned offset, unsigned to);
-static int yaffs_readlink(struct dentry *dentry, char *buffer, int buflen);
+static int yaffs_readlink(struct dentry *dentry, char __user *buffer, int buflen);
static int yaffs_follow_link(struct dentry *dentry, struct nameidata *nd);
static struct address_space_operations yaffs_file_address_operations = {
- readpage: yaffs_readpage,
- writepage: yaffs_writepage,
- prepare_write: yaffs_prepare_write,
- commit_write: yaffs_commit_write
+ .readpage= yaffs_readpage,
+ .writepage= yaffs_writepage,
+ .prepare_write= yaffs_prepare_write,
+ .commit_write= yaffs_commit_write
};
static struct file_operations yaffs_file_operations = {
- read: generic_file_read,
- write: generic_file_write,
+ .read= generic_file_read,
+ .write= generic_file_write,
- mmap: generic_file_mmap,
- flush: yaffs_file_flush,
- fsync: yaffs_sync_object,
+ .mmap= generic_file_mmap,
+ .flush= yaffs_file_flush,
+ .fsync= yaffs_sync_object,
};
static struct inode_operations yaffs_file_inode_operations = {
- setattr: yaffs_setattr,
+ .setattr= yaffs_setattr,
};
struct inode_operations yaffs_symlink_inode_operations =
{
- readlink: yaffs_readlink,
- follow_link: yaffs_follow_link,
- setattr: yaffs_setattr
+ .readlink= yaffs_readlink,
+ .follow_link= yaffs_follow_link,
+ .setattr= yaffs_setattr
};
static struct inode_operations yaffs_dir_inode_operations = {
- create: yaffs_create,
- lookup: yaffs_lookup,
- link: yaffs_link,
- unlink: yaffs_unlink,
- symlink: yaffs_symlink,
- mkdir: yaffs_mkdir,
- rmdir: yaffs_unlink,
- mknod: yaffs_mknod,
- rename: yaffs_rename,
- setattr: yaffs_setattr,
+ .create= yaffs_create,
+ .lookup= yaffs_lookup,
+ .link= yaffs_link,
+ .unlink= yaffs_unlink,
+ .symlink= yaffs_symlink,
+ .mkdir= yaffs_mkdir,
+ .rmdir= yaffs_unlink,
+ .mknod= yaffs_mknod,
+ .rename= yaffs_rename,
+ .setattr= yaffs_setattr,
};
static struct file_operations yaffs_dir_operations = {
- read: generic_read_dir,
- readdir: yaffs_readdir,
- fsync: yaffs_sync_object,
+ .read= generic_read_dir,
+ .readdir= yaffs_readdir,
+ .fsync= yaffs_sync_object,
};
static struct super_operations yaffs_super_ops = {
- statfs: yaffs_statfs,
- read_inode: yaffs_read_inode,
- put_inode: yaffs_put_inode,
- put_super: yaffs_put_super,
-// remount_fs:
- delete_inode: yaffs_delete_inode,
- clear_inode: yaffs_clear_inode,
+ .statfs= yaffs_statfs,
+ .read_inode= yaffs_read_inode,
+ .put_inode= yaffs_put_inode,
+ .put_super= yaffs_put_super,
+ .delete_inode= yaffs_delete_inode,
+ .clear_inode= yaffs_clear_inode,
};
}
-static int yaffs_readlink(struct dentry *dentry, char *buffer, int buflen)
+static int yaffs_readlink(struct dentry *dentry, char __user *buffer, int buflen)
{
unsigned char *alias;
int ret;
{
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)
{
dev = obj->myDev;
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
+ BUG_ON(!PageLocked(pg));
+#else
if (!PageLocked(pg))
PAGE_BUG(pg);
+#endif
pg_buf = kmap(pg);
/* FIXME: Can kmap fail? */
// writepage inspired by/stolen from smbfs
//
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
+static int yaffs_writepage(struct page *page, struct writeback_control *wbc)
+#else
static int yaffs_writepage(struct page *page)
+#endif
{
struct address_space *mapping = page->mapping;
struct inode *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);
+ if (!error)
+ 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
return NULL;
}
- T(YAFFS_TRACE_OS,(" erase %x\n",mtd->erase));
- T(YAFFS_TRACE_OS,(" read %x\n",mtd->read));
- T(YAFFS_TRACE_OS,(" write %x\n",mtd->write));
- T(YAFFS_TRACE_OS,(" readoob %x\n",mtd->read_oob));
- T(YAFFS_TRACE_OS,(" writeoob %x\n",mtd->write_oob));
- T(YAFFS_TRACE_OS,(" block_isbad %x\n",mtd->block_isbad));
- T(YAFFS_TRACE_OS,(" block_markbad %x\n",mtd->block_markbad));
+ 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));
// 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
static struct super_block *yaffs_ram_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_ram);
+ return get_sb_nodev(fs, flags, data, yaffs_internal_read_super_ram);
}
.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,
+ .fs_flags = 0 ,
};
#else
static struct super_block *yaffs_ram_read_super(struct super_block * sb, void * data, int silent)
static struct super_block *yaffs2_ram_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_ram);
+ return get_sb_nodev(fs, flags, data, yaffs2_internal_read_super_ram);
}
.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,
+ .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");
+