49 	/* Pick an eraseblock to garbage collect next. This is where we'll  in jffs2_find_gc_block()
51 	/* We possibly want to favour the dirtier blocks more when the  in jffs2_find_gc_block()
105 	/* Have we accidentally picked a clean block with wasted space ? */  in jffs2_find_gc_block()
137 		/* We can't start doing GC yet. We haven't finished checking  in jffs2_garbage_collect_pass()
180 			/* We need to wait for it to finish, lest we move on  in jffs2_garbage_collect_pass()
181 			   and trigger the BUG() above while we haven't yet  in jffs2_garbage_collect_pass()
208 	/* First, work out which block we're garbage-collecting */  in jffs2_garbage_collect_pass()
252 		   we don't grok that has JFFS2_NODETYPE_RWCOMPAT_COPY, we should do so */  in jffs2_garbage_collect_pass()
261 	/* We need to hold the inocache. Either the erase_completion_lock or  in jffs2_garbage_collect_pass()
262 	   the inocache_lock are sufficient; we trade down since the inocache_lock  in jffs2_garbage_collect_pass()
271 	   1. Inode is already in-core. We must iget it and do proper  in jffs2_garbage_collect_pass()
273 	   2. Inode is not in-core, node is REF_PRISTINE. We lock the  in jffs2_garbage_collect_pass()
275 	   3. Inode is not in-core, node is not pristine. We must iget()  in jffs2_garbage_collect_pass()
282 		   We can just copy any pristine nodes, but have  in jffs2_garbage_collect_pass()
284 		   we're at it, so we set the state accordingly */  in jffs2_garbage_collect_pass()
300 		/* Should never happen. We should have finished checking  in jffs2_garbage_collect_pass()
301 		   by the time we actually start doing any GC, and since  in jffs2_garbage_collect_pass()
302 		   we're holding the alloc_sem, no other garbage collection  in jffs2_garbage_collect_pass()
312 		/* Someone's currently trying to read it. We must wait for  in jffs2_garbage_collect_pass()
315 		   the alloc_sem() (for marking nodes invalid) so we must  in jffs2_garbage_collect_pass()
322 		/* And because we dropped the alloc_sem we must start again from the  in jffs2_garbage_collect_pass()
323 		   beginning. Ponder chance of livelock here -- we're returning success  in jffs2_garbage_collect_pass()
327 		   again by the time we next enter this function? And that this happens  in jffs2_garbage_collect_pass()
335 	/* OK. Now if the inode is in state INO_STATE_GC, we are going to copy the  in jffs2_garbage_collect_pass()
336 	   node intact, and we don't have to muck about with the fragtree etc.  in jffs2_garbage_collect_pass()
337 	   because we know it's not in-core. If it _was_ in-core, we go through  in jffs2_garbage_collect_pass()
386 	/* If we've finished this block, start it erasing */  in jffs2_garbage_collect_pass()
392 		/* We're GC'ing an empty block? */  in jffs2_garbage_collect_pass()
414 	/* Now we have the lock for this inode. Check that it's still the one at the head  in jffs2_garbage_collect_live()
432 	/* OK. Looks safe. And nobody can get us now because we have the semaphore. Move the block */  in jffs2_garbage_collect_live()
447 				break; /* We've found them all */  in jffs2_garbage_collect_live()
460 		/* We found a datanode. Do the GC */  in jffs2_garbage_collect_live()
465 			/* It could still be a hole. But we GC the page this way anyway */  in jffs2_garbage_collect_live()
485 			printk(KERN_WARNING "But it's obsolete so we don't mind too much\n");  in jffs2_garbage_collect_live()
513 	/* Ask for a small amount of space (or the totlen if smaller) because we  in jffs2_garbage_collect_pristine()
522 		/* Doesn't fit untouched. We'll go the old route and split it */  in jffs2_garbage_collect_pristine()
648 	   state being INO_STATE_GC. Note that if we're doing this  in jffs2_garbage_collect_pristine()
680 		/* For these, we don't actually need to read the old node */  in jffs2_garbage_collect_metadata()
801 	/* On a medium where we can't actually mark nodes obsolete  in jffs2_garbage_collect_deletion_dirent()
802 	   pernamently, such as NAND flash, we need to work out  in jffs2_garbage_collect_deletion_dirent()
820 		   we're looking at them. I really don't like this extra lock but  in jffs2_garbage_collect_deletion_dirent()
826 			/* We only care about obsolete ones */  in jffs2_garbage_collect_deletion_dirent()
834 			/* Doesn't matter if there's one in the same erase block. We're going to  in jffs2_garbage_collect_deletion_dirent()
842 			   length. We need to take a closer look...*/  in jffs2_garbage_collect_deletion_dirent()
846 				/* If we can't read it, we don't need to continue to obsolete it. Continue */  in jffs2_garbage_collect_deletion_dirent()
871 			   the flash which our deletion dirent obsoletes. So we have to write out  in jffs2_garbage_collect_deletion_dirent()
921 		/* It's partially obsoleted by a later write. So we have to  in jffs2_garbage_collect_hole()
945 			/* FIXME: We could possibly deal with this by writing new holes for each frag */  in jffs2_garbage_collect_hole()
1012 	 * We should only get here in the case where the node we are  in jffs2_garbage_collect_hole()
1013 	 * replacing had more than one frag, so we kept the same version  in jffs2_garbage_collect_hole()
1074 		   to be dirty. Otherwise we end up with GC just going round in  in jffs2_garbage_collect_dnode()
1076 		   on NAND where we have small eraseblocks and hence a much higher  in jffs2_garbage_collect_dnode()
1139 		/* Find last frag which is actually part of the node we're to GC. */  in jffs2_garbage_collect_dnode()
1195 	/* Q: What happens if we actually try to GC the _same_ page for which commit_write()  in jffs2_garbage_collect_dnode()
1197 	 * A: I _think_ it's OK. read_cache_page shouldn't deadlock, we'll write out the  in jffs2_garbage_collect_dnode()
1198 	 *    page OK. We'll actually write it out again in commit_write, which is a little  in jffs2_garbage_collect_dnode()
1199 	 *    suboptimal, but at least we're correct.  in jffs2_garbage_collect_dnode()