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.83 2005/01/24 21:24:15 hammache 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>
23 /* For testing write failures */
28 static unsigned char *brokenbuf;
31 /* max. erase failures before we mark a block bad */
32 #define MAX_ERASE_FAILURES 2
34 /* two seconds timeout for timed wbuf-flushing */
35 #define WBUF_FLUSH_TIMEOUT 2 * HZ
37 struct jffs2_inodirty {
39 struct jffs2_inodirty *next;
42 static struct jffs2_inodirty inodirty_nomem;
44 static int jffs2_wbuf_pending_for_ino(struct jffs2_sb_info *c, uint32_t ino)
46 struct jffs2_inodirty *this = c->wbuf_inodes;
48 /* If a malloc failed, consider _everything_ dirty */
49 if (this == &inodirty_nomem)
52 /* If ino == 0, _any_ non-GC writes mean 'yes' */
56 /* Look to see if the inode in question is pending in the wbuf */
65 static void jffs2_clear_wbuf_ino_list(struct jffs2_sb_info *c)
67 struct jffs2_inodirty *this;
69 this = c->wbuf_inodes;
71 if (this != &inodirty_nomem) {
73 struct jffs2_inodirty *next = this->next;
78 c->wbuf_inodes = NULL;
81 static void jffs2_wbuf_dirties_inode(struct jffs2_sb_info *c, uint32_t ino)
83 struct jffs2_inodirty *new;
85 /* Mark the superblock dirty so that kupdated will flush... */
86 OFNI_BS_2SFFJ(c)->s_dirt = 1;
88 if (jffs2_wbuf_pending_for_ino(c, ino))
91 new = kmalloc(sizeof(*new), GFP_KERNEL);
93 D1(printk(KERN_DEBUG "No memory to allocate inodirty. Fallback to all considered dirty\n"));
94 jffs2_clear_wbuf_ino_list(c);
95 c->wbuf_inodes = &inodirty_nomem;
99 new->next = c->wbuf_inodes;
100 c->wbuf_inodes = new;
104 static inline void jffs2_refile_wbuf_blocks(struct jffs2_sb_info *c)
106 struct list_head *this, *next;
109 if (list_empty(&c->erasable_pending_wbuf_list))
112 list_for_each_safe(this, next, &c->erasable_pending_wbuf_list) {
113 struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list);
115 D1(printk(KERN_DEBUG "Removing eraseblock at 0x%08x from erasable_pending_wbuf_list...\n", jeb->offset));
117 if ((jiffies + (n++)) & 127) {
118 /* Most of the time, we just erase it immediately. Otherwise we
119 spend ages scanning it on mount, etc. */
120 D1(printk(KERN_DEBUG "...and adding to erase_pending_list\n"));
121 list_add_tail(&jeb->list, &c->erase_pending_list);
122 c->nr_erasing_blocks++;
123 jffs2_erase_pending_trigger(c);
125 /* Sometimes, however, we leave it elsewhere so it doesn't get
126 immediately reused, and we spread the load a bit. */
127 D1(printk(KERN_DEBUG "...and adding to erasable_list\n"));
128 list_add_tail(&jeb->list, &c->erasable_list);
133 #define REFILE_NOTEMPTY 0
134 #define REFILE_ANYWAY 1
136 static void jffs2_block_refile(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, int allow_empty)
138 D1(printk("About to refile bad block at %08x\n", jeb->offset));
140 D2(jffs2_dump_block_lists(c));
141 /* File the existing block on the bad_used_list.... */
142 if (c->nextblock == jeb)
144 else /* Not sure this should ever happen... need more coffee */
145 list_del(&jeb->list);
146 if (jeb->first_node) {
147 D1(printk("Refiling block at %08x to bad_used_list\n", jeb->offset));
148 list_add(&jeb->list, &c->bad_used_list);
150 if (allow_empty == REFILE_NOTEMPTY)
152 /* It has to have had some nodes or we couldn't be here */
153 D1(printk("Refiling block at %08x to erase_pending_list\n", jeb->offset));
154 list_add(&jeb->list, &c->erase_pending_list);
155 c->nr_erasing_blocks++;
156 jffs2_erase_pending_trigger(c);
158 D2(jffs2_dump_block_lists(c));
160 /* Adjust its size counts accordingly */
161 c->wasted_size += jeb->free_size;
162 c->free_size -= jeb->free_size;
163 jeb->wasted_size += jeb->free_size;
166 ACCT_SANITY_CHECK(c,jeb);
167 D1(ACCT_PARANOIA_CHECK(jeb));
170 /* Recover from failure to write wbuf. Recover the nodes up to the
171 * wbuf, not the one which we were starting to try to write. */
173 static void jffs2_wbuf_recover(struct jffs2_sb_info *c)
175 struct jffs2_eraseblock *jeb, *new_jeb;
176 struct jffs2_raw_node_ref **first_raw, **raw;
180 uint32_t start, end, ofs, len;
182 spin_lock(&c->erase_completion_lock);
184 jeb = &c->blocks[c->wbuf_ofs / c->sector_size];
186 jffs2_block_refile(c, jeb, REFILE_NOTEMPTY);
188 /* Find the first node to be recovered, by skipping over every
189 node which ends before the wbuf starts, or which is obsolete. */
190 first_raw = &jeb->first_node;
192 (ref_obsolete(*first_raw) ||
193 (ref_offset(*first_raw)+ref_totlen(c, jeb, *first_raw)) < c->wbuf_ofs)) {
194 D1(printk(KERN_DEBUG "Skipping node at 0x%08x(%d)-0x%08x which is either before 0x%08x or obsolete\n",
195 ref_offset(*first_raw), ref_flags(*first_raw),
196 (ref_offset(*first_raw) + ref_totlen(c, jeb, *first_raw)),
198 first_raw = &(*first_raw)->next_phys;
202 /* All nodes were obsolete. Nothing to recover. */
203 D1(printk(KERN_DEBUG "No non-obsolete nodes to be recovered. Just filing block bad\n"));
204 spin_unlock(&c->erase_completion_lock);
208 start = ref_offset(*first_raw);
209 end = ref_offset(*first_raw) + ref_totlen(c, jeb, *first_raw);
211 /* Find the last node to be recovered */
214 if (!ref_obsolete(*raw))
215 end = ref_offset(*raw) + ref_totlen(c, jeb, *raw);
217 raw = &(*raw)->next_phys;
219 spin_unlock(&c->erase_completion_lock);
221 D1(printk(KERN_DEBUG "wbuf recover %08x-%08x\n", start, end));
224 if (start < c->wbuf_ofs) {
225 /* First affected node was already partially written.
226 * Attempt to reread the old data into our buffer. */
228 buf = kmalloc(end - start, GFP_KERNEL);
230 printk(KERN_CRIT "Malloc failure in wbuf recovery. Data loss ensues.\n");
236 if (jffs2_cleanmarker_oob(c))
237 ret = c->mtd->read_ecc(c->mtd, start, c->wbuf_ofs - start, &retlen, buf, NULL, c->oobinfo);
239 ret = c->mtd->read(c->mtd, start, c->wbuf_ofs - start, &retlen, buf);
241 if (ret == -EBADMSG && retlen == c->wbuf_ofs - start) {
245 if (ret || retlen != c->wbuf_ofs - start) {
246 printk(KERN_CRIT "Old data are already lost in wbuf recovery. Data loss ensues.\n");
251 first_raw = &(*first_raw)->next_phys;
252 /* If this was the only node to be recovered, give up */
256 /* It wasn't. Go on and try to recover nodes complete in the wbuf */
257 start = ref_offset(*first_raw);
259 /* Read succeeded. Copy the remaining data from the wbuf */
260 memcpy(buf + (c->wbuf_ofs - start), c->wbuf, end - c->wbuf_ofs);
263 /* OK... we're to rewrite (end-start) bytes of data from first_raw onwards.
264 Either 'buf' contains the data, or we find it in the wbuf */
267 /* ... and get an allocation of space from a shiny new block instead */
268 ret = jffs2_reserve_space_gc(c, end-start, &ofs, &len);
270 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");
310 struct jffs2_raw_node_ref *raw2;
312 raw2 = jffs2_alloc_raw_node_ref();
316 raw2->flash_offset = ofs | REF_OBSOLETE;
317 raw2->__totlen = ref_totlen(c, jeb, *first_raw);
318 raw2->next_phys = NULL;
319 raw2->next_in_ino = NULL;
321 jffs2_add_physical_node_ref(c, raw2);
325 printk(KERN_NOTICE "Recovery of wbuf succeeded to %08x\n", ofs);
327 c->wbuf_len = (end - start) - towrite;
328 c->wbuf_ofs = ofs + towrite;
329 memmove(c->wbuf, rewrite_buf + towrite, c->wbuf_len);
330 /* Don't muck about with c->wbuf_inodes. False positives are harmless. */
334 /* OK, now we're left with the dregs in whichever buffer we're using */
336 memcpy(c->wbuf, buf, end-start);
339 memmove(c->wbuf, c->wbuf + (start - c->wbuf_ofs), end - start);
342 c->wbuf_len = end - start;
345 /* Now sort out the jffs2_raw_node_refs, moving them from the old to the next block */
346 new_jeb = &c->blocks[ofs / c->sector_size];
348 spin_lock(&c->erase_completion_lock);
349 if (new_jeb->first_node) {
350 /* Odd, but possible with ST flash later maybe */
351 new_jeb->last_node->next_phys = *first_raw;
353 new_jeb->first_node = *first_raw;
358 uint32_t rawlen = ref_totlen(c, jeb, *raw);
360 D1(printk(KERN_DEBUG "Refiling block of %08x at %08x(%d) to %08x\n",
361 rawlen, ref_offset(*raw), ref_flags(*raw), ofs));
363 if (ref_obsolete(*raw)) {
364 /* Shouldn't really happen much */
365 new_jeb->dirty_size += rawlen;
366 new_jeb->free_size -= rawlen;
367 c->dirty_size += rawlen;
369 new_jeb->used_size += rawlen;
370 new_jeb->free_size -= rawlen;
371 jeb->dirty_size += rawlen;
372 jeb->used_size -= rawlen;
373 c->dirty_size += rawlen;
375 c->free_size -= rawlen;
376 (*raw)->flash_offset = ofs | ref_flags(*raw);
378 new_jeb->last_node = *raw;
380 raw = &(*raw)->next_phys;
383 /* Fix up the original jeb now it's on the bad_list */
385 if (first_raw == &jeb->first_node) {
386 jeb->last_node = NULL;
387 D1(printk(KERN_DEBUG "Failing block at %08x is now empty. Moving to erase_pending_list\n", jeb->offset));
388 list_del(&jeb->list);
389 list_add(&jeb->list, &c->erase_pending_list);
390 c->nr_erasing_blocks++;
391 jffs2_erase_pending_trigger(c);
394 jeb->last_node = container_of(first_raw, struct jffs2_raw_node_ref, next_phys);
396 ACCT_SANITY_CHECK(c,jeb);
397 D1(ACCT_PARANOIA_CHECK(jeb));
399 ACCT_SANITY_CHECK(c,new_jeb);
400 D1(ACCT_PARANOIA_CHECK(new_jeb));
402 spin_unlock(&c->erase_completion_lock);
404 D1(printk(KERN_DEBUG "wbuf recovery completed OK\n"));
407 /* Meaning of pad argument:
408 0: Do not pad. Probably pointless - we only ever use this when we can't pad anyway.
409 1: Pad, do not adjust nextblock free_size
410 2: Pad, adjust nextblock free_size
413 #define PAD_NOACCOUNT 1
414 #define PAD_ACCOUNTING 2
416 static int __jffs2_flush_wbuf(struct jffs2_sb_info *c, int pad)
421 /* Nothing to do if not NAND flash. In particular, we shouldn't
422 del_timer() the timer we never initialised. */
423 if (jffs2_can_mark_obsolete(c))
426 if (!down_trylock(&c->alloc_sem)) {
428 printk(KERN_CRIT "jffs2_flush_wbuf() called with alloc_sem not locked!\n");
432 if(!c->wbuf || !c->wbuf_len)
435 /* claim remaining space on the page
436 this happens, if we have a change to a new block,
437 or if fsync forces us to flush the writebuffer.
438 if we have a switch to next page, we will not have
439 enough remaining space for this.
442 c->wbuf_len = PAD(c->wbuf_len);
444 /* Pad with JFFS2_DIRTY_BITMASK initially. this helps out ECC'd NOR
445 with 8 byte page size */
446 memset(c->wbuf + c->wbuf_len, 0, c->wbuf_pagesize - c->wbuf_len);
448 if ( c->wbuf_len + sizeof(struct jffs2_unknown_node) < c->wbuf_pagesize) {
449 struct jffs2_unknown_node *padnode = (void *)(c->wbuf + c->wbuf_len);
450 padnode->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
451 padnode->nodetype = cpu_to_je16(JFFS2_NODETYPE_PADDING);
452 padnode->totlen = cpu_to_je32(c->wbuf_pagesize - c->wbuf_len);
453 padnode->hdr_crc = cpu_to_je32(crc32(0, padnode, sizeof(*padnode)-4));
456 /* else jffs2_flash_writev has actually filled in the rest of the
457 buffer for us, and will deal with the node refs etc. later. */
461 if (breakme++ == 20) {
462 printk(KERN_NOTICE "Faking write error at 0x%08x\n", c->wbuf_ofs);
464 c->mtd->write_ecc(c->mtd, c->wbuf_ofs, c->wbuf_pagesize,
465 &retlen, brokenbuf, NULL, c->oobinfo);
470 if (jffs2_cleanmarker_oob(c))
471 ret = c->mtd->write_ecc(c->mtd, c->wbuf_ofs, c->wbuf_pagesize, &retlen, c->wbuf, NULL, c->oobinfo);
473 ret = c->mtd->write(c->mtd, c->wbuf_ofs, c->wbuf_pagesize, &retlen, c->wbuf);
475 if (ret || retlen != c->wbuf_pagesize) {
477 printk(KERN_WARNING "jffs2_flush_wbuf(): Write failed with %d\n",ret);
479 printk(KERN_WARNING "jffs2_flush_wbuf(): Write was short: %zd instead of %d\n",
480 retlen, c->wbuf_pagesize);
484 jffs2_wbuf_recover(c);
489 spin_lock(&c->erase_completion_lock);
491 /* Adjust free size of the block if we padded. */
493 struct jffs2_eraseblock *jeb;
495 jeb = &c->blocks[c->wbuf_ofs / c->sector_size];
497 D1(printk(KERN_DEBUG "jffs2_flush_wbuf() adjusting free_size of %sblock at %08x\n",
498 (jeb==c->nextblock)?"next":"", jeb->offset));
500 /* wbuf_pagesize - wbuf_len is the amount of space that's to be
501 padded. If there is less free space in the block than that,
502 something screwed up */
503 if (jeb->free_size < (c->wbuf_pagesize - c->wbuf_len)) {
504 printk(KERN_CRIT "jffs2_flush_wbuf(): Accounting error. wbuf at 0x%08x has 0x%03x bytes, 0x%03x left.\n",
505 c->wbuf_ofs, c->wbuf_len, c->wbuf_pagesize-c->wbuf_len);
506 printk(KERN_CRIT "jffs2_flush_wbuf(): But free_size for block at 0x%08x is only 0x%08x\n",
507 jeb->offset, jeb->free_size);
510 jeb->free_size -= (c->wbuf_pagesize - c->wbuf_len);
511 c->free_size -= (c->wbuf_pagesize - c->wbuf_len);
512 jeb->wasted_size += (c->wbuf_pagesize - c->wbuf_len);
513 c->wasted_size += (c->wbuf_pagesize - c->wbuf_len);
516 /* Stick any now-obsoleted blocks on the erase_pending_list */
517 jffs2_refile_wbuf_blocks(c);
518 jffs2_clear_wbuf_ino_list(c);
519 spin_unlock(&c->erase_completion_lock);
521 memset(c->wbuf,0xff,c->wbuf_pagesize);
522 /* adjust write buffer offset, else we get a non contiguous write bug */
523 c->wbuf_ofs += c->wbuf_pagesize;
528 /* Trigger garbage collection to flush the write-buffer.
529 If ino arg is zero, do it if _any_ real (i.e. not GC) writes are
530 outstanding. If ino arg non-zero, do it only if a write for the
531 given inode is outstanding. */
532 int jffs2_flush_wbuf_gc(struct jffs2_sb_info *c, uint32_t ino)
534 uint32_t old_wbuf_ofs;
535 uint32_t old_wbuf_len;
538 D1(printk(KERN_DEBUG "jffs2_flush_wbuf_gc() called for ino #%u...\n", ino));
541 if (!jffs2_wbuf_pending_for_ino(c, ino)) {
542 D1(printk(KERN_DEBUG "Ino #%d not pending in wbuf. Returning\n", ino));
547 old_wbuf_ofs = c->wbuf_ofs;
548 old_wbuf_len = c->wbuf_len;
550 if (c->unchecked_size) {
551 /* GC won't make any progress for a while */
552 D1(printk(KERN_DEBUG "jffs2_flush_wbuf_gc() padding. Not finished checking\n"));
553 down_write(&c->wbuf_sem);
554 ret = __jffs2_flush_wbuf(c, PAD_ACCOUNTING);
555 /* retry flushing wbuf in case jffs2_wbuf_recover
556 left some data in the wbuf */
559 ret = __jffs2_flush_wbuf(c, PAD_ACCOUNTING);
561 up_write(&c->wbuf_sem);
562 } else while (old_wbuf_len &&
563 old_wbuf_ofs == c->wbuf_ofs) {
567 D1(printk(KERN_DEBUG "jffs2_flush_wbuf_gc() calls gc pass\n"));
569 ret = jffs2_garbage_collect_pass(c);
571 /* GC failed. Flush it with padding instead */
573 down_write(&c->wbuf_sem);
574 ret = __jffs2_flush_wbuf(c, PAD_ACCOUNTING);
575 /* retry flushing wbuf in case jffs2_wbuf_recover
576 left some data in the wbuf */
579 ret = __jffs2_flush_wbuf(c, PAD_ACCOUNTING);
581 up_write(&c->wbuf_sem);
587 D1(printk(KERN_DEBUG "jffs2_flush_wbuf_gc() ends...\n"));
593 /* Pad write-buffer to end and write it, wasting space. */
594 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 #define PAGE_DIV(x) ( (x) & (~(c->wbuf_pagesize - 1)) )
609 #define PAGE_MOD(x) ( (x) & (c->wbuf_pagesize - 1) )
610 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)
612 struct kvec outvecs[3];
614 uint32_t split_ofs = 0;
616 int ret, splitvec = -1;
619 unsigned char *wbuf_ptr;
621 uint32_t outvec_to = to;
623 /* If not NAND flash, don't bother */
625 return jffs2_flash_direct_writev(c, invecs, count, to, retlen);
627 down_write(&c->wbuf_sem);
629 /* If wbuf_ofs is not initialized, set it to target address */
630 if (c->wbuf_ofs == 0xFFFFFFFF) {
631 c->wbuf_ofs = PAGE_DIV(to);
632 c->wbuf_len = PAGE_MOD(to);
633 memset(c->wbuf,0xff,c->wbuf_pagesize);
636 /* Fixup the wbuf if we are moving to a new eraseblock. The checks below
637 fail for ECC'd NOR because cleanmarker == 16, so a block starts at
639 if (jffs2_nor_ecc(c)) {
640 if (((c->wbuf_ofs % c->sector_size) == 0) && !c->wbuf_len) {
641 c->wbuf_ofs = PAGE_DIV(to);
642 c->wbuf_len = PAGE_MOD(to);
643 memset(c->wbuf,0xff,c->wbuf_pagesize);
647 /* Sanity checks on target address.
648 It's permitted to write at PAD(c->wbuf_len+c->wbuf_ofs),
649 and it's permitted to write at the beginning of a new
650 erase block. Anything else, and you die.
651 New block starts at xxx000c (0-b = block header)
653 if ( (to & ~(c->sector_size-1)) != (c->wbuf_ofs & ~(c->sector_size-1)) ) {
654 /* It's a write to a new block */
656 D1(printk(KERN_DEBUG "jffs2_flash_writev() to 0x%lx causes flush of wbuf at 0x%08x\n", (unsigned long)to, c->wbuf_ofs));
657 ret = __jffs2_flush_wbuf(c, PAD_NOACCOUNT);
659 /* the underlying layer has to check wbuf_len to do the cleanup */
660 D1(printk(KERN_WARNING "jffs2_flush_wbuf() called from jffs2_flash_writev() failed %d\n", ret));
665 /* set pointer to new block */
666 c->wbuf_ofs = PAGE_DIV(to);
667 c->wbuf_len = PAGE_MOD(to);
670 if (to != PAD(c->wbuf_ofs + c->wbuf_len)) {
671 /* We're not writing immediately after the writebuffer. Bad. */
672 printk(KERN_CRIT "jffs2_flash_writev(): Non-contiguous write to %08lx\n", (unsigned long)to);
674 printk(KERN_CRIT "wbuf was previously %08x-%08x\n",
675 c->wbuf_ofs, c->wbuf_ofs+c->wbuf_len);
679 /* Note outvecs[3] above. We know count is never greater than 2 */
681 printk(KERN_CRIT "jffs2_flash_writev(): count is %ld\n", count);
688 /* Fill writebuffer first, if already in use */
690 uint32_t invec_ofs = 0;
692 /* adjust alignment offset */
693 if (c->wbuf_len != PAGE_MOD(to)) {
694 c->wbuf_len = PAGE_MOD(to);
695 /* take care of alignment to next page */
697 c->wbuf_len = c->wbuf_pagesize;
700 while(c->wbuf_len < c->wbuf_pagesize) {
706 thislen = c->wbuf_pagesize - c->wbuf_len;
708 if (thislen >= invecs[invec].iov_len)
709 thislen = invecs[invec].iov_len;
713 memcpy(c->wbuf + c->wbuf_len, invecs[invec].iov_base, thislen);
714 c->wbuf_len += thislen;
716 /* Get next invec, if actual did not fill the buffer */
717 if (c->wbuf_len < c->wbuf_pagesize)
721 /* write buffer is full, flush buffer */
722 ret = __jffs2_flush_wbuf(c, NOPAD);
724 /* the underlying layer has to check wbuf_len to do the cleanup */
725 D1(printk(KERN_WARNING "jffs2_flush_wbuf() called from jffs2_flash_writev() failed %d\n", ret));
726 /* Retlen zero to make sure our caller doesn't mark the space dirty.
727 We've already done everything that's necessary */
731 outvec_to += donelen;
732 c->wbuf_ofs = outvec_to;
734 /* All invecs done ? */
738 /* Set up the first outvec, containing the remainder of the
739 invec we partially used */
740 if (invecs[invec].iov_len > invec_ofs) {
741 outvecs[0].iov_base = invecs[invec].iov_base+invec_ofs;
742 totlen = outvecs[0].iov_len = invecs[invec].iov_len-invec_ofs;
743 if (totlen > c->wbuf_pagesize) {
745 split_ofs = outvecs[0].iov_len - PAGE_MOD(totlen);
752 /* OK, now we've flushed the wbuf and the start of the bits
753 we have been asked to write, now to write the rest.... */
755 /* totlen holds the amount of data still to be written */
757 for ( ; invec < count; invec++,outvec++ ) {
758 outvecs[outvec].iov_base = invecs[invec].iov_base;
759 totlen += outvecs[outvec].iov_len = invecs[invec].iov_len;
760 if (PAGE_DIV(totlen) != PAGE_DIV(old_totlen)) {
762 split_ofs = outvecs[outvec].iov_len - PAGE_MOD(totlen);
767 /* Now the outvecs array holds all the remaining data to write */
768 /* Up to splitvec,split_ofs is to be written immediately. The rest
769 goes into the (now-empty) wbuf */
771 if (splitvec != -1) {
774 remainder = outvecs[splitvec].iov_len - split_ofs;
775 outvecs[splitvec].iov_len = split_ofs;
777 /* We did cross a page boundary, so we write some now */
778 if (jffs2_cleanmarker_oob(c))
779 ret = c->mtd->writev_ecc(c->mtd, outvecs, splitvec+1, outvec_to, &wbuf_retlen, NULL, c->oobinfo);
781 ret = jffs2_flash_direct_writev(c, outvecs, splitvec+1, outvec_to, &wbuf_retlen);
783 if (ret < 0 || wbuf_retlen != PAGE_DIV(totlen)) {
784 /* At this point we have no problem,
785 c->wbuf is empty. However refile nextblock to avoid
786 writing again to same address.
788 struct jffs2_eraseblock *jeb;
790 spin_lock(&c->erase_completion_lock);
792 jeb = &c->blocks[outvec_to / c->sector_size];
793 jffs2_block_refile(c, jeb, REFILE_ANYWAY);
796 spin_unlock(&c->erase_completion_lock);
800 donelen += wbuf_retlen;
801 c->wbuf_ofs = PAGE_DIV(outvec_to) + PAGE_DIV(totlen);
804 outvecs[splitvec].iov_base += split_ofs;
805 outvecs[splitvec].iov_len = remainder;
814 /* Now splitvec points to the start of the bits we have to copy
818 for ( ; splitvec < outvec; splitvec++) {
819 /* Don't copy the wbuf into itself */
820 if (outvecs[splitvec].iov_base == c->wbuf)
822 memcpy(wbuf_ptr, outvecs[splitvec].iov_base, outvecs[splitvec].iov_len);
823 wbuf_ptr += outvecs[splitvec].iov_len;
824 donelen += outvecs[splitvec].iov_len;
826 c->wbuf_len = wbuf_ptr - c->wbuf;
828 /* If there's a remainder in the wbuf and it's a non-GC write,
829 remember that the wbuf affects this ino */
833 if (c->wbuf_len && ino)
834 jffs2_wbuf_dirties_inode(c, ino);
839 up_write(&c->wbuf_sem);
844 * This is the entry for flash write.
845 * Check, if we work on NAND FLASH, if so build an kvec and write it via vritev
847 int jffs2_flash_write(struct jffs2_sb_info *c, loff_t ofs, size_t len, size_t *retlen, const u_char *buf)
851 if (jffs2_can_mark_obsolete(c))
852 return c->mtd->write(c->mtd, ofs, len, retlen, buf);
854 vecs[0].iov_base = (unsigned char *) buf;
855 vecs[0].iov_len = len;
856 return jffs2_flash_writev(c, vecs, 1, ofs, retlen, 0);
860 Handle readback from writebuffer and ECC failure return
862 int jffs2_flash_read(struct jffs2_sb_info *c, loff_t ofs, size_t len, size_t *retlen, u_char *buf)
864 loff_t orbf = 0, owbf = 0, lwbf = 0;
868 if (!jffs2_can_mark_obsolete(c)) {
869 down_read(&c->wbuf_sem);
871 if (jffs2_cleanmarker_oob(c))
872 ret = c->mtd->read_ecc(c->mtd, ofs, len, retlen, buf, NULL, c->oobinfo);
874 ret = c->mtd->read(c->mtd, ofs, len, retlen, buf);
876 if ( (ret == -EBADMSG) && (*retlen == len) ) {
877 printk(KERN_WARNING "mtd->read(0x%zx bytes from 0x%llx) returned ECC error\n",
880 * We have the raw data without ECC correction in the buffer, maybe
881 * we are lucky and all data or parts are correct. We check the node.
882 * If data are corrupted node check will sort it out.
883 * We keep this block, it will fail on write or erase and the we
884 * mark it bad. Or should we do that now? But we should give him a chance.
885 * Maybe we had a system crash or power loss before the ecc write or
886 * a erase was completed.
887 * So we return success. :)
892 return c->mtd->read(c->mtd, ofs, len, retlen, buf);
894 /* if no writebuffer available or write buffer empty, return */
895 if (!c->wbuf_pagesize || !c->wbuf_len)
898 /* if we read in a different block, return */
899 if ( (ofs & ~(c->sector_size-1)) != (c->wbuf_ofs & ~(c->sector_size-1)) )
902 if (ofs >= c->wbuf_ofs) {
903 owbf = (ofs - c->wbuf_ofs); /* offset in write buffer */
904 if (owbf > c->wbuf_len) /* is read beyond write buffer ? */
906 lwbf = c->wbuf_len - owbf; /* number of bytes to copy */
910 orbf = (c->wbuf_ofs - ofs); /* offset in read buffer */
911 if (orbf > len) /* is write beyond write buffer ? */
913 lwbf = len - orbf; /* number of bytes to copy */
914 if (lwbf > c->wbuf_len)
918 memcpy(buf+orbf,c->wbuf+owbf,lwbf);
921 up_read(&c->wbuf_sem);
926 * Check, if the out of band area is empty
928 int jffs2_check_oob_empty( struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, int mode)
936 /* allocate a buffer for all oob data in this sector */
937 oob_size = c->mtd->oobsize;
939 buf = kmalloc(len, GFP_KERNEL);
941 printk(KERN_NOTICE "jffs2_check_oob_empty(): allocation of temporary data buffer for oob check failed\n");
945 * if mode = 0, we scan for a total empty oob area, else we have
946 * to take care of the cleanmarker in the first page of the block
948 ret = jffs2_flash_read_oob(c, jeb->offset, len , &retlen, buf);
950 D1(printk(KERN_WARNING "jffs2_check_oob_empty(): Read OOB failed %d for block at %08x\n", ret, jeb->offset));
955 D1(printk(KERN_WARNING "jffs2_check_oob_empty(): Read OOB return short read "
956 "(%zd bytes not %d) for block at %08x\n", retlen, len, jeb->offset));
961 /* Special check for first page */
962 for(i = 0; i < oob_size ; i++) {
963 /* Yeah, we know about the cleanmarker. */
964 if (mode && i >= c->fsdata_pos &&
965 i < c->fsdata_pos + c->fsdata_len)
968 if (buf[i] != 0xFF) {
969 D2(printk(KERN_DEBUG "Found %02x at %x in OOB for %08x\n",
970 buf[page+i], page+i, jeb->offset));
976 /* we know, we are aligned :) */
977 for (page = oob_size; page < len; page += sizeof(long)) {
978 unsigned long dat = *(unsigned long *)(&buf[page]);
992 * Scan for a valid cleanmarker and for bad blocks
993 * For virtual blocks (concatenated physical blocks) check the cleanmarker
994 * only in the first page of the first physical block, but scan for bad blocks in all
997 int jffs2_check_nand_cleanmarker (struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb)
999 struct jffs2_unknown_node n;
1000 unsigned char buf[2 * NAND_MAX_OOBSIZE];
1002 int ret, i, cnt, retval = 0;
1003 size_t retlen, offset;
1006 offset = jeb->offset;
1007 oob_size = c->mtd->oobsize;
1009 /* Loop through the physical blocks */
1010 for (cnt = 0; cnt < (c->sector_size / c->mtd->erasesize); cnt++) {
1011 /* Check first if the block is bad. */
1012 if (c->mtd->block_isbad (c->mtd, offset)) {
1013 D1 (printk (KERN_WARNING "jffs2_check_nand_cleanmarker(): Bad block at %08x\n", jeb->offset));
1017 * We read oob data from page 0 and 1 of the block.
1018 * page 0 contains cleanmarker and badblock info
1019 * page 1 contains failure count of this block
1021 ret = c->mtd->read_oob (c->mtd, offset, oob_size << 1, &retlen, buf);
1024 D1 (printk (KERN_WARNING "jffs2_check_nand_cleanmarker(): Read OOB failed %d for block at %08x\n", ret, jeb->offset));
1027 if (retlen < (oob_size << 1)) {
1028 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));
1032 /* Check cleanmarker only on the first physical block */
1034 n.magic = cpu_to_je16 (JFFS2_MAGIC_BITMASK);
1035 n.nodetype = cpu_to_je16 (JFFS2_NODETYPE_CLEANMARKER);
1036 n.totlen = cpu_to_je32 (8);
1037 p = (unsigned char *) &n;
1039 for (i = 0; i < c->fsdata_len; i++) {
1040 if (buf[c->fsdata_pos + i] != p[i]) {
1044 D1(if (retval == 1) {
1045 printk(KERN_WARNING "jffs2_check_nand_cleanmarker(): Cleanmarker node not detected in block at %08x\n", jeb->offset);
1046 printk(KERN_WARNING "OOB at %08x was ", offset);
1047 for (i=0; i < oob_size; i++) {
1048 printk("%02x ", buf[i]);
1053 offset += c->mtd->erasesize;
1058 int jffs2_write_nand_cleanmarker(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb)
1060 struct jffs2_unknown_node n;
1064 n.magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
1065 n.nodetype = cpu_to_je16(JFFS2_NODETYPE_CLEANMARKER);
1066 n.totlen = cpu_to_je32(8);
1068 ret = jffs2_flash_write_oob(c, jeb->offset + c->fsdata_pos, c->fsdata_len, &retlen, (unsigned char *)&n);
1071 D1(printk(KERN_WARNING "jffs2_write_nand_cleanmarker(): Write failed for block at %08x: error %d\n", jeb->offset, ret));
1074 if (retlen != c->fsdata_len) {
1075 D1(printk(KERN_WARNING "jffs2_write_nand_cleanmarker(): Short write for block at %08x: %zd not %d\n", jeb->offset, retlen, c->fsdata_len));
1082 * On NAND we try to mark this block bad. If the block was erased more
1083 * than MAX_ERASE_FAILURES we mark it finaly bad.
1084 * Don't care about failures. This block remains on the erase-pending
1085 * or badblock list as long as nobody manipulates the flash with
1086 * a bootloader or something like that.
1089 int jffs2_write_nand_badblock(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, uint32_t bad_offset)
1093 /* if the count is < max, we try to write the counter to the 2nd page oob area */
1094 if( ++jeb->bad_count < MAX_ERASE_FAILURES)
1097 if (!c->mtd->block_markbad)
1098 return 1; // What else can we do?
1100 D1(printk(KERN_WARNING "jffs2_write_nand_badblock(): Marking bad block at %08x\n", bad_offset));
1101 ret = c->mtd->block_markbad(c->mtd, bad_offset);
1104 D1(printk(KERN_WARNING "jffs2_write_nand_badblock(): Write failed for block at %08x: error %d\n", jeb->offset, ret));
1110 #define NAND_JFFS2_OOB16_FSDALEN 8
1112 static struct nand_oobinfo jffs2_oobinfo_docecc = {
1113 .useecc = MTD_NANDECC_PLACE,
1115 .eccpos = {0,1,2,3,4,5}
1119 static int jffs2_nand_set_oobinfo(struct jffs2_sb_info *c)
1121 struct nand_oobinfo *oinfo = &c->mtd->oobinfo;
1123 /* Do this only, if we have an oob buffer */
1124 if (!c->mtd->oobsize)
1127 /* Cleanmarker is out-of-band, so inline size zero */
1128 c->cleanmarker_size = 0;
1130 /* Should we use autoplacement ? */
1131 if (oinfo && oinfo->useecc == MTD_NANDECC_AUTOPLACE) {
1132 D1(printk(KERN_DEBUG "JFFS2 using autoplace on NAND\n"));
1133 /* Get the position of the free bytes */
1134 if (!oinfo->oobfree[0][1]) {
1135 printk (KERN_WARNING "jffs2_nand_set_oobinfo(): Eeep. Autoplacement selected and no empty space in oob\n");
1138 c->fsdata_pos = oinfo->oobfree[0][0];
1139 c->fsdata_len = oinfo->oobfree[0][1];
1140 if (c->fsdata_len > 8)
1143 /* This is just a legacy fallback and should go away soon */
1144 switch(c->mtd->ecctype) {
1145 case MTD_ECC_RS_DiskOnChip:
1146 printk(KERN_WARNING "JFFS2 using DiskOnChip hardware ECC without autoplacement. Fix it!\n");
1147 c->oobinfo = &jffs2_oobinfo_docecc;
1149 c->fsdata_len = NAND_JFFS2_OOB16_FSDALEN;
1150 c->badblock_pos = 15;
1154 D1(printk(KERN_DEBUG "JFFS2 on NAND. No autoplacment info found\n"));
1161 int jffs2_nand_flash_setup(struct jffs2_sb_info *c)
1165 /* Initialise write buffer */
1166 init_rwsem(&c->wbuf_sem);
1167 c->wbuf_pagesize = c->mtd->oobblock;
1168 c->wbuf_ofs = 0xFFFFFFFF;
1170 c->wbuf = kmalloc(c->wbuf_pagesize, GFP_KERNEL);
1174 res = jffs2_nand_set_oobinfo(c);
1178 brokenbuf = kmalloc(c->wbuf_pagesize, GFP_KERNEL);
1183 memset(brokenbuf, 0xdb, c->wbuf_pagesize);
1188 void jffs2_nand_flash_cleanup(struct jffs2_sb_info *c)
1193 #ifdef CONFIG_JFFS2_FS_NOR_ECC
1194 int jffs2_nor_ecc_flash_setup(struct jffs2_sb_info *c) {
1195 /* Cleanmarker is actually larger on the flashes */
1196 c->cleanmarker_size = 16;
1198 /* Initialize write buffer */
1199 init_rwsem(&c->wbuf_sem);
1200 c->wbuf_pagesize = c->mtd->eccsize;
1201 c->wbuf_ofs = 0xFFFFFFFF;
1203 c->wbuf = kmalloc(c->wbuf_pagesize, GFP_KERNEL);
1210 void jffs2_nor_ecc_flash_cleanup(struct jffs2_sb_info *c) {