*/
const char *yaffs_fs_c_version =
- "$Id: yaffs_fs.c,v 1.31 2005-09-21 01:14:03 charles Exp $";
+ "$Id: yaffs_fs.c,v 1.41 2006-01-27 23:54:21 tpoynor Exp $";
extern const char *yaffs_guts_c_version;
#include <linux/config.h>
#include <linux/mtd/mtd.h>
#include <linux/interrupt.h>
#include <linux/string.h>
+#include <linux/ctype.h>
#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
static int yaffs_readlink(struct dentry *dentry, char __user * buffer,
int buflen);
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,13))
+static void *yaffs_follow_link(struct dentry *dentry, struct nameidata *nd);
+#else
static int yaffs_follow_link(struct dentry *dentry, struct nameidata *nd);
+#endif
static struct address_space_operations yaffs_file_address_operations = {
.readpage = yaffs_readpage,
.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 = {
return ret;
}
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,13))
+static void *yaffs_follow_link(struct dentry *dentry, struct nameidata *nd)
+#else
static int yaffs_follow_link(struct dentry *dentry, struct nameidata *nd)
+#endif
{
unsigned char *alias;
int ret;
yaffs_GrossUnlock(dev);
if (!alias)
- return -ENOMEM;
+ {
+ ret = -ENOMEM;
+ goto out;
+ }
ret = vfs_follow_link(nd, alias);
kfree(alias);
+out:
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,13))
+ return ERR_PTR (ret);
+#else
return ret;
+#endif
}
struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev,
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,
/*dget(dentry); // try to solve directory bug */
d_add(dentry, inode);
- yaffs_GrossUnlock(dev);
-
/* return dentry; */
return NULL;
#endif
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 */
yaffs_DeleteFile(obj);
yaffs_GrossUnlock(dev);
}
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,13))
+ truncate_inode_pages (&inode->i_data, 0);
+#endif
clear_inode(inode);
}
}
T(YAFFS_TRACE_OS,
- (KERN_DEBUG "yaffs_commit_write returning %d\n", nWritten));
+ (KERN_DEBUG "yaffs_commit_write returning %d\n",
+ nWritten == nBytes ? 0 : nWritten));
- return nWritten;
+ return nWritten == nBytes ? 0 : nWritten;
}
/* 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;
}
}
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)
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);
error = -ENOMEM;
}
- yaffs_GrossUnlock(dev);
-
return error;
}
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;
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);
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 &&
+ mtd->oobblock >= 2048) {
+ T(YAFFS_TRACE_ALWAYS,("yaffs: auto selecting yaffs2\n"));
+ yaffsVersion = 2;
+ }
+#endif
if (yaffsVersion == 2) {
/* Check for version 2 style functions */
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);
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;
static int yaffs_internal_read_super_mtd(struct super_block *sb, void *data,
int silent)
{
- return yaffs_internal_read_super(1, sb, data, silent) ? 0 : -1;
+ return yaffs_internal_read_super(1, sb, data, silent) ? 0 : -EINVAL;
}
static struct super_block *yaffs_read_super(struct file_system_type *fs,
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;
+ return yaffs_internal_read_super(2, sb, data, silent) ? 0 : -EINVAL;
}
static struct super_block *yaffs2_read_super(struct file_system_type *fs,
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;
+ 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;
+ 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;
("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;
}
projects / yaffs2.git / blobdiff