*/
-const char *yaffs_fs_c_version = "$Id: yaffs_fs.c,v 1.8 2005-07-18 23:16:04 charles Exp $";
+const char *yaffs_fs_c_version = "$Id: yaffs_fs.c,v 1.12 2005-07-27 20:23:15 charles Exp $";
extern const char *yaffs_guts_c_version;
#include <linux/list.h>
#include <linux/fs.h>
#include <linux/proc_fs.h>
+#include <linux/smp_lock.h>
#include <linux/pagemap.h>
#include <linux/mtd/mtd.h>
#include <linux/interrupt.h>
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
+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,
};
}
-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;
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;
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;
+#endif
+ break;
case S_IFREG: // file
inode->i_op = &yaffs_file_inode_operations;
inode->i_fop = &yaffs_file_operations;
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;
+#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);
error = -EPERM;
}
yaffs_GrossUnlock(dev);
- error = inode_setattr(inode,attr);
+ if (!error)
+ error = inode_setattr(inode,attr);
}
return error;
}
}
-
-
-// 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)
{
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);
}
int nBlocks;
struct inode * inode = NULL;
struct dentry * root;
- yaffs_Device *dev;
+ yaffs_Device *dev = 0;
int err;
sb->s_magic = YAFFS_MAGIC;
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->initialiseNAND = nandemul_InitialiseNAND;
dev->isYaffs2 = 0;
}
-
- yaffsram_dev = dev;
-
#endif
}
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));
memset(dev,0,sizeof(yaffs_Device));
dev->genericDevice = mtd;
+ dev->name = mtd->name;
// Set up the memory size parameters....
#ifdef CONFIG_YAFFS_USE_NANDECC
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);
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,
+ .kill_sb = kill_litter_super,
.fs_flags = 0 ,
};
#else
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,
+ .kill_sb = kill_litter_super,
.fs_flags = 0 ,
};
#else
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);
buf +=sprintf(buf,"useNANDECC......... %d\n",dev->useNANDECC);
buf +=sprintf(buf,"isYaffs2........... %d\n",dev->isYaffs2);
-
return buf;
}
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;
+ /* hold lock_kernel while traversing yaffs_dev_list */
+ lock_kernel();
- /* 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");
-
+ /* 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();
- strcpy(page,my_buffer);
- return strlen(my_buffer);
+ return buf-page < count ? buf-page : count;
}
-
static int yaffs_proc_ram_write(
char *page,
char **start,
int error = 0;
struct file_system_to_install *fsinst;
- yaffs_dev = yaffsram_dev = NULL;
-
T(YAFFS_TRACE_ALWAYS,("yaffs " __DATE__ " " __TIME__ " Installing. \n"));
projects / yaffs2.git / blobdiff