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.92 2005/04/05 12:51:54 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>
25 /* For testing write failures */
30 static unsigned char *brokenbuf;
33 /* max. erase failures before we mark a block bad */
34 #define MAX_ERASE_FAILURES 2
36 /* two seconds timeout for timed wbuf-flushing */
37 #define WBUF_FLUSH_TIMEOUT 2 * HZ
39 struct jffs2_inodirty {
41 struct jffs2_inodirty *next;
44 static struct jffs2_inodirty inodirty_nomem;
46 static int jffs2_wbuf_pending_for_ino(struct jffs2_sb_info *c, uint32_t ino)
48 struct jffs2_inodirty *this = c->wbuf_inodes;
50 /* If a malloc failed, consider _everything_ dirty */
51 if (this == &inodirty_nomem)
54 /* If ino == 0, _any_ non-GC writes mean 'yes' */
58 /* Look to see if the inode in question is pending in the wbuf */
67 static void jffs2_clear_wbuf_ino_list(struct jffs2_sb_info *c)
69 struct jffs2_inodirty *this;
71 this = c->wbuf_inodes;
73 if (this != &inodirty_nomem) {
75 struct jffs2_inodirty *next = this->next;
80 c->wbuf_inodes = NULL;
83 static void jffs2_wbuf_dirties_inode(struct jffs2_sb_info *c, uint32_t ino)
85 struct jffs2_inodirty *new;
87 /* Mark the superblock dirty so that kupdated will flush... */
88 jffs2_erase_pending_trigger(c);
90 if (jffs2_wbuf_pending_for_ino(c, ino))
93 new = kmalloc(sizeof(*new), GFP_KERNEL);
95 D1(printk(KERN_DEBUG "No memory to allocate inodirty. Fallback to all considered dirty\n"));
96 jffs2_clear_wbuf_ino_list(c);
97 c->wbuf_inodes = &inodirty_nomem;
101 new->next = c->wbuf_inodes;
102 c->wbuf_inodes = new;
106 static inline void jffs2_refile_wbuf_blocks(struct jffs2_sb_info *c)
108 struct list_head *this, *next;
111 if (list_empty(&c->erasable_pending_wbuf_list))
114 list_for_each_safe(this, next, &c->erasable_pending_wbuf_list) {
115 struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list);
117 D1(printk(KERN_DEBUG "Removing eraseblock at 0x%08x from erasable_pending_wbuf_list...\n", jeb->offset));
119 if ((jiffies + (n++)) & 127) {
120 /* Most of the time, we just erase it immediately. Otherwise we
121 spend ages scanning it on mount, etc. */
122 D1(printk(KERN_DEBUG "...and adding to erase_pending_list\n"));
123 list_add_tail(&jeb->list, &c->erase_pending_list);
124 c->nr_erasing_blocks++;
125 jffs2_erase_pending_trigger(c);
127 /* Sometimes, however, we leave it elsewhere so it doesn't get
128 immediately reused, and we spread the load a bit. */
129 D1(printk(KERN_DEBUG "...and adding to erasable_list\n"));
130 list_add_tail(&jeb->list, &c->erasable_list);
135 #define REFILE_NOTEMPTY 0
136 #define REFILE_ANYWAY 1
138 static void jffs2_block_refile(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, int allow_empty)
140 D1(printk("About to refile bad block at %08x\n", jeb->offset));
142 D2(jffs2_dump_block_lists(c));
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);
159 D2(jffs2_dump_block_lists(c));
161 /* Adjust its size counts accordingly */
162 c->wasted_size += jeb->free_size;
163 c->free_size -= jeb->free_size;
164 jeb->wasted_size += jeb->free_size;
167 ACCT_SANITY_CHECK(c,jeb);
168 D1(ACCT_PARANOIA_CHECK(jeb));
171 /* Recover from failure to write wbuf. Recover the nodes up to the
172 * wbuf, not the one which we were starting to try to write. */
174 static void jffs2_wbuf_recover(struct jffs2_sb_info *c)
176 struct jffs2_eraseblock *jeb, *new_jeb;
177 struct jffs2_raw_node_ref **first_raw, **raw;
181 uint32_t start, end, ofs, len;
183 spin_lock(&c->erase_completion_lock);
185 jeb = &c->blocks[c->wbuf_ofs / c->sector_size];
187 jffs2_block_refile(c, jeb, REFILE_NOTEMPTY);
189 /* Find the first node to be recovered, by skipping over every
190 node which ends before the wbuf starts, or which is obsolete. */
191 first_raw = &jeb->first_node;
193 (ref_obsolete(*first_raw) ||
194 (ref_offset(*first_raw)+ref_totlen(c, jeb, *first_raw)) < c->wbuf_ofs)) {
195 D1(printk(KERN_DEBUG "Skipping node at 0x%08x(%d)-0x%08x which is either before 0x%08x or obsolete\n",
196 ref_offset(*first_raw), ref_flags(*first_raw),
197 (ref_offset(*first_raw) + ref_totlen(c, jeb, *first_raw)),
199 first_raw = &(*first_raw)->next_phys;
203 /* All nodes were obsolete. Nothing to recover. */
204 D1(printk(KERN_DEBUG "No non-obsolete nodes to be recovered. Just filing block bad\n"));
205 spin_unlock(&c->erase_completion_lock);
209 start = ref_offset(*first_raw);
210 end = ref_offset(*first_raw) + ref_totlen(c, jeb, *first_raw);
212 /* Find the last node to be recovered */
215 if (!ref_obsolete(*raw))
216 end = ref_offset(*raw) + ref_totlen(c, jeb, *raw);
218 raw = &(*raw)->next_phys;
220 spin_unlock(&c->erase_completion_lock);
222 D1(printk(KERN_DEBUG "wbuf recover %08x-%08x\n", start, end));
225 if (start < c->wbuf_ofs) {
226 /* First affected node was already partially written.
227 * Attempt to reread the old data into our buffer. */
229 buf = kmalloc(end - start, GFP_KERNEL);
231 printk(KERN_CRIT "Malloc failure in wbuf recovery. Data loss ensues.\n");
237 if (jffs2_cleanmarker_oob(c))
238 ret = c->mtd->read_ecc(c->mtd, start, c->wbuf_ofs - start, &retlen, buf, NULL, c->oobinfo);
240 ret = c->mtd->read(c->mtd, start, c->wbuf_ofs - start, &retlen, buf);
242 if (ret == -EBADMSG && retlen == c->wbuf_ofs - start) {
246 if (ret || retlen != c->wbuf_ofs - start) {
247 printk(KERN_CRIT "Old data are already lost in wbuf recovery. Data loss ensues.\n");
252 first_raw = &(*first_raw)->next_phys;
253 /* If this was the only node to be recovered, give up */
257 /* It wasn't. Go on and try to recover nodes complete in the wbuf */
258 start = ref_offset(*first_raw);
260 /* Read succeeded. Copy the remaining data from the wbuf */
261 memcpy(buf + (c->wbuf_ofs - start), c->wbuf, end - c->wbuf_ofs);
264 /* OK... we're to rewrite (end-start) bytes of data from first_raw onwards.
265 Either 'buf' contains the data, or we find it in the wbuf */
268 /* ... and get an allocation of space from a shiny new block instead */
269 ret = jffs2_reserve_space_gc(c, end-start, &ofs, &len);
271 printk(KERN_WARNING "Failed to allocate space for wbuf recovery. Data loss ensues.\n");
275 if (end-start >= c->wbuf_pagesize) {
276 /* Need to do another write immediately, but it's possible
277 that this is just because the wbuf itself is completely
278 full, and there's nothing earlier read back from the
279 flash. Hence 'buf' isn't necessarily what we're writing
281 unsigned char *rewrite_buf = buf?:c->wbuf;
282 uint32_t towrite = (end-start) - ((end-start)%c->wbuf_pagesize);
284 D1(printk(KERN_DEBUG "Write 0x%x bytes at 0x%08x in wbuf recover\n",
289 if (breakme++ == 20) {
290 printk(KERN_NOTICE "Faking write error at 0x%08x\n", ofs);
292 c->mtd->write_ecc(c->mtd, ofs, towrite, &retlen,
293 brokenbuf, NULL, c->oobinfo);
297 if (jffs2_cleanmarker_oob(c))
298 ret = c->mtd->write_ecc(c->mtd, ofs, towrite, &retlen,
299 rewrite_buf, NULL, c->oobinfo);
301 ret = c->mtd->write(c->mtd, ofs, towrite, &retlen, rewrite_buf);
303 if (ret || retlen != towrite) {
304 /* Argh. We tried. Really we did. */
305 printk(KERN_CRIT "Recovery of wbuf failed due to a second write error\n");
309 struct jffs2_raw_node_ref *raw2;
311 raw2 = jffs2_alloc_raw_node_ref();
315 raw2->flash_offset = ofs | REF_OBSOLETE;
316 raw2->__totlen = ref_totlen(c, jeb, *first_raw);
317 raw2->next_phys = NULL;
318 raw2->next_in_ino = NULL;
320 jffs2_add_physical_node_ref(c, raw2);
324 printk(KERN_NOTICE "Recovery of wbuf succeeded to %08x\n", ofs);
326 c->wbuf_len = (end - start) - towrite;
327 c->wbuf_ofs = ofs + towrite;
328 memmove(c->wbuf, rewrite_buf + towrite, c->wbuf_len);
329 /* Don't muck about with c->wbuf_inodes. False positives are harmless. */
332 /* OK, now we're left with the dregs in whichever buffer we're using */
334 memcpy(c->wbuf, buf, end-start);
337 memmove(c->wbuf, c->wbuf + (start - c->wbuf_ofs), end - start);
340 c->wbuf_len = end - start;
343 /* Now sort out the jffs2_raw_node_refs, moving them from the old to the next block */
344 new_jeb = &c->blocks[ofs / c->sector_size];
346 spin_lock(&c->erase_completion_lock);
347 if (new_jeb->first_node) {
348 /* Odd, but possible with ST flash later maybe */
349 new_jeb->last_node->next_phys = *first_raw;
351 new_jeb->first_node = *first_raw;
356 uint32_t rawlen = ref_totlen(c, jeb, *raw);
358 D1(printk(KERN_DEBUG "Refiling block of %08x at %08x(%d) to %08x\n",
359 rawlen, ref_offset(*raw), ref_flags(*raw), ofs));
361 if (ref_obsolete(*raw)) {
362 /* Shouldn't really happen much */
363 new_jeb->dirty_size += rawlen;
364 new_jeb->free_size -= rawlen;
365 c->dirty_size += rawlen;
367 new_jeb->used_size += rawlen;
368 new_jeb->free_size -= rawlen;
369 jeb->dirty_size += rawlen;
370 jeb->used_size -= rawlen;
371 c->dirty_size += rawlen;
373 c->free_size -= rawlen;
374 (*raw)->flash_offset = ofs | ref_flags(*raw);
376 new_jeb->last_node = *raw;
378 raw = &(*raw)->next_phys;
381 /* Fix up the original jeb now it's on the bad_list */
383 if (first_raw == &jeb->first_node) {
384 jeb->last_node = NULL;
385 D1(printk(KERN_DEBUG "Failing block at %08x is now empty. Moving to erase_pending_list\n", jeb->offset));
386 list_del(&jeb->list);
387 list_add(&jeb->list, &c->erase_pending_list);
388 c->nr_erasing_blocks++;
389 jffs2_erase_pending_trigger(c);
392 jeb->last_node = container_of(first_raw, struct jffs2_raw_node_ref, next_phys);
394 ACCT_SANITY_CHECK(c,jeb);
395 D1(ACCT_PARANOIA_CHECK(jeb));
397 ACCT_SANITY_CHECK(c,new_jeb);
398 D1(ACCT_PARANOIA_CHECK(new_jeb));
400 spin_unlock(&c->erase_completion_lock);
402 D1(printk(KERN_DEBUG "wbuf recovery completed OK\n"));
405 /* Meaning of pad argument:
406 0: Do not pad. Probably pointless - we only ever use this when we can't pad anyway.
407 1: Pad, do not adjust nextblock free_size
408 2: Pad, adjust nextblock free_size
411 #define PAD_NOACCOUNT 1
412 #define PAD_ACCOUNTING 2
414 static int __jffs2_flush_wbuf(struct jffs2_sb_info *c, int pad)
419 /* Nothing to do if not write-buffering the flash. In particular, we shouldn't
420 del_timer() the timer we never initialised. */
421 if (!jffs2_is_writebuffered(c))
424 if (!down_trylock(&c->alloc_sem)) {
426 printk(KERN_CRIT "jffs2_flush_wbuf() called with alloc_sem not locked!\n");
430 if (!c->wbuf_len) /* already checked c->wbuf above */
433 /* claim remaining space on the page
434 this happens, if we have a change to a new block,
435 or if fsync forces us to flush the writebuffer.
436 if we have a switch to next page, we will not have
437 enough remaining space for this.
439 if (pad && !jffs2_dataflash(c)) {
440 c->wbuf_len = PAD(c->wbuf_len);
442 /* Pad with JFFS2_DIRTY_BITMASK initially. this helps out ECC'd NOR
443 with 8 byte page size */
444 memset(c->wbuf + c->wbuf_len, 0, c->wbuf_pagesize - c->wbuf_len);
446 if ( c->wbuf_len + sizeof(struct jffs2_unknown_node) < c->wbuf_pagesize) {
447 struct jffs2_unknown_node *padnode = (void *)(c->wbuf + c->wbuf_len);
448 padnode->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
449 padnode->nodetype = cpu_to_je16(JFFS2_NODETYPE_PADDING);
450 padnode->totlen = cpu_to_je32(c->wbuf_pagesize - c->wbuf_len);
451 padnode->hdr_crc = cpu_to_je32(crc32(0, padnode, sizeof(*padnode)-4));
454 /* else jffs2_flash_writev has actually filled in the rest of the
455 buffer for us, and will deal with the node refs etc. later. */
459 if (breakme++ == 20) {
460 printk(KERN_NOTICE "Faking write error at 0x%08x\n", c->wbuf_ofs);
462 c->mtd->write_ecc(c->mtd, c->wbuf_ofs, c->wbuf_pagesize,
463 &retlen, brokenbuf, NULL, c->oobinfo);
468 if (jffs2_cleanmarker_oob(c))
469 ret = c->mtd->write_ecc(c->mtd, c->wbuf_ofs, c->wbuf_pagesize, &retlen, c->wbuf, NULL, c->oobinfo);
471 ret = c->mtd->write(c->mtd, c->wbuf_ofs, c->wbuf_pagesize, &retlen, c->wbuf);
473 if (ret || retlen != c->wbuf_pagesize) {
475 printk(KERN_WARNING "jffs2_flush_wbuf(): Write failed with %d\n",ret);
477 printk(KERN_WARNING "jffs2_flush_wbuf(): Write was short: %zd instead of %d\n",
478 retlen, c->wbuf_pagesize);
482 jffs2_wbuf_recover(c);
487 spin_lock(&c->erase_completion_lock);
489 /* Adjust free size of the block if we padded. */
490 if (pad && !jffs2_dataflash(c)) {
491 struct jffs2_eraseblock *jeb;
493 jeb = &c->blocks[c->wbuf_ofs / c->sector_size];
495 D1(printk(KERN_DEBUG "jffs2_flush_wbuf() adjusting free_size of %sblock at %08x\n",
496 (jeb==c->nextblock)?"next":"", jeb->offset));
498 /* wbuf_pagesize - wbuf_len is the amount of space that's to be
499 padded. If there is less free space in the block than that,
500 something screwed up */
501 if (jeb->free_size < (c->wbuf_pagesize - c->wbuf_len)) {
502 printk(KERN_CRIT "jffs2_flush_wbuf(): Accounting error. wbuf at 0x%08x has 0x%03x bytes, 0x%03x left.\n",
503 c->wbuf_ofs, c->wbuf_len, c->wbuf_pagesize-c->wbuf_len);
504 printk(KERN_CRIT "jffs2_flush_wbuf(): But free_size for block at 0x%08x is only 0x%08x\n",
505 jeb->offset, jeb->free_size);
508 jeb->free_size -= (c->wbuf_pagesize - c->wbuf_len);
509 c->free_size -= (c->wbuf_pagesize - c->wbuf_len);
510 jeb->wasted_size += (c->wbuf_pagesize - c->wbuf_len);
511 c->wasted_size += (c->wbuf_pagesize - c->wbuf_len);
514 /* Stick any now-obsoleted blocks on the erase_pending_list */
515 jffs2_refile_wbuf_blocks(c);
516 jffs2_clear_wbuf_ino_list(c);
517 spin_unlock(&c->erase_completion_lock);
519 memset(c->wbuf,0xff,c->wbuf_pagesize);
520 /* adjust write buffer offset, else we get a non contiguous write bug */
521 c->wbuf_ofs += c->wbuf_pagesize;
526 /* Trigger garbage collection to flush the write-buffer.
527 If ino arg is zero, do it if _any_ real (i.e. not GC) writes are
528 outstanding. If ino arg non-zero, do it only if a write for the
529 given inode is outstanding. */
530 int jffs2_flush_wbuf_gc(struct jffs2_sb_info *c, uint32_t ino)
532 uint32_t old_wbuf_ofs;
533 uint32_t old_wbuf_len;
536 D1(printk(KERN_DEBUG "jffs2_flush_wbuf_gc() called for ino #%u...\n", ino));
542 if (!jffs2_wbuf_pending_for_ino(c, ino)) {
543 D1(printk(KERN_DEBUG "Ino #%d not pending in wbuf. Returning\n", ino));
548 old_wbuf_ofs = c->wbuf_ofs;
549 old_wbuf_len = c->wbuf_len;
551 if (c->unchecked_size) {
552 /* GC won't make any progress for a while */
553 D1(printk(KERN_DEBUG "jffs2_flush_wbuf_gc() padding. Not finished checking\n"));
554 down_write(&c->wbuf_sem);
555 ret = __jffs2_flush_wbuf(c, PAD_ACCOUNTING);
556 /* retry flushing wbuf in case jffs2_wbuf_recover
557 left some data in the wbuf */
559 ret = __jffs2_flush_wbuf(c, PAD_ACCOUNTING);
560 up_write(&c->wbuf_sem);
561 } else while (old_wbuf_len &&
562 old_wbuf_ofs == c->wbuf_ofs) {
566 D1(printk(KERN_DEBUG "jffs2_flush_wbuf_gc() calls gc pass\n"));
568 ret = jffs2_garbage_collect_pass(c);
570 /* GC failed. Flush it with padding instead */
572 down_write(&c->wbuf_sem);
573 ret = __jffs2_flush_wbuf(c, PAD_ACCOUNTING);
574 /* retry flushing wbuf in case jffs2_wbuf_recover
575 left some data in the wbuf */
577 ret = __jffs2_flush_wbuf(c, PAD_ACCOUNTING);
578 up_write(&c->wbuf_sem);
584 D1(printk(KERN_DEBUG "jffs2_flush_wbuf_gc() ends...\n"));
590 /* Pad write-buffer to end and write it, wasting space. */
591 int jffs2_flush_wbuf_pad(struct jffs2_sb_info *c)
598 down_write(&c->wbuf_sem);
599 ret = __jffs2_flush_wbuf(c, PAD_NOACCOUNT);
600 /* retry - maybe wbuf recover left some data in wbuf. */
602 ret = __jffs2_flush_wbuf(c, PAD_NOACCOUNT);
603 up_write(&c->wbuf_sem);
608 #ifdef CONFIG_JFFS2_FS_WRITEBUFFER
609 #define PAGE_DIV(x) ( ((unsigned long)(x) / (unsigned long)(c->wbuf_pagesize)) * (unsigned long)(c->wbuf_pagesize) )
610 #define PAGE_MOD(x) ( (unsigned long)(x) % (unsigned long)(c->wbuf_pagesize) )
612 #define PAGE_DIV(x) ( (x) & (~(c->wbuf_pagesize - 1)) )
613 #define PAGE_MOD(x) ( (x) & (c->wbuf_pagesize - 1) )
616 int jffs2_flash_writev(struct jffs2_sb_info *c, const struct kvec *invecs, unsigned long count, loff_t to, size_t *retlen, uint32_t ino)
618 struct kvec outvecs[3];
620 uint32_t split_ofs = 0;
622 int ret, splitvec = -1;
625 unsigned char *wbuf_ptr;
627 uint32_t outvec_to = to;
629 /* If not NAND flash, don't bother */
630 if (!jffs2_is_writebuffered(c))
631 return jffs2_flash_direct_writev(c, invecs, count, to, retlen);
633 down_write(&c->wbuf_sem);
635 /* If wbuf_ofs is not initialized, set it to target address */
636 if (c->wbuf_ofs == 0xFFFFFFFF) {
637 c->wbuf_ofs = PAGE_DIV(to);
638 c->wbuf_len = PAGE_MOD(to);
639 memset(c->wbuf,0xff,c->wbuf_pagesize);
642 /* Fixup the wbuf if we are moving to a new eraseblock. The checks below
643 fail for ECC'd NOR because cleanmarker == 16, so a block starts at
645 if (jffs2_nor_ecc(c)) {
646 if (((c->wbuf_ofs % c->sector_size) == 0) && !c->wbuf_len) {
647 c->wbuf_ofs = PAGE_DIV(to);
648 c->wbuf_len = PAGE_MOD(to);
649 memset(c->wbuf,0xff,c->wbuf_pagesize);
653 /* Sanity checks on target address.
654 It's permitted to write at PAD(c->wbuf_len+c->wbuf_ofs),
655 and it's permitted to write at the beginning of a new
656 erase block. Anything else, and you die.
657 New block starts at xxx000c (0-b = block header)
659 if (SECTOR_ADDR(to) != SECTOR_ADDR(c->wbuf_ofs)) {
660 /* It's a write to a new block */
662 D1(printk(KERN_DEBUG "jffs2_flash_writev() to 0x%lx causes flush of wbuf at 0x%08x\n", (unsigned long)to, c->wbuf_ofs));
663 ret = __jffs2_flush_wbuf(c, PAD_NOACCOUNT);
665 /* the underlying layer has to check wbuf_len to do the cleanup */
666 D1(printk(KERN_WARNING "jffs2_flush_wbuf() called from jffs2_flash_writev() failed %d\n", ret));
671 /* set pointer to new block */
672 c->wbuf_ofs = PAGE_DIV(to);
673 c->wbuf_len = PAGE_MOD(to);
676 if (to != PAD(c->wbuf_ofs + c->wbuf_len)) {
677 /* We're not writing immediately after the writebuffer. Bad. */
678 printk(KERN_CRIT "jffs2_flash_writev(): Non-contiguous write to %08lx\n", (unsigned long)to);
680 printk(KERN_CRIT "wbuf was previously %08x-%08x\n",
681 c->wbuf_ofs, c->wbuf_ofs+c->wbuf_len);
685 /* Note outvecs[3] above. We know count is never greater than 2 */
687 printk(KERN_CRIT "jffs2_flash_writev(): count is %ld\n", count);
694 /* Fill writebuffer first, if already in use */
696 uint32_t invec_ofs = 0;
698 /* adjust alignment offset */
699 if (c->wbuf_len != PAGE_MOD(to)) {
700 c->wbuf_len = PAGE_MOD(to);
701 /* take care of alignment to next page */
703 c->wbuf_len = c->wbuf_pagesize;
706 while(c->wbuf_len < c->wbuf_pagesize) {
712 thislen = c->wbuf_pagesize - c->wbuf_len;
714 if (thislen >= invecs[invec].iov_len)
715 thislen = invecs[invec].iov_len;
719 memcpy(c->wbuf + c->wbuf_len, invecs[invec].iov_base, thislen);
720 c->wbuf_len += thislen;
722 /* Get next invec, if actual did not fill the buffer */
723 if (c->wbuf_len < c->wbuf_pagesize)
727 /* write buffer is full, flush buffer */
728 ret = __jffs2_flush_wbuf(c, NOPAD);
730 /* the underlying layer has to check wbuf_len to do the cleanup */
731 D1(printk(KERN_WARNING "jffs2_flush_wbuf() called from jffs2_flash_writev() failed %d\n", ret));
732 /* Retlen zero to make sure our caller doesn't mark the space dirty.
733 We've already done everything that's necessary */
737 outvec_to += donelen;
738 c->wbuf_ofs = outvec_to;
740 /* All invecs done ? */
744 /* Set up the first outvec, containing the remainder of the
745 invec we partially used */
746 if (invecs[invec].iov_len > invec_ofs) {
747 outvecs[0].iov_base = invecs[invec].iov_base+invec_ofs;
748 totlen = outvecs[0].iov_len = invecs[invec].iov_len-invec_ofs;
749 if (totlen > c->wbuf_pagesize) {
751 split_ofs = outvecs[0].iov_len - PAGE_MOD(totlen);
758 /* OK, now we've flushed the wbuf and the start of the bits
759 we have been asked to write, now to write the rest.... */
761 /* totlen holds the amount of data still to be written */
763 for ( ; invec < count; invec++,outvec++ ) {
764 outvecs[outvec].iov_base = invecs[invec].iov_base;
765 totlen += outvecs[outvec].iov_len = invecs[invec].iov_len;
766 if (PAGE_DIV(totlen) != PAGE_DIV(old_totlen)) {
768 split_ofs = outvecs[outvec].iov_len - PAGE_MOD(totlen);
773 /* Now the outvecs array holds all the remaining data to write */
774 /* Up to splitvec,split_ofs is to be written immediately. The rest
775 goes into the (now-empty) wbuf */
777 if (splitvec != -1) {
780 remainder = outvecs[splitvec].iov_len - split_ofs;
781 outvecs[splitvec].iov_len = split_ofs;
783 /* We did cross a page boundary, so we write some now */
784 if (jffs2_cleanmarker_oob(c))
785 ret = c->mtd->writev_ecc(c->mtd, outvecs, splitvec+1, outvec_to, &wbuf_retlen, NULL, c->oobinfo);
787 ret = jffs2_flash_direct_writev(c, outvecs, splitvec+1, outvec_to, &wbuf_retlen);
789 if (ret < 0 || wbuf_retlen != PAGE_DIV(totlen)) {
790 /* At this point we have no problem,
791 c->wbuf is empty. However refile nextblock to avoid
792 writing again to same address.
794 struct jffs2_eraseblock *jeb;
796 spin_lock(&c->erase_completion_lock);
798 jeb = &c->blocks[outvec_to / c->sector_size];
799 jffs2_block_refile(c, jeb, REFILE_ANYWAY);
802 spin_unlock(&c->erase_completion_lock);
806 donelen += wbuf_retlen;
807 c->wbuf_ofs = PAGE_DIV(outvec_to) + PAGE_DIV(totlen);
810 outvecs[splitvec].iov_base += split_ofs;
811 outvecs[splitvec].iov_len = remainder;
820 /* Now splitvec points to the start of the bits we have to copy
824 for ( ; splitvec < outvec; splitvec++) {
825 /* Don't copy the wbuf into itself */
826 if (outvecs[splitvec].iov_base == c->wbuf)
828 memcpy(wbuf_ptr, outvecs[splitvec].iov_base, outvecs[splitvec].iov_len);
829 wbuf_ptr += outvecs[splitvec].iov_len;
830 donelen += outvecs[splitvec].iov_len;
832 c->wbuf_len = wbuf_ptr - c->wbuf;
834 /* If there's a remainder in the wbuf and it's a non-GC write,
835 remember that the wbuf affects this ino */
839 if (c->wbuf_len && ino)
840 jffs2_wbuf_dirties_inode(c, ino);
845 up_write(&c->wbuf_sem);
850 * This is the entry for flash write.
851 * Check, if we work on NAND FLASH, if so build an kvec and write it via vritev
853 int jffs2_flash_write(struct jffs2_sb_info *c, loff_t ofs, size_t len, size_t *retlen, const u_char *buf)
857 if (!jffs2_is_writebuffered(c))
858 return c->mtd->write(c->mtd, ofs, len, retlen, buf);
860 vecs[0].iov_base = (unsigned char *) buf;
861 vecs[0].iov_len = len;
862 return jffs2_flash_writev(c, vecs, 1, ofs, retlen, 0);
866 Handle readback from writebuffer and ECC failure return
868 int jffs2_flash_read(struct jffs2_sb_info *c, loff_t ofs, size_t len, size_t *retlen, u_char *buf)
870 loff_t orbf = 0, owbf = 0, lwbf = 0;
873 if (!jffs2_is_writebuffered(c))
874 return c->mtd->read(c->mtd, ofs, len, retlen, buf);
877 down_read(&c->wbuf_sem);
878 if (jffs2_cleanmarker_oob(c))
879 ret = c->mtd->read_ecc(c->mtd, ofs, len, retlen, buf, NULL, c->oobinfo);
881 ret = c->mtd->read(c->mtd, ofs, len, retlen, buf);
883 if ( (ret == -EBADMSG) && (*retlen == len) ) {
884 printk(KERN_WARNING "mtd->read(0x%zx bytes from 0x%llx) returned ECC error\n",
887 * We have the raw data without ECC correction in the buffer, maybe
888 * we are lucky and all data or parts are correct. We check the node.
889 * If data are corrupted node check will sort it out.
890 * We keep this block, it will fail on write or erase and the we
891 * mark it bad. Or should we do that now? But we should give him a chance.
892 * Maybe we had a system crash or power loss before the ecc write or
893 * a erase was completed.
894 * So we return success. :)
899 /* if no writebuffer available or write buffer empty, return */
900 if (!c->wbuf_pagesize || !c->wbuf_len)
903 /* if we read in a different block, return */
904 if (SECTOR_ADDR(ofs) != SECTOR_ADDR(c->wbuf_ofs))
907 if (ofs >= c->wbuf_ofs) {
908 owbf = (ofs - c->wbuf_ofs); /* offset in write buffer */
909 if (owbf > c->wbuf_len) /* is read beyond write buffer ? */
911 lwbf = c->wbuf_len - owbf; /* number of bytes to copy */
915 orbf = (c->wbuf_ofs - ofs); /* offset in read buffer */
916 if (orbf > len) /* is write beyond write buffer ? */
918 lwbf = len - orbf; /* number of bytes to copy */
919 if (lwbf > c->wbuf_len)
923 memcpy(buf+orbf,c->wbuf+owbf,lwbf);
926 up_read(&c->wbuf_sem);
931 * Check, if the out of band area is empty
933 int jffs2_check_oob_empty( struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, int mode)
941 /* allocate a buffer for all oob data in this sector */
942 oob_size = c->mtd->oobsize;
944 buf = kmalloc(len, GFP_KERNEL);
946 printk(KERN_NOTICE "jffs2_check_oob_empty(): allocation of temporary data buffer for oob check failed\n");
950 * if mode = 0, we scan for a total empty oob area, else we have
951 * to take care of the cleanmarker in the first page of the block
953 ret = jffs2_flash_read_oob(c, jeb->offset, len , &retlen, buf);
955 D1(printk(KERN_WARNING "jffs2_check_oob_empty(): Read OOB failed %d for block at %08x\n", ret, jeb->offset));
960 D1(printk(KERN_WARNING "jffs2_check_oob_empty(): Read OOB return short read "
961 "(%zd bytes not %d) for block at %08x\n", retlen, len, jeb->offset));
966 /* Special check for first page */
967 for(i = 0; i < oob_size ; i++) {
968 /* Yeah, we know about the cleanmarker. */
969 if (mode && i >= c->fsdata_pos &&
970 i < c->fsdata_pos + c->fsdata_len)
973 if (buf[i] != 0xFF) {
974 D2(printk(KERN_DEBUG "Found %02x at %x in OOB for %08x\n",
975 buf[page+i], page+i, jeb->offset));
981 /* we know, we are aligned :) */
982 for (page = oob_size; page < len; page += sizeof(long)) {
983 unsigned long dat = *(unsigned long *)(&buf[page]);
997 * Scan for a valid cleanmarker and for bad blocks
998 * For virtual blocks (concatenated physical blocks) check the cleanmarker
999 * only in the first page of the first physical block, but scan for bad blocks in all
1002 int jffs2_check_nand_cleanmarker (struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb)
1004 struct jffs2_unknown_node n;
1005 unsigned char buf[2 * NAND_MAX_OOBSIZE];
1007 int ret, i, cnt, retval = 0;
1008 size_t retlen, offset;
1011 offset = jeb->offset;
1012 oob_size = c->mtd->oobsize;
1014 /* Loop through the physical blocks */
1015 for (cnt = 0; cnt < (c->sector_size / c->mtd->erasesize); cnt++) {
1016 /* Check first if the block is bad. */
1017 if (c->mtd->block_isbad (c->mtd, offset)) {
1018 D1 (printk (KERN_WARNING "jffs2_check_nand_cleanmarker(): Bad block at %08x\n", jeb->offset));
1022 * We read oob data from page 0 and 1 of the block.
1023 * page 0 contains cleanmarker and badblock info
1024 * page 1 contains failure count of this block
1026 ret = c->mtd->read_oob (c->mtd, offset, oob_size << 1, &retlen, buf);
1029 D1 (printk (KERN_WARNING "jffs2_check_nand_cleanmarker(): Read OOB failed %d for block at %08x\n", ret, jeb->offset));
1032 if (retlen < (oob_size << 1)) {
1033 D1 (printk (KERN_WARNING "jffs2_check_nand_cleanmarker(): Read OOB return short read (%zd bytes not %d) for block at %08x\n", retlen, oob_size << 1, jeb->offset));
1037 /* Check cleanmarker only on the first physical block */
1039 n.magic = cpu_to_je16 (JFFS2_MAGIC_BITMASK);
1040 n.nodetype = cpu_to_je16 (JFFS2_NODETYPE_CLEANMARKER);
1041 n.totlen = cpu_to_je32 (8);
1042 p = (unsigned char *) &n;
1044 for (i = 0; i < c->fsdata_len; i++) {
1045 if (buf[c->fsdata_pos + i] != p[i]) {
1049 D1(if (retval == 1) {
1050 printk(KERN_WARNING "jffs2_check_nand_cleanmarker(): Cleanmarker node not detected in block at %08x\n", jeb->offset);
1051 printk(KERN_WARNING "OOB at %08x was ", offset);
1052 for (i=0; i < oob_size; i++) {
1053 printk("%02x ", buf[i]);
1058 offset += c->mtd->erasesize;
1063 int jffs2_write_nand_cleanmarker(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb)
1065 struct jffs2_unknown_node n;
1069 n.magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
1070 n.nodetype = cpu_to_je16(JFFS2_NODETYPE_CLEANMARKER);
1071 n.totlen = cpu_to_je32(8);
1073 ret = jffs2_flash_write_oob(c, jeb->offset + c->fsdata_pos, c->fsdata_len, &retlen, (unsigned char *)&n);
1076 D1(printk(KERN_WARNING "jffs2_write_nand_cleanmarker(): Write failed for block at %08x: error %d\n", jeb->offset, ret));
1079 if (retlen != c->fsdata_len) {
1080 D1(printk(KERN_WARNING "jffs2_write_nand_cleanmarker(): Short write for block at %08x: %zd not %d\n", jeb->offset, retlen, c->fsdata_len));
1087 * On NAND we try to mark this block bad. If the block was erased more
1088 * than MAX_ERASE_FAILURES we mark it finaly bad.
1089 * Don't care about failures. This block remains on the erase-pending
1090 * or badblock list as long as nobody manipulates the flash with
1091 * a bootloader or something like that.
1094 int jffs2_write_nand_badblock(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, uint32_t bad_offset)
1098 /* if the count is < max, we try to write the counter to the 2nd page oob area */
1099 if( ++jeb->bad_count < MAX_ERASE_FAILURES)
1102 if (!c->mtd->block_markbad)
1103 return 1; // What else can we do?
1105 D1(printk(KERN_WARNING "jffs2_write_nand_badblock(): Marking bad block at %08x\n", bad_offset));
1106 ret = c->mtd->block_markbad(c->mtd, bad_offset);
1109 D1(printk(KERN_WARNING "jffs2_write_nand_badblock(): Write failed for block at %08x: error %d\n", jeb->offset, ret));
1115 #define NAND_JFFS2_OOB16_FSDALEN 8
1117 static struct nand_oobinfo jffs2_oobinfo_docecc = {
1118 .useecc = MTD_NANDECC_PLACE,
1120 .eccpos = {0,1,2,3,4,5}
1124 static int jffs2_nand_set_oobinfo(struct jffs2_sb_info *c)
1126 struct nand_oobinfo *oinfo = &c->mtd->oobinfo;
1128 /* Do this only, if we have an oob buffer */
1129 if (!c->mtd->oobsize)
1132 /* Cleanmarker is out-of-band, so inline size zero */
1133 c->cleanmarker_size = 0;
1135 /* Should we use autoplacement ? */
1136 if (oinfo && oinfo->useecc == MTD_NANDECC_AUTOPLACE) {
1137 D1(printk(KERN_DEBUG "JFFS2 using autoplace on NAND\n"));
1138 /* Get the position of the free bytes */
1139 if (!oinfo->oobfree[0][1]) {
1140 printk (KERN_WARNING "jffs2_nand_set_oobinfo(): Eeep. Autoplacement selected and no empty space in oob\n");
1143 c->fsdata_pos = oinfo->oobfree[0][0];
1144 c->fsdata_len = oinfo->oobfree[0][1];
1145 if (c->fsdata_len > 8)
1148 /* This is just a legacy fallback and should go away soon */
1149 switch(c->mtd->ecctype) {
1150 case MTD_ECC_RS_DiskOnChip:
1151 printk(KERN_WARNING "JFFS2 using DiskOnChip hardware ECC without autoplacement. Fix it!\n");
1152 c->oobinfo = &jffs2_oobinfo_docecc;
1154 c->fsdata_len = NAND_JFFS2_OOB16_FSDALEN;
1155 c->badblock_pos = 15;
1159 D1(printk(KERN_DEBUG "JFFS2 on NAND. No autoplacment info found\n"));
1166 int jffs2_nand_flash_setup(struct jffs2_sb_info *c)
1170 /* Initialise write buffer */
1171 init_rwsem(&c->wbuf_sem);
1172 c->wbuf_pagesize = c->mtd->oobblock;
1173 c->wbuf_ofs = 0xFFFFFFFF;
1175 c->wbuf = kmalloc(c->wbuf_pagesize, GFP_KERNEL);
1179 res = jffs2_nand_set_oobinfo(c);
1183 brokenbuf = kmalloc(c->wbuf_pagesize, GFP_KERNEL);
1188 memset(brokenbuf, 0xdb, c->wbuf_pagesize);
1193 void jffs2_nand_flash_cleanup(struct jffs2_sb_info *c)
1198 int jffs2_dataflash_setup(struct jffs2_sb_info *c) {
1199 c->cleanmarker_size = 0; /* No cleanmarkers needed */
1201 /* Initialize write buffer */
1202 init_rwsem(&c->wbuf_sem);
1203 c->wbuf_pagesize = c->sector_size;
1204 c->wbuf_ofs = 0xFFFFFFFF;
1206 c->wbuf = kmalloc(c->wbuf_pagesize, GFP_KERNEL);
1210 printk(KERN_INFO "JFFS2 write-buffering enabled (%i)\n", c->wbuf_pagesize);
1215 void jffs2_dataflash_cleanup(struct jffs2_sb_info *c) {
1219 int jffs2_nor_ecc_flash_setup(struct jffs2_sb_info *c) {
1220 /* Cleanmarker is actually larger on the flashes */
1221 c->cleanmarker_size = 16;
1223 /* Initialize write buffer */
1224 init_rwsem(&c->wbuf_sem);
1225 c->wbuf_pagesize = c->mtd->eccsize;
1226 c->wbuf_ofs = 0xFFFFFFFF;
1228 c->wbuf = kmalloc(c->wbuf_pagesize, GFP_KERNEL);
1235 void jffs2_nor_ecc_flash_cleanup(struct jffs2_sb_info *c) {