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_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);
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_do_sync_fs: %s %s%s\n",
+ 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 || oneshot_checkpoint) {
- 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;
}
unsigned long next_dir_update = now;
unsigned long next_gc = now;
unsigned long expires;
+ unsigned int urgency;
int gcResult;
- unsigned int erasedChunks;
struct timer_list timer;
T(YAFFS_TRACE_BACKGROUND,
now = jiffies;
- if(time_after(now, next_dir_update) &&
- !dev->isCheckpointed){
+ if(time_after(now, next_dir_update)){
yaffs_UpdateDirtyDirectories(dev);
next_dir_update = now + HZ;
}
- if(time_after(now,next_gc) &&
- ! dev->isCheckpointed){
- gcResult = yaffs_BackgroundGarbageCollect(dev);
- erasedChunks = dev->nErasedBlocks * dev->param.nChunksPerBlock;
- if(erasedChunks < dev->nFreeChunks/4)
- next_gc = now + HZ/50+1;
- else if(erasedChunks < dev->nFreeChunks/2)
- next_gc = now + HZ/20+1;
- else
- next_gc = now + HZ * 2;
+ 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);
#if 1
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_write_super\n"));
- yaffs_do_sync_fs(sb, yaffs_auto_checkpoint >= 2);
+ T(YAFFS_TRACE_OS | YAFFS_TRACE_SYNC | YAFFS_TRACE_BACKGROUND,
+ ("yaffs_write_super%s\n",
+ request_checkpoint ? " checkpt" : ""));
+
+ 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;
}
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);
nTnodes = dev->nTnodesCreated - dev->nFreeTnodes;
- buf += sprintf(buf,"%d, %d, %d, %d, %d\n",
+ 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);
projects / yaffs2.git / blobdiff