X-Git-Url: http://www.aleph1.co.uk/gitweb/?p=yaffs2.git;a=blobdiff_plain;f=yaffs_fs.c;h=df0870d1afeb2d79765833944ce554774b2c5023;hp=02d6b82197e101a89a286068c4fcbd7f5b138024;hb=2ae22f05374b4cb19202ddaac9fc47458c732f0d;hpb=8e45dc216be0b36eb0fd633543a2a184c81c5b9b diff --git a/yaffs_fs.c b/yaffs_fs.c index 02d6b82..df0870d 100644 --- a/yaffs_fs.c +++ b/yaffs_fs.c @@ -31,13 +31,15 @@ */ const char *yaffs_fs_c_version = - "$Id: yaffs_fs.c,v 1.34 2005-11-14 21:00:54 charles Exp $"; + "$Id: yaffs_fs.c,v 1.56 2007-01-19 04:07:48 charles Exp $"; extern const char *yaffs_guts_c_version; +#include +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19)) #include +#endif #include #include -#include #include #include #include @@ -48,6 +50,7 @@ extern const char *yaffs_guts_c_version; #include #include #include +#include #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)) @@ -65,6 +68,11 @@ extern const char *yaffs_guts_c_version; #define BDEVNAME_SIZE 0 #define yaffs_devname(sb, buf) kdevname(sb->s_dev) +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)) +/* added NCB 26/5/2006 for 2.4.25-vrs2-tcl1 kernel */ +#define __user +#endif + #endif #include @@ -72,7 +80,10 @@ extern const char *yaffs_guts_c_version; #include "yportenv.h" #include "yaffs_guts.h" -unsigned yaffs_traceMask = YAFFS_TRACE_ALWAYS | YAFFS_TRACE_BAD_BLOCKS /* | 0xFFFFFFFF */; +unsigned yaffs_traceMask = YAFFS_TRACE_ALWAYS | + YAFFS_TRACE_BAD_BLOCKS | + YAFFS_TRACE_CHECKPOINT + /* | 0xFFFFFFFF */; #include #include "yaffs_mtdif.h" @@ -80,7 +91,13 @@ unsigned yaffs_traceMask = YAFFS_TRACE_ALWAYS | YAFFS_TRACE_BAD_BLOCKS /* | 0xFF /*#define T(x) printk x */ -#define yaffs_InodeToObject(iptr) ((yaffs_Object *)((iptr)->u.generic_ip)) +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,18)) +#define yaffs_InodeToObjectLV(iptr) (iptr)->i_private +#else +#define yaffs_InodeToObjectLV(iptr) (iptr)->u.generic_ip +#endif + +#define yaffs_InodeToObject(iptr) ((yaffs_Object *)(yaffs_InodeToObjectLV(iptr))) #define yaffs_DentryToObject(dptr) yaffs_InodeToObject((dptr)->d_inode) #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)) @@ -94,7 +111,11 @@ static void yaffs_put_super(struct super_block *sb); static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n, loff_t * pos); +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17)) +static int yaffs_file_flush(struct file *file, fl_owner_t id); +#else static int yaffs_file_flush(struct file *file); +#endif static int yaffs_sync_object(struct file *file, struct dentry *dentry, int datasync); @@ -128,7 +149,17 @@ 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 (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)) +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17)) +static int yaffs_sync_fs(struct super_block *sb, int wait); +static void yaffs_write_super(struct super_block *sb); +#else +static int yaffs_sync_fs(struct super_block *sb); +static int yaffs_write_super(struct super_block *sb); +#endif + +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17)) +static int yaffs_statfs(struct dentry *dentry, struct kstatfs *buf); +#elif (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); @@ -166,11 +197,22 @@ static struct address_space_operations yaffs_file_address_operations = { }; static struct file_operations yaffs_file_operations = { +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,18)) + .read = do_sync_read, + .write = do_sync_write, + .aio_read = generic_file_aio_read, + .aio_write = generic_file_aio_write, +#else .read = generic_file_read, .write = generic_file_write, +#endif .mmap = generic_file_mmap, .flush = yaffs_file_flush, .fsync = yaffs_sync_object, +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)) + .sendfile = generic_file_sendfile, +#endif + }; static struct inode_operations yaffs_file_inode_operations = { @@ -209,6 +251,8 @@ static struct super_operations yaffs_super_ops = { .put_super = yaffs_put_super, .delete_inode = yaffs_delete_inode, .clear_inode = yaffs_clear_inode, + .sync_fs = yaffs_sync_fs, + .write_super = yaffs_write_super, }; static void yaffs_GrossLock(yaffs_Device * dev) @@ -309,6 +353,9 @@ static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry) dentry->d_name.name); obj = yaffs_GetEquivalentObject(obj); /* in case it was a hardlink */ + + /* Can't hold gross lock when calling yaffs_get_inode() */ + yaffs_GrossUnlock(dev); if (obj) { T(YAFFS_TRACE_OS, @@ -325,8 +372,6 @@ static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry) /*dget(dentry); // try to solve directory bug */ d_add(dentry, inode); - yaffs_GrossUnlock(dev); - /* return dentry; */ return NULL; #endif @@ -336,7 +381,6 @@ static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry) T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_lookup not found\n")); } - yaffs_GrossUnlock(dev); /* added NCB for 2.5/6 compatability - forces add even if inode is * NULL which creates dentry hash */ @@ -379,7 +423,7 @@ static void yaffs_clear_inode(struct inode *inode) * the yaffs_Object. */ obj->myInode = NULL; - inode->u.generic_ip = NULL; + yaffs_InodeToObjectLV(inode) = NULL; /* If the object freeing was deferred, then the real * free happens now. @@ -420,7 +464,11 @@ static void yaffs_delete_inode(struct inode *inode) clear_inode(inode); } +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17)) +static int yaffs_file_flush(struct file *file, fl_owner_t id) +#else static int yaffs_file_flush(struct file *file) +#endif { yaffs_Object *obj = yaffs_DentryToObject(file->f_dentry); @@ -624,20 +672,56 @@ static int yaffs_commit_write(struct file *f, struct page *pg, unsigned offset, T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_commit_write returning %d\n", - nWritten == nBytes ? 0 : -1)); + nWritten == nBytes ? 0 : nWritten)); - return nWritten == nBytes ? 0 : -1; + return nWritten == nBytes ? 0 : nWritten; } static void yaffs_FillInodeFromObject(struct inode *inode, yaffs_Object * obj) { if (inode && obj) { + + + /* Check mode against the variant type and attempt to repair if broken. */ + __u32 mode = obj->yst_mode; + switch( obj->variantType ){ + case YAFFS_OBJECT_TYPE_FILE : + if( ! S_ISREG(mode) ){ + obj->yst_mode &= ~S_IFMT; + obj->yst_mode |= S_IFREG; + } + + break; + case YAFFS_OBJECT_TYPE_SYMLINK : + if( ! S_ISLNK(mode) ){ + obj->yst_mode &= ~S_IFMT; + obj->yst_mode |= S_IFLNK; + } + + break; + case YAFFS_OBJECT_TYPE_DIRECTORY : + if( ! S_ISDIR(mode) ){ + obj->yst_mode &= ~S_IFMT; + obj->yst_mode |= S_IFDIR; + } + + break; + case YAFFS_OBJECT_TYPE_UNKNOWN : + case YAFFS_OBJECT_TYPE_HARDLINK : + case YAFFS_OBJECT_TYPE_SPECIAL : + default: + /* TODO? */ + break; + } + inode->i_ino = obj->objectId; inode->i_mode = obj->yst_mode; inode->i_uid = obj->yst_uid; inode->i_gid = obj->yst_gid; +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19)) inode->i_blksize = inode->i_sb->s_blocksize; +#endif #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)) inode->i_rdev = old_decode_dev(obj->yst_rdev); @@ -689,7 +773,8 @@ static void yaffs_FillInodeFromObject(struct inode *inode, yaffs_Object * obj) break; } - inode->u.generic_ip = obj; + yaffs_InodeToObjectLV(inode) = obj; + obj->myInode = inode; } else { @@ -725,6 +810,7 @@ struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev, /* NB Side effect: iget calls back to yaffs_read_inode(). */ /* iget also increments the inode's i_count */ + /* NB You can't be holding grossLock or deadlock will happen! */ return inode; } @@ -783,8 +869,7 @@ static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n, } yaffs_GrossUnlock(dev); - - return nWritten != n ? -ENOSPC : nWritten; + return nWritten == 0 ? -ENOSPC : nWritten; } static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir) @@ -833,6 +918,15 @@ static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir) curoffs = 1; + /* If the directory has changed since the open or last call to + readdir, rewind to after the 2 canned entries. */ + + if (f->f_version != inode->i_version) { + offset = 2; + f->f_pos = offset; + f->f_version = inode->i_version; + } + list_for_each(i, &obj->variant.directoryVariant.children) { curoffs++; if (curoffs >= offset) { @@ -888,6 +982,9 @@ static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode, int error = -ENOSPC; uid_t uid = current->fsuid; gid_t gid = (dir->i_mode & S_ISGID) ? dir->i_gid : current->fsgid; + + if((dir->i_mode & S_ISGID) && S_ISDIR(mode)) + mode |= S_ISGID; if (parent) { T(YAFFS_TRACE_OS, @@ -940,6 +1037,9 @@ static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode, obj = NULL; /* Do we ever get here? */ break; } + + /* Can not call yaffs_get_inode() with gross lock held */ + yaffs_GrossUnlock(dev); if (obj) { inode = yaffs_get_inode(dir->i_sb, mode, rdev, obj); @@ -954,8 +1054,6 @@ static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode, error = -ENOMEM; } - yaffs_GrossUnlock(dev); - return error; } @@ -1000,15 +1098,15 @@ static int yaffs_unlink(struct inode *dir, struct dentry *dentry) retVal = yaffs_Unlink(yaffs_InodeToObject(dir), dentry->d_name.name); - yaffs_GrossUnlock(dev); - if (retVal == YAFFS_OK) { dentry->d_inode->i_nlink--; + dir->i_version++; + yaffs_GrossUnlock(dev); mark_inode_dirty(dentry->d_inode); return 0; - } else { - return -ENOTEMPTY; } + yaffs_GrossUnlock(dev); + return -ENOTEMPTY; } /* @@ -1192,14 +1290,21 @@ static int yaffs_setattr(struct dentry *dentry, struct iattr *attr) return error; } -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)) +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17)) +static int yaffs_statfs(struct dentry *dentry, struct kstatfs *buf) +{ + yaffs_Device *dev = yaffs_DentryToObject(dentry)->myDev; + struct super_block *sb = dentry->d_sb; +#elif (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)) static int yaffs_statfs(struct super_block *sb, struct kstatfs *buf) +{ + yaffs_Device *dev = yaffs_SuperToDevice(sb); #else static int yaffs_statfs(struct super_block *sb, struct statfs *buf) -#endif { - yaffs_Device *dev = yaffs_SuperToDevice(sb); +#endif + T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_statfs\n")); yaffs_GrossLock(dev); @@ -1207,23 +1312,23 @@ static int yaffs_statfs(struct super_block *sb, struct statfs *buf) buf->f_type = YAFFS_MAGIC; buf->f_bsize = sb->s_blocksize; buf->f_namelen = 255; - if (sb->s_blocksize > dev->nBytesPerChunk) { + if (sb->s_blocksize > dev->nDataBytesPerChunk) { buf->f_blocks = (dev->endBlock - dev->startBlock + 1) * dev->nChunksPerBlock / (sb->s_blocksize / - dev->nBytesPerChunk); + dev->nDataBytesPerChunk); buf->f_bfree = yaffs_GetNumberOfFreeChunks(dev) / (sb->s_blocksize / - dev->nBytesPerChunk); + dev->nDataBytesPerChunk); } else { buf->f_blocks = (dev->endBlock - dev->startBlock + - 1) * dev->nChunksPerBlock * (dev->nBytesPerChunk / + 1) * dev->nChunksPerBlock * (dev->nDataBytesPerChunk / sb->s_blocksize); buf->f_bfree = - yaffs_GetNumberOfFreeChunks(dev) * (dev->nBytesPerChunk / + yaffs_GetNumberOfFreeChunks(dev) * (dev->nDataBytesPerChunk / sb->s_blocksize); } buf->f_files = 0; @@ -1234,10 +1339,61 @@ static int yaffs_statfs(struct super_block *sb, struct statfs *buf) return 0; } + +/** +static int yaffs_do_sync_fs(struct super_block *sb) +{ + + yaffs_Device *dev = yaffs_SuperToDevice(sb); + T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_do_sync_fs\n")); + + if(sb->s_dirt) { + yaffs_GrossLock(dev); + + if(dev) + yaffs_CheckpointSave(dev); + + yaffs_GrossUnlock(dev); + + sb->s_dirt = 0; + } + return 0; +} +**/ + +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17)) +static void yaffs_write_super(struct super_block *sb) +#else +static int yaffs_write_super(struct super_block *sb) +#endif +{ + + T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_write_super\n")); +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,18)) + return 0; /* yaffs_do_sync_fs(sb);*/ +#endif +} + + +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17)) +static int yaffs_sync_fs(struct super_block *sb, int wait) +#else +static int yaffs_sync_fs(struct super_block *sb) +#endif +{ + + T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_sync_fs\n")); + + return 0; /* yaffs_do_sync_fs(sb);*/ + +} + + static void yaffs_read_inode(struct inode *inode) { - /* NB This is called as a side effect of other functions and - * thus gross locking should always be in place already. + /* NB This is called as a side effect of other functions, but + * we had to release the lock to prevent deadlocks, so + * need to lock again. */ yaffs_Object *obj; @@ -1246,10 +1402,13 @@ static void yaffs_read_inode(struct inode *inode) T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_read_inode for %d\n", (int)inode->i_ino)); + yaffs_GrossLock(dev); + obj = yaffs_FindObjectByNumber(dev, inode->i_ino); yaffs_FillInodeFromObject(inode, obj); + yaffs_GrossUnlock(dev); } static LIST_HEAD(yaffs_dev_list); @@ -1258,15 +1417,28 @@ static void yaffs_put_super(struct super_block *sb) { yaffs_Device *dev = yaffs_SuperToDevice(sb); + T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_put_super\n")); + yaffs_GrossLock(dev); + + yaffs_FlushEntireDeviceCache(dev); + if (dev->putSuperFunc) { dev->putSuperFunc(sb); } + + yaffs_CheckpointSave(dev); yaffs_Deinitialise(dev); + yaffs_GrossUnlock(dev); /* we assume this is protected by lock_kernel() in mount/umount */ list_del(&dev->devList); + + if(dev->spareBuffer){ + YFREE(dev->spareBuffer); + dev->spareBuffer = NULL; + } kfree(dev); } @@ -1285,6 +1457,15 @@ static void yaffs_MTDPutSuper(struct super_block *sb) } +static void yaffs_MarkSuperBlockDirty(void *vsb) +{ + struct super_block *sb = (struct super_block *)vsb; + + T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_MarkSuperBlockDirty() sb = %p\n",sb)); +// if(sb) +// sb->s_dirt = 1; +} + static struct super_block *yaffs_internal_read_super(int yaffsVersion, struct super_block *sb, void *data, int silent) @@ -1354,10 +1535,39 @@ static struct super_block *yaffs_internal_read_super(int yaffsVersion, 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)); +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17)) + T(YAFFS_TRACE_OS, (" writesize %d\n", mtd->writesize)); +#else T(YAFFS_TRACE_OS, (" oobblock %d\n", mtd->oobblock)); +#endif 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)); + +#ifdef CONFIG_YAFFS_AUTO_YAFFS2 + + if (yaffsVersion == 1 && +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17)) + mtd->writesize >= 2048) { +#else + mtd->oobblock >= 2048) { +#endif + T(YAFFS_TRACE_ALWAYS,("yaffs: auto selecting yaffs2\n")); + yaffsVersion = 2; + } + + /* Added NCB 26/5/2006 for completeness */ + if (yaffsVersion == 2 && +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17)) + mtd->writesize == 512) { +#else + mtd->oobblock == 512) { +#endif + T(YAFFS_TRACE_ALWAYS,("yaffs: auto selecting yaffs1\n")); + yaffsVersion = 1; + } + +#endif if (yaffsVersion == 2) { /* Check for version 2 style functions */ @@ -1366,18 +1576,26 @@ static struct super_block *yaffs_internal_read_super(int yaffsVersion, !mtd->block_markbad || !mtd->read || !mtd->write || +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17)) + !mtd->read_oob || !mtd->write_oob) { +#else !mtd->write_ecc || !mtd->read_ecc || !mtd->read_oob || !mtd->write_oob) { +#endif T(YAFFS_TRACE_ALWAYS, ("yaffs: MTD device does not support required " "functions\n"));; return NULL; } +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17)) + if (mtd->writesize < YAFFS_MIN_YAFFS2_CHUNK_SIZE || +#else if (mtd->oobblock < YAFFS_MIN_YAFFS2_CHUNK_SIZE || +#endif mtd->oobsize < YAFFS_MIN_YAFFS2_SPARE_SIZE) { T(YAFFS_TRACE_ALWAYS, - ("yaffs: MTD device does not support have the " + ("yaffs: MTD device does not have the " "right page sizes\n")); return NULL; } @@ -1386,15 +1604,23 @@ static struct super_block *yaffs_internal_read_super(int yaffsVersion, if (!mtd->erase || !mtd->read || !mtd->write || +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17)) + !mtd->read_oob || !mtd->write_oob) { +#else !mtd->write_ecc || !mtd->read_ecc || !mtd->read_oob || !mtd->write_oob) { +#endif T(YAFFS_TRACE_ALWAYS, ("yaffs: MTD device does not support required " "functions\n"));; return NULL; } - if (mtd->oobblock != YAFFS_BYTES_PER_CHUNK || +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17)) + if (mtd->writesize < YAFFS_BYTES_PER_CHUNK || +#else + if (mtd->oobblock < YAFFS_BYTES_PER_CHUNK || +#endif mtd->oobsize != YAFFS_BYTES_PER_SPARE) { T(YAFFS_TRACE_ALWAYS, ("yaffs: MTD device does not support have the " @@ -1431,7 +1657,7 @@ static struct super_block *yaffs_internal_read_super(int yaffsVersion, dev->startBlock = 0; dev->endBlock = nBlocks - 1; dev->nChunksPerBlock = YAFFS_CHUNKS_PER_BLOCK; - dev->nBytesPerChunk = YAFFS_BYTES_PER_CHUNK; + dev->nDataBytesPerChunk = YAFFS_BYTES_PER_CHUNK; dev->nReservedBlocks = 5; dev->nShortOpCaches = 10; /* Enable short op caching */ @@ -1445,9 +1671,16 @@ static struct super_block *yaffs_internal_read_super(int yaffsVersion, dev->queryNANDBlock = nandmtd2_QueryNANDBlock; dev->spareBuffer = YMALLOC(mtd->oobsize); dev->isYaffs2 = 1; - dev->nBytesPerChunk = mtd->oobblock; +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17)) + dev->nDataBytesPerChunk = mtd->writesize; + dev->nChunksPerBlock = mtd->erasesize / mtd->writesize; +#else + dev->nDataBytesPerChunk = mtd->oobblock; dev->nChunksPerBlock = mtd->erasesize / mtd->oobblock; +#endif nBlocks = mtd->size / mtd->erasesize; + + dev->nCheckpointReservedBlocks = CONFIG_YAFFS_CHECKPOINT_RESERVED_BLOCKS; dev->startBlock = 0; dev->endBlock = nBlocks - 1; } else { @@ -1460,11 +1693,19 @@ static struct super_block *yaffs_internal_read_super(int yaffsVersion, dev->initialiseNAND = nandmtd_InitialiseNAND; dev->putSuperFunc = yaffs_MTDPutSuper; + + dev->superBlock = (void *)sb; + dev->markSuperBlockDirty = yaffs_MarkSuperBlockDirty; + #ifndef CONFIG_YAFFS_DOES_ECC dev->useNANDECC = 1; #endif +#ifdef CONFIG_YAFFS_DISABLE_WIDE_TNODES + dev->wideTnodesDisabled = 1; +#endif + /* we assume this is protected by lock_kernel() in mount/umount */ list_add_tail(&dev->devList, &yaffs_dev_list); @@ -1477,14 +1718,15 @@ static struct super_block *yaffs_internal_read_super(int yaffsVersion, T(YAFFS_TRACE_OS, ("yaffs_read_super: guts initialised %s\n", (err == YAFFS_OK) ? "OK" : "FAILED")); + + /* Release lock before yaffs_get_inode() */ + yaffs_GrossUnlock(dev); /* Create root inode */ if (err == YAFFS_OK) inode = yaffs_get_inode(sb, S_IFDIR | 0755, 0, yaffs_Root(dev)); - yaffs_GrossUnlock(dev); - if (!inode) return NULL; @@ -1515,6 +1757,16 @@ static int yaffs_internal_read_super_mtd(struct super_block *sb, void *data, return yaffs_internal_read_super(1, sb, data, silent) ? 0 : -EINVAL; } +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17)) +static int yaffs_read_super(struct file_system_type *fs, + int flags, const char *dev_name, + void *data, struct vfsmount *mnt) +{ + + return get_sb_bdev(fs, flags, dev_name, data, + yaffs_internal_read_super_mtd, mnt); +} +#else static struct super_block *yaffs_read_super(struct file_system_type *fs, int flags, const char *dev_name, void *data) @@ -1523,6 +1775,7 @@ static struct super_block *yaffs_read_super(struct file_system_type *fs, return get_sb_bdev(fs, flags, dev_name, data, yaffs_internal_read_super_mtd); } +#endif static struct file_system_type yaffs_fs_type = { .owner = THIS_MODULE, @@ -1552,6 +1805,15 @@ static int yaffs2_internal_read_super_mtd(struct super_block *sb, void *data, return yaffs_internal_read_super(2, sb, data, silent) ? 0 : -EINVAL; } +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17)) +static int yaffs2_read_super(struct file_system_type *fs, + int flags, const char *dev_name, void *data, + struct vfsmount *mnt) +{ + return get_sb_bdev(fs, flags, dev_name, data, + yaffs2_internal_read_super_mtd, mnt); +} +#else static struct super_block *yaffs2_read_super(struct file_system_type *fs, int flags, const char *dev_name, void *data) @@ -1560,6 +1822,7 @@ static struct super_block *yaffs2_read_super(struct file_system_type *fs, return get_sb_bdev(fs, flags, dev_name, data, yaffs2_internal_read_super_mtd); } +#endif static struct file_system_type yaffs2_fs_type = { .owner = THIS_MODULE, @@ -1664,6 +1927,119 @@ static int yaffs_proc_read(char *page, return buf - page < count ? buf - page : count; } +/** + * Set the verbosity of the warnings and error messages. + * + */ + +static struct { + char *mask_name; + unsigned mask_bitfield; +} mask_flags[] = { + {"allocate", YAFFS_TRACE_ALLOCATE}, + {"always", YAFFS_TRACE_ALWAYS}, + {"bad_blocks", YAFFS_TRACE_BAD_BLOCKS}, + {"buffers", YAFFS_TRACE_BUFFERS}, + {"bug", YAFFS_TRACE_BUG}, + {"deletion", YAFFS_TRACE_DELETION}, + {"erase", YAFFS_TRACE_ERASE}, + {"error", YAFFS_TRACE_ERROR}, + {"gc_detail", YAFFS_TRACE_GC_DETAIL}, + {"gc", YAFFS_TRACE_GC}, + {"mtd", YAFFS_TRACE_MTD}, + {"nandaccess", YAFFS_TRACE_NANDACCESS}, + {"os", YAFFS_TRACE_OS}, + {"scan_debug", YAFFS_TRACE_SCAN_DEBUG}, + {"scan", YAFFS_TRACE_SCAN}, + {"tracing", YAFFS_TRACE_TRACING}, + {"write", YAFFS_TRACE_WRITE}, + {"all", 0xffffffff}, + {"none", 0}, + {NULL, 0}, +}; + +static int yaffs_proc_write(struct file *file, const char *buf, + unsigned long count, void *data) +{ + unsigned rg = 0, mask_bitfield; + char *end, *mask_name; + int i; + int done = 0; + int add, len = 0; + int pos = 0; + + rg = yaffs_traceMask; + + while (!done && (pos < count)) { + done = 1; + while ((pos < count) && isspace(buf[pos])) { + pos++; + } + + switch (buf[pos]) { + case '+': + case '-': + case '=': + add = buf[pos]; + pos++; + break; + + default: + add = ' '; + break; + } + mask_name = NULL; + mask_bitfield = simple_strtoul(buf + pos, &end, 0); + if (end > buf + pos) { + mask_name = "numeral"; + len = end - (buf + pos); + done = 0; + } else { + + for (i = 0; mask_flags[i].mask_name != NULL; i++) { + len = strlen(mask_flags[i].mask_name); + if (strncmp(buf + pos, mask_flags[i].mask_name, len) == 0) { + mask_name = mask_flags[i].mask_name; + mask_bitfield = mask_flags[i].mask_bitfield; + done = 0; + break; + } + } + } + + if (mask_name != NULL) { + pos += len; + done = 0; + switch(add) { + case '-': + rg &= ~mask_bitfield; + break; + case '+': + rg |= mask_bitfield; + break; + case '=': + rg = mask_bitfield; + break; + default: + rg |= mask_bitfield; + break; + } + } + } + + yaffs_traceMask = rg | YAFFS_TRACE_ALWAYS; + + if (rg & YAFFS_TRACE_ALWAYS) { + for (i = 0; mask_flags[i].mask_name != NULL; i++) { + char flag; + flag = ((rg & mask_flags[i].mask_bitfield) == mask_flags[i].mask_bitfield) ? '+' : '-'; + printk("%c%s\n", flag, mask_flags[i].mask_name); + } + } + + return count; +} + /* Stuff to handle installation of file systems */ struct file_system_to_install { struct file_system_type *fst; @@ -1689,11 +2065,15 @@ static int __init init_yaffs_fs(void) ("yaffs " __DATE__ " " __TIME__ " Installing. \n")); /* Install the proc_fs entry */ - my_proc_entry = create_proc_read_entry("yaffs", + my_proc_entry = create_proc_entry("yaffs", S_IRUGO | S_IFREG, - &proc_root, - yaffs_proc_read, NULL); - if (!my_proc_entry) { + &proc_root); + + if (my_proc_entry) { + my_proc_entry->write_proc = yaffs_proc_write; + my_proc_entry->read_proc = yaffs_proc_read; + my_proc_entry->data = NULL; + } else { return -ENOMEM; } @@ -1751,5 +2131,5 @@ module_init(init_yaffs_fs) module_exit(exit_yaffs_fs) MODULE_DESCRIPTION("YAFFS2 - a NAND specific flash file system"); -MODULE_AUTHOR("Charles Manning, Aleph One Ltd., 2002,2003,2004"); +MODULE_AUTHOR("Charles Manning, Aleph One Ltd., 2002-2006"); MODULE_LICENSE("GPL");