applied patch 14-sparse-fix--remove-unused.diff
[yaffs2.git] / yaffs_fs.c
index e577688..ca78391 100644 (file)
  */
 
 
-const char *yaffs_fs_c_version = "$Id: yaffs_fs.c,v 1.10 2005-07-26 20:23:30 charles Exp $";
+const char *yaffs_fs_c_version = "$Id: yaffs_fs.c,v 1.18 2005-07-31 04:09:26 marty Exp $";
 extern const char *yaffs_guts_c_version;
 
 
-
 #include <linux/config.h>
 #include <linux/kernel.h>
 #include <linux/module.h>
@@ -44,6 +43,7 @@ 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>
@@ -56,12 +56,13 @@ extern const char *yaffs_guts_c_version;
 #include <asm/statfs.h>
 #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 <linux/locks.h>
+#define        BDEVNAME_SIZE           0
+#define        yaffs_devname(sb, buf)  kdevname(sb->s_dev)
 
 #endif
 
@@ -153,13 +154,6 @@ 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 *);
@@ -178,65 +172,57 @@ 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,
-       .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,
 };
 
 
@@ -918,6 +904,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)
        {
@@ -943,18 +931,18 @@ static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode, int r
                        // Special (socket, fifo, device...)
                        T(YAFFS_TRACE_OS,(KERN_DEBUG"yaffs_mknod: making special\n"));
 #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));
+                        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,current->uid, current->gid,rdev);
+                        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"));
@@ -1090,13 +1078,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);
 
@@ -1278,14 +1268,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)
 {
@@ -1299,9 +1282,9 @@ 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);
 }
 
@@ -1329,7 +1312,8 @@ static struct super_block *yaffs_internal_read_super(int yaffsVersion,int useRam
        int nBlocks;
        struct inode * inode = NULL;
        struct dentry * root;
-       yaffs_Device *dev;
+       yaffs_Device *dev = 0;
+       char devname_buf[BDEVNAME_SIZE+1];
        int err;
        
        sb->s_magic = YAFFS_MAGIC;
@@ -1339,10 +1323,10 @@ 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));
 
        
 
@@ -1384,6 +1368,7 @@ static struct super_block *yaffs_internal_read_super(int yaffsVersion,int useRam
 
                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;  
@@ -1415,19 +1400,16 @@ static struct super_block *yaffs_internal_read_super(int yaffsVersion,int useRam
                        dev->initialiseNAND = nandemul_InitialiseNAND;
                        dev->isYaffs2 = 0;
                }
-               
-               yaffsram_dev = dev;
-               
 #endif
 
        }
        else
        {       
-#ifdef CONFIG_YAFFS_MTD_ENABLED
+#if defined(CONFIG_YAFFS_MTD_ENABLED) || defined(CONFIG_YAFFS2_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)));
+                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)
@@ -1532,6 +1514,7 @@ static struct super_block *yaffs_internal_read_super(int yaffsVersion,int useRam
 
                memset(dev,0,sizeof(yaffs_Device));
                dev->genericDevice = mtd; 
+               dev->name = mtd->name;
 
                // Set up the memory size parameters....
                
@@ -1574,12 +1557,12 @@ static struct super_block *yaffs_internal_read_super(int yaffsVersion,int useRam
 #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);
        
        
@@ -1620,29 +1603,15 @@ 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;
-}
+
+#ifdef CONFIG_YAFFS_MTD_ENABLED
+
+#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;
 }
 
-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)
-{
-        return yaffs_internal_read_super(2,0,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)
 {
 
@@ -1673,6 +1642,11 @@ static DECLARE_FSTYPE(yaffs_fs_type, "yaffs", yaffs_read_super, FS_REQUIRES_DEV)
 #ifdef CONFIG_YAFFS2_MTD_ENABLED
 
 #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;
+}
+
 static struct super_block *yaffs2_read_super(struct file_system_type * fs, int flags, const char *dev_name, void *data)
 {
 
@@ -1704,6 +1678,11 @@ static DECLARE_FSTYPE(yaffs2_fs_type, "yaffs2", yaffs2_read_super, FS_REQUIRES_D
 #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)
 {
 
@@ -1732,6 +1711,11 @@ static DECLARE_FSTYPE(yaffs_ram_fs_type, "yaffsram", yaffs_ram_read_super, FS_SI
 #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)
 {
 
@@ -1760,11 +1744,9 @@ static DECLARE_FSTYPE(yaffs2_ram_fs_type, "yaffs2ram", yaffs2_ram_read_super, FS
 
 
 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);
@@ -1794,7 +1776,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;     
 }
 
@@ -1807,25 +1788,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;
+       /* 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,
@@ -1871,8 +1871,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"));