X-Git-Url: http://www.aleph1.co.uk/gitweb/?p=yaffs2.git;a=blobdiff_plain;f=yaffs_fs.c;h=e4ea466b54365b4512502743c4437d36d2c098b5;hp=569f22518604fe8cb1a44239c25877667d32b92e;hb=9625e7b16224f286bb177324f2c1283b9db08286;hpb=dccf947cb075996a9f2d833c55760af7d5e42be9 diff --git a/yaffs_fs.c b/yaffs_fs.c index 569f225..e4ea466 100644 --- a/yaffs_fs.c +++ b/yaffs_fs.c @@ -15,7 +15,8 @@ * 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. * * @@ -29,11 +30,10 @@ */ -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.28 2005-08-09 03:52:23 charles Exp $"; extern const char *yaffs_guts_c_version; - #include #include #include @@ -43,6 +43,7 @@ extern const char *yaffs_guts_c_version; #include #include #include +#include #include #include #include @@ -55,12 +56,13 @@ extern const char *yaffs_guts_c_version; #include #define UnlockPage(p) unlock_page(p) #define Page_Uptodate(page) test_bit(PG_uptodate, &(page)->flags) -//#define kdevname(x) cdevname(to_kdev_t(x)) -#define kdevname(x) "(unavailable)" // temporary fix +#define yaffs_devname(sb, buf) bdevname(sb->s_bdev, buf) // FIXME: use sb->s_id instead ? #else #include +#define BDEVNAME_SIZE 0 +#define yaffs_devname(sb, buf) kdevname(sb->s_dev) #endif @@ -76,21 +78,11 @@ 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_MTD_ENABLED +#ifdef CONFIG_YAFFS_YAFFS1 #include #include "yaffs_mtdif.h" #include "yaffs_mtdif2.h" -#endif //CONFIG_YAFFS_MTD_ENABLED +#endif //CONFIG_YAFFS_YAFFS1 //#define T(x) printk x @@ -98,9 +90,7 @@ unsigned yaffs_traceMask = YAFFS_TRACE_ALWAYS | YAFFS_TRACE_BAD_BLOCKS; #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 @@ -110,10 +100,6 @@ unsigned yaffs_traceMask = YAFFS_TRACE_ALWAYS | YAFFS_TRACE_BAD_BLOCKS; 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); @@ -122,7 +108,6 @@ static int yaffs_sync_object(struct file * file, struct dentry *dentry, int data 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); @@ -135,7 +120,6 @@ static int yaffs_unlink(struct inode * dir, struct dentry *dentry); 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 @@ -144,7 +128,6 @@ static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode, int d 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 @@ -152,87 +135,75 @@ static int yaffs_statfs(struct super_block *sb, struct statfs *buf); #endif static void yaffs_read_inode (struct inode *inode); -//#if defined(CONFIG_KERNEL_2_5) -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)) -static struct super_block *yaffs_read_super(struct file_system_type * fs, int flags, const char *dev_name, void *data); -#else -static struct super_block *yaffs_read_super(struct super_block * sb, void * data, int silent); -#endif - static void yaffs_put_inode (struct inode *inode); static void yaffs_delete_inode(struct inode *); 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, - - mmap: generic_file_mmap, - flush: yaffs_file_flush, - fsync: yaffs_sync_object, + .read = generic_file_read, + .write = generic_file_write, + .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 +static struct inode_operations yaffs_symlink_inode_operations = { + .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, }; @@ -251,7 +222,7 @@ static void yaffs_GrossUnlock(yaffs_Device *dev) } -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; @@ -300,7 +271,6 @@ struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev,yaffs_Ob /* * 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) @@ -329,7 +299,7 @@ static struct dentry * yaffs_lookup(struct inode *dir, struct dentry *dentry) { 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) { @@ -462,8 +432,12 @@ static int yaffs_readpage_nolock(struct file *f, struct page * pg) 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? */ @@ -507,9 +481,14 @@ static int yaffs_readpage(struct file *f, struct page * pg) // 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; + loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT; struct inode *inode; unsigned long end_index; char *buffer; @@ -523,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 */ @@ -547,8 +534,12 @@ 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); + 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); @@ -612,25 +603,24 @@ static void yaffs_FillInodeFromObject(struct inode *inode, yaffs_Object *obj) 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; @@ -640,11 +630,15 @@ static void yaffs_FillInodeFromObject(struct inode *inode, yaffs_Object *obj) 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; @@ -699,55 +693,6 @@ struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev,yaffs_Ob return inode; } -#if 0 - -// No longer used because we use generic rw */ -static ssize_t yaffs_file_read(struct file *f, char *buf, size_t n, loff_t *pos) -{ - yaffs_Object *obj; - int nRead,ipos; - struct inode *inode; - yaffs_Device *dev; - - T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_file_read\n")); - - obj = yaffs_DentryToObject(f->f_dentry); - - dev = obj->myDev; - - yaffs_GrossLock(dev); - - inode = f->f_dentry->d_inode; - - if (*pos < inode->i_size) - { - if (*pos + n > inode->i_size) - { - n = inode->i_size - *pos; - } - } - else - { - n = 0; - } - - nRead = yaffs_ReadDataFromFile(obj,buf,*pos,n); - if(nRead > 0) - { - f->f_pos += nRead; - } - - yaffs_GrossUnlock(dev); - - ipos = *pos; - - T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_file_read read %d bytes, %d read at %d\n",n,nRead,ipos)); - return nRead; - -} - -#endif - static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n, loff_t *pos) { yaffs_Object *obj; @@ -783,7 +728,7 @@ static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n, loff_ 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) @@ -887,7 +832,6 @@ static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir) /* * 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 @@ -902,6 +846,8 @@ static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode, int r yaffs_Object *parent = yaffs_InodeToObject(dir); int error = -ENOSPC; + uid_t uid = current->fsuid; + gid_t gid = (dir->i_mode & S_ISGID) ? dir->i_gid : current->fsgid; if(parent) { @@ -926,15 +872,19 @@ static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode, int r 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,uid, gid,old_encode_dev(rdev)); +#else + obj = yaffs_MknodSpecial(parent,dentry->d_name.name,mode,uid, 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); + obj = yaffs_MknodFile(parent,dentry->d_name.name,mode,uid, gid); break; case S_IFDIR: // directory T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_mknod: making directory\n")); - obj = yaffs_MknodDirectory(parent,dentry->d_name.name,mode,current->uid, current->gid); + obj = yaffs_MknodDirectory(parent,dentry->d_name.name,mode,uid, gid); break; case S_IFLNK: // symlink T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_mknod: making file\n")); @@ -975,7 +925,6 @@ static int yaffs_mkdir(struct inode * dir, struct dentry * dentry, int mode) 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 @@ -1070,13 +1019,15 @@ static int yaffs_symlink(struct inode * dir, struct dentry *dentry, const char * { yaffs_Object *obj; yaffs_Device *dev; + uid_t uid = current->fsuid; + gid_t gid = (dir->i_mode & S_ISGID) ? dir->i_gid : current->fsgid; T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_symlink\n")); dev = yaffs_InodeToObject(dir)->myDev; yaffs_GrossLock(dev); obj = yaffs_MknodSymLink(yaffs_InodeToObject(dir), dentry->d_name.name, - S_IFLNK | S_IRWXUGO, current->uid, current->gid, + S_IFLNK | S_IRWXUGO, uid, gid, symname); yaffs_GrossUnlock(dev); @@ -1085,7 +1036,7 @@ static int yaffs_symlink(struct inode * dir, struct dentry *dentry, const char * 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; @@ -1144,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); @@ -1194,32 +1143,47 @@ static int yaffs_setattr(struct dentry *dentry, struct iattr *attr) error = -EPERM; } yaffs_GrossUnlock(dev); - inode_setattr(inode,attr); + if (!error) + error = inode_setattr(inode,attr); } 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 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); @@ -1242,14 +1206,7 @@ static void yaffs_read_inode (struct inode *inode) } - - -// Todo -// Currently we only can report a single partition. Need to use lists here -static yaffs_Device *yaffs_dev; -static yaffs_Device *yaffsram_dev; - - +static LIST_HEAD(yaffs_dev_list); static void yaffs_put_super(struct super_block *sb) { @@ -1263,14 +1220,14 @@ static void yaffs_put_super(struct super_block *sb) yaffs_Deinitialise(dev); yaffs_GrossUnlock(dev); - if(dev == yaffs_dev) yaffs_dev = NULL; - if(dev == yaffsram_dev) yaffsram_dev = NULL; - + /* we assume this is protected by lock_kernel() in mount/umount */ + list_del(&dev->devList); + kfree(dev); } -#ifdef CONFIG_YAFFS_MTD_ENABLED +#ifdef CONFIG_YAFFS_YAFFS1 static void yaffs_MTDPutSuper(struct super_block *sb) { @@ -1288,12 +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; + yaffs_Device *dev = 0; + char devname_buf[BDEVNAME_SIZE+1]; + struct mtd_info *mtd; int err; sb->s_magic = YAFFS_MAGIC; @@ -1303,240 +1262,170 @@ static struct super_block *yaffs_internal_read_super(int yaffsVersion,int useRam printk(KERN_INFO"yaffs: sb is NULL\n"); else if(!sb->s_dev) printk(KERN_INFO"yaffs: sb->s_dev is NULL\n"); - else if(! kdevname(sb->s_dev)) - printk(KERN_INFO"yaffs: kdevname is NULL\n"); + else if(!yaffs_devname(sb, devname_buf)) + printk(KERN_INFO"yaffs: devname is NULL\n"); else - printk(KERN_INFO"yaffs: dev is %d name is \"%s\"\n", sb->s_dev, kdevname(sb->s_dev)); + printk(KERN_INFO"yaffs: dev is %d name is \"%s\"\n", sb->s_dev, yaffs_devname(sb, devname_buf)); -#ifdef CONFIG_YAFFS_USE_CHUNK_SIZE - sb->s_blocksize = YAFFS_BYTES_PER_CHUNK; - sb->s_blocksize_bits = YAFFS_CHUNK_SIZE_SHIFT; -#else sb->s_blocksize = PAGE_CACHE_SIZE; sb->s_blocksize_bits = PAGE_CACHE_SHIFT; -#endif 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 - - sb->u.generic_sbp = dev = kmalloc(sizeof(yaffs_Device),GFP_KERNEL); - 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. - - nBlocks = YAFFS_RAM_EMULATION_SIZE / (YAFFS_CHUNKS_PER_BLOCK * YAFFS_BYTES_PER_CHUNK); - dev->startBlock = 1; // Don't use block 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 = 1; // Don't use block 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; - } - - yaffsram_dev = dev; - -#endif - - } + T(YAFFS_TRACE_ALWAYS,("yaffs: MTD device does not support have the right page sizes\n")); + return NULL; + } } else - { -#ifdef CONFIG_YAFFS_MTD_ENABLED - 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),kdevname(sb->s_dev))); - - // 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 %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,(" 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; + 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); - dev->startBlock = 1; // Don't use block 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 - + // 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 = 1; // Don't use block 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; + // ... 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; + +#ifndef CONFIG_YAFFS_DOES_ECC + dev->useNANDECC = 1; #endif - yaffs_dev = dev; - -#endif - } + /* we assume this is protected by lock_kernel() in mount/umount */ + list_add_tail(&dev->devList, &yaffs_dev_list); init_MUTEX(&dev->grossLock); @@ -1578,153 +1467,78 @@ static struct super_block *yaffs_internal_read_super(int yaffsVersion,int useRam } -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 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; -} -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 int yaffs2_internal_read_super_mtd(struct super_block * sb, void * data, int silent) +#ifdef CONFIG_YAFFS_YAFFS1 + +#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(2,0,sb,data,silent) ? 0 : -1; + return yaffs_internal_read_super(1,sb,data,silent) ? 0 : -1; } - - -#ifdef CONFIG_YAFFS_MTD_ENABLED -//#if defined(CONFIG_KERNEL_2_5) -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)) 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, + .kill_sb = kill_block_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); #endif -#endif // CONFIG_YAFFS_MTD_ENABLED +#endif // CONFIG_YAFFS_YAFFS1 -#ifdef CONFIG_YAFFS2_MTD_ENABLED +#ifdef CONFIG_YAFFS_YAFFS2 #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,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, + .kill_sb = kill_block_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 -#endif // CONFIG_YAFFS2_MTD_ENABLED - - -#ifdef CONFIG_YAFFS_RAM_ENABLED - -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)) -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); -} - - -static struct file_system_type yaffs_ram_fs_type = { - .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, -}; -#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 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); -} - - -static struct file_system_type yaffs2_ram_fs_type = { - .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, -}; -#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_YAFFS_YAFFS2 -#endif // CONFIG_YAFFS2_RAM_ENABLED static struct proc_dir_entry *my_proc_entry; -static struct proc_dir_entry *my_proc_ram_write_entry; -static char * yaffs_dump_dev(char *buf,yaffs_Device *dev,char *name) +static char * yaffs_dump_dev(char *buf,yaffs_Device *dev) { - buf +=sprintf(buf,"\nDevice %s\n",name); buf +=sprintf(buf,"startBlock......... %d\n",dev->startBlock); buf +=sprintf(buf,"endBlock........... %d\n",dev->endBlock); buf +=sprintf(buf,"chunkGroupBits..... %d\n",dev->chunkGroupBits); @@ -1754,7 +1568,6 @@ static char * yaffs_dump_dev(char *buf,yaffs_Device *dev,char *name) buf +=sprintf(buf,"useNANDECC......... %d\n",dev->useNANDECC); buf +=sprintf(buf,"isYaffs2........... %d\n",dev->isYaffs2); - return buf; } @@ -1767,41 +1580,44 @@ static int yaffs_proc_read( void *data ) { + struct list_head *item; + char *buf = page; + int step = offset; + int n = 0; + + /* Get proc_file_read() to step 'offset' by one on each sucessive call. + * We use 'offset' (*ppos) to indicate where we are in devList. + * This also assumes the user has posted a read buffer large + * enough to hold the complete output; but that's life in /proc. + */ + + *(int *)start = 1; + + /* Print header first */ + if (step == 0) { + buf += sprintf(buf, "YAFFS built:" __DATE__ " "__TIME__ + "\n%s\n%s\n", yaffs_fs_c_version, yaffs_guts_c_version); + } - char my_buffer[3000]; - char *buf; - buf = my_buffer; - - if (offset > 0) return 0; - - /* Fill the buffer and get its length */ - buf +=sprintf(buf,"YAFFS built:"__DATE__ " "__TIME__"\n%s\n%s\n", yaffs_fs_c_version,yaffs_guts_c_version); - - if(yaffs_dev) buf = yaffs_dump_dev(buf,yaffs_dev,"yaffs"); - if(yaffsram_dev) buf = yaffs_dump_dev(buf,yaffsram_dev,"yaffsram"); - - - strcpy(page,my_buffer); - return strlen(my_buffer); -} - + /* hold lock_kernel while traversing yaffs_dev_list */ + lock_kernel(); -static int yaffs_proc_ram_write( - char *page, - char **start, - off_t offset, - int count, - int *eof, - void *data - ) -{ + /* Locate and print the Nth entry. Order N-squared but N is small. */ + list_for_each(item, &yaffs_dev_list) { + yaffs_Device *dev = list_entry(item, yaffs_Device, devList); + if (n < step) { + n++; + continue; + } + buf += sprintf(buf,"\nDevice %d \"%s\"\n", n, dev->name); + buf = yaffs_dump_dev(buf, dev); + break; + } + unlock_kernel(); - printk(KERN_DEBUG "yaffs write size %d\n",count); - return count; + return buf-page < count ? buf-page : count; } - - // Stuff to handle installation of file systems struct file_system_to_install { @@ -1811,16 +1627,10 @@ 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_MTD_ENABLED +#ifdef CONFIG_YAFFS_YAFFS1 { &yaffs_fs_type,0}, #endif -#ifdef CONFIG_YAFFS2_MTD_ENABLED +#ifdef CONFIG_YAFFS_YAFFS2 { &yaffs2_fs_type,0}, #endif { NULL,0} @@ -1831,8 +1641,6 @@ static int __init init_yaffs_fs(void) int error = 0; struct file_system_to_install *fsinst; - yaffs_dev = yaffsram_dev = NULL; - T(YAFFS_TRACE_ALWAYS,("yaffs " __DATE__ " " __TIME__ " Installing. \n")); @@ -1913,3 +1721,4 @@ MODULE_DESCRIPTION("YAFFS2 - a NAND specific flash file system"); MODULE_AUTHOR("Charles Manning, Aleph One Ltd., 2002,2003,2004"); MODULE_LICENSE("GPL"); +