1/*
2 * JFFS2 -- Journalling Flash File System, Version 2.
3 *
4 * Copyright © 2001-2007 Red Hat, Inc.
5 * Copyright © 2004-2010 David Woodhouse <dwmw2@infradead.org>
6 *
7 * Created by David Woodhouse <dwmw2@infradead.org>
8 *
9 * For licensing information, see the file 'LICENCE' in this directory.
10 *
11 */
12
13#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
14
15#include <linux/kernel.h>
16#include <linux/mtd/mtd.h>
17#include <linux/slab.h>
18#include <linux/pagemap.h>
19#include <linux/crc32.h>
20#include <linux/compiler.h>
21#include <linux/stat.h>
22#include "nodelist.h"
23#include "compr.h"
24
25static int jffs2_garbage_collect_pristine(struct jffs2_sb_info *c,
26					  struct jffs2_inode_cache *ic,
27					  struct jffs2_raw_node_ref *raw);
28static int jffs2_garbage_collect_metadata(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
29					struct jffs2_inode_info *f, struct jffs2_full_dnode *fd);
30static int jffs2_garbage_collect_dirent(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
31					struct jffs2_inode_info *f, struct jffs2_full_dirent *fd);
32static int jffs2_garbage_collect_deletion_dirent(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
33					struct jffs2_inode_info *f, struct jffs2_full_dirent *fd);
34static int jffs2_garbage_collect_hole(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
35				      struct jffs2_inode_info *f, struct jffs2_full_dnode *fn,
36				      uint32_t start, uint32_t end);
37static int jffs2_garbage_collect_dnode(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
38				       struct jffs2_inode_info *f, struct jffs2_full_dnode *fn,
39				       uint32_t start, uint32_t end);
40static int jffs2_garbage_collect_live(struct jffs2_sb_info *c,  struct jffs2_eraseblock *jeb,
41			       struct jffs2_raw_node_ref *raw, struct jffs2_inode_info *f);
42
43/* Called with erase_completion_lock held */
44static struct jffs2_eraseblock *jffs2_find_gc_block(struct jffs2_sb_info *c)
45{
46	struct jffs2_eraseblock *ret;
47	struct list_head *nextlist = NULL;
48	int n = jiffies % 128;
49
50	/* Pick an eraseblock to garbage collect next. This is where we'll
51	   put the clever wear-levelling algorithms. Eventually.  */
52	/* We possibly want to favour the dirtier blocks more when the
53	   number of free blocks is low. */
54again:
55	if (!list_empty(&c->bad_used_list) && c->nr_free_blocks > c->resv_blocks_gcbad) {
56		jffs2_dbg(1, "Picking block from bad_used_list to GC next\n");
57		nextlist = &c->bad_used_list;
58	} else if (n < 50 && !list_empty(&c->erasable_list)) {
59		/* Note that most of them will have gone directly to be erased.
60		   So don't favour the erasable_list _too_ much. */
61		jffs2_dbg(1, "Picking block from erasable_list to GC next\n");
62		nextlist = &c->erasable_list;
63	} else if (n < 110 && !list_empty(&c->very_dirty_list)) {
64		/* Most of the time, pick one off the very_dirty list */
65		jffs2_dbg(1, "Picking block from very_dirty_list to GC next\n");
66		nextlist = &c->very_dirty_list;
67	} else if (n < 126 && !list_empty(&c->dirty_list)) {
68		jffs2_dbg(1, "Picking block from dirty_list to GC next\n");
69		nextlist = &c->dirty_list;
70	} else if (!list_empty(&c->clean_list)) {
71		jffs2_dbg(1, "Picking block from clean_list to GC next\n");
72		nextlist = &c->clean_list;
73	} else if (!list_empty(&c->dirty_list)) {
74		jffs2_dbg(1, "Picking block from dirty_list to GC next (clean_list was empty)\n");
75
76		nextlist = &c->dirty_list;
77	} else if (!list_empty(&c->very_dirty_list)) {
78		jffs2_dbg(1, "Picking block from very_dirty_list to GC next (clean_list and dirty_list were empty)\n");
79		nextlist = &c->very_dirty_list;
80	} else if (!list_empty(&c->erasable_list)) {
81		jffs2_dbg(1, "Picking block from erasable_list to GC next (clean_list and {very_,}dirty_list were empty)\n");
82
83		nextlist = &c->erasable_list;
84	} else if (!list_empty(&c->erasable_pending_wbuf_list)) {
85		/* There are blocks are wating for the wbuf sync */
86		jffs2_dbg(1, "Synching wbuf in order to reuse erasable_pending_wbuf_list blocks\n");
87		spin_unlock(&c->erase_completion_lock);
88		jffs2_flush_wbuf_pad(c);
89		spin_lock(&c->erase_completion_lock);
90		goto again;
91	} else {
92		/* Eep. All were empty */
93		jffs2_dbg(1, "No clean, dirty _or_ erasable blocks to GC from! Where are they all?\n");
94		return NULL;
95	}
96
97	ret = list_entry(nextlist->next, struct jffs2_eraseblock, list);
98	list_del(&ret->list);
99	c->gcblock = ret;
100	ret->gc_node = ret->first_node;
101	if (!ret->gc_node) {
102		pr_warn("Eep. ret->gc_node for block at 0x%08x is NULL\n",
103			ret->offset);
104		BUG();
105	}
106
107	/* Have we accidentally picked a clean block with wasted space ? */
108	if (ret->wasted_size) {
109		jffs2_dbg(1, "Converting wasted_size %08x to dirty_size\n",
110			  ret->wasted_size);
111		ret->dirty_size += ret->wasted_size;
112		c->wasted_size -= ret->wasted_size;
113		c->dirty_size += ret->wasted_size;
114		ret->wasted_size = 0;
115	}
116
117	return ret;
118}
119
120/* jffs2_garbage_collect_pass
121 * Make a single attempt to progress GC. Move one node, and possibly
122 * start erasing one eraseblock.
123 */
124int jffs2_garbage_collect_pass(struct jffs2_sb_info *c)
125{
126	struct jffs2_inode_info *f;
127	struct jffs2_inode_cache *ic;
128	struct jffs2_eraseblock *jeb;
129	struct jffs2_raw_node_ref *raw;
130	uint32_t gcblock_dirty;
131	int ret = 0, inum, nlink;
132	int xattr = 0;
133
134	if (mutex_lock_interruptible(&c->alloc_sem))
135		return -EINTR;
136
137	for (;;) {
138		spin_lock(&c->erase_completion_lock);
139		if (!c->unchecked_size)
140			break;
141
142		/* We can't start doing GC yet. We haven't finished checking
143		   the node CRCs etc. Do it now. */
144
145		/* checked_ino is protected by the alloc_sem */
146		if (c->checked_ino > c->highest_ino && xattr) {
147			pr_crit("Checked all inodes but still 0x%x bytes of unchecked space?\n",
148				c->unchecked_size);
149			jffs2_dbg_dump_block_lists_nolock(c);
150			spin_unlock(&c->erase_completion_lock);
151			mutex_unlock(&c->alloc_sem);
152			return -ENOSPC;
153		}
154
155		spin_unlock(&c->erase_completion_lock);
156
157		if (!xattr)
158			xattr = jffs2_verify_xattr(c);
159
160		spin_lock(&c->inocache_lock);
161
162		ic = jffs2_get_ino_cache(c, c->checked_ino++);
163
164		if (!ic) {
165			spin_unlock(&c->inocache_lock);
166			continue;
167		}
168
169		if (!ic->pino_nlink) {
170			jffs2_dbg(1, "Skipping check of ino #%d with nlink/pino zero\n",
171				  ic->ino);
172			spin_unlock(&c->inocache_lock);
173			jffs2_xattr_delete_inode(c, ic);
174			continue;
175		}
176		switch(ic->state) {
177		case INO_STATE_CHECKEDABSENT:
178		case INO_STATE_PRESENT:
179			jffs2_dbg(1, "Skipping ino #%u already checked\n",
180				  ic->ino);
181			spin_unlock(&c->inocache_lock);
182			continue;
183
184		case INO_STATE_GC:
185		case INO_STATE_CHECKING:
186			pr_warn("Inode #%u is in state %d during CRC check phase!\n",
187				ic->ino, ic->state);
188			spin_unlock(&c->inocache_lock);
189			BUG();
190
191		case INO_STATE_READING:
192			/* We need to wait for it to finish, lest we move on
193			   and trigger the BUG() above while we haven't yet
194			   finished checking all its nodes */
195			jffs2_dbg(1, "Waiting for ino #%u to finish reading\n",
196				  ic->ino);
197			/* We need to come back again for the _same_ inode. We've
198			 made no progress in this case, but that should be OK */
199			c->checked_ino--;
200
201			mutex_unlock(&c->alloc_sem);
202			sleep_on_spinunlock(&c->inocache_wq, &c->inocache_lock);
203			return 0;
204
205		default:
206			BUG();
207
208		case INO_STATE_UNCHECKED:
209			;
210		}
211		ic->state = INO_STATE_CHECKING;
212		spin_unlock(&c->inocache_lock);
213
214		jffs2_dbg(1, "%s(): triggering inode scan of ino#%u\n",
215			  __func__, ic->ino);
216
217		ret = jffs2_do_crccheck_inode(c, ic);
218		if (ret)
219			pr_warn("Returned error for crccheck of ino #%u. Expect badness...\n",
220				ic->ino);
221
222		jffs2_set_inocache_state(c, ic, INO_STATE_CHECKEDABSENT);
223		mutex_unlock(&c->alloc_sem);
224		return ret;
225	}
226
227	/* If there are any blocks which need erasing, erase them now */
228	if (!list_empty(&c->erase_complete_list) ||
229	    !list_empty(&c->erase_pending_list)) {
230		spin_unlock(&c->erase_completion_lock);
231		mutex_unlock(&c->alloc_sem);
232		jffs2_dbg(1, "%s(): erasing pending blocks\n", __func__);
233		if (jffs2_erase_pending_blocks(c, 1))
234			return 0;
235
236		jffs2_dbg(1, "No progress from erasing block; doing GC anyway\n");
237		mutex_lock(&c->alloc_sem);
238		spin_lock(&c->erase_completion_lock);
239	}
240
241	/* First, work out which block we're garbage-collecting */
242	jeb = c->gcblock;
243
244	if (!jeb)
245		jeb = jffs2_find_gc_block(c);
246
247	if (!jeb) {
248		/* Couldn't find a free block. But maybe we can just erase one and make 'progress'? */
249		if (c->nr_erasing_blocks) {
250			spin_unlock(&c->erase_completion_lock);
251			mutex_unlock(&c->alloc_sem);
252			return -EAGAIN;
253		}
254		jffs2_dbg(1, "Couldn't find erase block to garbage collect!\n");
255		spin_unlock(&c->erase_completion_lock);
256		mutex_unlock(&c->alloc_sem);
257		return -EIO;
258	}
259
260	jffs2_dbg(1, "GC from block %08x, used_size %08x, dirty_size %08x, free_size %08x\n",
261		  jeb->offset, jeb->used_size, jeb->dirty_size, jeb->free_size);
262	D1(if (c->nextblock)
263	   printk(KERN_DEBUG "Nextblock at  %08x, used_size %08x, dirty_size %08x, wasted_size %08x, free_size %08x\n", c->nextblock->offset, c->nextblock->used_size, c->nextblock->dirty_size, c->nextblock->wasted_size, c->nextblock->free_size));
264
265	if (!jeb->used_size) {
266		mutex_unlock(&c->alloc_sem);
267		goto eraseit;
268	}
269
270	raw = jeb->gc_node;
271	gcblock_dirty = jeb->dirty_size;
272
273	while(ref_obsolete(raw)) {
274		jffs2_dbg(1, "Node at 0x%08x is obsolete... skipping\n",
275			  ref_offset(raw));
276		raw = ref_next(raw);
277		if (unlikely(!raw)) {
278			pr_warn("eep. End of raw list while still supposedly nodes to GC\n");
279			pr_warn("erase block at 0x%08x. free_size 0x%08x, dirty_size 0x%08x, used_size 0x%08x\n",
280				jeb->offset, jeb->free_size,
281				jeb->dirty_size, jeb->used_size);
282			jeb->gc_node = raw;
283			spin_unlock(&c->erase_completion_lock);
284			mutex_unlock(&c->alloc_sem);
285			BUG();
286		}
287	}
288	jeb->gc_node = raw;
289
290	jffs2_dbg(1, "Going to garbage collect node at 0x%08x\n",
291		  ref_offset(raw));
292
293	if (!raw->next_in_ino) {
294		/* Inode-less node. Clean marker, snapshot or something like that */
295		spin_unlock(&c->erase_completion_lock);
296		if (ref_flags(raw) == REF_PRISTINE) {
297			/* It's an unknown node with JFFS2_FEATURE_RWCOMPAT_COPY */
298			jffs2_garbage_collect_pristine(c, NULL, raw);
299		} else {
300			/* Just mark it obsolete */
301			jffs2_mark_node_obsolete(c, raw);
302		}
303		mutex_unlock(&c->alloc_sem);
304		goto eraseit_lock;
305	}
306
307	ic = jffs2_raw_ref_to_ic(raw);
308
309#ifdef CONFIG_JFFS2_FS_XATTR
310	/* When 'ic' refers xattr_datum/xattr_ref, this node is GCed as xattr.
311	 * We can decide whether this node is inode or xattr by ic->class.     */
312	if (ic->class == RAWNODE_CLASS_XATTR_DATUM
313	    || ic->class == RAWNODE_CLASS_XATTR_REF) {
314		spin_unlock(&c->erase_completion_lock);
315
316		if (ic->class == RAWNODE_CLASS_XATTR_DATUM) {
317			ret = jffs2_garbage_collect_xattr_datum(c, (struct jffs2_xattr_datum *)ic, raw);
318		} else {
319			ret = jffs2_garbage_collect_xattr_ref(c, (struct jffs2_xattr_ref *)ic, raw);
320		}
321		goto test_gcnode;
322	}
323#endif
324
325	/* We need to hold the inocache. Either the erase_completion_lock or
326	   the inocache_lock are sufficient; we trade down since the inocache_lock
327	   causes less contention. */
328	spin_lock(&c->inocache_lock);
329
330	spin_unlock(&c->erase_completion_lock);
331
332	jffs2_dbg(1, "%s(): collecting from block @0x%08x. Node @0x%08x(%d), ino #%u\n",
333		  __func__, jeb->offset, ref_offset(raw), ref_flags(raw),
334		  ic->ino);
335
336	/* Three possibilities:
337	   1. Inode is already in-core. We must iget it and do proper
338	      updating to its fragtree, etc.
339	   2. Inode is not in-core, node is REF_PRISTINE. We lock the
340	      inocache to prevent a read_inode(), copy the node intact.
341	   3. Inode is not in-core, node is not pristine. We must iget()
342	      and take the slow path.
343	*/
344
345	switch(ic->state) {
346	case INO_STATE_CHECKEDABSENT:
347		/* It's been checked, but it's not currently in-core.
348		   We can just copy any pristine nodes, but have
349		   to prevent anyone else from doing read_inode() while
350		   we're at it, so we set the state accordingly */
351		if (ref_flags(raw) == REF_PRISTINE)
352			ic->state = INO_STATE_GC;
353		else {
354			jffs2_dbg(1, "Ino #%u is absent but node not REF_PRISTINE. Reading.\n",
355				  ic->ino);
356		}
357		break;
358
359	case INO_STATE_PRESENT:
360		/* It's in-core. GC must iget() it. */
361		break;
362
363	case INO_STATE_UNCHECKED:
364	case INO_STATE_CHECKING:
365	case INO_STATE_GC:
366		/* Should never happen. We should have finished checking
367		   by the time we actually start doing any GC, and since
368		   we're holding the alloc_sem, no other garbage collection
369		   can happen.
370		*/
371		pr_crit("Inode #%u already in state %d in jffs2_garbage_collect_pass()!\n",
372			ic->ino, ic->state);
373		mutex_unlock(&c->alloc_sem);
374		spin_unlock(&c->inocache_lock);
375		BUG();
376
377	case INO_STATE_READING:
378		/* Someone's currently trying to read it. We must wait for
379		   them to finish and then go through the full iget() route
380		   to do the GC. However, sometimes read_inode() needs to get
381		   the alloc_sem() (for marking nodes invalid) so we must
382		   drop the alloc_sem before sleeping. */
383
384		mutex_unlock(&c->alloc_sem);
385		jffs2_dbg(1, "%s(): waiting for ino #%u in state %d\n",
386			  __func__, ic->ino, ic->state);
387		sleep_on_spinunlock(&c->inocache_wq, &c->inocache_lock);
388		/* And because we dropped the alloc_sem we must start again from the
389		   beginning. Ponder chance of livelock here -- we're returning success
390		   without actually making any progress.
391
392		   Q: What are the chances that the inode is back in INO_STATE_READING
393		   again by the time we next enter this function? And that this happens
394		   enough times to cause a real delay?
395
396		   A: Small enough that I don't care :)
397		*/
398		return 0;
399	}
400
401	/* OK. Now if the inode is in state INO_STATE_GC, we are going to copy the
402	   node intact, and we don't have to muck about with the fragtree etc.
403	   because we know it's not in-core. If it _was_ in-core, we go through
404	   all the iget() crap anyway */
405
406	if (ic->state == INO_STATE_GC) {
407		spin_unlock(&c->inocache_lock);
408
409		ret = jffs2_garbage_collect_pristine(c, ic, raw);
410
411		spin_lock(&c->inocache_lock);
412		ic->state = INO_STATE_CHECKEDABSENT;
413		wake_up(&c->inocache_wq);
414
415		if (ret != -EBADFD) {
416			spin_unlock(&c->inocache_lock);
417			goto test_gcnode;
418		}
419
420		/* Fall through if it wanted us to, with inocache_lock held */
421	}
422
423	/* Prevent the fairly unlikely race where the gcblock is
424	   entirely obsoleted by the final close of a file which had
425	   the only valid nodes in the block, followed by erasure,
426	   followed by freeing of the ic because the erased block(s)
427	   held _all_ the nodes of that inode.... never been seen but
428	   it's vaguely possible. */
429
430	inum = ic->ino;
431	nlink = ic->pino_nlink;
432	spin_unlock(&c->inocache_lock);
433
434	f = jffs2_gc_fetch_inode(c, inum, !nlink);
435	if (IS_ERR(f)) {
436		ret = PTR_ERR(f);
437		goto release_sem;
438	}
439	if (!f) {
440		ret = 0;
441		goto release_sem;
442	}
443
444	ret = jffs2_garbage_collect_live(c, jeb, raw, f);
445
446	jffs2_gc_release_inode(c, f);
447
448 test_gcnode:
449	if (jeb->dirty_size == gcblock_dirty && !ref_obsolete(jeb->gc_node)) {
450		/* Eep. This really should never happen. GC is broken */
451		pr_err("Error garbage collecting node at %08x!\n",
452		       ref_offset(jeb->gc_node));
453		ret = -ENOSPC;
454	}
455 release_sem:
456	mutex_unlock(&c->alloc_sem);
457
458 eraseit_lock:
459	/* If we've finished this block, start it erasing */
460	spin_lock(&c->erase_completion_lock);
461
462 eraseit:
463	if (c->gcblock && !c->gcblock->used_size) {
464		jffs2_dbg(1, "Block at 0x%08x completely obsoleted by GC. Moving to erase_pending_list\n",
465			  c->gcblock->offset);
466		/* We're GC'ing an empty block? */
467		list_add_tail(&c->gcblock->list, &c->erase_pending_list);
468		c->gcblock = NULL;
469		c->nr_erasing_blocks++;
470		jffs2_garbage_collect_trigger(c);
471	}
472	spin_unlock(&c->erase_completion_lock);
473
474	return ret;
475}
476
477static int jffs2_garbage_collect_live(struct jffs2_sb_info *c,  struct jffs2_eraseblock *jeb,
478				      struct jffs2_raw_node_ref *raw, struct jffs2_inode_info *f)
479{
480	struct jffs2_node_frag *frag;
481	struct jffs2_full_dnode *fn = NULL;
482	struct jffs2_full_dirent *fd;
483	uint32_t start = 0, end = 0, nrfrags = 0;
484	int ret = 0;
485
486	mutex_lock(&f->sem);
487
488	/* Now we have the lock for this inode. Check that it's still the one at the head
489	   of the list. */
490
491	spin_lock(&c->erase_completion_lock);
492
493	if (c->gcblock != jeb) {
494		spin_unlock(&c->erase_completion_lock);
495		jffs2_dbg(1, "GC block is no longer gcblock. Restart\n");
496		goto upnout;
497	}
498	if (ref_obsolete(raw)) {
499		spin_unlock(&c->erase_completion_lock);
500		jffs2_dbg(1, "node to be GC'd was obsoleted in the meantime.\n");
501		/* They'll call again */
502		goto upnout;
503	}
504	spin_unlock(&c->erase_completion_lock);
505
506	/* OK. Looks safe. And nobody can get us now because we have the semaphore. Move the block */
507	if (f->metadata && f->metadata->raw == raw) {
508		fn = f->metadata;
509		ret = jffs2_garbage_collect_metadata(c, jeb, f, fn);
510		goto upnout;
511	}
512
513	/* FIXME. Read node and do lookup? */
514	for (frag = frag_first(&f->fragtree); frag; frag = frag_next(frag)) {
515		if (frag->node && frag->node->raw == raw) {
516			fn = frag->node;
517			end = frag->ofs + frag->size;
518			if (!nrfrags++)
519				start = frag->ofs;
520			if (nrfrags == frag->node->frags)
521				break; /* We've found them all */
522		}
523	}
524	if (fn) {
525		if (ref_flags(raw) == REF_PRISTINE) {
526			ret = jffs2_garbage_collect_pristine(c, f->inocache, raw);
527			if (!ret) {
528				/* Urgh. Return it sensibly. */
529				frag->node->raw = f->inocache->nodes;
530			}
531			if (ret != -EBADFD)
532				goto upnout;
533		}
534		/* We found a datanode. Do the GC */
535		if((start >> PAGE_CACHE_SHIFT) < ((end-1) >> PAGE_CACHE_SHIFT)) {
536			/* It crosses a page boundary. Therefore, it must be a hole. */
537			ret = jffs2_garbage_collect_hole(c, jeb, f, fn, start, end);
538		} else {
539			/* It could still be a hole. But we GC the page this way anyway */
540			ret = jffs2_garbage_collect_dnode(c, jeb, f, fn, start, end);
541		}
542		goto upnout;
543	}
544
545	/* Wasn't a dnode. Try dirent */
546	for (fd = f->dents; fd; fd=fd->next) {
547		if (fd->raw == raw)
548			break;
549	}
550
551	if (fd && fd->ino) {
552		ret = jffs2_garbage_collect_dirent(c, jeb, f, fd);
553	} else if (fd) {
554		ret = jffs2_garbage_collect_deletion_dirent(c, jeb, f, fd);
555	} else {
556		pr_warn("Raw node at 0x%08x wasn't in node lists for ino #%u\n",
557			ref_offset(raw), f->inocache->ino);
558		if (ref_obsolete(raw)) {
559			pr_warn("But it's obsolete so we don't mind too much\n");
560		} else {
561			jffs2_dbg_dump_node(c, ref_offset(raw));
562			BUG();
563		}
564	}
565 upnout:
566	mutex_unlock(&f->sem);
567
568	return ret;
569}
570
571static int jffs2_garbage_collect_pristine(struct jffs2_sb_info *c,
572					  struct jffs2_inode_cache *ic,
573					  struct jffs2_raw_node_ref *raw)
574{
575	union jffs2_node_union *node;
576	size_t retlen;
577	int ret;
578	uint32_t phys_ofs, alloclen;
579	uint32_t crc, rawlen;
580	int retried = 0;
581
582	jffs2_dbg(1, "Going to GC REF_PRISTINE node at 0x%08x\n",
583		  ref_offset(raw));
584
585	alloclen = rawlen = ref_totlen(c, c->gcblock, raw);
586
587	/* Ask for a small amount of space (or the totlen if smaller) because we
588	   don't want to force wastage of the end of a block if splitting would
589	   work. */
590	if (ic && alloclen > sizeof(struct jffs2_raw_inode) + JFFS2_MIN_DATA_LEN)
591		alloclen = sizeof(struct jffs2_raw_inode) + JFFS2_MIN_DATA_LEN;
592
593	ret = jffs2_reserve_space_gc(c, alloclen, &alloclen, rawlen);
594	/* 'rawlen' is not the exact summary size; it is only an upper estimation */
595
596	if (ret)
597		return ret;
598
599	if (alloclen < rawlen) {
600		/* Doesn't fit untouched. We'll go the old route and split it */
601		return -EBADFD;
602	}
603
604	node = kmalloc(rawlen, GFP_KERNEL);
605	if (!node)
606		return -ENOMEM;
607
608	ret = jffs2_flash_read(c, ref_offset(raw), rawlen, &retlen, (char *)node);
609	if (!ret && retlen != rawlen)
610		ret = -EIO;
611	if (ret)
612		goto out_node;
613
614	crc = crc32(0, node, sizeof(struct jffs2_unknown_node)-4);
615	if (je32_to_cpu(node->u.hdr_crc) != crc) {
616		pr_warn("Header CRC failed on REF_PRISTINE node at 0x%08x: Read 0x%08x, calculated 0x%08x\n",
617			ref_offset(raw), je32_to_cpu(node->u.hdr_crc), crc);
618		goto bail;
619	}
620
621	switch(je16_to_cpu(node->u.nodetype)) {
622	case JFFS2_NODETYPE_INODE:
623		crc = crc32(0, node, sizeof(node->i)-8);
624		if (je32_to_cpu(node->i.node_crc) != crc) {
625			pr_warn("Node CRC failed on REF_PRISTINE data node at 0x%08x: Read 0x%08x, calculated 0x%08x\n",
626				ref_offset(raw), je32_to_cpu(node->i.node_crc),
627				crc);
628			goto bail;
629		}
630
631		if (je32_to_cpu(node->i.dsize)) {
632			crc = crc32(0, node->i.data, je32_to_cpu(node->i.csize));
633			if (je32_to_cpu(node->i.data_crc) != crc) {
634				pr_warn("Data CRC failed on REF_PRISTINE data node at 0x%08x: Read 0x%08x, calculated 0x%08x\n",
635					ref_offset(raw),
636					je32_to_cpu(node->i.data_crc), crc);
637				goto bail;
638			}
639		}
640		break;
641
642	case JFFS2_NODETYPE_DIRENT:
643		crc = crc32(0, node, sizeof(node->d)-8);
644		if (je32_to_cpu(node->d.node_crc) != crc) {
645			pr_warn("Node CRC failed on REF_PRISTINE dirent node at 0x%08x: Read 0x%08x, calculated 0x%08x\n",
646				ref_offset(raw),
647				je32_to_cpu(node->d.node_crc), crc);
648			goto bail;
649		}
650
651		if (strnlen(node->d.name, node->d.nsize) != node->d.nsize) {
652			pr_warn("Name in dirent node at 0x%08x contains zeroes\n",
653				ref_offset(raw));
654			goto bail;
655		}
656
657		if (node->d.nsize) {
658			crc = crc32(0, node->d.name, node->d.nsize);
659			if (je32_to_cpu(node->d.name_crc) != crc) {
660				pr_warn("Name CRC failed on REF_PRISTINE dirent node at 0x%08x: Read 0x%08x, calculated 0x%08x\n",
661					ref_offset(raw),
662					je32_to_cpu(node->d.name_crc), crc);
663				goto bail;
664			}
665		}
666		break;
667	default:
668		/* If it's inode-less, we don't _know_ what it is. Just copy it intact */
669		if (ic) {
670			pr_warn("Unknown node type for REF_PRISTINE node at 0x%08x: 0x%04x\n",
671				ref_offset(raw), je16_to_cpu(node->u.nodetype));
672			goto bail;
673		}
674	}
675
676	/* OK, all the CRCs are good; this node can just be copied as-is. */
677 retry:
678	phys_ofs = write_ofs(c);
679
680	ret = jffs2_flash_write(c, phys_ofs, rawlen, &retlen, (char *)node);
681
682	if (ret || (retlen != rawlen)) {
683		pr_notice("Write of %d bytes at 0x%08x failed. returned %d, retlen %zd\n",
684			  rawlen, phys_ofs, ret, retlen);
685		if (retlen) {
686			jffs2_add_physical_node_ref(c, phys_ofs | REF_OBSOLETE, rawlen, NULL);
687		} else {
688			pr_notice("Not marking the space at 0x%08x as dirty because the flash driver returned retlen zero\n",
689				  phys_ofs);
690		}
691		if (!retried) {
692			/* Try to reallocate space and retry */
693			uint32_t dummy;
694			struct jffs2_eraseblock *jeb = &c->blocks[phys_ofs / c->sector_size];
695
696			retried = 1;
697
698			jffs2_dbg(1, "Retrying failed write of REF_PRISTINE node.\n");
699
700			jffs2_dbg_acct_sanity_check(c,jeb);
701			jffs2_dbg_acct_paranoia_check(c, jeb);
702
703			ret = jffs2_reserve_space_gc(c, rawlen, &dummy, rawlen);
704						/* this is not the exact summary size of it,
705							it is only an upper estimation */
706
707			if (!ret) {
708				jffs2_dbg(1, "Allocated space at 0x%08x to retry failed write.\n",
709					  phys_ofs);
710
711				jffs2_dbg_acct_sanity_check(c,jeb);
712				jffs2_dbg_acct_paranoia_check(c, jeb);
713
714				goto retry;
715			}
716			jffs2_dbg(1, "Failed to allocate space to retry failed write: %d!\n",
717				  ret);
718		}
719
720		if (!ret)
721			ret = -EIO;
722		goto out_node;
723	}
724	jffs2_add_physical_node_ref(c, phys_ofs | REF_PRISTINE, rawlen, ic);
725
726	jffs2_mark_node_obsolete(c, raw);
727	jffs2_dbg(1, "WHEEE! GC REF_PRISTINE node at 0x%08x succeeded\n",
728		  ref_offset(raw));
729
730 out_node:
731	kfree(node);
732	return ret;
733 bail:
734	ret = -EBADFD;
735	goto out_node;
736}
737
738static int jffs2_garbage_collect_metadata(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
739					struct jffs2_inode_info *f, struct jffs2_full_dnode *fn)
740{
741	struct jffs2_full_dnode *new_fn;
742	struct jffs2_raw_inode ri;
743	struct jffs2_node_frag *last_frag;
744	union jffs2_device_node dev;
745	char *mdata = NULL;
746	int mdatalen = 0;
747	uint32_t alloclen, ilen;
748	int ret;
749
750	if (S_ISBLK(JFFS2_F_I_MODE(f)) ||
751	    S_ISCHR(JFFS2_F_I_MODE(f)) ) {
752		/* For these, we don't actually need to read the old node */
753		mdatalen = jffs2_encode_dev(&dev, JFFS2_F_I_RDEV(f));
754		mdata = (char *)&dev;
755		jffs2_dbg(1, "%s(): Writing %d bytes of kdev_t\n",
756			  __func__, mdatalen);
757	} else if (S_ISLNK(JFFS2_F_I_MODE(f))) {
758		mdatalen = fn->size;
759		mdata = kmalloc(fn->size, GFP_KERNEL);
760		if (!mdata) {
761			pr_warn("kmalloc of mdata failed in jffs2_garbage_collect_metadata()\n");
762			return -ENOMEM;
763		}
764		ret = jffs2_read_dnode(c, f, fn, mdata, 0, mdatalen);
765		if (ret) {
766			pr_warn("read of old metadata failed in jffs2_garbage_collect_metadata(): %d\n",
767				ret);
768			kfree(mdata);
769			return ret;
770		}
771		jffs2_dbg(1, "%s(): Writing %d bites of symlink target\n",
772			  __func__, mdatalen);
773
774	}
775
776	ret = jffs2_reserve_space_gc(c, sizeof(ri) + mdatalen, &alloclen,
777				JFFS2_SUMMARY_INODE_SIZE);
778	if (ret) {
779		pr_warn("jffs2_reserve_space_gc of %zd bytes for garbage_collect_metadata failed: %d\n",
780			sizeof(ri) + mdatalen, ret);
781		goto out;
782	}
783
784	last_frag = frag_last(&f->fragtree);
785	if (last_frag)
786		/* Fetch the inode length from the fragtree rather then
787		 * from i_size since i_size may have not been updated yet */
788		ilen = last_frag->ofs + last_frag->size;
789	else
790		ilen = JFFS2_F_I_SIZE(f);
791
792	memset(&ri, 0, sizeof(ri));
793	ri.magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
794	ri.nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE);
795	ri.totlen = cpu_to_je32(sizeof(ri) + mdatalen);
796	ri.hdr_crc = cpu_to_je32(crc32(0, &ri, sizeof(struct jffs2_unknown_node)-4));
797
798	ri.ino = cpu_to_je32(f->inocache->ino);
799	ri.version = cpu_to_je32(++f->highest_version);
800	ri.mode = cpu_to_jemode(JFFS2_F_I_MODE(f));
801	ri.uid = cpu_to_je16(JFFS2_F_I_UID(f));
802	ri.gid = cpu_to_je16(JFFS2_F_I_GID(f));
803	ri.isize = cpu_to_je32(ilen);
804	ri.atime = cpu_to_je32(JFFS2_F_I_ATIME(f));
805	ri.ctime = cpu_to_je32(JFFS2_F_I_CTIME(f));
806	ri.mtime = cpu_to_je32(JFFS2_F_I_MTIME(f));
807	ri.offset = cpu_to_je32(0);
808	ri.csize = cpu_to_je32(mdatalen);
809	ri.dsize = cpu_to_je32(mdatalen);
810	ri.compr = JFFS2_COMPR_NONE;
811	ri.node_crc = cpu_to_je32(crc32(0, &ri, sizeof(ri)-8));
812	ri.data_crc = cpu_to_je32(crc32(0, mdata, mdatalen));
813
814	new_fn = jffs2_write_dnode(c, f, &ri, mdata, mdatalen, ALLOC_GC);
815
816	if (IS_ERR(new_fn)) {
817		pr_warn("Error writing new dnode: %ld\n", PTR_ERR(new_fn));
818		ret = PTR_ERR(new_fn);
819		goto out;
820	}
821	jffs2_mark_node_obsolete(c, fn->raw);
822	jffs2_free_full_dnode(fn);
823	f->metadata = new_fn;
824 out:
825	if (S_ISLNK(JFFS2_F_I_MODE(f)))
826		kfree(mdata);
827	return ret;
828}
829
830static int jffs2_garbage_collect_dirent(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
831					struct jffs2_inode_info *f, struct jffs2_full_dirent *fd)
832{
833	struct jffs2_full_dirent *new_fd;
834	struct jffs2_raw_dirent rd;
835	uint32_t alloclen;
836	int ret;
837
838	rd.magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
839	rd.nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT);
840	rd.nsize = strlen(fd->name);
841	rd.totlen = cpu_to_je32(sizeof(rd) + rd.nsize);
842	rd.hdr_crc = cpu_to_je32(crc32(0, &rd, sizeof(struct jffs2_unknown_node)-4));
843
844	rd.pino = cpu_to_je32(f->inocache->ino);
845	rd.version = cpu_to_je32(++f->highest_version);
846	rd.ino = cpu_to_je32(fd->ino);
847	/* If the times on this inode were set by explicit utime() they can be different,
848	   so refrain from splatting them. */
849	if (JFFS2_F_I_MTIME(f) == JFFS2_F_I_CTIME(f))
850		rd.mctime = cpu_to_je32(JFFS2_F_I_MTIME(f));
851	else
852		rd.mctime = cpu_to_je32(0);
853	rd.type = fd->type;
854	rd.node_crc = cpu_to_je32(crc32(0, &rd, sizeof(rd)-8));
855	rd.name_crc = cpu_to_je32(crc32(0, fd->name, rd.nsize));
856
857	ret = jffs2_reserve_space_gc(c, sizeof(rd)+rd.nsize, &alloclen,
858				JFFS2_SUMMARY_DIRENT_SIZE(rd.nsize));
859	if (ret) {
860		pr_warn("jffs2_reserve_space_gc of %zd bytes for garbage_collect_dirent failed: %d\n",
861			sizeof(rd)+rd.nsize, ret);
862		return ret;
863	}
864	new_fd = jffs2_write_dirent(c, f, &rd, fd->name, rd.nsize, ALLOC_GC);
865
866	if (IS_ERR(new_fd)) {
867		pr_warn("jffs2_write_dirent in garbage_collect_dirent failed: %ld\n",
868			PTR_ERR(new_fd));
869		return PTR_ERR(new_fd);
870	}
871	jffs2_add_fd_to_list(c, new_fd, &f->dents);
872	return 0;
873}
874
875static int jffs2_garbage_collect_deletion_dirent(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
876					struct jffs2_inode_info *f, struct jffs2_full_dirent *fd)
877{
878	struct jffs2_full_dirent **fdp = &f->dents;
879	int found = 0;
880
881	/* On a medium where we can't actually mark nodes obsolete
882	   pernamently, such as NAND flash, we need to work out
883	   whether this deletion dirent is still needed to actively
884	   delete a 'real' dirent with the same name that's still
885	   somewhere else on the flash. */
886	if (!jffs2_can_mark_obsolete(c)) {
887		struct jffs2_raw_dirent *rd;
888		struct jffs2_raw_node_ref *raw;
889		int ret;
890		size_t retlen;
891		int name_len = strlen(fd->name);
892		uint32_t name_crc = crc32(0, fd->name, name_len);
893		uint32_t rawlen = ref_totlen(c, jeb, fd->raw);
894
895		rd = kmalloc(rawlen, GFP_KERNEL);
896		if (!rd)
897			return -ENOMEM;
898
899		/* Prevent the erase code from nicking the obsolete node refs while
900		   we're looking at them. I really don't like this extra lock but
901		   can't see any alternative. Suggestions on a postcard to... */
902		mutex_lock(&c->erase_free_sem);
903
904		for (raw = f->inocache->nodes; raw != (void *)f->inocache; raw = raw->next_in_ino) {
905
906			cond_resched();
907
908			/* We only care about obsolete ones */
909			if (!(ref_obsolete(raw)))
910				continue;
911
912			/* Any dirent with the same name is going to have the same length... */
913			if (ref_totlen(c, NULL, raw) != rawlen)
914				continue;
915
916			/* Doesn't matter if there's one in the same erase block. We're going to
917			   delete it too at the same time. */
918			if (SECTOR_ADDR(raw->flash_offset) == SECTOR_ADDR(fd->raw->flash_offset))
919				continue;
920
921			jffs2_dbg(1, "Check potential deletion dirent at %08x\n",
922				  ref_offset(raw));
923
924			/* This is an obsolete node belonging to the same directory, and it's of the right
925			   length. We need to take a closer look...*/
926			ret = jffs2_flash_read(c, ref_offset(raw), rawlen, &retlen, (char *)rd);
927			if (ret) {
928				pr_warn("%s(): Read error (%d) reading obsolete node at %08x\n",
929					__func__, ret, ref_offset(raw));
930				/* If we can't read it, we don't need to continue to obsolete it. Continue */
931				continue;
932			}
933			if (retlen != rawlen) {
934				pr_warn("%s(): Short read (%zd not %u) reading header from obsolete node at %08x\n",
935					__func__, retlen, rawlen,
936					ref_offset(raw));
937				continue;
938			}
939
940			if (je16_to_cpu(rd->nodetype) != JFFS2_NODETYPE_DIRENT)
941				continue;
942
943			/* If the name CRC doesn't match, skip */
944			if (je32_to_cpu(rd->name_crc) != name_crc)
945				continue;
946
947			/* If the name length doesn't match, or it's another deletion dirent, skip */
948			if (rd->nsize != name_len || !je32_to_cpu(rd->ino))
949				continue;
950
951			/* OK, check the actual name now */
952			if (memcmp(rd->name, fd->name, name_len))
953				continue;
954
955			/* OK. The name really does match. There really is still an older node on
956			   the flash which our deletion dirent obsoletes. So we have to write out
957			   a new deletion dirent to replace it */
958			mutex_unlock(&c->erase_free_sem);
959
960			jffs2_dbg(1, "Deletion dirent at %08x still obsoletes real dirent \"%s\" at %08x for ino #%u\n",
961				  ref_offset(fd->raw), fd->name,
962				  ref_offset(raw), je32_to_cpu(rd->ino));
963			kfree(rd);
964
965			return jffs2_garbage_collect_dirent(c, jeb, f, fd);
966		}
967
968		mutex_unlock(&c->erase_free_sem);
969		kfree(rd);
970	}
971
972	/* FIXME: If we're deleting a dirent which contains the current mtime and ctime,
973	   we should update the metadata node with those times accordingly */
974
975	/* No need for it any more. Just mark it obsolete and remove it from the list */
976	while (*fdp) {
977		if ((*fdp) == fd) {
978			found = 1;
979			*fdp = fd->next;
980			break;
981		}
982		fdp = &(*fdp)->next;
983	}
984	if (!found) {
985		pr_warn("Deletion dirent \"%s\" not found in list for ino #%u\n",
986			fd->name, f->inocache->ino);
987	}
988	jffs2_mark_node_obsolete(c, fd->raw);
989	jffs2_free_full_dirent(fd);
990	return 0;
991}
992
993static int jffs2_garbage_collect_hole(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
994				      struct jffs2_inode_info *f, struct jffs2_full_dnode *fn,
995				      uint32_t start, uint32_t end)
996{
997	struct jffs2_raw_inode ri;
998	struct jffs2_node_frag *frag;
999	struct jffs2_full_dnode *new_fn;
1000	uint32_t alloclen, ilen;
1001	int ret;
1002
1003	jffs2_dbg(1, "Writing replacement hole node for ino #%u from offset 0x%x to 0x%x\n",
1004		  f->inocache->ino, start, end);
1005
1006	memset(&ri, 0, sizeof(ri));
1007
1008	if(fn->frags > 1) {
1009		size_t readlen;
1010		uint32_t crc;
1011		/* It's partially obsoleted by a later write. So we have to
1012		   write it out again with the _same_ version as before */
1013		ret = jffs2_flash_read(c, ref_offset(fn->raw), sizeof(ri), &readlen, (char *)&ri);
1014		if (readlen != sizeof(ri) || ret) {
1015			pr_warn("Node read failed in jffs2_garbage_collect_hole. Ret %d, retlen %zd. Data will be lost by writing new hole node\n",
1016				ret, readlen);
1017			goto fill;
1018		}
1019		if (je16_to_cpu(ri.nodetype) != JFFS2_NODETYPE_INODE) {
1020			pr_warn("%s(): Node at 0x%08x had node type 0x%04x instead of JFFS2_NODETYPE_INODE(0x%04x)\n",
1021				__func__, ref_offset(fn->raw),
1022				je16_to_cpu(ri.nodetype), JFFS2_NODETYPE_INODE);
1023			return -EIO;
1024		}
1025		if (je32_to_cpu(ri.totlen) != sizeof(ri)) {
1026			pr_warn("%s(): Node at 0x%08x had totlen 0x%x instead of expected 0x%zx\n",
1027				__func__, ref_offset(fn->raw),
1028				je32_to_cpu(ri.totlen), sizeof(ri));
1029			return -EIO;
1030		}
1031		crc = crc32(0, &ri, sizeof(ri)-8);
1032		if (crc != je32_to_cpu(ri.node_crc)) {
1033			pr_warn("%s: Node at 0x%08x had CRC 0x%08x which doesn't match calculated CRC 0x%08x\n",
1034				__func__, ref_offset(fn->raw),
1035				je32_to_cpu(ri.node_crc), crc);
1036			/* FIXME: We could possibly deal with this by writing new holes for each frag */
1037			pr_warn("Data in the range 0x%08x to 0x%08x of inode #%u will be lost\n",
1038				start, end, f->inocache->ino);
1039			goto fill;
1040		}
1041		if (ri.compr != JFFS2_COMPR_ZERO) {
1042			pr_warn("%s(): Node 0x%08x wasn't a hole node!\n",
1043				__func__, ref_offset(fn->raw));
1044			pr_warn("Data in the range 0x%08x to 0x%08x of inode #%u will be lost\n",
1045				start, end, f->inocache->ino);
1046			goto fill;
1047		}
1048	} else {
1049	fill:
1050		ri.magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
1051		ri.nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE);
1052		ri.totlen = cpu_to_je32(sizeof(ri));
1053		ri.hdr_crc = cpu_to_je32(crc32(0, &ri, sizeof(struct jffs2_unknown_node)-4));
1054
1055		ri.ino = cpu_to_je32(f->inocache->ino);
1056		ri.version = cpu_to_je32(++f->highest_version);
1057		ri.offset = cpu_to_je32(start);
1058		ri.dsize = cpu_to_je32(end - start);
1059		ri.csize = cpu_to_je32(0);
1060		ri.compr = JFFS2_COMPR_ZERO;
1061	}
1062
1063	frag = frag_last(&f->fragtree);
1064	if (frag)
1065		/* Fetch the inode length from the fragtree rather then
1066		 * from i_size since i_size may have not been updated yet */
1067		ilen = frag->ofs + frag->size;
1068	else
1069		ilen = JFFS2_F_I_SIZE(f);
1070
1071	ri.mode = cpu_to_jemode(JFFS2_F_I_MODE(f));
1072	ri.uid = cpu_to_je16(JFFS2_F_I_UID(f));
1073	ri.gid = cpu_to_je16(JFFS2_F_I_GID(f));
1074	ri.isize = cpu_to_je32(ilen);
1075	ri.atime = cpu_to_je32(JFFS2_F_I_ATIME(f));
1076	ri.ctime = cpu_to_je32(JFFS2_F_I_CTIME(f));
1077	ri.mtime = cpu_to_je32(JFFS2_F_I_MTIME(f));
1078	ri.data_crc = cpu_to_je32(0);
1079	ri.node_crc = cpu_to_je32(crc32(0, &ri, sizeof(ri)-8));
1080
1081	ret = jffs2_reserve_space_gc(c, sizeof(ri), &alloclen,
1082				     JFFS2_SUMMARY_INODE_SIZE);
1083	if (ret) {
1084		pr_warn("jffs2_reserve_space_gc of %zd bytes for garbage_collect_hole failed: %d\n",
1085			sizeof(ri), ret);
1086		return ret;
1087	}
1088	new_fn = jffs2_write_dnode(c, f, &ri, NULL, 0, ALLOC_GC);
1089
1090	if (IS_ERR(new_fn)) {
1091		pr_warn("Error writing new hole node: %ld\n", PTR_ERR(new_fn));
1092		return PTR_ERR(new_fn);
1093	}
1094	if (je32_to_cpu(ri.version) == f->highest_version) {
1095		jffs2_add_full_dnode_to_inode(c, f, new_fn);
1096		if (f->metadata) {
1097			jffs2_mark_node_obsolete(c, f->metadata->raw);
1098			jffs2_free_full_dnode(f->metadata);
1099			f->metadata = NULL;
1100		}
1101		return 0;
1102	}
1103
1104	/*
1105	 * We should only get here in the case where the node we are
1106	 * replacing had more than one frag, so we kept the same version
1107	 * number as before. (Except in case of error -- see 'goto fill;'
1108	 * above.)
1109	 */
1110	D1(if(unlikely(fn->frags <= 1)) {
1111			pr_warn("%s(): Replacing fn with %d frag(s) but new ver %d != highest_version %d of ino #%d\n",
1112				__func__, fn->frags, je32_to_cpu(ri.version),
1113				f->highest_version, je32_to_cpu(ri.ino));
1114	});
1115
1116	/* This is a partially-overlapped hole node. Mark it REF_NORMAL not REF_PRISTINE */
1117	mark_ref_normal(new_fn->raw);
1118
1119	for (frag = jffs2_lookup_node_frag(&f->fragtree, fn->ofs);
1120	     frag; frag = frag_next(frag)) {
1121		if (frag->ofs > fn->size + fn->ofs)
1122			break;
1123		if (frag->node == fn) {
1124			frag->node = new_fn;
1125			new_fn->frags++;
1126			fn->frags--;
1127		}
1128	}
1129	if (fn->frags) {
1130		pr_warn("%s(): Old node still has frags!\n", __func__);
1131		BUG();
1132	}
1133	if (!new_fn->frags) {
1134		pr_warn("%s(): New node has no frags!\n", __func__);
1135		BUG();
1136	}
1137
1138	jffs2_mark_node_obsolete(c, fn->raw);
1139	jffs2_free_full_dnode(fn);
1140
1141	return 0;
1142}
1143
1144static int jffs2_garbage_collect_dnode(struct jffs2_sb_info *c, struct jffs2_eraseblock *orig_jeb,
1145				       struct jffs2_inode_info *f, struct jffs2_full_dnode *fn,
1146				       uint32_t start, uint32_t end)
1147{
1148	struct jffs2_full_dnode *new_fn;
1149	struct jffs2_raw_inode ri;
1150	uint32_t alloclen, offset, orig_end, orig_start;
1151	int ret = 0;
1152	unsigned char *comprbuf = NULL, *writebuf;
1153	unsigned long pg;
1154	unsigned char *pg_ptr;
1155
1156	memset(&ri, 0, sizeof(ri));
1157
1158	jffs2_dbg(1, "Writing replacement dnode for ino #%u from offset 0x%x to 0x%x\n",
1159		  f->inocache->ino, start, end);
1160
1161	orig_end = end;
1162	orig_start = start;
1163
1164	if (c->nr_free_blocks + c->nr_erasing_blocks > c->resv_blocks_gcmerge) {
1165		/* Attempt to do some merging. But only expand to cover logically
1166		   adjacent frags if the block containing them is already considered
1167		   to be dirty. Otherwise we end up with GC just going round in
1168		   circles dirtying the nodes it already wrote out, especially
1169		   on NAND where we have small eraseblocks and hence a much higher
1170		   chance of nodes having to be split to cross boundaries. */
1171
1172		struct jffs2_node_frag *frag;
1173		uint32_t min, max;
1174
1175		min = start & ~(PAGE_CACHE_SIZE-1);
1176		max = min + PAGE_CACHE_SIZE;
1177
1178		frag = jffs2_lookup_node_frag(&f->fragtree, start);
1179
1180		/* BUG_ON(!frag) but that'll happen anyway... */
1181
1182		BUG_ON(frag->ofs != start);
1183
1184		/* First grow down... */
1185		while((frag = frag_prev(frag)) && frag->ofs >= min) {
1186
1187			/* If the previous frag doesn't even reach the beginning, there's
1188			   excessive fragmentation. Just merge. */
1189			if (frag->ofs > min) {
1190				jffs2_dbg(1, "Expanding down to cover partial frag (0x%x-0x%x)\n",
1191					  frag->ofs, frag->ofs+frag->size);
1192				start = frag->ofs;
1193				continue;
1194			}
1195			/* OK. This frag holds the first byte of the page. */
1196			if (!frag->node || !frag->node->raw) {
1197				jffs2_dbg(1, "First frag in page is hole (0x%x-0x%x). Not expanding down.\n",
1198					  frag->ofs, frag->ofs+frag->size);
1199				break;
1200			} else {
1201
1202				/* OK, it's a frag which extends to the beginning of the page. Does it live
1203				   in a block which is still considered clean? If so, don't obsolete it.
1204				   If not, cover it anyway. */
1205
1206				struct jffs2_raw_node_ref *raw = frag->node->raw;
1207				struct jffs2_eraseblock *jeb;
1208
1209				jeb = &c->blocks[raw->flash_offset / c->sector_size];
1210
1211				if (jeb == c->gcblock) {
1212					jffs2_dbg(1, "Expanding down to cover frag (0x%x-0x%x) in gcblock at %08x\n",
1213						  frag->ofs,
1214						  frag->ofs + frag->size,
1215						  ref_offset(raw));
1216					start = frag->ofs;
1217					break;
1218				}
1219				if (!ISDIRTY(jeb->dirty_size + jeb->wasted_size)) {
1220					jffs2_dbg(1, "Not expanding down to cover frag (0x%x-0x%x) in clean block %08x\n",
1221						  frag->ofs,
1222						  frag->ofs + frag->size,
1223						  jeb->offset);
1224					break;
1225				}
1226
1227				jffs2_dbg(1, "Expanding down to cover frag (0x%x-0x%x) in dirty block %08x\n",
1228					  frag->ofs,
1229					  frag->ofs + frag->size,
1230					  jeb->offset);
1231				start = frag->ofs;
1232				break;
1233			}
1234		}
1235
1236		/* ... then up */
1237
1238		/* Find last frag which is actually part of the node we're to GC. */
1239		frag = jffs2_lookup_node_frag(&f->fragtree, end-1);
1240
1241		while((frag = frag_next(frag)) && frag->ofs+frag->size <= max) {
1242
1243			/* If the previous frag doesn't even reach the beginning, there's lots
1244			   of fragmentation. Just merge. */
1245			if (frag->ofs+frag->size < max) {
1246				jffs2_dbg(1, "Expanding up to cover partial frag (0x%x-0x%x)\n",
1247					  frag->ofs, frag->ofs+frag->size);
1248				end = frag->ofs + frag->size;
1249				continue;
1250			}
1251
1252			if (!frag->node || !frag->node->raw) {
1253				jffs2_dbg(1, "Last frag in page is hole (0x%x-0x%x). Not expanding up.\n",
1254					  frag->ofs, frag->ofs+frag->size);
1255				break;
1256			} else {
1257
1258				/* OK, it's a frag which extends to the beginning of the page. Does it live
1259				   in a block which is still considered clean? If so, don't obsolete it.
1260				   If not, cover it anyway. */
1261
1262				struct jffs2_raw_node_ref *raw = frag->node->raw;
1263				struct jffs2_eraseblock *jeb;
1264
1265				jeb = &c->blocks[raw->flash_offset / c->sector_size];
1266
1267				if (jeb == c->gcblock) {
1268					jffs2_dbg(1, "Expanding up to cover frag (0x%x-0x%x) in gcblock at %08x\n",
1269						  frag->ofs,
1270						  frag->ofs + frag->size,
1271						  ref_offset(raw));
1272					end = frag->ofs + frag->size;
1273					break;
1274				}
1275				if (!ISDIRTY(jeb->dirty_size + jeb->wasted_size)) {
1276					jffs2_dbg(1, "Not expanding up to cover frag (0x%x-0x%x) in clean block %08x\n",
1277						  frag->ofs,
1278						  frag->ofs + frag->size,
1279						  jeb->offset);
1280					break;
1281				}
1282
1283				jffs2_dbg(1, "Expanding up to cover frag (0x%x-0x%x) in dirty block %08x\n",
1284					  frag->ofs,
1285					  frag->ofs + frag->size,
1286					  jeb->offset);
1287				end = frag->ofs + frag->size;
1288				break;
1289			}
1290		}
1291		jffs2_dbg(1, "Expanded dnode to write from (0x%x-0x%x) to (0x%x-0x%x)\n",
1292			  orig_start, orig_end, start, end);
1293
1294		D1(BUG_ON(end > frag_last(&f->fragtree)->ofs + frag_last(&f->fragtree)->size));
1295		BUG_ON(end < orig_end);
1296		BUG_ON(start > orig_start);
1297	}
1298
1299	/* The rules state that we must obtain the page lock *before* f->sem, so
1300	 * drop f->sem temporarily. Since we also hold c->alloc_sem, nothing's
1301	 * actually going to *change* so we're safe; we only allow reading.
1302	 *
1303	 * It is important to note that jffs2_write_begin() will ensure that its
1304	 * page is marked Uptodate before allocating space. That means that if we
1305	 * end up here trying to GC the *same* page that jffs2_write_begin() is
1306	 * trying to write out, read_cache_page() will not deadlock. */
1307	mutex_unlock(&f->sem);
1308	pg_ptr = jffs2_gc_fetch_page(c, f, start, &pg);
1309	mutex_lock(&f->sem);
1310
1311	if (IS_ERR(pg_ptr)) {
1312		pr_warn("read_cache_page() returned error: %ld\n",
1313			PTR_ERR(pg_ptr));
1314		return PTR_ERR(pg_ptr);
1315	}
1316
1317	offset = start;
1318	while(offset < orig_end) {
1319		uint32_t datalen;
1320		uint32_t cdatalen;
1321		uint16_t comprtype = JFFS2_COMPR_NONE;
1322
1323		ret = jffs2_reserve_space_gc(c, sizeof(ri) + JFFS2_MIN_DATA_LEN,
1324					&alloclen, JFFS2_SUMMARY_INODE_SIZE);
1325
1326		if (ret) {
1327			pr_warn("jffs2_reserve_space_gc of %zd bytes for garbage_collect_dnode failed: %d\n",
1328				sizeof(ri) + JFFS2_MIN_DATA_LEN, ret);
1329			break;
1330		}
1331		cdatalen = min_t(uint32_t, alloclen - sizeof(ri), end - offset);
1332		datalen = end - offset;
1333
1334		writebuf = pg_ptr + (offset & (PAGE_CACHE_SIZE -1));
1335
1336		comprtype = jffs2_compress(c, f, writebuf, &comprbuf, &datalen, &cdatalen);
1337
1338		ri.magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
1339		ri.nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE);
1340		ri.totlen = cpu_to_je32(sizeof(ri) + cdatalen);
1341		ri.hdr_crc = cpu_to_je32(crc32(0, &ri, sizeof(struct jffs2_unknown_node)-4));
1342
1343		ri.ino = cpu_to_je32(f->inocache->ino);
1344		ri.version = cpu_to_je32(++f->highest_version);
1345		ri.mode = cpu_to_jemode(JFFS2_F_I_MODE(f));
1346		ri.uid = cpu_to_je16(JFFS2_F_I_UID(f));
1347		ri.gid = cpu_to_je16(JFFS2_F_I_GID(f));
1348		ri.isize = cpu_to_je32(JFFS2_F_I_SIZE(f));
1349		ri.atime = cpu_to_je32(JFFS2_F_I_ATIME(f));
1350		ri.ctime = cpu_to_je32(JFFS2_F_I_CTIME(f));
1351		ri.mtime = cpu_to_je32(JFFS2_F_I_MTIME(f));
1352		ri.offset = cpu_to_je32(offset);
1353		ri.csize = cpu_to_je32(cdatalen);
1354		ri.dsize = cpu_to_je32(datalen);
1355		ri.compr = comprtype & 0xff;
1356		ri.usercompr = (comprtype >> 8) & 0xff;
1357		ri.node_crc = cpu_to_je32(crc32(0, &ri, sizeof(ri)-8));
1358		ri.data_crc = cpu_to_je32(crc32(0, comprbuf, cdatalen));
1359
1360		new_fn = jffs2_write_dnode(c, f, &ri, comprbuf, cdatalen, ALLOC_GC);
1361
1362		jffs2_free_comprbuf(comprbuf, writebuf);
1363
1364		if (IS_ERR(new_fn)) {
1365			pr_warn("Error writing new dnode: %ld\n",
1366				PTR_ERR(new_fn));
1367			ret = PTR_ERR(new_fn);
1368			break;
1369		}
1370		ret = jffs2_add_full_dnode_to_inode(c, f, new_fn);
1371		offset += datalen;
1372		if (f->metadata) {
1373			jffs2_mark_node_obsolete(c, f->metadata->raw);
1374			jffs2_free_full_dnode(f->metadata);
1375			f->metadata = NULL;
1376		}
1377	}
1378
1379	jffs2_gc_release_page(c, pg_ptr, &pg);
1380	return ret;
1381}
1382