1
2
3
4
5
6
7
8
9
10
11
12#include <linux/kernel.h>
13#include <linux/mtd/mtd.h>
14#include <linux/slab.h>
15#include <linux/pagemap.h>
16#include <linux/crc32.h>
17#include <linux/compiler.h>
18#include <linux/stat.h>
19#include "nodelist.h"
20#include "compr.h"
21
22static int jffs2_garbage_collect_pristine(struct jffs2_sb_info *c,
23 struct jffs2_inode_cache *ic,
24 struct jffs2_raw_node_ref *raw);
25static int jffs2_garbage_collect_metadata(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
26 struct jffs2_inode_info *f, struct jffs2_full_dnode *fd);
27static int jffs2_garbage_collect_dirent(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
28 struct jffs2_inode_info *f, struct jffs2_full_dirent *fd);
29static int jffs2_garbage_collect_deletion_dirent(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
30 struct jffs2_inode_info *f, struct jffs2_full_dirent *fd);
31static int jffs2_garbage_collect_hole(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
32 struct jffs2_inode_info *f, struct jffs2_full_dnode *fn,
33 uint32_t start, uint32_t end);
34static int jffs2_garbage_collect_dnode(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_live(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
38 struct jffs2_raw_node_ref *raw, struct jffs2_inode_info *f);
39
40
41static struct jffs2_eraseblock *jffs2_find_gc_block(struct jffs2_sb_info *c)
42{
43 struct jffs2_eraseblock *ret;
44 struct list_head *nextlist = NULL;
45 int n = jiffies % 128;
46
47
48
49
50
51again:
52 if (!list_empty(&c->bad_used_list) && c->nr_free_blocks > c->resv_blocks_gcbad) {
53 D1(printk(KERN_DEBUG "Picking block from bad_used_list to GC next\n"));
54 nextlist = &c->bad_used_list;
55 } else if (n < 50 && !list_empty(&c->erasable_list)) {
56
57
58 D1(printk(KERN_DEBUG "Picking block from erasable_list to GC next\n"));
59 nextlist = &c->erasable_list;
60 } else if (n < 110 && !list_empty(&c->very_dirty_list)) {
61
62 D1(printk(KERN_DEBUG "Picking block from very_dirty_list to GC next\n"));
63 nextlist = &c->very_dirty_list;
64 } else if (n < 126 && !list_empty(&c->dirty_list)) {
65 D1(printk(KERN_DEBUG "Picking block from dirty_list to GC next\n"));
66 nextlist = &c->dirty_list;
67 } else if (!list_empty(&c->clean_list)) {
68 D1(printk(KERN_DEBUG "Picking block from clean_list to GC next\n"));
69 nextlist = &c->clean_list;
70 } else if (!list_empty(&c->dirty_list)) {
71 D1(printk(KERN_DEBUG "Picking block from dirty_list to GC next (clean_list was empty)\n"));
72
73 nextlist = &c->dirty_list;
74 } else if (!list_empty(&c->very_dirty_list)) {
75 D1(printk(KERN_DEBUG "Picking block from very_dirty_list to GC next (clean_list and dirty_list were empty)\n"));
76 nextlist = &c->very_dirty_list;
77 } else if (!list_empty(&c->erasable_list)) {
78 D1(printk(KERN_DEBUG "Picking block from erasable_list to GC next (clean_list and {very_,}dirty_list were empty)\n"));
79
80 nextlist = &c->erasable_list;
81 } else if (!list_empty(&c->erasable_pending_wbuf_list)) {
82
83 D1(printk(KERN_DEBUG "Synching wbuf in order to reuse erasable_pending_wbuf_list blocks\n"));
84 spin_unlock(&c->erase_completion_lock);
85 jffs2_flush_wbuf_pad(c);
86 spin_lock(&c->erase_completion_lock);
87 goto again;
88 } else {
89
90 D1(printk(KERN_NOTICE "jffs2: No clean, dirty _or_ erasable blocks to GC from! Where are they all?\n"));
91 return NULL;
92 }
93
94 ret = list_entry(nextlist->next, struct jffs2_eraseblock, list);
95 list_del(&ret->list);
96 c->gcblock = ret;
97 ret->gc_node = ret->first_node;
98 if (!ret->gc_node) {
99 printk(KERN_WARNING "Eep. ret->gc_node for block at 0x%08x is NULL\n", ret->offset);
100 BUG();
101 }
102
103
104 if (ret->wasted_size) {
105 D1(printk(KERN_DEBUG "Converting wasted_size %08x to dirty_size\n", ret->wasted_size));
106 ret->dirty_size += ret->wasted_size;
107 c->wasted_size -= ret->wasted_size;
108 c->dirty_size += ret->wasted_size;
109 ret->wasted_size = 0;
110 }
111
112 return ret;
113}
114
115
116
117
118
119int jffs2_garbage_collect_pass(struct jffs2_sb_info *c)
120{
121 struct jffs2_inode_info *f;
122 struct jffs2_inode_cache *ic;
123 struct jffs2_eraseblock *jeb;
124 struct jffs2_raw_node_ref *raw;
125 uint32_t gcblock_dirty;
126 int ret = 0, inum, nlink;
127 int xattr = 0;
128
129 if (mutex_lock_interruptible(&c->alloc_sem))
130 return -EINTR;
131
132 for (;;) {
133 spin_lock(&c->erase_completion_lock);
134 if (!c->unchecked_size)
135 break;
136
137
138
139
140
141 if (c->checked_ino > c->highest_ino && xattr) {
142 printk(KERN_CRIT "Checked all inodes but still 0x%x bytes of unchecked space?\n",
143 c->unchecked_size);
144 jffs2_dbg_dump_block_lists_nolock(c);
145 spin_unlock(&c->erase_completion_lock);
146 mutex_unlock(&c->alloc_sem);
147 return -ENOSPC;
148 }
149
150 spin_unlock(&c->erase_completion_lock);
151
152 if (!xattr)
153 xattr = jffs2_verify_xattr(c);
154
155 spin_lock(&c->inocache_lock);
156
157 ic = jffs2_get_ino_cache(c, c->checked_ino++);
158
159 if (!ic) {
160 spin_unlock(&c->inocache_lock);
161 continue;
162 }
163
164 if (!ic->pino_nlink) {
165 D1(printk(KERN_DEBUG "Skipping check of ino #%d with nlink/pino zero\n",
166 ic->ino));
167 spin_unlock(&c->inocache_lock);
168 jffs2_xattr_delete_inode(c, ic);
169 continue;
170 }
171 switch(ic->state) {
172 case INO_STATE_CHECKEDABSENT:
173 case INO_STATE_PRESENT:
174 D1(printk(KERN_DEBUG "Skipping ino #%u already checked\n", ic->ino));
175 spin_unlock(&c->inocache_lock);
176 continue;
177
178 case INO_STATE_GC:
179 case INO_STATE_CHECKING:
180 printk(KERN_WARNING "Inode #%u is in state %d during CRC check phase!\n", ic->ino, ic->state);
181 spin_unlock(&c->inocache_lock);
182 BUG();
183
184 case INO_STATE_READING:
185
186
187
188 D1(printk(KERN_DEBUG "Waiting for ino #%u to finish reading\n", ic->ino));
189
190
191 c->checked_ino--;
192
193 mutex_unlock(&c->alloc_sem);
194 sleep_on_spinunlock(&c->inocache_wq, &c->inocache_lock);
195 return 0;
196
197 default:
198 BUG();
199
200 case INO_STATE_UNCHECKED:
201 ;
202 }
203 ic->state = INO_STATE_CHECKING;
204 spin_unlock(&c->inocache_lock);
205
206 D1(printk(KERN_DEBUG "jffs2_garbage_collect_pass() triggering inode scan of ino#%u\n", ic->ino));
207
208 ret = jffs2_do_crccheck_inode(c, ic);
209 if (ret)
210 printk(KERN_WARNING "Returned error for crccheck of ino #%u. Expect badness...\n", ic->ino);
211
212 jffs2_set_inocache_state(c, ic, INO_STATE_CHECKEDABSENT);
213 mutex_unlock(&c->alloc_sem);
214 return ret;
215 }
216
217
218 jeb = c->gcblock;
219
220 if (!jeb)
221 jeb = jffs2_find_gc_block(c);
222
223 if (!jeb) {
224
225 if (!list_empty(&c->erase_pending_list)) {
226 spin_unlock(&c->erase_completion_lock);
227 mutex_unlock(&c->alloc_sem);
228 return -EAGAIN;
229 }
230 D1(printk(KERN_NOTICE "jffs2: Couldn't find erase block to garbage collect!\n"));
231 spin_unlock(&c->erase_completion_lock);
232 mutex_unlock(&c->alloc_sem);
233 return -EIO;
234 }
235
236 D1(printk(KERN_DEBUG "GC from block %08x, used_size %08x, dirty_size %08x, free_size %08x\n", jeb->offset, jeb->used_size, jeb->dirty_size, jeb->free_size));
237 D1(if (c->nextblock)
238 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));
239
240 if (!jeb->used_size) {
241 mutex_unlock(&c->alloc_sem);
242 goto eraseit;
243 }
244
245 raw = jeb->gc_node;
246 gcblock_dirty = jeb->dirty_size;
247
248 while(ref_obsolete(raw)) {
249 D1(printk(KERN_DEBUG "Node at 0x%08x is obsolete... skipping\n", ref_offset(raw)));
250 raw = ref_next(raw);
251 if (unlikely(!raw)) {
252 printk(KERN_WARNING "eep. End of raw list while still supposedly nodes to GC\n");
253 printk(KERN_WARNING "erase block at 0x%08x. free_size 0x%08x, dirty_size 0x%08x, used_size 0x%08x\n",
254 jeb->offset, jeb->free_size, jeb->dirty_size, jeb->used_size);
255 jeb->gc_node = raw;
256 spin_unlock(&c->erase_completion_lock);
257 mutex_unlock(&c->alloc_sem);
258 BUG();
259 }
260 }
261 jeb->gc_node = raw;
262
263 D1(printk(KERN_DEBUG "Going to garbage collect node at 0x%08x\n", ref_offset(raw)));
264
265 if (!raw->next_in_ino) {
266
267 spin_unlock(&c->erase_completion_lock);
268 if (ref_flags(raw) == REF_PRISTINE) {
269
270 jffs2_garbage_collect_pristine(c, NULL, raw);
271 } else {
272
273 jffs2_mark_node_obsolete(c, raw);
274 }
275 mutex_unlock(&c->alloc_sem);
276 goto eraseit_lock;
277 }
278
279 ic = jffs2_raw_ref_to_ic(raw);
280
281#ifdef CONFIG_JFFS2_FS_XATTR
282
283
284 if (ic->class == RAWNODE_CLASS_XATTR_DATUM
285 || ic->class == RAWNODE_CLASS_XATTR_REF) {
286 spin_unlock(&c->erase_completion_lock);
287
288 if (ic->class == RAWNODE_CLASS_XATTR_DATUM) {
289 ret = jffs2_garbage_collect_xattr_datum(c, (struct jffs2_xattr_datum *)ic, raw);
290 } else {
291 ret = jffs2_garbage_collect_xattr_ref(c, (struct jffs2_xattr_ref *)ic, raw);
292 }
293 goto test_gcnode;
294 }
295#endif
296
297
298
299
300 spin_lock(&c->inocache_lock);
301
302 spin_unlock(&c->erase_completion_lock);
303
304 D1(printk(KERN_DEBUG "jffs2_garbage_collect_pass collecting from block @0x%08x. Node @0x%08x(%d), ino #%u\n", jeb->offset, ref_offset(raw), ref_flags(raw), ic->ino));
305
306
307
308
309
310
311
312
313
314
315 switch(ic->state) {
316 case INO_STATE_CHECKEDABSENT:
317
318
319
320
321 if (ref_flags(raw) == REF_PRISTINE)
322 ic->state = INO_STATE_GC;
323 else {
324 D1(printk(KERN_DEBUG "Ino #%u is absent but node not REF_PRISTINE. Reading.\n",
325 ic->ino));
326 }
327 break;
328
329 case INO_STATE_PRESENT:
330
331 break;
332
333 case INO_STATE_UNCHECKED:
334 case INO_STATE_CHECKING:
335 case INO_STATE_GC:
336
337
338
339
340
341 printk(KERN_CRIT "Inode #%u already in state %d in jffs2_garbage_collect_pass()!\n",
342 ic->ino, ic->state);
343 mutex_unlock(&c->alloc_sem);
344 spin_unlock(&c->inocache_lock);
345 BUG();
346
347 case INO_STATE_READING:
348
349
350
351
352
353
354 mutex_unlock(&c->alloc_sem);
355 D1(printk(KERN_DEBUG "jffs2_garbage_collect_pass() waiting for ino #%u in state %d\n",
356 ic->ino, ic->state));
357 sleep_on_spinunlock(&c->inocache_wq, &c->inocache_lock);
358
359
360
361
362
363
364
365
366
367
368 return 0;
369 }
370
371
372
373
374
375
376 if (ic->state == INO_STATE_GC) {
377 spin_unlock(&c->inocache_lock);
378
379 ret = jffs2_garbage_collect_pristine(c, ic, raw);
380
381 spin_lock(&c->inocache_lock);
382 ic->state = INO_STATE_CHECKEDABSENT;
383 wake_up(&c->inocache_wq);
384
385 if (ret != -EBADFD) {
386 spin_unlock(&c->inocache_lock);
387 goto test_gcnode;
388 }
389
390
391 }
392
393
394
395
396
397
398
399
400 inum = ic->ino;
401 nlink = ic->pino_nlink;
402 spin_unlock(&c->inocache_lock);
403
404 f = jffs2_gc_fetch_inode(c, inum, !nlink);
405 if (IS_ERR(f)) {
406 ret = PTR_ERR(f);
407 goto release_sem;
408 }
409 if (!f) {
410 ret = 0;
411 goto release_sem;
412 }
413
414 ret = jffs2_garbage_collect_live(c, jeb, raw, f);
415
416 jffs2_gc_release_inode(c, f);
417
418 test_gcnode:
419 if (jeb->dirty_size == gcblock_dirty && !ref_obsolete(jeb->gc_node)) {
420
421 printk(KERN_ERR "Error garbage collecting node at %08x!\n", ref_offset(jeb->gc_node));
422 ret = -ENOSPC;
423 }
424 release_sem:
425 mutex_unlock(&c->alloc_sem);
426
427 eraseit_lock:
428
429 spin_lock(&c->erase_completion_lock);
430
431 eraseit:
432 if (c->gcblock && !c->gcblock->used_size) {
433 D1(printk(KERN_DEBUG "Block at 0x%08x completely obsoleted by GC. Moving to erase_pending_list\n", c->gcblock->offset));
434
435 list_add_tail(&c->gcblock->list, &c->erase_pending_list);
436 c->gcblock = NULL;
437 c->nr_erasing_blocks++;
438 jffs2_erase_pending_trigger(c);
439 }
440 spin_unlock(&c->erase_completion_lock);
441
442 return ret;
443}
444
445static int jffs2_garbage_collect_live(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
446 struct jffs2_raw_node_ref *raw, struct jffs2_inode_info *f)
447{
448 struct jffs2_node_frag *frag;
449 struct jffs2_full_dnode *fn = NULL;
450 struct jffs2_full_dirent *fd;
451 uint32_t start = 0, end = 0, nrfrags = 0;
452 int ret = 0;
453
454 mutex_lock(&f->sem);
455
456
457
458
459 spin_lock(&c->erase_completion_lock);
460
461 if (c->gcblock != jeb) {
462 spin_unlock(&c->erase_completion_lock);
463 D1(printk(KERN_DEBUG "GC block is no longer gcblock. Restart\n"));
464 goto upnout;
465 }
466 if (ref_obsolete(raw)) {
467 spin_unlock(&c->erase_completion_lock);
468 D1(printk(KERN_DEBUG "node to be GC'd was obsoleted in the meantime.\n"));
469
470 goto upnout;
471 }
472 spin_unlock(&c->erase_completion_lock);
473
474
475 if (f->metadata && f->metadata->raw == raw) {
476 fn = f->metadata;
477 ret = jffs2_garbage_collect_metadata(c, jeb, f, fn);
478 goto upnout;
479 }
480
481
482 for (frag = frag_first(&f->fragtree); frag; frag = frag_next(frag)) {
483 if (frag->node && frag->node->raw == raw) {
484 fn = frag->node;
485 end = frag->ofs + frag->size;
486 if (!nrfrags++)
487 start = frag->ofs;
488 if (nrfrags == frag->node->frags)
489 break;
490 }
491 }
492 if (fn) {
493 if (ref_flags(raw) == REF_PRISTINE) {
494 ret = jffs2_garbage_collect_pristine(c, f->inocache, raw);
495 if (!ret) {
496
497 frag->node->raw = f->inocache->nodes;
498 }
499 if (ret != -EBADFD)
500 goto upnout;
501 }
502
503 if((start >> PAGE_CACHE_SHIFT) < ((end-1) >> PAGE_CACHE_SHIFT)) {
504
505 ret = jffs2_garbage_collect_hole(c, jeb, f, fn, start, end);
506 } else {
507
508 ret = jffs2_garbage_collect_dnode(c, jeb, f, fn, start, end);
509 }
510 goto upnout;
511 }
512
513
514 for (fd = f->dents; fd; fd=fd->next) {
515 if (fd->raw == raw)
516 break;
517 }
518
519 if (fd && fd->ino) {
520 ret = jffs2_garbage_collect_dirent(c, jeb, f, fd);
521 } else if (fd) {
522 ret = jffs2_garbage_collect_deletion_dirent(c, jeb, f, fd);
523 } else {
524 printk(KERN_WARNING "Raw node at 0x%08x wasn't in node lists for ino #%u\n",
525 ref_offset(raw), f->inocache->ino);
526 if (ref_obsolete(raw)) {
527 printk(KERN_WARNING "But it's obsolete so we don't mind too much\n");
528 } else {
529 jffs2_dbg_dump_node(c, ref_offset(raw));
530 BUG();
531 }
532 }
533 upnout:
534 mutex_unlock(&f->sem);
535
536 return ret;
537}
538
539static int jffs2_garbage_collect_pristine(struct jffs2_sb_info *c,
540 struct jffs2_inode_cache *ic,
541 struct jffs2_raw_node_ref *raw)
542{
543 union jffs2_node_union *node;
544 size_t retlen;
545 int ret;
546 uint32_t phys_ofs, alloclen;
547 uint32_t crc, rawlen;
548 int retried = 0;
549
550 D1(printk(KERN_DEBUG "Going to GC REF_PRISTINE node at 0x%08x\n", ref_offset(raw)));
551
552 alloclen = rawlen = ref_totlen(c, c->gcblock, raw);
553
554
555
556
557 if (ic && alloclen > sizeof(struct jffs2_raw_inode) + JFFS2_MIN_DATA_LEN)
558 alloclen = sizeof(struct jffs2_raw_inode) + JFFS2_MIN_DATA_LEN;
559
560 ret = jffs2_reserve_space_gc(c, alloclen, &alloclen, rawlen);
561
562
563 if (ret)
564 return ret;
565
566 if (alloclen < rawlen) {
567
568 return -EBADFD;
569 }
570
571 node = kmalloc(rawlen, GFP_KERNEL);
572 if (!node)
573 return -ENOMEM;
574
575 ret = jffs2_flash_read(c, ref_offset(raw), rawlen, &retlen, (char *)node);
576 if (!ret && retlen != rawlen)
577 ret = -EIO;
578 if (ret)
579 goto out_node;
580
581 crc = crc32(0, node, sizeof(struct jffs2_unknown_node)-4);
582 if (je32_to_cpu(node->u.hdr_crc) != crc) {
583 printk(KERN_WARNING "Header CRC failed on REF_PRISTINE node at 0x%08x: Read 0x%08x, calculated 0x%08x\n",
584 ref_offset(raw), je32_to_cpu(node->u.hdr_crc), crc);
585 goto bail;
586 }
587
588 switch(je16_to_cpu(node->u.nodetype)) {
589 case JFFS2_NODETYPE_INODE:
590 crc = crc32(0, node, sizeof(node->i)-8);
591 if (je32_to_cpu(node->i.node_crc) != crc) {
592 printk(KERN_WARNING "Node CRC failed on REF_PRISTINE data node at 0x%08x: Read 0x%08x, calculated 0x%08x\n",
593 ref_offset(raw), je32_to_cpu(node->i.node_crc), crc);
594 goto bail;
595 }
596
597 if (je32_to_cpu(node->i.dsize)) {
598 crc = crc32(0, node->i.data, je32_to_cpu(node->i.csize));
599 if (je32_to_cpu(node->i.data_crc) != crc) {
600 printk(KERN_WARNING "Data CRC failed on REF_PRISTINE data node at 0x%08x: Read 0x%08x, calculated 0x%08x\n",
601 ref_offset(raw), je32_to_cpu(node->i.data_crc), crc);
602 goto bail;
603 }
604 }
605 break;
606
607 case JFFS2_NODETYPE_DIRENT:
608 crc = crc32(0, node, sizeof(node->d)-8);
609 if (je32_to_cpu(node->d.node_crc) != crc) {
610 printk(KERN_WARNING "Node CRC failed on REF_PRISTINE dirent node at 0x%08x: Read 0x%08x, calculated 0x%08x\n",
611 ref_offset(raw), je32_to_cpu(node->d.node_crc), crc);
612 goto bail;
613 }
614
615 if (strnlen(node->d.name, node->d.nsize) != node->d.nsize) {
616 printk(KERN_WARNING "Name in dirent node at 0x%08x contains zeroes\n", ref_offset(raw));
617 goto bail;
618 }
619
620 if (node->d.nsize) {
621 crc = crc32(0, node->d.name, node->d.nsize);
622 if (je32_to_cpu(node->d.name_crc) != crc) {
623 printk(KERN_WARNING "Name CRC failed on REF_PRISTINE dirent node at 0x%08x: Read 0x%08x, calculated 0x%08x\n",
624 ref_offset(raw), je32_to_cpu(node->d.name_crc), crc);
625 goto bail;
626 }
627 }
628 break;
629 default:
630
631 if (ic) {
632 printk(KERN_WARNING "Unknown node type for REF_PRISTINE node at 0x%08x: 0x%04x\n",
633 ref_offset(raw), je16_to_cpu(node->u.nodetype));
634 goto bail;
635 }
636 }
637
638
639 retry:
640 phys_ofs = write_ofs(c);
641
642 ret = jffs2_flash_write(c, phys_ofs, rawlen, &retlen, (char *)node);
643
644 if (ret || (retlen != rawlen)) {
645 printk(KERN_NOTICE "Write of %d bytes at 0x%08x failed. returned %d, retlen %zd\n",
646 rawlen, phys_ofs, ret, retlen);
647 if (retlen) {
648 jffs2_add_physical_node_ref(c, phys_ofs | REF_OBSOLETE, rawlen, NULL);
649 } else {
650 printk(KERN_NOTICE "Not marking the space at 0x%08x as dirty because the flash driver returned retlen zero\n", phys_ofs);
651 }
652 if (!retried) {
653
654 uint32_t dummy;
655 struct jffs2_eraseblock *jeb = &c->blocks[phys_ofs / c->sector_size];
656
657 retried = 1;
658
659 D1(printk(KERN_DEBUG "Retrying failed write of REF_PRISTINE node.\n"));
660
661 jffs2_dbg_acct_sanity_check(c,jeb);
662 jffs2_dbg_acct_paranoia_check(c, jeb);
663
664 ret = jffs2_reserve_space_gc(c, rawlen, &dummy, rawlen);
665
666
667
668 if (!ret) {
669 D1(printk(KERN_DEBUG "Allocated space at 0x%08x to retry failed write.\n", phys_ofs));
670
671 jffs2_dbg_acct_sanity_check(c,jeb);
672 jffs2_dbg_acct_paranoia_check(c, jeb);
673
674 goto retry;
675 }
676 D1(printk(KERN_DEBUG "Failed to allocate space to retry failed write: %d!\n", ret));
677 }
678
679 if (!ret)
680 ret = -EIO;
681 goto out_node;
682 }
683 jffs2_add_physical_node_ref(c, phys_ofs | REF_PRISTINE, rawlen, ic);
684
685 jffs2_mark_node_obsolete(c, raw);
686 D1(printk(KERN_DEBUG "WHEEE! GC REF_PRISTINE node at 0x%08x succeeded\n", ref_offset(raw)));
687
688 out_node:
689 kfree(node);
690 return ret;
691 bail:
692 ret = -EBADFD;
693 goto out_node;
694}
695
696static int jffs2_garbage_collect_metadata(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
697 struct jffs2_inode_info *f, struct jffs2_full_dnode *fn)
698{
699 struct jffs2_full_dnode *new_fn;
700 struct jffs2_raw_inode ri;
701 struct jffs2_node_frag *last_frag;
702 union jffs2_device_node dev;
703 char *mdata = NULL, mdatalen = 0;
704 uint32_t alloclen, ilen;
705 int ret;
706
707 if (S_ISBLK(JFFS2_F_I_MODE(f)) ||
708 S_ISCHR(JFFS2_F_I_MODE(f)) ) {
709
710 mdatalen = jffs2_encode_dev(&dev, JFFS2_F_I_RDEV(f));
711 mdata = (char *)&dev;
712 D1(printk(KERN_DEBUG "jffs2_garbage_collect_metadata(): Writing %d bytes of kdev_t\n", mdatalen));
713 } else if (S_ISLNK(JFFS2_F_I_MODE(f))) {
714 mdatalen = fn->size;
715 mdata = kmalloc(fn->size, GFP_KERNEL);
716 if (!mdata) {
717 printk(KERN_WARNING "kmalloc of mdata failed in jffs2_garbage_collect_metadata()\n");
718 return -ENOMEM;
719 }
720 ret = jffs2_read_dnode(c, f, fn, mdata, 0, mdatalen);
721 if (ret) {
722 printk(KERN_WARNING "read of old metadata failed in jffs2_garbage_collect_metadata(): %d\n", ret);
723 kfree(mdata);
724 return ret;
725 }
726 D1(printk(KERN_DEBUG "jffs2_garbage_collect_metadata(): Writing %d bites of symlink target\n", mdatalen));
727
728 }
729
730 ret = jffs2_reserve_space_gc(c, sizeof(ri) + mdatalen, &alloclen,
731 JFFS2_SUMMARY_INODE_SIZE);
732 if (ret) {
733 printk(KERN_WARNING "jffs2_reserve_space_gc of %zd bytes for garbage_collect_metadata failed: %d\n",
734 sizeof(ri)+ mdatalen, ret);
735 goto out;
736 }
737
738 last_frag = frag_last(&f->fragtree);
739 if (last_frag)
740
741
742 ilen = last_frag->ofs + last_frag->size;
743 else
744 ilen = JFFS2_F_I_SIZE(f);
745
746 memset(&ri, 0, sizeof(ri));
747 ri.magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
748 ri.nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE);
749 ri.totlen = cpu_to_je32(sizeof(ri) + mdatalen);
750 ri.hdr_crc = cpu_to_je32(crc32(0, &ri, sizeof(struct jffs2_unknown_node)-4));
751
752 ri.ino = cpu_to_je32(f->inocache->ino);
753 ri.version = cpu_to_je32(++f->highest_version);
754 ri.mode = cpu_to_jemode(JFFS2_F_I_MODE(f));
755 ri.uid = cpu_to_je16(JFFS2_F_I_UID(f));
756 ri.gid = cpu_to_je16(JFFS2_F_I_GID(f));
757 ri.isize = cpu_to_je32(ilen);
758 ri.atime = cpu_to_je32(JFFS2_F_I_ATIME(f));
759 ri.ctime = cpu_to_je32(JFFS2_F_I_CTIME(f));
760 ri.mtime = cpu_to_je32(JFFS2_F_I_MTIME(f));
761 ri.offset = cpu_to_je32(0);
762 ri.csize = cpu_to_je32(mdatalen);
763 ri.dsize = cpu_to_je32(mdatalen);
764 ri.compr = JFFS2_COMPR_NONE;
765 ri.node_crc = cpu_to_je32(crc32(0, &ri, sizeof(ri)-8));
766 ri.data_crc = cpu_to_je32(crc32(0, mdata, mdatalen));
767
768 new_fn = jffs2_write_dnode(c, f, &ri, mdata, mdatalen, ALLOC_GC);
769
770 if (IS_ERR(new_fn)) {
771 printk(KERN_WARNING "Error writing new dnode: %ld\n", PTR_ERR(new_fn));
772 ret = PTR_ERR(new_fn);
773 goto out;
774 }
775 jffs2_mark_node_obsolete(c, fn->raw);
776 jffs2_free_full_dnode(fn);
777 f->metadata = new_fn;
778 out:
779 if (S_ISLNK(JFFS2_F_I_MODE(f)))
780 kfree(mdata);
781 return ret;
782}
783
784static int jffs2_garbage_collect_dirent(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
785 struct jffs2_inode_info *f, struct jffs2_full_dirent *fd)
786{
787 struct jffs2_full_dirent *new_fd;
788 struct jffs2_raw_dirent rd;
789 uint32_t alloclen;
790 int ret;
791
792 rd.magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
793 rd.nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT);
794 rd.nsize = strlen(fd->name);
795 rd.totlen = cpu_to_je32(sizeof(rd) + rd.nsize);
796 rd.hdr_crc = cpu_to_je32(crc32(0, &rd, sizeof(struct jffs2_unknown_node)-4));
797
798 rd.pino = cpu_to_je32(f->inocache->ino);
799 rd.version = cpu_to_je32(++f->highest_version);
800 rd.ino = cpu_to_je32(fd->ino);
801
802
803 if (JFFS2_F_I_MTIME(f) == JFFS2_F_I_CTIME(f))
804 rd.mctime = cpu_to_je32(JFFS2_F_I_MTIME(f));
805 else
806 rd.mctime = cpu_to_je32(0);
807 rd.type = fd->type;
808 rd.node_crc = cpu_to_je32(crc32(0, &rd, sizeof(rd)-8));
809 rd.name_crc = cpu_to_je32(crc32(0, fd->name, rd.nsize));
810
811 ret = jffs2_reserve_space_gc(c, sizeof(rd)+rd.nsize, &alloclen,
812 JFFS2_SUMMARY_DIRENT_SIZE(rd.nsize));
813 if (ret) {
814 printk(KERN_WARNING "jffs2_reserve_space_gc of %zd bytes for garbage_collect_dirent failed: %d\n",
815 sizeof(rd)+rd.nsize, ret);
816 return ret;
817 }
818 new_fd = jffs2_write_dirent(c, f, &rd, fd->name, rd.nsize, ALLOC_GC);
819
820 if (IS_ERR(new_fd)) {
821 printk(KERN_WARNING "jffs2_write_dirent in garbage_collect_dirent failed: %ld\n", PTR_ERR(new_fd));
822 return PTR_ERR(new_fd);
823 }
824 jffs2_add_fd_to_list(c, new_fd, &f->dents);
825 return 0;
826}
827
828static int jffs2_garbage_collect_deletion_dirent(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
829 struct jffs2_inode_info *f, struct jffs2_full_dirent *fd)
830{
831 struct jffs2_full_dirent **fdp = &f->dents;
832 int found = 0;
833
834
835
836
837
838
839 if (!jffs2_can_mark_obsolete(c)) {
840 struct jffs2_raw_dirent *rd;
841 struct jffs2_raw_node_ref *raw;
842 int ret;
843 size_t retlen;
844 int name_len = strlen(fd->name);
845 uint32_t name_crc = crc32(0, fd->name, name_len);
846 uint32_t rawlen = ref_totlen(c, jeb, fd->raw);
847
848 rd = kmalloc(rawlen, GFP_KERNEL);
849 if (!rd)
850 return -ENOMEM;
851
852
853
854
855 mutex_lock(&c->erase_free_sem);
856
857 for (raw = f->inocache->nodes; raw != (void *)f->inocache; raw = raw->next_in_ino) {
858
859 cond_resched();
860
861
862 if (!(ref_obsolete(raw)))
863 continue;
864
865
866 if (ref_totlen(c, NULL, raw) != rawlen)
867 continue;
868
869
870
871 if (SECTOR_ADDR(raw->flash_offset) == SECTOR_ADDR(fd->raw->flash_offset))
872 continue;
873
874 D1(printk(KERN_DEBUG "Check potential deletion dirent at %08x\n", ref_offset(raw)));
875
876
877
878 ret = jffs2_flash_read(c, ref_offset(raw), rawlen, &retlen, (char *)rd);
879 if (ret) {
880 printk(KERN_WARNING "jffs2_g_c_deletion_dirent(): Read error (%d) reading obsolete node at %08x\n", ret, ref_offset(raw));
881
882 continue;
883 }
884 if (retlen != rawlen) {
885 printk(KERN_WARNING "jffs2_g_c_deletion_dirent(): Short read (%zd not %u) reading header from obsolete node at %08x\n",
886 retlen, rawlen, ref_offset(raw));
887 continue;
888 }
889
890 if (je16_to_cpu(rd->nodetype) != JFFS2_NODETYPE_DIRENT)
891 continue;
892
893
894 if (je32_to_cpu(rd->name_crc) != name_crc)
895 continue;
896
897
898 if (rd->nsize != name_len || !je32_to_cpu(rd->ino))
899 continue;
900
901
902 if (memcmp(rd->name, fd->name, name_len))
903 continue;
904
905
906
907
908 mutex_unlock(&c->erase_free_sem);
909
910 D1(printk(KERN_DEBUG "Deletion dirent at %08x still obsoletes real dirent \"%s\" at %08x for ino #%u\n",
911 ref_offset(fd->raw), fd->name, ref_offset(raw), je32_to_cpu(rd->ino)));
912 kfree(rd);
913
914 return jffs2_garbage_collect_dirent(c, jeb, f, fd);
915 }
916
917 mutex_unlock(&c->erase_free_sem);
918 kfree(rd);
919 }
920
921
922
923
924
925 while (*fdp) {
926 if ((*fdp) == fd) {
927 found = 1;
928 *fdp = fd->next;
929 break;
930 }
931 fdp = &(*fdp)->next;
932 }
933 if (!found) {
934 printk(KERN_WARNING "Deletion dirent \"%s\" not found in list for ino #%u\n", fd->name, f->inocache->ino);
935 }
936 jffs2_mark_node_obsolete(c, fd->raw);
937 jffs2_free_full_dirent(fd);
938 return 0;
939}
940
941static int jffs2_garbage_collect_hole(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
942 struct jffs2_inode_info *f, struct jffs2_full_dnode *fn,
943 uint32_t start, uint32_t end)
944{
945 struct jffs2_raw_inode ri;
946 struct jffs2_node_frag *frag;
947 struct jffs2_full_dnode *new_fn;
948 uint32_t alloclen, ilen;
949 int ret;
950
951 D1(printk(KERN_DEBUG "Writing replacement hole node for ino #%u from offset 0x%x to 0x%x\n",
952 f->inocache->ino, start, end));
953
954 memset(&ri, 0, sizeof(ri));
955
956 if(fn->frags > 1) {
957 size_t readlen;
958 uint32_t crc;
959
960
961 ret = jffs2_flash_read(c, ref_offset(fn->raw), sizeof(ri), &readlen, (char *)&ri);
962 if (readlen != sizeof(ri) || ret) {
963 printk(KERN_WARNING "Node read failed in jffs2_garbage_collect_hole. Ret %d, retlen %zd. Data will be lost by writing new hole node\n", ret, readlen);
964 goto fill;
965 }
966 if (je16_to_cpu(ri.nodetype) != JFFS2_NODETYPE_INODE) {
967 printk(KERN_WARNING "jffs2_garbage_collect_hole: Node at 0x%08x had node type 0x%04x instead of JFFS2_NODETYPE_INODE(0x%04x)\n",
968 ref_offset(fn->raw),
969 je16_to_cpu(ri.nodetype), JFFS2_NODETYPE_INODE);
970 return -EIO;
971 }
972 if (je32_to_cpu(ri.totlen) != sizeof(ri)) {
973 printk(KERN_WARNING "jffs2_garbage_collect_hole: Node at 0x%08x had totlen 0x%x instead of expected 0x%zx\n",
974 ref_offset(fn->raw),
975 je32_to_cpu(ri.totlen), sizeof(ri));
976 return -EIO;
977 }
978 crc = crc32(0, &ri, sizeof(ri)-8);
979 if (crc != je32_to_cpu(ri.node_crc)) {
980 printk(KERN_WARNING "jffs2_garbage_collect_hole: Node at 0x%08x had CRC 0x%08x which doesn't match calculated CRC 0x%08x\n",
981 ref_offset(fn->raw),
982 je32_to_cpu(ri.node_crc), crc);
983
984 printk(KERN_WARNING "Data in the range 0x%08x to 0x%08x of inode #%u will be lost\n",
985 start, end, f->inocache->ino);
986 goto fill;
987 }
988 if (ri.compr != JFFS2_COMPR_ZERO) {
989 printk(KERN_WARNING "jffs2_garbage_collect_hole: Node 0x%08x wasn't a hole node!\n", ref_offset(fn->raw));
990 printk(KERN_WARNING "Data in the range 0x%08x to 0x%08x of inode #%u will be lost\n",
991 start, end, f->inocache->ino);
992 goto fill;
993 }
994 } else {
995 fill:
996 ri.magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
997 ri.nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE);
998 ri.totlen = cpu_to_je32(sizeof(ri));
999 ri.hdr_crc = cpu_to_je32(crc32(0, &ri, sizeof(struct jffs2_unknown_node)-4));
1000
1001 ri.ino = cpu_to_je32(f->inocache->ino);
1002 ri.version = cpu_to_je32(++f->highest_version);
1003 ri.offset = cpu_to_je32(start);
1004 ri.dsize = cpu_to_je32(end - start);
1005 ri.csize = cpu_to_je32(0);
1006 ri.compr = JFFS2_COMPR_ZERO;
1007 }
1008
1009 frag = frag_last(&f->fragtree);
1010 if (frag)
1011
1012
1013 ilen = frag->ofs + frag->size;
1014 else
1015 ilen = JFFS2_F_I_SIZE(f);
1016
1017 ri.mode = cpu_to_jemode(JFFS2_F_I_MODE(f));
1018 ri.uid = cpu_to_je16(JFFS2_F_I_UID(f));
1019 ri.gid = cpu_to_je16(JFFS2_F_I_GID(f));
1020 ri.isize = cpu_to_je32(ilen);
1021 ri.atime = cpu_to_je32(JFFS2_F_I_ATIME(f));
1022 ri.ctime = cpu_to_je32(JFFS2_F_I_CTIME(f));
1023 ri.mtime = cpu_to_je32(JFFS2_F_I_MTIME(f));
1024 ri.data_crc = cpu_to_je32(0);
1025 ri.node_crc = cpu_to_je32(crc32(0, &ri, sizeof(ri)-8));
1026
1027 ret = jffs2_reserve_space_gc(c, sizeof(ri), &alloclen,
1028 JFFS2_SUMMARY_INODE_SIZE);
1029 if (ret) {
1030 printk(KERN_WARNING "jffs2_reserve_space_gc of %zd bytes for garbage_collect_hole failed: %d\n",
1031 sizeof(ri), ret);
1032 return ret;
1033 }
1034 new_fn = jffs2_write_dnode(c, f, &ri, NULL, 0, ALLOC_GC);
1035
1036 if (IS_ERR(new_fn)) {
1037 printk(KERN_WARNING "Error writing new hole node: %ld\n", PTR_ERR(new_fn));
1038 return PTR_ERR(new_fn);
1039 }
1040 if (je32_to_cpu(ri.version) == f->highest_version) {
1041 jffs2_add_full_dnode_to_inode(c, f, new_fn);
1042 if (f->metadata) {
1043 jffs2_mark_node_obsolete(c, f->metadata->raw);
1044 jffs2_free_full_dnode(f->metadata);
1045 f->metadata = NULL;
1046 }
1047 return 0;
1048 }
1049
1050
1051
1052
1053
1054
1055
1056 D1(if(unlikely(fn->frags <= 1)) {
1057 printk(KERN_WARNING "jffs2_garbage_collect_hole: Replacing fn with %d frag(s) but new ver %d != highest_version %d of ino #%d\n",
1058 fn->frags, je32_to_cpu(ri.version), f->highest_version,
1059 je32_to_cpu(ri.ino));
1060 });
1061
1062
1063 mark_ref_normal(new_fn->raw);
1064
1065 for (frag = jffs2_lookup_node_frag(&f->fragtree, fn->ofs);
1066 frag; frag = frag_next(frag)) {
1067 if (frag->ofs > fn->size + fn->ofs)
1068 break;
1069 if (frag->node == fn) {
1070 frag->node = new_fn;
1071 new_fn->frags++;
1072 fn->frags--;
1073 }
1074 }
1075 if (fn->frags) {
1076 printk(KERN_WARNING "jffs2_garbage_collect_hole: Old node still has frags!\n");
1077 BUG();
1078 }
1079 if (!new_fn->frags) {
1080 printk(KERN_WARNING "jffs2_garbage_collect_hole: New node has no frags!\n");
1081 BUG();
1082 }
1083
1084 jffs2_mark_node_obsolete(c, fn->raw);
1085 jffs2_free_full_dnode(fn);
1086
1087 return 0;
1088}
1089
1090static int jffs2_garbage_collect_dnode(struct jffs2_sb_info *c, struct jffs2_eraseblock *orig_jeb,
1091 struct jffs2_inode_info *f, struct jffs2_full_dnode *fn,
1092 uint32_t start, uint32_t end)
1093{
1094 struct jffs2_full_dnode *new_fn;
1095 struct jffs2_raw_inode ri;
1096 uint32_t alloclen, offset, orig_end, orig_start;
1097 int ret = 0;
1098 unsigned char *comprbuf = NULL, *writebuf;
1099 unsigned long pg;
1100 unsigned char *pg_ptr;
1101
1102 memset(&ri, 0, sizeof(ri));
1103
1104 D1(printk(KERN_DEBUG "Writing replacement dnode for ino #%u from offset 0x%x to 0x%x\n",
1105 f->inocache->ino, start, end));
1106
1107 orig_end = end;
1108 orig_start = start;
1109
1110 if (c->nr_free_blocks + c->nr_erasing_blocks > c->resv_blocks_gcmerge) {
1111
1112
1113
1114
1115
1116
1117
1118 struct jffs2_node_frag *frag;
1119 uint32_t min, max;
1120
1121 min = start & ~(PAGE_CACHE_SIZE-1);
1122 max = min + PAGE_CACHE_SIZE;
1123
1124 frag = jffs2_lookup_node_frag(&f->fragtree, start);
1125
1126
1127
1128 BUG_ON(frag->ofs != start);
1129
1130
1131 while((frag = frag_prev(frag)) && frag->ofs >= min) {
1132
1133
1134
1135 if (frag->ofs > min) {
1136 D1(printk(KERN_DEBUG "Expanding down to cover partial frag (0x%x-0x%x)\n",
1137 frag->ofs, frag->ofs+frag->size));
1138 start = frag->ofs;
1139 continue;
1140 }
1141
1142 if (!frag->node || !frag->node->raw) {
1143 D1(printk(KERN_DEBUG "First frag in page is hole (0x%x-0x%x). Not expanding down.\n",
1144 frag->ofs, frag->ofs+frag->size));
1145 break;
1146 } else {
1147
1148
1149
1150
1151
1152 struct jffs2_raw_node_ref *raw = frag->node->raw;
1153 struct jffs2_eraseblock *jeb;
1154
1155 jeb = &c->blocks[raw->flash_offset / c->sector_size];
1156
1157 if (jeb == c->gcblock) {
1158 D1(printk(KERN_DEBUG "Expanding down to cover frag (0x%x-0x%x) in gcblock at %08x\n",
1159 frag->ofs, frag->ofs+frag->size, ref_offset(raw)));
1160 start = frag->ofs;
1161 break;
1162 }
1163 if (!ISDIRTY(jeb->dirty_size + jeb->wasted_size)) {
1164 D1(printk(KERN_DEBUG "Not expanding down to cover frag (0x%x-0x%x) in clean block %08x\n",
1165 frag->ofs, frag->ofs+frag->size, jeb->offset));
1166 break;
1167 }
1168
1169 D1(printk(KERN_DEBUG "Expanding down to cover frag (0x%x-0x%x) in dirty block %08x\n",
1170 frag->ofs, frag->ofs+frag->size, jeb->offset));
1171 start = frag->ofs;
1172 break;
1173 }
1174 }
1175
1176
1177
1178
1179 frag = jffs2_lookup_node_frag(&f->fragtree, end-1);
1180
1181 while((frag = frag_next(frag)) && frag->ofs+frag->size <= max) {
1182
1183
1184
1185 if (frag->ofs+frag->size < max) {
1186 D1(printk(KERN_DEBUG "Expanding up to cover partial frag (0x%x-0x%x)\n",
1187 frag->ofs, frag->ofs+frag->size));
1188 end = frag->ofs + frag->size;
1189 continue;
1190 }
1191
1192 if (!frag->node || !frag->node->raw) {
1193 D1(printk(KERN_DEBUG "Last frag in page is hole (0x%x-0x%x). Not expanding up.\n",
1194 frag->ofs, frag->ofs+frag->size));
1195 break;
1196 } else {
1197
1198
1199
1200
1201
1202 struct jffs2_raw_node_ref *raw = frag->node->raw;
1203 struct jffs2_eraseblock *jeb;
1204
1205 jeb = &c->blocks[raw->flash_offset / c->sector_size];
1206
1207 if (jeb == c->gcblock) {
1208 D1(printk(KERN_DEBUG "Expanding up to cover frag (0x%x-0x%x) in gcblock at %08x\n",
1209 frag->ofs, frag->ofs+frag->size, ref_offset(raw)));
1210 end = frag->ofs + frag->size;
1211 break;
1212 }
1213 if (!ISDIRTY(jeb->dirty_size + jeb->wasted_size)) {
1214 D1(printk(KERN_DEBUG "Not expanding up to cover frag (0x%x-0x%x) in clean block %08x\n",
1215 frag->ofs, frag->ofs+frag->size, jeb->offset));
1216 break;
1217 }
1218
1219 D1(printk(KERN_DEBUG "Expanding up to cover frag (0x%x-0x%x) in dirty block %08x\n",
1220 frag->ofs, frag->ofs+frag->size, jeb->offset));
1221 end = frag->ofs + frag->size;
1222 break;
1223 }
1224 }
1225 D1(printk(KERN_DEBUG "Expanded dnode to write from (0x%x-0x%x) to (0x%x-0x%x)\n",
1226 orig_start, orig_end, start, end));
1227
1228 D1(BUG_ON(end > frag_last(&f->fragtree)->ofs + frag_last(&f->fragtree)->size));
1229 BUG_ON(end < orig_end);
1230 BUG_ON(start > orig_start);
1231 }
1232
1233
1234
1235
1236
1237
1238
1239
1240 pg_ptr = jffs2_gc_fetch_page(c, f, start, &pg);
1241
1242 if (IS_ERR(pg_ptr)) {
1243 printk(KERN_WARNING "read_cache_page() returned error: %ld\n", PTR_ERR(pg_ptr));
1244 return PTR_ERR(pg_ptr);
1245 }
1246
1247 offset = start;
1248 while(offset < orig_end) {
1249 uint32_t datalen;
1250 uint32_t cdatalen;
1251 uint16_t comprtype = JFFS2_COMPR_NONE;
1252
1253 ret = jffs2_reserve_space_gc(c, sizeof(ri) + JFFS2_MIN_DATA_LEN,
1254 &alloclen, JFFS2_SUMMARY_INODE_SIZE);
1255
1256 if (ret) {
1257 printk(KERN_WARNING "jffs2_reserve_space_gc of %zd bytes for garbage_collect_dnode failed: %d\n",
1258 sizeof(ri)+ JFFS2_MIN_DATA_LEN, ret);
1259 break;
1260 }
1261 cdatalen = min_t(uint32_t, alloclen - sizeof(ri), end - offset);
1262 datalen = end - offset;
1263
1264 writebuf = pg_ptr + (offset & (PAGE_CACHE_SIZE -1));
1265
1266 comprtype = jffs2_compress(c, f, writebuf, &comprbuf, &datalen, &cdatalen);
1267
1268 ri.magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
1269 ri.nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE);
1270 ri.totlen = cpu_to_je32(sizeof(ri) + cdatalen);
1271 ri.hdr_crc = cpu_to_je32(crc32(0, &ri, sizeof(struct jffs2_unknown_node)-4));
1272
1273 ri.ino = cpu_to_je32(f->inocache->ino);
1274 ri.version = cpu_to_je32(++f->highest_version);
1275 ri.mode = cpu_to_jemode(JFFS2_F_I_MODE(f));
1276 ri.uid = cpu_to_je16(JFFS2_F_I_UID(f));
1277 ri.gid = cpu_to_je16(JFFS2_F_I_GID(f));
1278 ri.isize = cpu_to_je32(JFFS2_F_I_SIZE(f));
1279 ri.atime = cpu_to_je32(JFFS2_F_I_ATIME(f));
1280 ri.ctime = cpu_to_je32(JFFS2_F_I_CTIME(f));
1281 ri.mtime = cpu_to_je32(JFFS2_F_I_MTIME(f));
1282 ri.offset = cpu_to_je32(offset);
1283 ri.csize = cpu_to_je32(cdatalen);
1284 ri.dsize = cpu_to_je32(datalen);
1285 ri.compr = comprtype & 0xff;
1286 ri.usercompr = (comprtype >> 8) & 0xff;
1287 ri.node_crc = cpu_to_je32(crc32(0, &ri, sizeof(ri)-8));
1288 ri.data_crc = cpu_to_je32(crc32(0, comprbuf, cdatalen));
1289
1290 new_fn = jffs2_write_dnode(c, f, &ri, comprbuf, cdatalen, ALLOC_GC);
1291
1292 jffs2_free_comprbuf(comprbuf, writebuf);
1293
1294 if (IS_ERR(new_fn)) {
1295 printk(KERN_WARNING "Error writing new dnode: %ld\n", PTR_ERR(new_fn));
1296 ret = PTR_ERR(new_fn);
1297 break;
1298 }
1299 ret = jffs2_add_full_dnode_to_inode(c, f, new_fn);
1300 offset += datalen;
1301 if (f->metadata) {
1302 jffs2_mark_node_obsolete(c, f->metadata->raw);
1303 jffs2_free_full_dnode(f->metadata);
1304 f->metadata = NULL;
1305 }
1306 }
1307
1308 jffs2_gc_release_page(c, pg_ptr, &pg);
1309 return ret;
1310}