*/
const char *yaffs_fs_c_version =
- "$Id: yaffs_fs.c,v 1.100 2010-03-15 06:28:36 charles Exp $";
+ "$Id: yaffs_fs.c,v 1.102 2010-03-15 23:10:33 charles Exp $";
extern const char *yaffs_guts_c_version;
#include <linux/version.h>
#define YAFFS_COMPILE_BACKGROUND
#endif
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,28))
+#define YAFFS_COMPILE_EXPORTFS
+#endif
+
+
#if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 19))
#include <linux/config.h>
#endif
#include <linux/string.h>
#include <linux/ctype.h>
+#ifdef YAFFS_COMPILE_EXPORTFS
+#include <linux/exportfs.h>
+#endif
+
#ifdef YAFFS_COMPILE_BACKGROUND
#include <linux/kthread.h>
#include <linux/delay.h>
+#include <linux/freezer.h>
#endif
unsigned int yaffs_traceMask = YAFFS_TRACE_BAD_BLOCKS | YAFFS_TRACE_ALWAYS;
unsigned int yaffs_wr_attempts = YAFFS_WR_ATTEMPTS;
unsigned int yaffs_auto_checkpoint = 1;
+unsigned int yaffs_gc_control = 1;
/* Module Parameters */
#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0))
module_param(yaffs_traceMask, uint, 0644);
module_param(yaffs_wr_attempts, uint, 0644);
module_param(yaffs_auto_checkpoint, uint, 0644);
+module_param(yaffs_gc_control, uint, 0644);
#else
MODULE_PARM(yaffs_traceMask, "i");
MODULE_PARM(yaffs_wr_attempts, "i");
MODULE_PARM(yaffs_auto_checkpoint, "i");
+MODULE_PARM(yaffs_gc_control, "i");
#endif
#if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 25))
#else
static int yaffs_follow_link(struct dentry *dentry, struct nameidata *nd);
#endif
+static loff_t yaffs_dir_llseek(struct file *file, loff_t offset, int origin);
static struct address_space_operations yaffs_file_address_operations = {
.readpage = yaffs_readpage,
.read = generic_read_dir,
.readdir = yaffs_readdir,
.fsync = yaffs_sync_object,
+ .llseek = yaffs_dir_llseek,
};
static const struct super_operations yaffs_super_ops = {
.sync_fs = yaffs_sync_fs,
.write_super = yaffs_write_super,
};
+
+static unsigned yaffs_gc_control_callback(yaffs_Device *dev)
+{
+ return yaffs_gc_control;
+}
static void yaffs_GrossLock(yaffs_Device *dev)
{
up(&(yaffs_DeviceToContext(dev)->grossLock));
}
+#ifdef YAFFS_COMPILE_EXPORTFS
+
+static struct inode *
+yaffs2_nfs_get_inode(struct super_block *sb, uint64_t ino, uint32_t generation)
+{
+ return Y_IGET(sb, ino);
+}
+
+static struct dentry *
+yaffs2_fh_to_dentry(struct super_block *sb, struct fid *fid, int fh_len, int fh_type)
+{
+ return generic_fh_to_dentry(sb, fid, fh_len, fh_type, yaffs2_nfs_get_inode) ;
+}
+
+static struct dentry *
+ yaffs2_fh_to_parent(struct super_block *sb, struct fid *fid, int fh_len, int fh_type)
+{
+ return generic_fh_to_parent(sb, fid, fh_len, fh_type, yaffs2_nfs_get_inode);
+}
+
+struct dentry *yaffs2_get_parent(struct dentry *dentry)
+{
+
+ struct super_block *sb = dentry->d_inode->i_sb;
+ struct dentry *parent = ERR_PTR(-ENOENT);
+ struct inode *inode;
+ unsigned long parent_ino;
+ yaffs_Object *d_obj;
+ yaffs_Object *parent_obj;
+
+ d_obj = yaffs_InodeToObject(dentry->d_inode);
+
+ if (d_obj) {
+ parent_obj = d_obj->parent;
+ if (parent_obj) {
+ parent_ino = yaffs_GetObjectInode(parent_obj);
+ inode = Y_IGET(sb, parent_ino);
+
+ if (IS_ERR(inode)) {
+ parent = ERR_CAST(inode);
+ } else {
+ parent = d_obtain_alias(inode);
+ if (!IS_ERR(parent)) {
+ parent = ERR_PTR(-ENOMEM);
+ iput(inode);
+ }
+ }
+ }
+ }
+
+ return parent;
+}
+
+/* Just declare a zero structure as a NULL value implies
+ * using the default functions of expfs.
+ */
+
+static struct export_operations yaffs_export_ops =
+{
+ .fh_to_dentry = yaffs2_fh_to_dentry,
+ .fh_to_parent = yaffs2_fh_to_parent,
+ .get_parent = yaffs2_get_parent,
+} ;
+
+#endif
/*-----------------------------------------------------------------*/
/* Directory search context allows us to unlock access to yaffs during
yaffs_Device *dev = yaffs_InodeToObject(dir)->myDev;
- yaffs_GrossLock(dev);
+ if(current != yaffs_DeviceToContext(dev)->readdirProcess)
+ yaffs_GrossLock(dev);
T(YAFFS_TRACE_OS,
("yaffs_lookup for %d:%s\n",
obj = yaffs_GetEquivalentObject(obj); /* in case it was a hardlink */
/* Can't hold gross lock when calling yaffs_get_inode() */
- yaffs_GrossUnlock(dev);
+ if(current != yaffs_DeviceToContext(dev)->readdirProcess)
+ yaffs_GrossUnlock(dev);
if (obj) {
T(YAFFS_TRACE_OS,
addr = kva + offset_into_page;
T(YAFFS_TRACE_OS,
- ("yaffs_write_end addr %x pos %x nBytes %d\n",
- (unsigned) addr,
- (int)pos, copied));
+ ("yaffs_write_end addr %p pos %x nBytes %d\n",
+ addr,(unsigned)pos, copied));
ret = yaffs_file_write(filp, addr, copied, &pos);
yaffs_GrossUnlock(dev);
}
+
+static loff_t yaffs_dir_llseek(struct file *file, loff_t offset, int origin)
+{
+ long long retval;
+
+ lock_kernel();
+
+ switch (origin){
+ case 2:
+ offset += i_size_read(file->f_path.dentry->d_inode);
+ break;
+ case 1:
+ offset += file->f_pos;
+ }
+ retval = -EINVAL;
+
+ if (offset >= 0){
+ if (offset != file->f_pos)
+ file->f_pos = offset;
+
+ retval = offset;
+ }
+ unlock_kernel();
+ return retval;
+}
+
+
static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir)
{
yaffs_Object *obj;
yaffs_GrossLock(dev);
+ yaffs_DeviceToContext(dev)->readdirProcess = current;
+
offset = f->f_pos;
sc = yaffs_NewSearch(obj);
/* 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;
}
unlock_out:
+ yaffs_DeviceToContext(dev)->readdirProcess = NULL;
+
yaffs_GrossUnlock(dev);
out:
yaffs_EndSearch(sc);
return retVal;
}
+
+
/*
* File creation. Allocate an inode, and we're done..
*/
("yaffs_mknod created object %d count = %d\n",
obj->objectId, atomic_read(&inode->i_count)));
error = 0;
+ yaffs_FillInodeFromObject(dir,parent);
} else {
T(YAFFS_TRACE_OS,
("yaffs_mknod failed making object\n"));
int retVal;
yaffs_Device *dev;
+ yaffs_Object *obj;
T(YAFFS_TRACE_OS,
("yaffs_unlink %d:%s\n", (int)(dir->i_ino),
dentry->d_name.name));
-
- dev = yaffs_InodeToObject(dir)->myDev;
+ obj = yaffs_InodeToObject(dir);
+ dev = obj->myDev;
yaffs_GrossLock(dev);
- retVal = yaffs_Unlink(yaffs_InodeToObject(dir), dentry->d_name.name);
+ retVal = yaffs_Unlink(obj, dentry->d_name.name);
if (retVal == YAFFS_OK) {
dentry->d_inode->i_nlink--;
yaffs_CheckpointSave(dev);
}
-static int yaffs_do_sync_fs(struct super_block *sb, int do_checkpoint)
+
+static unsigned yaffs_bg_gc_urgency(yaffs_Device *dev)
+{
+ unsigned erasedChunks = dev->nErasedBlocks * dev->param.nChunksPerBlock;
+ struct yaffs_LinuxContext *context = yaffs_DeviceToContext(dev);
+ unsigned scatteredFree = 0; /* Free chunks not in an erased block */
+
+ if(erasedChunks < dev->nFreeChunks)
+ scatteredFree = (dev->nFreeChunks - erasedChunks);
+
+ if(!context->bgRunning)
+ return 0;
+ else if(scatteredFree < (dev->param.nChunksPerBlock * 2))
+ return 0;
+ else if(erasedChunks > dev->nFreeChunks/2)
+ return 0;
+ else if(erasedChunks > dev->nFreeChunks/4)
+ return 1;
+ else
+ return 2;
+}
+
+static int yaffs_do_sync_fs(struct super_block *sb,
+ int request_checkpoint)
{
yaffs_Device *dev = yaffs_SuperToDevice(sb);
- T(YAFFS_TRACE_OS | YAFFS_TRACE_SYNC,
- ("yaffs_do_sync_fs: %s %s\n",
+ unsigned int oneshot_checkpoint = (yaffs_auto_checkpoint & 4);
+ unsigned gc_urgent = yaffs_bg_gc_urgency(dev);
+ int do_checkpoint;
+
+ T(YAFFS_TRACE_OS | YAFFS_TRACE_SYNC | YAFFS_TRACE_BACKGROUND,
+ ("yaffs_do_sync_fs: gc-urgency %d %s %s%s\n",
+ gc_urgent,
sb->s_dirt ? "dirty" : "clean",
- do_checkpoint ? "with checkpoint" : "no checkpoint"));
+ request_checkpoint ? "checkpoint requested" : "no checkpoint",
+ oneshot_checkpoint ? " one-shot" : "" ));
- if (sb->s_dirt) {
- yaffs_GrossLock(dev);
- yaffs_FlushSuperBlock(sb,do_checkpoint);
- yaffs_GrossUnlock(dev);
+ yaffs_GrossLock(dev);
+ do_checkpoint = ((request_checkpoint && !gc_urgent) ||
+ oneshot_checkpoint) &&
+ !dev->isCheckpointed;
+ if (sb->s_dirt || do_checkpoint) {
+ yaffs_FlushSuperBlock(sb, !dev->isCheckpointed && do_checkpoint);
sb->s_dirt = 0;
+ if(oneshot_checkpoint)
+ yaffs_auto_checkpoint &= ~4;
}
+ yaffs_GrossUnlock(dev);
+
return 0;
}
*/
#ifdef YAFFS_COMPILE_BACKGROUND
+
+void yaffs_background_waker(unsigned long data)
+{
+ wake_up_process((struct task_struct *)data);
+}
+
static int yaffs_BackgroundThread(void *data)
{
yaffs_Device *dev = (yaffs_Device *)data;
struct yaffs_LinuxContext *context = yaffs_DeviceToContext(dev);
+ unsigned long now = jiffies;
+ unsigned long next_dir_update = now;
+ unsigned long next_gc = now;
+ unsigned long expires;
+ unsigned int urgency;
+
+ int gcResult;
+ struct timer_list timer;
T(YAFFS_TRACE_BACKGROUND,
("yaffs_background starting for dev %p\n",
(void *)dev));
-
+
+ set_freezable();
+
while(context->bgRunning){
T(YAFFS_TRACE_BACKGROUND,
("yaffs_background\n"));
if(kthread_should_stop())
break;
+
+ if(try_to_freeze())
+ continue;
+
yaffs_GrossLock(dev);
- yaffs_UpdateDirtyDirectories(dev);
+
+ now = jiffies;
+
+ if(time_after(now, next_dir_update)){
+ yaffs_UpdateDirtyDirectories(dev);
+ next_dir_update = now + HZ;
+ }
+
+ if(time_after(now,next_gc)){
+ if(!dev->isCheckpointed){
+ urgency = yaffs_bg_gc_urgency(dev);
+ gcResult = yaffs_BackgroundGarbageCollect(dev, urgency);
+ if(urgency > 1)
+ next_gc = now + HZ/20+1;
+ else if(urgency > 0)
+ next_gc = now + HZ/10+1;
+ else
+ next_gc = now + HZ * 2;
+ } else /*
+ * gc not running so set to next_dir_update
+ * to cut down on wake ups
+ */
+ next_gc = next_dir_update;
+ }
yaffs_GrossUnlock(dev);
- msleep(500);
+#if 1
+ expires = next_dir_update;
+ if (time_before(next_gc,expires))
+ expires = next_gc;
+ if(time_before(expires,now))
+ expires = now + HZ;
+
+ init_timer(&timer);
+ timer.expires = expires+1;
+ timer.data = (unsigned long) current;
+ timer.function = yaffs_background_waker;
+
+ set_current_state(TASK_INTERRUPTIBLE);
+ add_timer(&timer);
+ schedule();
+ del_timer_sync(&timer);
+#else
+ msleep(10);
+#endif
}
+
return 0;
}
static int yaffs_BackgroundStart(yaffs_Device *dev)
{
int retval = 0;
-
struct yaffs_LinuxContext *context = yaffs_DeviceToContext(dev);
context->bgRunning = 1;
- context->bgThread = kthread_run(yaffs_BackgroundThread,(void *)dev,"yaffs_%x",(unsigned)dev);
+ context->bgThread = kthread_run(yaffs_BackgroundThread,
+ (void *)dev,"yaffs-bg");
if(IS_ERR(context->bgThread)){
retval = PTR_ERR(context->bgThread);
static int yaffs_write_super(struct super_block *sb)
#endif
{
+ unsigned request_checkpoint = (yaffs_auto_checkpoint >= 2);
+
+ T(YAFFS_TRACE_OS | YAFFS_TRACE_SYNC | YAFFS_TRACE_BACKGROUND,
+ ("yaffs_write_super%s\n",
+ request_checkpoint ? " checkpt" : ""));
- T(YAFFS_TRACE_OS | YAFFS_TRACE_SYNC, ("yaffs_write_super\n"));
- yaffs_do_sync_fs(sb, yaffs_auto_checkpoint >= 2);
+ yaffs_do_sync_fs(sb, request_checkpoint);
#if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 18))
return 0;
static int yaffs_sync_fs(struct super_block *sb)
#endif
{
- T(YAFFS_TRACE_OS | YAFFS_TRACE_SYNC, ("yaffs_sync_fs\n"));
+ unsigned request_checkpoint = (yaffs_auto_checkpoint >= 1);
+
+ T(YAFFS_TRACE_OS | YAFFS_TRACE_SYNC,
+ ("yaffs_sync_fs%s\n",
+ request_checkpoint ? " checkpt" : ""));
- yaffs_do_sync_fs(sb,yaffs_auto_checkpoint >= 1);
+ yaffs_do_sync_fs(sb, request_checkpoint);
return 0;
}
T(YAFFS_TRACE_OS,
("yaffs_read_inode for %d\n", (int)inode->i_ino));
- yaffs_GrossLock(dev);
+ if(current != yaffs_DeviceToContext(dev)->readdirProcess)
+ yaffs_GrossLock(dev);
obj = yaffs_FindObjectByNumber(dev, inode->i_ino);
yaffs_FillInodeFromObject(inode, obj);
- yaffs_GrossUnlock(dev);
+ if(current != yaffs_DeviceToContext(dev)->readdirProcess)
+ yaffs_GrossUnlock(dev);
}
#endif
T(YAFFS_TRACE_OS, ("yaffs_put_super\n"));
+ T(YAFFS_TRACE_OS | YAFFS_TRACE_BACKGROUND, ("Shutting down yaffs background thread\n"));
+ yaffs_BackgroundStop(dev);
+ T(YAFFS_TRACE_OS | YAFFS_TRACE_BACKGROUND, ("yaffs background thread shut down\n"));
+
yaffs_GrossLock(dev);
yaffs_FlushSuperBlock(sb,1);
if (yaffs_DeviceToContext(dev)->putSuperFunc)
yaffs_DeviceToContext(dev)->putSuperFunc(sb);
- yaffs_BackgroundStop(dev);
yaffs_Deinitialise(dev);
sb->s_op = &yaffs_super_ops;
sb->s_flags |= MS_NOATIME;
+#ifdef YAFFS_COMPILE_EXPORTFS
+ sb->s_export_op = &yaffs_export_ops;
+#endif
+
if (!sb)
printk(KERN_INFO "yaffs: sb is NULL\n");
else if (!sb->s_dev)
#ifdef CONFIG_YAFFS_DISABLE_BLOCK_REFRESHING
param->refreshPeriod = 0;
#else
- param->refreshPeriod = 10000;
+ param->refreshPeriod = 100;
#endif
if(options.empty_lost_and_found_overridden)
yaffs_DeviceToContext(dev)->putSuperFunc = yaffs_MTDPutSuper;
param->markSuperBlockDirty = yaffs_MarkSuperBlockDirty;
+ param->gcControl = yaffs_gc_control_callback;
yaffs_DeviceToContext(dev)->superBlock= sb;
buf += sprintf(buf, "nPageReads......... %u\n", dev->nPageReads);
buf += sprintf(buf, "nBlockErasures..... %u\n", dev->nBlockErasures);
buf += sprintf(buf, "nGCCopies.......... %u\n", dev->nGCCopies);
- buf += sprintf(buf, "garbageCollections. %u\n", dev->garbageCollections);
- buf += sprintf(buf, "passiveGCs......... %u\n", dev->passiveGarbageCollections);
+ buf += sprintf(buf, "allGCs............. %u\n", dev->allGCs);
+ buf += sprintf(buf, "passiveGCs......... %u\n", dev->passiveGCs);
+ buf += sprintf(buf, "oldestDirtyGCs..... %u\n", dev->oldestDirtyGCs);
+ buf += sprintf(buf, "backgroundGCs...... %u\n", dev->backgroundGCs);
buf += sprintf(buf, "nRetriedWrites..... %u\n", dev->nRetriedWrites);
buf += sprintf(buf, "nRetireBlocks...... %u\n", dev->nRetiredBlocks);
buf += sprintf(buf, "eccFixed........... %u\n", dev->eccFixed);
{
struct ylist_head *item;
char *buf = page;
- int step = offset;
int n = 0;
down(&yaffs_context_lock);
ylist_for_each(item, &yaffs_context_list) {
struct yaffs_LinuxContext *dc = ylist_entry(item, struct yaffs_LinuxContext, contextList);
yaffs_Device *dev = dc->dev;
+
+ int erasedChunks;
+ int nObjects;
+ int nTnodes;
+
+ erasedChunks = dev->nErasedBlocks * dev->param.nChunksPerBlock;
+ nObjects = dev->nObjectsCreated -dev->nFreeObjects;
+ nTnodes = dev->nTnodesCreated - dev->nFreeTnodes;
+
- buf += sprintf(buf,"%d %u %u\n", n, dev->nFreeChunks, dev->nErasedBlocks * dev->param.nChunksPerBlock);
+ buf += sprintf(buf,"%d, %d, %d, %u, %u, %d, %d\n",
+ n, dev->nFreeChunks, erasedChunks,
+ dev->backgroundGCs, dev->oldestDirtyGCs,
+ nObjects, nTnodes);
}
up(&yaffs_context_lock);
" removing. \n"));
remove_proc_entry("yaffs", YPROC_ROOT);
+ remove_proc_entry("yaffs_debug", YPROC_ROOT);
fsinst = fs_to_install;
projects / yaffs2.git / blobdiff