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>
25 /* For testing write failures */
30 static unsigned char *brokenbuf
;
33 #define PAGE_DIV(x) ( ((unsigned long)(x) / (unsigned long)(c->wbuf_pagesize)) * (unsigned long)(c->wbuf_pagesize) )
34 #define PAGE_MOD(x) ( (unsigned long)(x) % (unsigned long)(c->wbuf_pagesize) )
36 /* max. erase failures before we mark a block bad */
37 #define MAX_ERASE_FAILURES 2
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 /* File the existing block on the bad_used_list.... */
143 if (c
->nextblock
== jeb
)
145 else /* Not sure this should ever happen... need more coffee */
146 list_del(&jeb
->list
);
147 if (jeb
->first_node
) {
148 D1(printk("Refiling block at %08x to bad_used_list\n", jeb
->offset
));
149 list_add(&jeb
->list
, &c
->bad_used_list
);
151 BUG_ON(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
);
159 /* Adjust its size counts accordingly */
160 c
->wasted_size
+= jeb
->free_size
;
161 c
->free_size
-= jeb
->free_size
;
162 jeb
->wasted_size
+= jeb
->free_size
;
165 jffs2_dbg_dump_block_lists_nolock(c
);
166 jffs2_dbg_acct_sanity_check_nolock(c
,jeb
);
167 jffs2_dbg_acct_paranoia_check_nolock(c
, 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 if (jffs2_prealloc_raw_node_refs(c
, c
->reserved_refs
+ 1))
185 spin_lock(&c
->erase_completion_lock
);
187 jeb
= &c
->blocks
[c
->wbuf_ofs
/ c
->sector_size
];
189 jffs2_block_refile(c
, jeb
, REFILE_NOTEMPTY
);
191 /* Find the first node to be recovered, by skipping over every
192 node which ends before the wbuf starts, or which is obsolete. */
193 first_raw
= &jeb
->first_node
;
195 (ref_obsolete(*first_raw
) ||
196 (ref_offset(*first_raw
)+ref_totlen(c
, jeb
, *first_raw
)) < c
->wbuf_ofs
)) {
197 D1(printk(KERN_DEBUG
"Skipping node at 0x%08x(%d)-0x%08x which is either before 0x%08x or obsolete\n",
198 ref_offset(*first_raw
), ref_flags(*first_raw
),
199 (ref_offset(*first_raw
) + ref_totlen(c
, jeb
, *first_raw
)),
201 first_raw
= &(*first_raw
)->next_phys
;
205 /* All nodes were obsolete. Nothing to recover. */
206 D1(printk(KERN_DEBUG
"No non-obsolete nodes to be recovered. Just filing block bad\n"));
207 spin_unlock(&c
->erase_completion_lock
);
211 start
= ref_offset(*first_raw
);
212 end
= ref_offset(*first_raw
) + ref_totlen(c
, jeb
, *first_raw
);
214 /* Find the last node to be recovered */
217 if (!ref_obsolete(*raw
))
218 end
= ref_offset(*raw
) + ref_totlen(c
, jeb
, *raw
);
220 raw
= &(*raw
)->next_phys
;
222 spin_unlock(&c
->erase_completion_lock
);
224 D1(printk(KERN_DEBUG
"wbuf recover %08x-%08x\n", start
, end
));
227 if (start
< c
->wbuf_ofs
) {
228 /* First affected node was already partially written.
229 * Attempt to reread the old data into our buffer. */
231 buf
= kmalloc(end
- start
, GFP_KERNEL
);
233 printk(KERN_CRIT
"Malloc failure in wbuf recovery. Data loss ensues.\n");
239 if (jffs2_cleanmarker_oob(c
))
240 ret
= c
->mtd
->read_ecc(c
->mtd
, start
, c
->wbuf_ofs
- start
, &retlen
, buf
, NULL
, c
->oobinfo
);
242 ret
= c
->mtd
->read(c
->mtd
, start
, c
->wbuf_ofs
- start
, &retlen
, buf
);
244 if (ret
== -EBADMSG
&& retlen
== c
->wbuf_ofs
- start
) {
248 if (ret
|| retlen
!= c
->wbuf_ofs
- start
) {
249 printk(KERN_CRIT
"Old data are already lost in wbuf recovery. Data loss ensues.\n");
254 first_raw
= &(*first_raw
)->next_phys
;
255 /* If this was the only node to be recovered, give up */
259 /* It wasn't. Go on and try to recover nodes complete in the wbuf */
260 start
= ref_offset(*first_raw
);
262 /* Read succeeded. Copy the remaining data from the wbuf */
263 memcpy(buf
+ (c
->wbuf_ofs
- start
), c
->wbuf
, end
- c
->wbuf_ofs
);
266 /* OK... we're to rewrite (end-start) bytes of data from first_raw onwards.
267 Either 'buf' contains the data, or we find it in the wbuf */
270 /* ... and get an allocation of space from a shiny new block instead */
271 ret
= jffs2_reserve_space_gc(c
, end
-start
, &len
, JFFS2_SUMMARY_NOSUM_SIZE
);
273 printk(KERN_WARNING
"Failed to allocate space for wbuf recovery. Data loss ensues.\n");
279 if (end
-start
>= c
->wbuf_pagesize
) {
280 /* Need to do another write immediately, but it's possible
281 that this is just because the wbuf itself is completely
282 full, and there's nothing earlier read back from the
283 flash. Hence 'buf' isn't necessarily what we're writing
285 unsigned char *rewrite_buf
= buf
?:c
->wbuf
;
286 uint32_t towrite
= (end
-start
) - ((end
-start
)%c
->wbuf_pagesize
);
288 D1(printk(KERN_DEBUG
"Write 0x%x bytes at 0x%08x in wbuf recover\n",
293 if (breakme
++ == 20) {
294 printk(KERN_NOTICE
"Faking write error at 0x%08x\n", ofs
);
296 c
->mtd
->write_ecc(c
->mtd
, ofs
, towrite
, &retlen
,
297 brokenbuf
, NULL
, c
->oobinfo
);
301 if (jffs2_cleanmarker_oob(c
))
302 ret
= c
->mtd
->write_ecc(c
->mtd
, ofs
, towrite
, &retlen
,
303 rewrite_buf
, NULL
, c
->oobinfo
);
305 ret
= c
->mtd
->write(c
->mtd
, ofs
, towrite
, &retlen
, rewrite_buf
);
307 if (ret
|| retlen
!= towrite
) {
308 /* Argh. We tried. Really we did. */
309 printk(KERN_CRIT
"Recovery of wbuf failed due to a second write error\n");
313 jffs2_add_physical_node_ref(c
, ofs
| REF_OBSOLETE
, ref_totlen(c
, jeb
, *first_raw
), NULL
);
317 printk(KERN_NOTICE
"Recovery of wbuf succeeded to %08x\n", ofs
);
319 c
->wbuf_len
= (end
- start
) - towrite
;
320 c
->wbuf_ofs
= ofs
+ towrite
;
321 memmove(c
->wbuf
, rewrite_buf
+ towrite
, c
->wbuf_len
);
322 /* Don't muck about with c->wbuf_inodes. False positives are harmless. */
325 /* OK, now we're left with the dregs in whichever buffer we're using */
327 memcpy(c
->wbuf
, buf
, end
-start
);
330 memmove(c
->wbuf
, c
->wbuf
+ (start
- c
->wbuf_ofs
), end
- start
);
333 c
->wbuf_len
= end
- start
;
336 /* Now sort out the jffs2_raw_node_refs, moving them from the old to the next block */
337 new_jeb
= &c
->blocks
[ofs
/ c
->sector_size
];
339 spin_lock(&c
->erase_completion_lock
);
340 if (new_jeb
->first_node
) {
341 /* Odd, but possible with ST flash later maybe */
342 new_jeb
->last_node
->next_phys
= *first_raw
;
344 new_jeb
->first_node
= *first_raw
;
349 uint32_t rawlen
= ref_totlen(c
, jeb
, *raw
);
351 D1(printk(KERN_DEBUG
"Refiling block of %08x at %08x(%d) to %08x\n",
352 rawlen
, ref_offset(*raw
), ref_flags(*raw
), ofs
));
354 if (ref_obsolete(*raw
)) {
355 /* Shouldn't really happen much */
356 new_jeb
->dirty_size
+= rawlen
;
357 new_jeb
->free_size
-= rawlen
;
358 c
->dirty_size
+= rawlen
;
360 new_jeb
->used_size
+= rawlen
;
361 new_jeb
->free_size
-= rawlen
;
362 jeb
->dirty_size
+= rawlen
;
363 jeb
->used_size
-= rawlen
;
364 c
->dirty_size
+= rawlen
;
366 c
->free_size
-= rawlen
;
367 (*raw
)->flash_offset
= ofs
| ref_flags(*raw
);
369 new_jeb
->last_node
= *raw
;
371 raw
= &(*raw
)->next_phys
;
374 /* Fix up the original jeb now it's on the bad_list */
376 if (first_raw
== &jeb
->first_node
) {
377 jeb
->last_node
= NULL
;
378 D1(printk(KERN_DEBUG
"Failing block at %08x is now empty. Moving to erase_pending_list\n", jeb
->offset
));
379 list_del(&jeb
->list
);
380 list_add(&jeb
->list
, &c
->erase_pending_list
);
381 c
->nr_erasing_blocks
++;
382 jffs2_erase_pending_trigger(c
);
385 jeb
->last_node
= container_of(first_raw
, struct jffs2_raw_node_ref
, next_phys
);
387 jffs2_dbg_acct_sanity_check_nolock(c
, jeb
);
388 jffs2_dbg_acct_paranoia_check_nolock(c
, jeb
);
390 jffs2_dbg_acct_sanity_check_nolock(c
, new_jeb
);
391 jffs2_dbg_acct_paranoia_check_nolock(c
, new_jeb
);
393 spin_unlock(&c
->erase_completion_lock
);
395 D1(printk(KERN_DEBUG
"wbuf recovery completed OK\n"));
398 /* Meaning of pad argument:
399 0: Do not pad. Probably pointless - we only ever use this when we can't pad anyway.
400 1: Pad, do not adjust nextblock free_size
401 2: Pad, adjust nextblock free_size
404 #define PAD_NOACCOUNT 1
405 #define PAD_ACCOUNTING 2
407 static int __jffs2_flush_wbuf(struct jffs2_sb_info
*c
, int pad
)
412 /* Nothing to do if not write-buffering the flash. In particular, we shouldn't
413 del_timer() the timer we never initialised. */
414 if (!jffs2_is_writebuffered(c
))
417 if (!down_trylock(&c
->alloc_sem
)) {
419 printk(KERN_CRIT
"jffs2_flush_wbuf() called with alloc_sem not locked!\n");
423 if (!c
->wbuf_len
) /* already checked c->wbuf above */
426 if (jffs2_prealloc_raw_node_refs(c
, c
->reserved_refs
+ 1))
429 /* claim remaining space on the page
430 this happens, if we have a change to a new block,
431 or if fsync forces us to flush the writebuffer.
432 if we have a switch to next page, we will not have
433 enough remaining space for this.
436 c
->wbuf_len
= PAD(c
->wbuf_len
);
438 /* Pad with JFFS2_DIRTY_BITMASK initially. this helps out ECC'd NOR
439 with 8 byte page size */
440 memset(c
->wbuf
+ c
->wbuf_len
, 0, c
->wbuf_pagesize
- c
->wbuf_len
);
442 if ( c
->wbuf_len
+ sizeof(struct jffs2_unknown_node
) < c
->wbuf_pagesize
) {
443 struct jffs2_unknown_node
*padnode
= (void *)(c
->wbuf
+ c
->wbuf_len
);
444 padnode
->magic
= cpu_to_je16(JFFS2_MAGIC_BITMASK
);
445 padnode
->nodetype
= cpu_to_je16(JFFS2_NODETYPE_PADDING
);
446 padnode
->totlen
= cpu_to_je32(c
->wbuf_pagesize
- c
->wbuf_len
);
447 padnode
->hdr_crc
= cpu_to_je32(crc32(0, padnode
, sizeof(*padnode
)-4));
450 /* else jffs2_flash_writev has actually filled in the rest of the
451 buffer for us, and will deal with the node refs etc. later. */
455 if (breakme
++ == 20) {
456 printk(KERN_NOTICE
"Faking write error at 0x%08x\n", c
->wbuf_ofs
);
458 c
->mtd
->write_ecc(c
->mtd
, c
->wbuf_ofs
, c
->wbuf_pagesize
,
459 &retlen
, brokenbuf
, NULL
, c
->oobinfo
);
464 if (jffs2_cleanmarker_oob(c
))
465 ret
= c
->mtd
->write_ecc(c
->mtd
, c
->wbuf_ofs
, c
->wbuf_pagesize
, &retlen
, c
->wbuf
, NULL
, c
->oobinfo
);
467 ret
= c
->mtd
->write(c
->mtd
, c
->wbuf_ofs
, c
->wbuf_pagesize
, &retlen
, c
->wbuf
);
469 if (ret
|| retlen
!= c
->wbuf_pagesize
) {
471 printk(KERN_WARNING
"jffs2_flush_wbuf(): Write failed with %d\n",ret
);
473 printk(KERN_WARNING
"jffs2_flush_wbuf(): Write was short: %zd instead of %d\n",
474 retlen
, c
->wbuf_pagesize
);
478 jffs2_wbuf_recover(c
);
483 /* Adjust free size of the block if we padded. */
485 struct jffs2_eraseblock
*jeb
;
486 uint32_t waste
= c
->wbuf_pagesize
- c
->wbuf_len
;
488 jeb
= &c
->blocks
[c
->wbuf_ofs
/ c
->sector_size
];
490 D1(printk(KERN_DEBUG
"jffs2_flush_wbuf() adjusting free_size of %sblock at %08x\n",
491 (jeb
==c
->nextblock
)?"next":"", jeb
->offset
));
493 /* wbuf_pagesize - wbuf_len is the amount of space that's to be
494 padded. If there is less free space in the block than that,
495 something screwed up */
496 if (jeb
->free_size
< waste
) {
497 printk(KERN_CRIT
"jffs2_flush_wbuf(): Accounting error. wbuf at 0x%08x has 0x%03x bytes, 0x%03x left.\n",
498 c
->wbuf_ofs
, c
->wbuf_len
, waste
);
499 printk(KERN_CRIT
"jffs2_flush_wbuf(): But free_size for block at 0x%08x is only 0x%08x\n",
500 jeb
->offset
, jeb
->free_size
);
504 spin_lock(&c
->erase_completion_lock
);
506 jffs2_link_node_ref(c
, jeb
, (c
->wbuf_ofs
+ c
->wbuf_len
) | REF_OBSOLETE
, waste
, NULL
);
507 /* FIXME: that made it count as dirty. Convert to wasted */
508 jeb
->dirty_size
-= waste
;
509 c
->dirty_size
-= waste
;
510 jeb
->wasted_size
+= waste
;
511 c
->wasted_size
+= waste
;
513 spin_lock(&c
->erase_completion_lock
);
515 /* Stick any now-obsoleted blocks on the erase_pending_list */
516 jffs2_refile_wbuf_blocks(c
);
517 jffs2_clear_wbuf_ino_list(c
);
518 spin_unlock(&c
->erase_completion_lock
);
520 memset(c
->wbuf
,0xff,c
->wbuf_pagesize
);
521 /* adjust write buffer offset, else we get a non contiguous write bug */
522 c
->wbuf_ofs
+= c
->wbuf_pagesize
;
527 /* Trigger garbage collection to flush the write-buffer.
528 If ino arg is zero, do it if _any_ real (i.e. not GC) writes are
529 outstanding. If ino arg non-zero, do it only if a write for the
530 given inode is outstanding. */
531 int jffs2_flush_wbuf_gc(struct jffs2_sb_info
*c
, uint32_t ino
)
533 uint32_t old_wbuf_ofs
;
534 uint32_t old_wbuf_len
;
537 D1(printk(KERN_DEBUG
"jffs2_flush_wbuf_gc() called for ino #%u...\n", ino
));
543 if (!jffs2_wbuf_pending_for_ino(c
, ino
)) {
544 D1(printk(KERN_DEBUG
"Ino #%d not pending in wbuf. Returning\n", ino
));
549 old_wbuf_ofs
= c
->wbuf_ofs
;
550 old_wbuf_len
= c
->wbuf_len
;
552 if (c
->unchecked_size
) {
553 /* GC won't make any progress for a while */
554 D1(printk(KERN_DEBUG
"jffs2_flush_wbuf_gc() padding. Not finished checking\n"));
555 down_write(&c
->wbuf_sem
);
556 ret
= __jffs2_flush_wbuf(c
, PAD_ACCOUNTING
);
557 /* retry flushing wbuf in case jffs2_wbuf_recover
558 left some data in the wbuf */
560 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 */
578 ret
= __jffs2_flush_wbuf(c
, PAD_ACCOUNTING
);
579 up_write(&c
->wbuf_sem
);
585 D1(printk(KERN_DEBUG
"jffs2_flush_wbuf_gc() ends...\n"));
591 /* Pad write-buffer to end and write it, wasting space. */
592 int jffs2_flush_wbuf_pad(struct jffs2_sb_info
*c
)
599 down_write(&c
->wbuf_sem
);
600 ret
= __jffs2_flush_wbuf(c
, PAD_NOACCOUNT
);
601 /* retry - maybe wbuf recover left some data in wbuf. */
603 ret
= __jffs2_flush_wbuf(c
, PAD_NOACCOUNT
);
604 up_write(&c
->wbuf_sem
);
609 static size_t jffs2_fill_wbuf(struct jffs2_sb_info
*c
, const uint8_t *buf
,
612 if (len
&& !c
->wbuf_len
&& (len
>= c
->wbuf_pagesize
))
615 if (len
> (c
->wbuf_pagesize
- c
->wbuf_len
))
616 len
= c
->wbuf_pagesize
- c
->wbuf_len
;
617 memcpy(c
->wbuf
+ c
->wbuf_len
, buf
, len
);
618 c
->wbuf_len
+= (uint32_t) len
;
622 int jffs2_flash_writev(struct jffs2_sb_info
*c
, const struct kvec
*invecs
,
623 unsigned long count
, loff_t to
, size_t *retlen
,
626 struct jffs2_eraseblock
*jeb
;
627 size_t wbuf_retlen
, donelen
= 0;
628 uint32_t outvec_to
= to
;
631 /* If not writebuffered flash, don't bother */
632 if (!jffs2_is_writebuffered(c
))
633 return jffs2_flash_direct_writev(c
, invecs
, count
, to
, retlen
);
635 down_write(&c
->wbuf_sem
);
637 /* If wbuf_ofs is not initialized, set it to target address */
638 if (c
->wbuf_ofs
== 0xFFFFFFFF) {
639 c
->wbuf_ofs
= PAGE_DIV(to
);
640 c
->wbuf_len
= PAGE_MOD(to
);
641 memset(c
->wbuf
,0xff,c
->wbuf_pagesize
);
645 * Sanity checks on target address. It's permitted to write
646 * at PAD(c->wbuf_len+c->wbuf_ofs), and it's permitted to
647 * write at the beginning of a new erase block. Anything else,
648 * and you die. New block starts at xxx000c (0-b = block
651 if (SECTOR_ADDR(to
) != SECTOR_ADDR(c
->wbuf_ofs
)) {
652 /* It's a write to a new block */
654 D1(printk(KERN_DEBUG
"jffs2_flash_writev() to 0x%lx "
655 "causes flush of wbuf at 0x%08x\n",
656 (unsigned long)to
, c
->wbuf_ofs
));
657 ret
= __jffs2_flush_wbuf(c
, PAD_NOACCOUNT
);
661 /* set pointer to new block */
662 c
->wbuf_ofs
= PAGE_DIV(to
);
663 c
->wbuf_len
= PAGE_MOD(to
);
666 if (to
!= PAD(c
->wbuf_ofs
+ c
->wbuf_len
)) {
667 /* We're not writing immediately after the writebuffer. Bad. */
668 printk(KERN_CRIT
"jffs2_flash_writev(): Non-contiguous write "
669 "to %08lx\n", (unsigned long)to
);
671 printk(KERN_CRIT
"wbuf was previously %08x-%08x\n",
672 c
->wbuf_ofs
, c
->wbuf_ofs
+c
->wbuf_len
);
676 /* adjust alignment offset */
677 if (c
->wbuf_len
!= PAGE_MOD(to
)) {
678 c
->wbuf_len
= PAGE_MOD(to
);
679 /* take care of alignment to next page */
681 c
->wbuf_len
= c
->wbuf_pagesize
;
682 ret
= __jffs2_flush_wbuf(c
, NOPAD
);
688 for (invec
= 0; invec
< count
; invec
++) {
689 int vlen
= invecs
[invec
].iov_len
;
690 uint8_t *v
= invecs
[invec
].iov_base
;
692 wbuf_retlen
= jffs2_fill_wbuf(c
, v
, vlen
);
694 if (c
->wbuf_len
== c
->wbuf_pagesize
) {
695 ret
= __jffs2_flush_wbuf(c
, NOPAD
);
700 outvec_to
+= wbuf_retlen
;
701 donelen
+= wbuf_retlen
;
704 if (vlen
>= c
->wbuf_pagesize
) {
705 ret
= c
->mtd
->write(c
->mtd
, outvec_to
, PAGE_DIV(vlen
),
707 if (ret
< 0 || wbuf_retlen
!= PAGE_DIV(vlen
))
711 outvec_to
+= wbuf_retlen
;
712 c
->wbuf_ofs
= outvec_to
;
713 donelen
+= wbuf_retlen
;
717 wbuf_retlen
= jffs2_fill_wbuf(c
, v
, vlen
);
718 if (c
->wbuf_len
== c
->wbuf_pagesize
) {
719 ret
= __jffs2_flush_wbuf(c
, NOPAD
);
724 outvec_to
+= wbuf_retlen
;
725 donelen
+= wbuf_retlen
;
729 * If there's a remainder in the wbuf and it's a non-GC write,
730 * remember that the wbuf affects this ino
734 if (jffs2_sum_active()) {
735 int res
= jffs2_sum_add_kvec(c
, invecs
, count
, (uint32_t) to
);
740 if (c
->wbuf_len
&& ino
)
741 jffs2_wbuf_dirties_inode(c
, ino
);
744 up_write(&c
->wbuf_sem
);
749 * At this point we have no problem, c->wbuf is empty. However
750 * refile nextblock to avoid writing again to same address.
753 spin_lock(&c
->erase_completion_lock
);
755 jeb
= &c
->blocks
[outvec_to
/ c
->sector_size
];
756 jffs2_block_refile(c
, jeb
, REFILE_ANYWAY
);
758 spin_unlock(&c
->erase_completion_lock
);
762 up_write(&c
->wbuf_sem
);
767 * This is the entry for flash write.
768 * Check, if we work on NAND FLASH, if so build an kvec and write it via vritev
770 int jffs2_flash_write(struct jffs2_sb_info
*c
, loff_t ofs
, size_t len
, size_t *retlen
, const u_char
*buf
)
774 if (!jffs2_is_writebuffered(c
))
775 return jffs2_flash_direct_write(c
, ofs
, len
, retlen
, buf
);
777 vecs
[0].iov_base
= (unsigned char *) buf
;
778 vecs
[0].iov_len
= len
;
779 return jffs2_flash_writev(c
, vecs
, 1, ofs
, retlen
, 0);
783 Handle readback from writebuffer and ECC failure return
785 int jffs2_flash_read(struct jffs2_sb_info
*c
, loff_t ofs
, size_t len
, size_t *retlen
, u_char
*buf
)
787 loff_t orbf
= 0, owbf
= 0, lwbf
= 0;
790 if (!jffs2_is_writebuffered(c
))
791 return c
->mtd
->read(c
->mtd
, ofs
, len
, retlen
, buf
);
794 down_read(&c
->wbuf_sem
);
795 if (jffs2_cleanmarker_oob(c
))
796 ret
= c
->mtd
->read_ecc(c
->mtd
, ofs
, len
, retlen
, buf
, NULL
, c
->oobinfo
);
798 ret
= c
->mtd
->read(c
->mtd
, ofs
, len
, retlen
, buf
);
800 if ( (ret
== -EBADMSG
) && (*retlen
== len
) ) {
801 printk(KERN_WARNING
"mtd->read(0x%zx bytes from 0x%llx) returned ECC error\n",
804 * We have the raw data without ECC correction in the buffer, maybe
805 * we are lucky and all data or parts are correct. We check the node.
806 * If data are corrupted node check will sort it out.
807 * We keep this block, it will fail on write or erase and the we
808 * mark it bad. Or should we do that now? But we should give him a chance.
809 * Maybe we had a system crash or power loss before the ecc write or
810 * a erase was completed.
811 * So we return success. :)
816 /* if no writebuffer available or write buffer empty, return */
817 if (!c
->wbuf_pagesize
|| !c
->wbuf_len
)
820 /* if we read in a different block, return */
821 if (SECTOR_ADDR(ofs
) != SECTOR_ADDR(c
->wbuf_ofs
))
824 if (ofs
>= c
->wbuf_ofs
) {
825 owbf
= (ofs
- c
->wbuf_ofs
); /* offset in write buffer */
826 if (owbf
> c
->wbuf_len
) /* is read beyond write buffer ? */
828 lwbf
= c
->wbuf_len
- owbf
; /* number of bytes to copy */
832 orbf
= (c
->wbuf_ofs
- ofs
); /* offset in read buffer */
833 if (orbf
> len
) /* is write beyond write buffer ? */
835 lwbf
= len
- orbf
; /* number of bytes to copy */
836 if (lwbf
> c
->wbuf_len
)
840 memcpy(buf
+orbf
,c
->wbuf
+owbf
,lwbf
);
843 up_read(&c
->wbuf_sem
);
848 * Check, if the out of band area is empty
850 int jffs2_check_oob_empty( struct jffs2_sb_info
*c
, struct jffs2_eraseblock
*jeb
, int mode
)
858 /* allocate a buffer for all oob data in this sector */
859 oob_size
= c
->mtd
->oobsize
;
861 buf
= kmalloc(len
, GFP_KERNEL
);
863 printk(KERN_NOTICE
"jffs2_check_oob_empty(): allocation of temporary data buffer for oob check failed\n");
867 * if mode = 0, we scan for a total empty oob area, else we have
868 * to take care of the cleanmarker in the first page of the block
870 ret
= jffs2_flash_read_oob(c
, jeb
->offset
, len
, &retlen
, buf
);
872 D1(printk(KERN_WARNING
"jffs2_check_oob_empty(): Read OOB failed %d for block at %08x\n", ret
, jeb
->offset
));
877 D1(printk(KERN_WARNING
"jffs2_check_oob_empty(): Read OOB return short read "
878 "(%zd bytes not %d) for block at %08x\n", retlen
, len
, jeb
->offset
));
883 /* Special check for first page */
884 for(i
= 0; i
< oob_size
; i
++) {
885 /* Yeah, we know about the cleanmarker. */
886 if (mode
&& i
>= c
->fsdata_pos
&&
887 i
< c
->fsdata_pos
+ c
->fsdata_len
)
890 if (buf
[i
] != 0xFF) {
891 D2(printk(KERN_DEBUG
"Found %02x at %x in OOB for %08x\n",
892 buf
[i
], i
, jeb
->offset
));
898 /* we know, we are aligned :) */
899 for (page
= oob_size
; page
< len
; page
+= sizeof(long)) {
900 unsigned long dat
= *(unsigned long *)(&buf
[page
]);
914 * Scan for a valid cleanmarker and for bad blocks
915 * For virtual blocks (concatenated physical blocks) check the cleanmarker
916 * only in the first page of the first physical block, but scan for bad blocks in all
919 int jffs2_check_nand_cleanmarker (struct jffs2_sb_info
*c
, struct jffs2_eraseblock
*jeb
)
921 struct jffs2_unknown_node n
;
922 unsigned char buf
[2 * NAND_MAX_OOBSIZE
];
924 int ret
, i
, cnt
, retval
= 0;
925 size_t retlen
, offset
;
928 offset
= jeb
->offset
;
929 oob_size
= c
->mtd
->oobsize
;
931 /* Loop through the physical blocks */
932 for (cnt
= 0; cnt
< (c
->sector_size
/ c
->mtd
->erasesize
); cnt
++) {
933 /* Check first if the block is bad. */
934 if (c
->mtd
->block_isbad (c
->mtd
, offset
)) {
935 D1 (printk (KERN_WARNING
"jffs2_check_nand_cleanmarker(): Bad block at %08x\n", jeb
->offset
));
939 * We read oob data from page 0 and 1 of the block.
940 * page 0 contains cleanmarker and badblock info
941 * page 1 contains failure count of this block
943 ret
= c
->mtd
->read_oob (c
->mtd
, offset
, oob_size
<< 1, &retlen
, buf
);
946 D1 (printk (KERN_WARNING
"jffs2_check_nand_cleanmarker(): Read OOB failed %d for block at %08x\n", ret
, jeb
->offset
));
949 if (retlen
< (oob_size
<< 1)) {
950 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
));
954 /* Check cleanmarker only on the first physical block */
956 n
.magic
= cpu_to_je16 (JFFS2_MAGIC_BITMASK
);
957 n
.nodetype
= cpu_to_je16 (JFFS2_NODETYPE_CLEANMARKER
);
958 n
.totlen
= cpu_to_je32 (8);
959 p
= (unsigned char *) &n
;
961 for (i
= 0; i
< c
->fsdata_len
; i
++) {
962 if (buf
[c
->fsdata_pos
+ i
] != p
[i
]) {
966 D1(if (retval
== 1) {
967 printk(KERN_WARNING
"jffs2_check_nand_cleanmarker(): Cleanmarker node not detected in block at %08x\n", jeb
->offset
);
968 printk(KERN_WARNING
"OOB at %08x was ", offset
);
969 for (i
=0; i
< oob_size
; i
++) {
970 printk("%02x ", buf
[i
]);
975 offset
+= c
->mtd
->erasesize
;
980 int jffs2_write_nand_cleanmarker(struct jffs2_sb_info
*c
, struct jffs2_eraseblock
*jeb
)
982 struct jffs2_unknown_node n
;
986 n
.magic
= cpu_to_je16(JFFS2_MAGIC_BITMASK
);
987 n
.nodetype
= cpu_to_je16(JFFS2_NODETYPE_CLEANMARKER
);
988 n
.totlen
= cpu_to_je32(8);
990 ret
= jffs2_flash_write_oob(c
, jeb
->offset
+ c
->fsdata_pos
, c
->fsdata_len
, &retlen
, (unsigned char *)&n
);
993 D1(printk(KERN_WARNING
"jffs2_write_nand_cleanmarker(): Write failed for block at %08x: error %d\n", jeb
->offset
, ret
));
996 if (retlen
!= c
->fsdata_len
) {
997 D1(printk(KERN_WARNING
"jffs2_write_nand_cleanmarker(): Short write for block at %08x: %zd not %d\n", jeb
->offset
, retlen
, c
->fsdata_len
));
1004 * On NAND we try to mark this block bad. If the block was erased more
1005 * than MAX_ERASE_FAILURES we mark it finaly bad.
1006 * Don't care about failures. This block remains on the erase-pending
1007 * or badblock list as long as nobody manipulates the flash with
1008 * a bootloader or something like that.
1011 int jffs2_write_nand_badblock(struct jffs2_sb_info
*c
, struct jffs2_eraseblock
*jeb
, uint32_t bad_offset
)
1015 /* if the count is < max, we try to write the counter to the 2nd page oob area */
1016 if( ++jeb
->bad_count
< MAX_ERASE_FAILURES
)
1019 if (!c
->mtd
->block_markbad
)
1020 return 1; // What else can we do?
1022 D1(printk(KERN_WARNING
"jffs2_write_nand_badblock(): Marking bad block at %08x\n", bad_offset
));
1023 ret
= c
->mtd
->block_markbad(c
->mtd
, bad_offset
);
1026 D1(printk(KERN_WARNING
"jffs2_write_nand_badblock(): Write failed for block at %08x: error %d\n", jeb
->offset
, ret
));
1032 #define NAND_JFFS2_OOB16_FSDALEN 8
1034 static struct nand_oobinfo jffs2_oobinfo_docecc
= {
1035 .useecc
= MTD_NANDECC_PLACE
,
1037 .eccpos
= {0,1,2,3,4,5}
1041 static int jffs2_nand_set_oobinfo(struct jffs2_sb_info
*c
)
1043 struct nand_oobinfo
*oinfo
= &c
->mtd
->oobinfo
;
1045 /* Do this only, if we have an oob buffer */
1046 if (!c
->mtd
->oobsize
)
1049 /* Cleanmarker is out-of-band, so inline size zero */
1050 c
->cleanmarker_size
= 0;
1052 /* Should we use autoplacement ? */
1053 if (oinfo
&& oinfo
->useecc
== MTD_NANDECC_AUTOPLACE
) {
1054 D1(printk(KERN_DEBUG
"JFFS2 using autoplace on NAND\n"));
1055 /* Get the position of the free bytes */
1056 if (!oinfo
->oobfree
[0][1]) {
1057 printk (KERN_WARNING
"jffs2_nand_set_oobinfo(): Eeep. Autoplacement selected and no empty space in oob\n");
1060 c
->fsdata_pos
= oinfo
->oobfree
[0][0];
1061 c
->fsdata_len
= oinfo
->oobfree
[0][1];
1062 if (c
->fsdata_len
> 8)
1065 /* This is just a legacy fallback and should go away soon */
1066 switch(c
->mtd
->ecctype
) {
1067 case MTD_ECC_RS_DiskOnChip
:
1068 printk(KERN_WARNING
"JFFS2 using DiskOnChip hardware ECC without autoplacement. Fix it!\n");
1069 c
->oobinfo
= &jffs2_oobinfo_docecc
;
1071 c
->fsdata_len
= NAND_JFFS2_OOB16_FSDALEN
;
1072 c
->badblock_pos
= 15;
1076 D1(printk(KERN_DEBUG
"JFFS2 on NAND. No autoplacment info found\n"));
1083 int jffs2_nand_flash_setup(struct jffs2_sb_info
*c
)
1087 /* Initialise write buffer */
1088 init_rwsem(&c
->wbuf_sem
);
1089 c
->wbuf_pagesize
= c
->mtd
->writesize
;
1090 c
->wbuf_ofs
= 0xFFFFFFFF;
1092 c
->wbuf
= kmalloc(c
->wbuf_pagesize
, GFP_KERNEL
);
1096 res
= jffs2_nand_set_oobinfo(c
);
1100 brokenbuf
= kmalloc(c
->wbuf_pagesize
, GFP_KERNEL
);
1105 memset(brokenbuf
, 0xdb, c
->wbuf_pagesize
);
1110 void jffs2_nand_flash_cleanup(struct jffs2_sb_info
*c
)
1115 int jffs2_dataflash_setup(struct jffs2_sb_info
*c
) {
1116 c
->cleanmarker_size
= 0; /* No cleanmarkers needed */
1118 /* Initialize write buffer */
1119 init_rwsem(&c
->wbuf_sem
);
1122 c
->wbuf_pagesize
= c
->mtd
->erasesize
;
1124 /* Find a suitable c->sector_size
1125 * - Not too much sectors
1126 * - Sectors have to be at least 4 K + some bytes
1127 * - All known dataflashes have erase sizes of 528 or 1056
1128 * - we take at least 8 eraseblocks and want to have at least 8K size
1129 * - The concatenation should be a power of 2
1132 c
->sector_size
= 8 * c
->mtd
->erasesize
;
1134 while (c
->sector_size
< 8192) {
1135 c
->sector_size
*= 2;
1138 /* It may be necessary to adjust the flash size */
1139 c
->flash_size
= c
->mtd
->size
;
1141 if ((c
->flash_size
% c
->sector_size
) != 0) {
1142 c
->flash_size
= (c
->flash_size
/ c
->sector_size
) * c
->sector_size
;
1143 printk(KERN_WARNING
"JFFS2 flash size adjusted to %dKiB\n", c
->flash_size
);
1146 c
->wbuf_ofs
= 0xFFFFFFFF;
1147 c
->wbuf
= kmalloc(c
->wbuf_pagesize
, GFP_KERNEL
);
1151 printk(KERN_INFO
"JFFS2 write-buffering enabled buffer (%d) erasesize (%d)\n", c
->wbuf_pagesize
, c
->sector_size
);
1156 void jffs2_dataflash_cleanup(struct jffs2_sb_info
*c
) {
1160 int jffs2_nor_wbuf_flash_setup(struct jffs2_sb_info
*c
) {
1161 /* Cleanmarker currently occupies whole programming regions,
1162 * either one or 2 for 8Byte STMicro flashes. */
1163 c
->cleanmarker_size
= max(16u, c
->mtd
->writesize
);
1165 /* Initialize write buffer */
1166 init_rwsem(&c
->wbuf_sem
);
1167 c
->wbuf_pagesize
= c
->mtd
->writesize
;
1168 c
->wbuf_ofs
= 0xFFFFFFFF;
1170 c
->wbuf
= kmalloc(c
->wbuf_pagesize
, GFP_KERNEL
);
1177 void jffs2_nor_wbuf_flash_cleanup(struct jffs2_sb_info
*c
) {