2 * JFFS2 -- Journalling Flash File System, Version 2.
4 * Copyright (C) 2001-2003 Red Hat, Inc.
5 * Copyright (C) 2004 Thomas Gleixner <tglx@linutronix.de>
7 * Created by David Woodhouse <dwmw2@infradead.org>
8 * Modified debugged and enhanced by Thomas Gleixner <tglx@linutronix.de>
10 * For licensing information, see the file 'LICENCE' in this directory.
12 * $Id: wbuf.c,v 1.100 2005/09/30 13:59:13 dedekind Exp $
16 #include <linux/kernel.h>
17 #include <linux/slab.h>
18 #include <linux/mtd/mtd.h>
19 #include <linux/crc32.h>
20 #include <linux/mtd/nand.h>
21 #include <linux/jiffies.h>
22 #include <linux/sched.h>
26 /* For testing write failures */
31 static unsigned char *brokenbuf;
34 #define PAGE_DIV(x) ( ((unsigned long)(x) / (unsigned long)(c->wbuf_pagesize)) * (unsigned long)(c->wbuf_pagesize) )
35 #define PAGE_MOD(x) ( (unsigned long)(x) % (unsigned long)(c->wbuf_pagesize) )
37 /* max. erase failures before we mark a block bad */
38 #define MAX_ERASE_FAILURES 2
40 struct jffs2_inodirty {
42 struct jffs2_inodirty *next;
45 static struct jffs2_inodirty inodirty_nomem;
47 static int jffs2_wbuf_pending_for_ino(struct jffs2_sb_info *c, uint32_t ino)
49 struct jffs2_inodirty *this = c->wbuf_inodes;
51 /* If a malloc failed, consider _everything_ dirty */
52 if (this == &inodirty_nomem)
55 /* If ino == 0, _any_ non-GC writes mean 'yes' */
59 /* Look to see if the inode in question is pending in the wbuf */
68 static void jffs2_clear_wbuf_ino_list(struct jffs2_sb_info *c)
70 struct jffs2_inodirty *this;
72 this = c->wbuf_inodes;
74 if (this != &inodirty_nomem) {
76 struct jffs2_inodirty *next = this->next;
81 c->wbuf_inodes = NULL;
84 static void jffs2_wbuf_dirties_inode(struct jffs2_sb_info *c, uint32_t ino)
86 struct jffs2_inodirty *new;
88 /* Mark the superblock dirty so that kupdated will flush... */
89 jffs2_erase_pending_trigger(c);
91 if (jffs2_wbuf_pending_for_ino(c, ino))
94 new = kmalloc(sizeof(*new), GFP_KERNEL);
96 D1(printk(KERN_DEBUG "No memory to allocate inodirty. Fallback to all considered dirty\n"));
97 jffs2_clear_wbuf_ino_list(c);
98 c->wbuf_inodes = &inodirty_nomem;
102 new->next = c->wbuf_inodes;
103 c->wbuf_inodes = new;
107 static inline void jffs2_refile_wbuf_blocks(struct jffs2_sb_info *c)
109 struct list_head *this, *next;
112 if (list_empty(&c->erasable_pending_wbuf_list))
115 list_for_each_safe(this, next, &c->erasable_pending_wbuf_list) {
116 struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list);
118 D1(printk(KERN_DEBUG "Removing eraseblock at 0x%08x from erasable_pending_wbuf_list...\n", jeb->offset));
120 if ((jiffies + (n++)) & 127) {
121 /* Most of the time, we just erase it immediately. Otherwise we
122 spend ages scanning it on mount, etc. */
123 D1(printk(KERN_DEBUG "...and adding to erase_pending_list\n"));
124 list_add_tail(&jeb->list, &c->erase_pending_list);
125 c->nr_erasing_blocks++;
126 jffs2_erase_pending_trigger(c);
128 /* Sometimes, however, we leave it elsewhere so it doesn't get
129 immediately reused, and we spread the load a bit. */
130 D1(printk(KERN_DEBUG "...and adding to erasable_list\n"));
131 list_add_tail(&jeb->list, &c->erasable_list);
136 #define REFILE_NOTEMPTY 0
137 #define REFILE_ANYWAY 1
139 static void jffs2_block_refile(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, int allow_empty)
141 D1(printk("About to refile bad block at %08x\n", jeb->offset));
143 /* File the existing block on the bad_used_list.... */
144 if (c->nextblock == jeb)
146 else /* Not sure this should ever happen... need more coffee */
147 list_del(&jeb->list);
148 if (jeb->first_node) {
149 D1(printk("Refiling block at %08x to bad_used_list\n", jeb->offset));
150 list_add(&jeb->list, &c->bad_used_list);
152 BUG_ON(allow_empty == REFILE_NOTEMPTY);
153 /* It has to have had some nodes or we couldn't be here */
154 D1(printk("Refiling block at %08x to erase_pending_list\n", jeb->offset));
155 list_add(&jeb->list, &c->erase_pending_list);
156 c->nr_erasing_blocks++;
157 jffs2_erase_pending_trigger(c);
160 if (!jffs2_prealloc_raw_node_refs(c, jeb, 1)) {
161 uint32_t oldfree = jeb->free_size;
163 jffs2_link_node_ref(c, jeb,
164 (jeb->offset+c->sector_size-oldfree) | REF_OBSOLETE,
166 /* convert to wasted */
167 c->wasted_size += oldfree;
168 jeb->wasted_size += oldfree;
169 c->dirty_size -= oldfree;
170 jeb->dirty_size -= oldfree;
173 jffs2_dbg_dump_block_lists_nolock(c);
174 jffs2_dbg_acct_sanity_check_nolock(c,jeb);
175 jffs2_dbg_acct_paranoia_check_nolock(c, jeb);
178 static struct jffs2_raw_node_ref **jffs2_incore_replace_raw(struct jffs2_sb_info *c,
179 struct jffs2_inode_info *f,
180 struct jffs2_raw_node_ref *raw,
181 union jffs2_node_union *node)
183 struct jffs2_node_frag *frag;
184 struct jffs2_full_dirent *fd;
186 dbg_noderef("incore_replace_raw: node at %p is {%04x,%04x}\n",
187 node, je16_to_cpu(node->u.magic), je16_to_cpu(node->u.nodetype));
189 BUG_ON(je16_to_cpu(node->u.magic) != 0x1985 &&
190 je16_to_cpu(node->u.magic) != 0);
192 switch (je16_to_cpu(node->u.nodetype)) {
193 case JFFS2_NODETYPE_INODE:
194 if (f->metadata && f->metadata->raw == raw) {
195 dbg_noderef("Will replace ->raw in f->metadata at %p\n", f->metadata);
196 return &f->metadata->raw;
198 frag = jffs2_lookup_node_frag(&f->fragtree, je32_to_cpu(node->i.offset));
200 /* Find a frag which refers to the full_dnode we want to modify */
201 while (!frag->node || frag->node->raw != raw) {
202 frag = frag_next(frag);
205 dbg_noderef("Will replace ->raw in full_dnode at %p\n", frag->node);
206 return &frag->node->raw;
208 case JFFS2_NODETYPE_DIRENT:
209 for (fd = f->dents; fd; fd = fd->next) {
210 if (fd->raw == raw) {
211 dbg_noderef("Will replace ->raw in full_dirent at %p\n", fd);
218 dbg_noderef("Don't care about replacing raw for nodetype %x\n",
219 je16_to_cpu(node->u.nodetype));
225 /* Recover from failure to write wbuf. Recover the nodes up to the
226 * wbuf, not the one which we were starting to try to write. */
228 static void jffs2_wbuf_recover(struct jffs2_sb_info *c)
230 struct jffs2_eraseblock *jeb, *new_jeb;
231 struct jffs2_raw_node_ref *raw, *next, *first_raw = NULL;
236 uint32_t start, end, ofs, len;
238 jeb = &c->blocks[c->wbuf_ofs / c->sector_size];
240 spin_lock(&c->erase_completion_lock);
241 if (c->wbuf_ofs % c->mtd->erasesize)
242 jffs2_block_refile(c, jeb, REFILE_NOTEMPTY);
244 jffs2_block_refile(c, jeb, REFILE_ANYWAY);
245 spin_unlock(&c->erase_completion_lock);
247 BUG_ON(!ref_obsolete(jeb->last_node));
249 /* Find the first node to be recovered, by skipping over every
250 node which ends before the wbuf starts, or which is obsolete. */
251 for (next = raw = jeb->first_node; next; raw = next) {
252 next = ref_next(raw);
254 if (ref_obsolete(raw) ||
255 (next && ref_offset(next) <= c->wbuf_ofs)) {
256 dbg_noderef("Skipping node at 0x%08x(%d)-0x%08x which is either before 0x%08x or obsolete\n",
257 ref_offset(raw), ref_flags(raw),
258 (ref_offset(raw) + ref_totlen(c, jeb, raw)),
262 dbg_noderef("First node to be recovered is at 0x%08x(%d)-0x%08x\n",
263 ref_offset(raw), ref_flags(raw),
264 (ref_offset(raw) + ref_totlen(c, jeb, raw)));
271 /* All nodes were obsolete. Nothing to recover. */
272 D1(printk(KERN_DEBUG "No non-obsolete nodes to be recovered. Just filing block bad\n"));
277 start = ref_offset(first_raw);
278 end = ref_offset(jeb->last_node);
281 /* Count the number of refs which need to be copied */
282 while ((raw = ref_next(raw)) != jeb->last_node)
285 dbg_noderef("wbuf recover %08x-%08x (%d bytes in %d nodes)\n",
286 start, end, end - start, nr_refile);
289 if (start < c->wbuf_ofs) {
290 /* First affected node was already partially written.
291 * Attempt to reread the old data into our buffer. */
293 buf = kmalloc(end - start, GFP_KERNEL);
295 printk(KERN_CRIT "Malloc failure in wbuf recovery. Data loss ensues.\n");
301 ret = c->mtd->read(c->mtd, start, c->wbuf_ofs - start, &retlen, buf);
303 /* ECC recovered ? */
304 if ((ret == -EUCLEAN || ret == -EBADMSG) &&
305 (retlen == c->wbuf_ofs - start))
308 if (ret || retlen != c->wbuf_ofs - start) {
309 printk(KERN_CRIT "Old data are already lost in wbuf recovery. Data loss ensues.\n");
314 first_raw = ref_next(first_raw);
316 while (first_raw && ref_obsolete(first_raw)) {
317 first_raw = ref_next(first_raw);
321 /* If this was the only node to be recovered, give up */
327 /* It wasn't. Go on and try to recover nodes complete in the wbuf */
328 start = ref_offset(first_raw);
329 dbg_noderef("wbuf now recover %08x-%08x (%d bytes in %d nodes)\n",
330 start, end, end - start, nr_refile);
333 /* Read succeeded. Copy the remaining data from the wbuf */
334 memcpy(buf + (c->wbuf_ofs - start), c->wbuf, end - c->wbuf_ofs);
337 /* OK... we're to rewrite (end-start) bytes of data from first_raw onwards.
338 Either 'buf' contains the data, or we find it in the wbuf */
340 /* ... and get an allocation of space from a shiny new block instead */
341 ret = jffs2_reserve_space_gc(c, end-start, &len, JFFS2_SUMMARY_NOSUM_SIZE);
343 printk(KERN_WARNING "Failed to allocate space for wbuf recovery. Data loss ensues.\n");
348 /* The summary is not recovered, so it must be disabled for this erase block */
349 jffs2_sum_disable_collecting(c->summary);
351 ret = jffs2_prealloc_raw_node_refs(c, c->nextblock, nr_refile);
353 printk(KERN_WARNING "Failed to allocate node refs for wbuf recovery. Data loss ensues.\n");
360 if (end-start >= c->wbuf_pagesize) {
361 /* Need to do another write immediately, but it's possible
362 that this is just because the wbuf itself is completely
363 full, and there's nothing earlier read back from the
364 flash. Hence 'buf' isn't necessarily what we're writing
366 unsigned char *rewrite_buf = buf?:c->wbuf;
367 uint32_t towrite = (end-start) - ((end-start)%c->wbuf_pagesize);
369 D1(printk(KERN_DEBUG "Write 0x%x bytes at 0x%08x in wbuf recover\n",
374 if (breakme++ == 20) {
375 printk(KERN_NOTICE "Faking write error at 0x%08x\n", ofs);
377 c->mtd->write(c->mtd, ofs, towrite, &retlen,
382 ret = c->mtd->write(c->mtd, ofs, towrite, &retlen,
385 if (ret || retlen != towrite) {
386 /* Argh. We tried. Really we did. */
387 printk(KERN_CRIT "Recovery of wbuf failed due to a second write error\n");
391 jffs2_add_physical_node_ref(c, ofs | REF_OBSOLETE, ref_totlen(c, jeb, first_raw), NULL);
395 printk(KERN_NOTICE "Recovery of wbuf succeeded to %08x\n", ofs);
397 c->wbuf_len = (end - start) - towrite;
398 c->wbuf_ofs = ofs + towrite;
399 memmove(c->wbuf, rewrite_buf + towrite, c->wbuf_len);
400 /* Don't muck about with c->wbuf_inodes. False positives are harmless. */
402 /* OK, now we're left with the dregs in whichever buffer we're using */
404 memcpy(c->wbuf, buf, end-start);
406 memmove(c->wbuf, c->wbuf + (start - c->wbuf_ofs), end - start);
409 c->wbuf_len = end - start;
412 /* Now sort out the jffs2_raw_node_refs, moving them from the old to the next block */
413 new_jeb = &c->blocks[ofs / c->sector_size];
415 spin_lock(&c->erase_completion_lock);
416 for (raw = first_raw; raw != jeb->last_node; raw = ref_next(raw)) {
417 uint32_t rawlen = ref_totlen(c, jeb, raw);
418 struct jffs2_inode_cache *ic;
419 struct jffs2_raw_node_ref *new_ref;
420 struct jffs2_raw_node_ref **adjust_ref = NULL;
421 struct jffs2_inode_info *f = NULL;
423 D1(printk(KERN_DEBUG "Refiling block of %08x at %08x(%d) to %08x\n",
424 rawlen, ref_offset(raw), ref_flags(raw), ofs));
426 ic = jffs2_raw_ref_to_ic(raw);
428 /* Ick. This XATTR mess should be fixed shortly... */
429 if (ic && ic->class == RAWNODE_CLASS_XATTR_DATUM) {
430 struct jffs2_xattr_datum *xd = (void *)ic;
431 BUG_ON(xd->node != raw);
432 adjust_ref = &xd->node;
433 raw->next_in_ino = NULL;
435 } else if (ic && ic->class == RAWNODE_CLASS_XATTR_REF) {
436 struct jffs2_xattr_datum *xr = (void *)ic;
437 BUG_ON(xr->node != raw);
438 adjust_ref = &xr->node;
439 raw->next_in_ino = NULL;
441 } else if (ic && ic->class == RAWNODE_CLASS_INODE_CACHE) {
442 struct jffs2_raw_node_ref **p = &ic->nodes;
444 /* Remove the old node from the per-inode list */
445 while (*p && *p != (void *)ic) {
447 (*p) = (raw->next_in_ino);
448 raw->next_in_ino = NULL;
451 p = &((*p)->next_in_ino);
454 if (ic->state == INO_STATE_PRESENT && !ref_obsolete(raw)) {
455 /* If it's an in-core inode, then we have to adjust any
456 full_dirent or full_dnode structure to point to the
457 new version instead of the old */
458 f = jffs2_gc_fetch_inode(c, ic->ino, ic->nlink);
460 /* Should never happen; it _must_ be present */
461 JFFS2_ERROR("Failed to iget() ino #%u, err %ld\n",
462 ic->ino, PTR_ERR(f));
465 /* We don't lock f->sem. There's a number of ways we could
466 end up in here with it already being locked, and nobody's
467 going to modify it on us anyway because we hold the
468 alloc_sem. We're only changing one ->raw pointer too,
469 which we can get away with without upsetting readers. */
470 adjust_ref = jffs2_incore_replace_raw(c, f, raw,
471 (void *)(buf?:c->wbuf) + (ref_offset(raw) - start));
472 } else if (unlikely(ic->state != INO_STATE_PRESENT &&
473 ic->state != INO_STATE_CHECKEDABSENT &&
474 ic->state != INO_STATE_GC)) {
475 JFFS2_ERROR("Inode #%u is in strange state %d!\n", ic->ino, ic->state);
480 new_ref = jffs2_link_node_ref(c, new_jeb, ofs | ref_flags(raw), rawlen, ic);
483 BUG_ON(*adjust_ref != raw);
484 *adjust_ref = new_ref;
487 jffs2_gc_release_inode(c, f);
489 if (!ref_obsolete(raw)) {
490 jeb->dirty_size += rawlen;
491 jeb->used_size -= rawlen;
492 c->dirty_size += rawlen;
493 c->used_size -= rawlen;
494 raw->flash_offset = ref_offset(raw) | REF_OBSOLETE;
495 BUG_ON(raw->next_in_ino);
502 /* Fix up the original jeb now it's on the bad_list */
503 if (first_raw == jeb->first_node) {
504 D1(printk(KERN_DEBUG "Failing block at %08x is now empty. Moving to erase_pending_list\n", jeb->offset));
505 list_move(&jeb->list, &c->erase_pending_list);
506 c->nr_erasing_blocks++;
507 jffs2_erase_pending_trigger(c);
510 jffs2_dbg_acct_sanity_check_nolock(c, jeb);
511 jffs2_dbg_acct_paranoia_check_nolock(c, jeb);
513 jffs2_dbg_acct_sanity_check_nolock(c, new_jeb);
514 jffs2_dbg_acct_paranoia_check_nolock(c, new_jeb);
516 spin_unlock(&c->erase_completion_lock);
518 D1(printk(KERN_DEBUG "wbuf recovery completed OK. wbuf_ofs 0x%08x, len 0x%x\n", c->wbuf_ofs, c->wbuf_len));
522 /* Meaning of pad argument:
523 0: Do not pad. Probably pointless - we only ever use this when we can't pad anyway.
524 1: Pad, do not adjust nextblock free_size
525 2: Pad, adjust nextblock free_size
528 #define PAD_NOACCOUNT 1
529 #define PAD_ACCOUNTING 2
531 static int __jffs2_flush_wbuf(struct jffs2_sb_info *c, int pad)
533 struct jffs2_eraseblock *wbuf_jeb;
537 /* Nothing to do if not write-buffering the flash. In particular, we shouldn't
538 del_timer() the timer we never initialised. */
539 if (!jffs2_is_writebuffered(c))
542 if (!down_trylock(&c->alloc_sem)) {
544 printk(KERN_CRIT "jffs2_flush_wbuf() called with alloc_sem not locked!\n");
548 if (!c->wbuf_len) /* already checked c->wbuf above */
551 wbuf_jeb = &c->blocks[c->wbuf_ofs / c->sector_size];
552 if (jffs2_prealloc_raw_node_refs(c, wbuf_jeb, c->nextblock->allocated_refs + 1))
555 /* claim remaining space on the page
556 this happens, if we have a change to a new block,
557 or if fsync forces us to flush the writebuffer.
558 if we have a switch to next page, we will not have
559 enough remaining space for this.
562 c->wbuf_len = PAD(c->wbuf_len);
564 /* Pad with JFFS2_DIRTY_BITMASK initially. this helps out ECC'd NOR
565 with 8 byte page size */
566 memset(c->wbuf + c->wbuf_len, 0, c->wbuf_pagesize - c->wbuf_len);
568 if ( c->wbuf_len + sizeof(struct jffs2_unknown_node) < c->wbuf_pagesize) {
569 struct jffs2_unknown_node *padnode = (void *)(c->wbuf + c->wbuf_len);
570 padnode->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
571 padnode->nodetype = cpu_to_je16(JFFS2_NODETYPE_PADDING);
572 padnode->totlen = cpu_to_je32(c->wbuf_pagesize - c->wbuf_len);
573 padnode->hdr_crc = cpu_to_je32(crc32(0, padnode, sizeof(*padnode)-4));
576 /* else jffs2_flash_writev has actually filled in the rest of the
577 buffer for us, and will deal with the node refs etc. later. */
581 if (breakme++ == 20) {
582 printk(KERN_NOTICE "Faking write error at 0x%08x\n", c->wbuf_ofs);
584 c->mtd->write(c->mtd, c->wbuf_ofs, c->wbuf_pagesize, &retlen,
590 ret = c->mtd->write(c->mtd, c->wbuf_ofs, c->wbuf_pagesize, &retlen, c->wbuf);
592 if (ret || retlen != c->wbuf_pagesize) {
594 printk(KERN_WARNING "jffs2_flush_wbuf(): Write failed with %d\n",ret);
596 printk(KERN_WARNING "jffs2_flush_wbuf(): Write was short: %zd instead of %d\n",
597 retlen, c->wbuf_pagesize);
601 jffs2_wbuf_recover(c);
606 /* Adjust free size of the block if we padded. */
608 uint32_t waste = c->wbuf_pagesize - c->wbuf_len;
610 D1(printk(KERN_DEBUG "jffs2_flush_wbuf() adjusting free_size of %sblock at %08x\n",
611 (wbuf_jeb==c->nextblock)?"next":"", wbuf_jeb->offset));
613 /* wbuf_pagesize - wbuf_len is the amount of space that's to be
614 padded. If there is less free space in the block than that,
615 something screwed up */
616 if (wbuf_jeb->free_size < waste) {
617 printk(KERN_CRIT "jffs2_flush_wbuf(): Accounting error. wbuf at 0x%08x has 0x%03x bytes, 0x%03x left.\n",
618 c->wbuf_ofs, c->wbuf_len, waste);
619 printk(KERN_CRIT "jffs2_flush_wbuf(): But free_size for block at 0x%08x is only 0x%08x\n",
620 wbuf_jeb->offset, wbuf_jeb->free_size);
624 spin_lock(&c->erase_completion_lock);
626 jffs2_link_node_ref(c, wbuf_jeb, (c->wbuf_ofs + c->wbuf_len) | REF_OBSOLETE, waste, NULL);
627 /* FIXME: that made it count as dirty. Convert to wasted */
628 wbuf_jeb->dirty_size -= waste;
629 c->dirty_size -= waste;
630 wbuf_jeb->wasted_size += waste;
631 c->wasted_size += waste;
633 spin_lock(&c->erase_completion_lock);
635 /* Stick any now-obsoleted blocks on the erase_pending_list */
636 jffs2_refile_wbuf_blocks(c);
637 jffs2_clear_wbuf_ino_list(c);
638 spin_unlock(&c->erase_completion_lock);
640 memset(c->wbuf,0xff,c->wbuf_pagesize);
641 /* adjust write buffer offset, else we get a non contiguous write bug */
642 c->wbuf_ofs += c->wbuf_pagesize;
647 /* Trigger garbage collection to flush the write-buffer.
648 If ino arg is zero, do it if _any_ real (i.e. not GC) writes are
649 outstanding. If ino arg non-zero, do it only if a write for the
650 given inode is outstanding. */
651 int jffs2_flush_wbuf_gc(struct jffs2_sb_info *c, uint32_t ino)
653 uint32_t old_wbuf_ofs;
654 uint32_t old_wbuf_len;
657 D1(printk(KERN_DEBUG "jffs2_flush_wbuf_gc() called for ino #%u...\n", ino));
663 if (!jffs2_wbuf_pending_for_ino(c, ino)) {
664 D1(printk(KERN_DEBUG "Ino #%d not pending in wbuf. Returning\n", ino));
669 old_wbuf_ofs = c->wbuf_ofs;
670 old_wbuf_len = c->wbuf_len;
672 if (c->unchecked_size) {
673 /* GC won't make any progress for a while */
674 D1(printk(KERN_DEBUG "jffs2_flush_wbuf_gc() padding. Not finished checking\n"));
675 down_write(&c->wbuf_sem);
676 ret = __jffs2_flush_wbuf(c, PAD_ACCOUNTING);
677 /* retry flushing wbuf in case jffs2_wbuf_recover
678 left some data in the wbuf */
680 ret = __jffs2_flush_wbuf(c, PAD_ACCOUNTING);
681 up_write(&c->wbuf_sem);
682 } else while (old_wbuf_len &&
683 old_wbuf_ofs == c->wbuf_ofs) {
687 D1(printk(KERN_DEBUG "jffs2_flush_wbuf_gc() calls gc pass\n"));
689 ret = jffs2_garbage_collect_pass(c);
691 /* GC failed. Flush it with padding instead */
693 down_write(&c->wbuf_sem);
694 ret = __jffs2_flush_wbuf(c, PAD_ACCOUNTING);
695 /* retry flushing wbuf in case jffs2_wbuf_recover
696 left some data in the wbuf */
698 ret = __jffs2_flush_wbuf(c, PAD_ACCOUNTING);
699 up_write(&c->wbuf_sem);
705 D1(printk(KERN_DEBUG "jffs2_flush_wbuf_gc() ends...\n"));
711 /* Pad write-buffer to end and write it, wasting space. */
712 int jffs2_flush_wbuf_pad(struct jffs2_sb_info *c)
719 down_write(&c->wbuf_sem);
720 ret = __jffs2_flush_wbuf(c, PAD_NOACCOUNT);
721 /* retry - maybe wbuf recover left some data in wbuf. */
723 ret = __jffs2_flush_wbuf(c, PAD_NOACCOUNT);
724 up_write(&c->wbuf_sem);
729 static size_t jffs2_fill_wbuf(struct jffs2_sb_info *c, const uint8_t *buf,
732 if (len && !c->wbuf_len && (len >= c->wbuf_pagesize))
735 if (len > (c->wbuf_pagesize - c->wbuf_len))
736 len = c->wbuf_pagesize - c->wbuf_len;
737 memcpy(c->wbuf + c->wbuf_len, buf, len);
738 c->wbuf_len += (uint32_t) len;
742 int jffs2_flash_writev(struct jffs2_sb_info *c, const struct kvec *invecs,
743 unsigned long count, loff_t to, size_t *retlen,
746 struct jffs2_eraseblock *jeb;
747 size_t wbuf_retlen, donelen = 0;
748 uint32_t outvec_to = to;
751 /* If not writebuffered flash, don't bother */
752 if (!jffs2_is_writebuffered(c))
753 return jffs2_flash_direct_writev(c, invecs, count, to, retlen);
755 down_write(&c->wbuf_sem);
757 /* If wbuf_ofs is not initialized, set it to target address */
758 if (c->wbuf_ofs == 0xFFFFFFFF) {
759 c->wbuf_ofs = PAGE_DIV(to);
760 c->wbuf_len = PAGE_MOD(to);
761 memset(c->wbuf,0xff,c->wbuf_pagesize);
765 * Sanity checks on target address. It's permitted to write
766 * at PAD(c->wbuf_len+c->wbuf_ofs), and it's permitted to
767 * write at the beginning of a new erase block. Anything else,
768 * and you die. New block starts at xxx000c (0-b = block
771 if (SECTOR_ADDR(to) != SECTOR_ADDR(c->wbuf_ofs)) {
772 /* It's a write to a new block */
774 D1(printk(KERN_DEBUG "jffs2_flash_writev() to 0x%lx "
775 "causes flush of wbuf at 0x%08x\n",
776 (unsigned long)to, c->wbuf_ofs));
777 ret = __jffs2_flush_wbuf(c, PAD_NOACCOUNT);
781 /* set pointer to new block */
782 c->wbuf_ofs = PAGE_DIV(to);
783 c->wbuf_len = PAGE_MOD(to);
786 if (to != PAD(c->wbuf_ofs + c->wbuf_len)) {
787 /* We're not writing immediately after the writebuffer. Bad. */
788 printk(KERN_CRIT "jffs2_flash_writev(): Non-contiguous write "
789 "to %08lx\n", (unsigned long)to);
791 printk(KERN_CRIT "wbuf was previously %08x-%08x\n",
792 c->wbuf_ofs, c->wbuf_ofs+c->wbuf_len);
796 /* adjust alignment offset */
797 if (c->wbuf_len != PAGE_MOD(to)) {
798 c->wbuf_len = PAGE_MOD(to);
799 /* take care of alignment to next page */
801 c->wbuf_len = c->wbuf_pagesize;
802 ret = __jffs2_flush_wbuf(c, NOPAD);
808 for (invec = 0; invec < count; invec++) {
809 int vlen = invecs[invec].iov_len;
810 uint8_t *v = invecs[invec].iov_base;
812 wbuf_retlen = jffs2_fill_wbuf(c, v, vlen);
814 if (c->wbuf_len == c->wbuf_pagesize) {
815 ret = __jffs2_flush_wbuf(c, NOPAD);
820 outvec_to += wbuf_retlen;
821 donelen += wbuf_retlen;
824 if (vlen >= c->wbuf_pagesize) {
825 ret = c->mtd->write(c->mtd, outvec_to, PAGE_DIV(vlen),
827 if (ret < 0 || wbuf_retlen != PAGE_DIV(vlen))
831 outvec_to += wbuf_retlen;
832 c->wbuf_ofs = outvec_to;
833 donelen += wbuf_retlen;
837 wbuf_retlen = jffs2_fill_wbuf(c, v, vlen);
838 if (c->wbuf_len == c->wbuf_pagesize) {
839 ret = __jffs2_flush_wbuf(c, NOPAD);
844 outvec_to += wbuf_retlen;
845 donelen += wbuf_retlen;
849 * If there's a remainder in the wbuf and it's a non-GC write,
850 * remember that the wbuf affects this ino
854 if (jffs2_sum_active()) {
855 int res = jffs2_sum_add_kvec(c, invecs, count, (uint32_t) to);
860 if (c->wbuf_len && ino)
861 jffs2_wbuf_dirties_inode(c, ino);
864 up_write(&c->wbuf_sem);
869 * At this point we have no problem, c->wbuf is empty. However
870 * refile nextblock to avoid writing again to same address.
873 spin_lock(&c->erase_completion_lock);
875 jeb = &c->blocks[outvec_to / c->sector_size];
876 jffs2_block_refile(c, jeb, REFILE_ANYWAY);
878 spin_unlock(&c->erase_completion_lock);
882 up_write(&c->wbuf_sem);
887 * This is the entry for flash write.
888 * Check, if we work on NAND FLASH, if so build an kvec and write it via vritev
890 int jffs2_flash_write(struct jffs2_sb_info *c, loff_t ofs, size_t len,
891 size_t *retlen, const u_char *buf)
895 if (!jffs2_is_writebuffered(c))
896 return jffs2_flash_direct_write(c, ofs, len, retlen, buf);
898 vecs[0].iov_base = (unsigned char *) buf;
899 vecs[0].iov_len = len;
900 return jffs2_flash_writev(c, vecs, 1, ofs, retlen, 0);
904 Handle readback from writebuffer and ECC failure return
906 int jffs2_flash_read(struct jffs2_sb_info *c, loff_t ofs, size_t len, size_t *retlen, u_char *buf)
908 loff_t orbf = 0, owbf = 0, lwbf = 0;
911 if (!jffs2_is_writebuffered(c))
912 return c->mtd->read(c->mtd, ofs, len, retlen, buf);
915 down_read(&c->wbuf_sem);
916 ret = c->mtd->read(c->mtd, ofs, len, retlen, buf);
918 if ( (ret == -EBADMSG || ret == -EUCLEAN) && (*retlen == len) ) {
920 printk(KERN_WARNING "mtd->read(0x%zx bytes from 0x%llx)"
921 " returned ECC error\n", len, ofs);
923 * We have the raw data without ECC correction in the buffer,
924 * maybe we are lucky and all data or parts are correct. We
925 * check the node. If data are corrupted node check will sort
926 * it out. We keep this block, it will fail on write or erase
927 * and the we mark it bad. Or should we do that now? But we
928 * should give him a chance. Maybe we had a system crash or
929 * power loss before the ecc write or a erase was completed.
930 * So we return success. :)
935 /* if no writebuffer available or write buffer empty, return */
936 if (!c->wbuf_pagesize || !c->wbuf_len)
939 /* if we read in a different block, return */
940 if (SECTOR_ADDR(ofs) != SECTOR_ADDR(c->wbuf_ofs))
943 if (ofs >= c->wbuf_ofs) {
944 owbf = (ofs - c->wbuf_ofs); /* offset in write buffer */
945 if (owbf > c->wbuf_len) /* is read beyond write buffer ? */
947 lwbf = c->wbuf_len - owbf; /* number of bytes to copy */
951 orbf = (c->wbuf_ofs - ofs); /* offset in read buffer */
952 if (orbf > len) /* is write beyond write buffer ? */
954 lwbf = len - orbf; /* number of bytes to copy */
955 if (lwbf > c->wbuf_len)
959 memcpy(buf+orbf,c->wbuf+owbf,lwbf);
962 up_read(&c->wbuf_sem);
966 #define NR_OOB_SCAN_PAGES 4
968 /* For historical reasons we use only 12 bytes for OOB clean marker */
969 #define OOB_CM_SIZE 12
971 static const struct jffs2_unknown_node oob_cleanmarker =
973 .magic = constant_cpu_to_je16(JFFS2_MAGIC_BITMASK),
974 .nodetype = constant_cpu_to_je16(JFFS2_NODETYPE_CLEANMARKER),
975 .totlen = constant_cpu_to_je32(8)
979 * Check, if the out of band area is empty. This function knows about the clean
980 * marker and if it is present in OOB, treats the OOB as empty anyway.
982 int jffs2_check_oob_empty(struct jffs2_sb_info *c,
983 struct jffs2_eraseblock *jeb, int mode)
986 int cmlen = min_t(int, c->oobavail, OOB_CM_SIZE);
987 struct mtd_oob_ops ops;
989 ops.mode = MTD_OOB_AUTO;
990 ops.ooblen = NR_OOB_SCAN_PAGES * c->oobavail;
991 ops.oobbuf = c->oobbuf;
992 ops.len = ops.ooboffs = ops.retlen = ops.oobretlen = 0;
995 ret = c->mtd->read_oob(c->mtd, jeb->offset, &ops);
996 if (ret || ops.oobretlen != ops.ooblen) {
997 printk(KERN_ERR "cannot read OOB for EB at %08x, requested %zd"
998 " bytes, read %zd bytes, error %d\n",
999 jeb->offset, ops.ooblen, ops.oobretlen, ret);
1005 for(i = 0; i < ops.ooblen; i++) {
1006 if (mode && i < cmlen)
1007 /* Yeah, we know about the cleanmarker */
1010 if (ops.oobbuf[i] != 0xFF) {
1011 D2(printk(KERN_DEBUG "Found %02x at %x in OOB for "
1012 "%08x\n", ops.oobbuf[i], i, jeb->offset));
1021 * Check for a valid cleanmarker.
1022 * Returns: 0 if a valid cleanmarker was found
1023 * 1 if no cleanmarker was found
1024 * negative error code if an error occurred
1026 int jffs2_check_nand_cleanmarker(struct jffs2_sb_info *c,
1027 struct jffs2_eraseblock *jeb)
1029 struct mtd_oob_ops ops;
1030 int ret, cmlen = min_t(int, c->oobavail, OOB_CM_SIZE);
1032 ops.mode = MTD_OOB_AUTO;
1034 ops.oobbuf = c->oobbuf;
1035 ops.len = ops.ooboffs = ops.retlen = ops.oobretlen = 0;
1038 ret = c->mtd->read_oob(c->mtd, jeb->offset, &ops);
1039 if (ret || ops.oobretlen != ops.ooblen) {
1040 printk(KERN_ERR "cannot read OOB for EB at %08x, requested %zd"
1041 " bytes, read %zd bytes, error %d\n",
1042 jeb->offset, ops.ooblen, ops.oobretlen, ret);
1048 return !!memcmp(&oob_cleanmarker, c->oobbuf, cmlen);
1051 int jffs2_write_nand_cleanmarker(struct jffs2_sb_info *c,
1052 struct jffs2_eraseblock *jeb)
1055 struct mtd_oob_ops ops;
1056 int cmlen = min_t(int, c->oobavail, OOB_CM_SIZE);
1058 ops.mode = MTD_OOB_AUTO;
1060 ops.oobbuf = (uint8_t *)&oob_cleanmarker;
1061 ops.len = ops.ooboffs = ops.retlen = ops.oobretlen = 0;
1064 ret = c->mtd->write_oob(c->mtd, jeb->offset, &ops);
1065 if (ret || ops.oobretlen != ops.ooblen) {
1066 printk(KERN_ERR "cannot write OOB for EB at %08x, requested %zd"
1067 " bytes, read %zd bytes, error %d\n",
1068 jeb->offset, ops.ooblen, ops.oobretlen, ret);
1078 * On NAND we try to mark this block bad. If the block was erased more
1079 * than MAX_ERASE_FAILURES we mark it finaly bad.
1080 * Don't care about failures. This block remains on the erase-pending
1081 * or badblock list as long as nobody manipulates the flash with
1082 * a bootloader or something like that.
1085 int jffs2_write_nand_badblock(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, uint32_t bad_offset)
1089 /* if the count is < max, we try to write the counter to the 2nd page oob area */
1090 if( ++jeb->bad_count < MAX_ERASE_FAILURES)
1093 if (!c->mtd->block_markbad)
1094 return 1; // What else can we do?
1096 printk(KERN_WARNING "JFFS2: marking eraseblock at %08x\n as bad", bad_offset);
1097 ret = c->mtd->block_markbad(c->mtd, bad_offset);
1100 D1(printk(KERN_WARNING "jffs2_write_nand_badblock(): Write failed for block at %08x: error %d\n", jeb->offset, ret));
1106 int jffs2_nand_flash_setup(struct jffs2_sb_info *c)
1108 struct nand_ecclayout *oinfo = c->mtd->ecclayout;
1110 if (!c->mtd->oobsize)
1113 /* Cleanmarker is out-of-band, so inline size zero */
1114 c->cleanmarker_size = 0;
1116 if (!oinfo || oinfo->oobavail == 0) {
1117 printk(KERN_ERR "inconsistent device description\n");
1121 D1(printk(KERN_DEBUG "JFFS2 using OOB on NAND\n"));
1123 c->oobavail = oinfo->oobavail;
1125 /* Initialise write buffer */
1126 init_rwsem(&c->wbuf_sem);
1127 c->wbuf_pagesize = c->mtd->writesize;
1128 c->wbuf_ofs = 0xFFFFFFFF;
1130 c->wbuf = kmalloc(c->wbuf_pagesize, GFP_KERNEL);
1134 c->oobbuf = kmalloc(NR_OOB_SCAN_PAGES * c->oobavail, GFP_KERNEL);
1143 void jffs2_nand_flash_cleanup(struct jffs2_sb_info *c)
1149 int jffs2_dataflash_setup(struct jffs2_sb_info *c) {
1150 c->cleanmarker_size = 0; /* No cleanmarkers needed */
1152 /* Initialize write buffer */
1153 init_rwsem(&c->wbuf_sem);
1156 c->wbuf_pagesize = c->mtd->erasesize;
1158 /* Find a suitable c->sector_size
1159 * - Not too much sectors
1160 * - Sectors have to be at least 4 K + some bytes
1161 * - All known dataflashes have erase sizes of 528 or 1056
1162 * - we take at least 8 eraseblocks and want to have at least 8K size
1163 * - The concatenation should be a power of 2
1166 c->sector_size = 8 * c->mtd->erasesize;
1168 while (c->sector_size < 8192) {
1169 c->sector_size *= 2;
1172 /* It may be necessary to adjust the flash size */
1173 c->flash_size = c->mtd->size;
1175 if ((c->flash_size % c->sector_size) != 0) {
1176 c->flash_size = (c->flash_size / c->sector_size) * c->sector_size;
1177 printk(KERN_WARNING "JFFS2 flash size adjusted to %dKiB\n", c->flash_size);
1180 c->wbuf_ofs = 0xFFFFFFFF;
1181 c->wbuf = kmalloc(c->wbuf_pagesize, GFP_KERNEL);
1185 printk(KERN_INFO "JFFS2 write-buffering enabled buffer (%d) erasesize (%d)\n", c->wbuf_pagesize, c->sector_size);
1190 void jffs2_dataflash_cleanup(struct jffs2_sb_info *c) {
1194 int jffs2_nor_wbuf_flash_setup(struct jffs2_sb_info *c) {
1195 /* Cleanmarker currently occupies whole programming regions,
1196 * either one or 2 for 8Byte STMicro flashes. */
1197 c->cleanmarker_size = max(16u, c->mtd->writesize);
1199 /* Initialize write buffer */
1200 init_rwsem(&c->wbuf_sem);
1201 c->wbuf_pagesize = c->mtd->writesize;
1202 c->wbuf_ofs = 0xFFFFFFFF;
1204 c->wbuf = kmalloc(c->wbuf_pagesize, GFP_KERNEL);
1211 void jffs2_nor_wbuf_flash_cleanup(struct jffs2_sb_info *c) {