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.88 2005/02/09 09:17:41 pavlov 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 BUG_ON(allow_empty
== REFILE_NOTEMPTY
);
151 /* It has to have had some nodes or we couldn't be here */
152 D1(printk("Refiling block at %08x to erase_pending_list\n", jeb
->offset
));
153 list_add(&jeb
->list
, &c
->erase_pending_list
);
154 c
->nr_erasing_blocks
++;
155 jffs2_erase_pending_trigger(c
);
157 D2(jffs2_dump_block_lists(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 ACCT_SANITY_CHECK(c
,jeb
);
166 D1(ACCT_PARANOIA_CHECK(jeb
));
169 /* Recover from failure to write wbuf. Recover the nodes up to the
170 * wbuf, not the one which we were starting to try to write. */
172 static void jffs2_wbuf_recover(struct jffs2_sb_info
*c
)
174 struct jffs2_eraseblock
*jeb
, *new_jeb
;
175 struct jffs2_raw_node_ref
**first_raw
, **raw
;
179 uint32_t start
, end
, ofs
, len
;
181 spin_lock(&c
->erase_completion_lock
);
183 jeb
= &c
->blocks
[c
->wbuf_ofs
/ c
->sector_size
];
185 jffs2_block_refile(c
, jeb
, REFILE_NOTEMPTY
);
187 /* Find the first node to be recovered, by skipping over every
188 node which ends before the wbuf starts, or which is obsolete. */
189 first_raw
= &jeb
->first_node
;
191 (ref_obsolete(*first_raw
) ||
192 (ref_offset(*first_raw
)+ref_totlen(c
, jeb
, *first_raw
)) < c
->wbuf_ofs
)) {
193 D1(printk(KERN_DEBUG
"Skipping node at 0x%08x(%d)-0x%08x which is either before 0x%08x or obsolete\n",
194 ref_offset(*first_raw
), ref_flags(*first_raw
),
195 (ref_offset(*first_raw
) + ref_totlen(c
, jeb
, *first_raw
)),
197 first_raw
= &(*first_raw
)->next_phys
;
201 /* All nodes were obsolete. Nothing to recover. */
202 D1(printk(KERN_DEBUG
"No non-obsolete nodes to be recovered. Just filing block bad\n"));
203 spin_unlock(&c
->erase_completion_lock
);
207 start
= ref_offset(*first_raw
);
208 end
= ref_offset(*first_raw
) + ref_totlen(c
, jeb
, *first_raw
);
210 /* Find the last node to be recovered */
213 if (!ref_obsolete(*raw
))
214 end
= ref_offset(*raw
) + ref_totlen(c
, jeb
, *raw
);
216 raw
= &(*raw
)->next_phys
;
218 spin_unlock(&c
->erase_completion_lock
);
220 D1(printk(KERN_DEBUG
"wbuf recover %08x-%08x\n", start
, end
));
223 if (start
< c
->wbuf_ofs
) {
224 /* First affected node was already partially written.
225 * Attempt to reread the old data into our buffer. */
227 buf
= kmalloc(end
- start
, GFP_KERNEL
);
229 printk(KERN_CRIT
"Malloc failure in wbuf recovery. Data loss ensues.\n");
235 if (jffs2_cleanmarker_oob(c
))
236 ret
= c
->mtd
->read_ecc(c
->mtd
, start
, c
->wbuf_ofs
- start
, &retlen
, buf
, NULL
, c
->oobinfo
);
238 ret
= c
->mtd
->read(c
->mtd
, start
, c
->wbuf_ofs
- start
, &retlen
, buf
);
240 if (ret
== -EBADMSG
&& retlen
== c
->wbuf_ofs
- start
) {
244 if (ret
|| retlen
!= c
->wbuf_ofs
- start
) {
245 printk(KERN_CRIT
"Old data are already lost in wbuf recovery. Data loss ensues.\n");
250 first_raw
= &(*first_raw
)->next_phys
;
251 /* If this was the only node to be recovered, give up */
255 /* It wasn't. Go on and try to recover nodes complete in the wbuf */
256 start
= ref_offset(*first_raw
);
258 /* Read succeeded. Copy the remaining data from the wbuf */
259 memcpy(buf
+ (c
->wbuf_ofs
- start
), c
->wbuf
, end
- c
->wbuf_ofs
);
262 /* OK... we're to rewrite (end-start) bytes of data from first_raw onwards.
263 Either 'buf' contains the data, or we find it in the wbuf */
266 /* ... and get an allocation of space from a shiny new block instead */
267 ret
= jffs2_reserve_space_gc(c
, end
-start
, &ofs
, &len
);
269 printk(KERN_WARNING
"Failed to allocate space for wbuf recovery. Data loss ensues.\n");
273 if (end
-start
>= c
->wbuf_pagesize
) {
274 /* Need to do another write immediately, but it's possible
275 that this is just because the wbuf itself is completely
276 full, and there's nothing earlier read back from the
277 flash. Hence 'buf' isn't necessarily what we're writing
279 unsigned char *rewrite_buf
= buf
?:c
->wbuf
;
280 uint32_t towrite
= (end
-start
) - ((end
-start
)%c
->wbuf_pagesize
);
282 D1(printk(KERN_DEBUG
"Write 0x%x bytes at 0x%08x in wbuf recover\n",
287 if (breakme
++ == 20) {
288 printk(KERN_NOTICE
"Faking write error at 0x%08x\n", ofs
);
290 c
->mtd
->write_ecc(c
->mtd
, ofs
, towrite
, &retlen
,
291 brokenbuf
, NULL
, c
->oobinfo
);
295 if (jffs2_cleanmarker_oob(c
))
296 ret
= c
->mtd
->write_ecc(c
->mtd
, ofs
, towrite
, &retlen
,
297 rewrite_buf
, NULL
, c
->oobinfo
);
299 ret
= c
->mtd
->write(c
->mtd
, ofs
, towrite
, &retlen
, rewrite_buf
);
301 if (ret
|| retlen
!= towrite
) {
302 /* Argh. We tried. Really we did. */
303 printk(KERN_CRIT
"Recovery of wbuf failed due to a second write error\n");
307 struct jffs2_raw_node_ref
*raw2
;
309 raw2
= jffs2_alloc_raw_node_ref();
313 raw2
->flash_offset
= ofs
| REF_OBSOLETE
;
314 raw2
->__totlen
= ref_totlen(c
, jeb
, *first_raw
);
315 raw2
->next_phys
= NULL
;
316 raw2
->next_in_ino
= NULL
;
318 jffs2_add_physical_node_ref(c
, raw2
);
322 printk(KERN_NOTICE
"Recovery of wbuf succeeded to %08x\n", ofs
);
324 c
->wbuf_len
= (end
- start
) - towrite
;
325 c
->wbuf_ofs
= ofs
+ towrite
;
326 memmove(c
->wbuf
, rewrite_buf
+ towrite
, c
->wbuf_len
);
327 /* Don't muck about with c->wbuf_inodes. False positives are harmless. */
331 /* OK, now we're left with the dregs in whichever buffer we're using */
333 memcpy(c
->wbuf
, buf
, end
-start
);
336 memmove(c
->wbuf
, c
->wbuf
+ (start
- c
->wbuf_ofs
), end
- start
);
339 c
->wbuf_len
= end
- start
;
342 /* Now sort out the jffs2_raw_node_refs, moving them from the old to the next block */
343 new_jeb
= &c
->blocks
[ofs
/ c
->sector_size
];
345 spin_lock(&c
->erase_completion_lock
);
346 if (new_jeb
->first_node
) {
347 /* Odd, but possible with ST flash later maybe */
348 new_jeb
->last_node
->next_phys
= *first_raw
;
350 new_jeb
->first_node
= *first_raw
;
355 uint32_t rawlen
= ref_totlen(c
, jeb
, *raw
);
357 D1(printk(KERN_DEBUG
"Refiling block of %08x at %08x(%d) to %08x\n",
358 rawlen
, ref_offset(*raw
), ref_flags(*raw
), ofs
));
360 if (ref_obsolete(*raw
)) {
361 /* Shouldn't really happen much */
362 new_jeb
->dirty_size
+= rawlen
;
363 new_jeb
->free_size
-= rawlen
;
364 c
->dirty_size
+= rawlen
;
366 new_jeb
->used_size
+= rawlen
;
367 new_jeb
->free_size
-= rawlen
;
368 jeb
->dirty_size
+= rawlen
;
369 jeb
->used_size
-= rawlen
;
370 c
->dirty_size
+= rawlen
;
372 c
->free_size
-= rawlen
;
373 (*raw
)->flash_offset
= ofs
| ref_flags(*raw
);
375 new_jeb
->last_node
= *raw
;
377 raw
= &(*raw
)->next_phys
;
380 /* Fix up the original jeb now it's on the bad_list */
382 if (first_raw
== &jeb
->first_node
) {
383 jeb
->last_node
= NULL
;
384 D1(printk(KERN_DEBUG
"Failing block at %08x is now empty. Moving to erase_pending_list\n", jeb
->offset
));
385 list_del(&jeb
->list
);
386 list_add(&jeb
->list
, &c
->erase_pending_list
);
387 c
->nr_erasing_blocks
++;
388 jffs2_erase_pending_trigger(c
);
391 jeb
->last_node
= container_of(first_raw
, struct jffs2_raw_node_ref
, next_phys
);
393 ACCT_SANITY_CHECK(c
,jeb
);
394 D1(ACCT_PARANOIA_CHECK(jeb
));
396 ACCT_SANITY_CHECK(c
,new_jeb
);
397 D1(ACCT_PARANOIA_CHECK(new_jeb
));
399 spin_unlock(&c
->erase_completion_lock
);
401 D1(printk(KERN_DEBUG
"wbuf recovery completed OK\n"));
404 /* Meaning of pad argument:
405 0: Do not pad. Probably pointless - we only ever use this when we can't pad anyway.
406 1: Pad, do not adjust nextblock free_size
407 2: Pad, adjust nextblock free_size
410 #define PAD_NOACCOUNT 1
411 #define PAD_ACCOUNTING 2
413 static int __jffs2_flush_wbuf(struct jffs2_sb_info
*c
, int pad
)
418 /* Nothing to do if not write-buffering the flash. In particular, we shouldn't
419 del_timer() the timer we never initialised. */
420 if (!jffs2_is_writebuffered(c
))
423 if (!down_trylock(&c
->alloc_sem
)) {
425 printk(KERN_CRIT
"jffs2_flush_wbuf() called with alloc_sem not locked!\n");
429 if (!c
->wbuf_len
) /* already checked c->wbuf above */
432 /* claim remaining space on the page
433 this happens, if we have a change to a new block,
434 or if fsync forces us to flush the writebuffer.
435 if we have a switch to next page, we will not have
436 enough remaining space for this.
438 if (pad
&& !jffs2_dataflash(c
)) {
439 c
->wbuf_len
= PAD(c
->wbuf_len
);
441 /* Pad with JFFS2_DIRTY_BITMASK initially. this helps out ECC'd NOR
442 with 8 byte page size */
443 memset(c
->wbuf
+ c
->wbuf_len
, 0, c
->wbuf_pagesize
- c
->wbuf_len
);
445 if ( c
->wbuf_len
+ sizeof(struct jffs2_unknown_node
) < c
->wbuf_pagesize
) {
446 struct jffs2_unknown_node
*padnode
= (void *)(c
->wbuf
+ c
->wbuf_len
);
447 padnode
->magic
= cpu_to_je16(JFFS2_MAGIC_BITMASK
);
448 padnode
->nodetype
= cpu_to_je16(JFFS2_NODETYPE_PADDING
);
449 padnode
->totlen
= cpu_to_je32(c
->wbuf_pagesize
- c
->wbuf_len
);
450 padnode
->hdr_crc
= cpu_to_je32(crc32(0, padnode
, sizeof(*padnode
)-4));
453 /* else jffs2_flash_writev has actually filled in the rest of the
454 buffer for us, and will deal with the node refs etc. later. */
458 if (breakme
++ == 20) {
459 printk(KERN_NOTICE
"Faking write error at 0x%08x\n", c
->wbuf_ofs
);
461 c
->mtd
->write_ecc(c
->mtd
, c
->wbuf_ofs
, c
->wbuf_pagesize
,
462 &retlen
, brokenbuf
, NULL
, c
->oobinfo
);
467 if (jffs2_cleanmarker_oob(c
))
468 ret
= c
->mtd
->write_ecc(c
->mtd
, c
->wbuf_ofs
, c
->wbuf_pagesize
, &retlen
, c
->wbuf
, NULL
, c
->oobinfo
);
470 ret
= c
->mtd
->write(c
->mtd
, c
->wbuf_ofs
, c
->wbuf_pagesize
, &retlen
, c
->wbuf
);
472 if (ret
|| retlen
!= c
->wbuf_pagesize
) {
474 printk(KERN_WARNING
"jffs2_flush_wbuf(): Write failed with %d\n",ret
);
476 printk(KERN_WARNING
"jffs2_flush_wbuf(): Write was short: %zd instead of %d\n",
477 retlen
, c
->wbuf_pagesize
);
481 jffs2_wbuf_recover(c
);
486 spin_lock(&c
->erase_completion_lock
);
488 /* Adjust free size of the block if we padded. */
489 if (pad
&& !jffs2_dataflash(c
)) {
490 struct jffs2_eraseblock
*jeb
;
492 jeb
= &c
->blocks
[c
->wbuf_ofs
/ c
->sector_size
];
494 D1(printk(KERN_DEBUG
"jffs2_flush_wbuf() adjusting free_size of %sblock at %08x\n",
495 (jeb
==c
->nextblock
)?"next":"", jeb
->offset
));
497 /* wbuf_pagesize - wbuf_len is the amount of space that's to be
498 padded. If there is less free space in the block than that,
499 something screwed up */
500 if (jeb
->free_size
< (c
->wbuf_pagesize
- c
->wbuf_len
)) {
501 printk(KERN_CRIT
"jffs2_flush_wbuf(): Accounting error. wbuf at 0x%08x has 0x%03x bytes, 0x%03x left.\n",
502 c
->wbuf_ofs
, c
->wbuf_len
, c
->wbuf_pagesize
-c
->wbuf_len
);
503 printk(KERN_CRIT
"jffs2_flush_wbuf(): But free_size for block at 0x%08x is only 0x%08x\n",
504 jeb
->offset
, jeb
->free_size
);
507 jeb
->free_size
-= (c
->wbuf_pagesize
- c
->wbuf_len
);
508 c
->free_size
-= (c
->wbuf_pagesize
- c
->wbuf_len
);
509 jeb
->wasted_size
+= (c
->wbuf_pagesize
- c
->wbuf_len
);
510 c
->wasted_size
+= (c
->wbuf_pagesize
- c
->wbuf_len
);
513 /* Stick any now-obsoleted blocks on the erase_pending_list */
514 jffs2_refile_wbuf_blocks(c
);
515 jffs2_clear_wbuf_ino_list(c
);
516 spin_unlock(&c
->erase_completion_lock
);
518 memset(c
->wbuf
,0xff,c
->wbuf_pagesize
);
519 /* adjust write buffer offset, else we get a non contiguous write bug */
520 c
->wbuf_ofs
+= c
->wbuf_pagesize
;
525 /* Trigger garbage collection to flush the write-buffer.
526 If ino arg is zero, do it if _any_ real (i.e. not GC) writes are
527 outstanding. If ino arg non-zero, do it only if a write for the
528 given inode is outstanding. */
529 int jffs2_flush_wbuf_gc(struct jffs2_sb_info
*c
, uint32_t ino
)
531 uint32_t old_wbuf_ofs
;
532 uint32_t old_wbuf_len
;
535 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 */
558 ret
= __jffs2_flush_wbuf(c
, PAD_ACCOUNTING
);
559 up_write(&c
->wbuf_sem
);
560 } else while (old_wbuf_len
&&
561 old_wbuf_ofs
== c
->wbuf_ofs
) {
565 D1(printk(KERN_DEBUG
"jffs2_flush_wbuf_gc() calls gc pass\n"));
567 ret
= jffs2_garbage_collect_pass(c
);
569 /* GC failed. Flush it with padding instead */
571 down_write(&c
->wbuf_sem
);
572 ret
= __jffs2_flush_wbuf(c
, PAD_ACCOUNTING
);
573 /* retry flushing wbuf in case jffs2_wbuf_recover
574 left some data in the wbuf */
576 ret
= __jffs2_flush_wbuf(c
, PAD_ACCOUNTING
);
577 up_write(&c
->wbuf_sem
);
583 D1(printk(KERN_DEBUG
"jffs2_flush_wbuf_gc() ends...\n"));
589 /* Pad write-buffer to end and write it, wasting space. */
590 int jffs2_flush_wbuf_pad(struct jffs2_sb_info
*c
)
597 down_write(&c
->wbuf_sem
);
598 ret
= __jffs2_flush_wbuf(c
, PAD_NOACCOUNT
);
599 /* retry - maybe wbuf recover left some data in wbuf. */
601 ret
= __jffs2_flush_wbuf(c
, PAD_NOACCOUNT
);
602 up_write(&c
->wbuf_sem
);
607 #ifdef CONFIG_JFFS2_FS_DATAFLASH
608 #define PAGE_DIV(x) ( ((unsigned long)(x) / (unsigned long)(c->wbuf_pagesize)) * (unsigned long)(c->wbuf_pagesize) )
609 #define PAGE_MOD(x) ( (unsigned long)(x) % (unsigned long)(c->wbuf_pagesize) )
611 #define PAGE_DIV(x) ( (x) & (~(c->wbuf_pagesize - 1)) )
612 #define PAGE_MOD(x) ( (x) & (c->wbuf_pagesize - 1) )
615 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
)
617 struct kvec outvecs
[3];
619 uint32_t split_ofs
= 0;
621 int ret
, splitvec
= -1;
624 unsigned char *wbuf_ptr
;
626 uint32_t outvec_to
= to
;
628 /* If not NAND flash, don't bother */
629 if (!jffs2_is_writebuffered(c
))
630 return jffs2_flash_direct_writev(c
, invecs
, count
, to
, retlen
);
632 down_write(&c
->wbuf_sem
);
634 /* If wbuf_ofs is not initialized, set it to target address */
635 if (c
->wbuf_ofs
== 0xFFFFFFFF) {
636 c
->wbuf_ofs
= PAGE_DIV(to
);
637 c
->wbuf_len
= PAGE_MOD(to
);
638 memset(c
->wbuf
,0xff,c
->wbuf_pagesize
);
641 /* Fixup the wbuf if we are moving to a new eraseblock. The checks below
642 fail for ECC'd NOR because cleanmarker == 16, so a block starts at
644 if (jffs2_nor_ecc(c
)) {
645 if (((c
->wbuf_ofs
% c
->sector_size
) == 0) && !c
->wbuf_len
) {
646 c
->wbuf_ofs
= PAGE_DIV(to
);
647 c
->wbuf_len
= PAGE_MOD(to
);
648 memset(c
->wbuf
,0xff,c
->wbuf_pagesize
);
652 /* Sanity checks on target address.
653 It's permitted to write at PAD(c->wbuf_len+c->wbuf_ofs),
654 and it's permitted to write at the beginning of a new
655 erase block. Anything else, and you die.
656 New block starts at xxx000c (0-b = block header)
658 if (SECTOR_ADDR(to
) != SECTOR_ADDR(c
->wbuf_ofs
)) {
659 /* It's a write to a new block */
661 D1(printk(KERN_DEBUG
"jffs2_flash_writev() to 0x%lx causes flush of wbuf at 0x%08x\n", (unsigned long)to
, c
->wbuf_ofs
));
662 ret
= __jffs2_flush_wbuf(c
, PAD_NOACCOUNT
);
664 /* the underlying layer has to check wbuf_len to do the cleanup */
665 D1(printk(KERN_WARNING
"jffs2_flush_wbuf() called from jffs2_flash_writev() failed %d\n", ret
));
670 /* set pointer to new block */
671 c
->wbuf_ofs
= PAGE_DIV(to
);
672 c
->wbuf_len
= PAGE_MOD(to
);
675 if (to
!= PAD(c
->wbuf_ofs
+ c
->wbuf_len
)) {
676 /* We're not writing immediately after the writebuffer. Bad. */
677 printk(KERN_CRIT
"jffs2_flash_writev(): Non-contiguous write to %08lx\n", (unsigned long)to
);
679 printk(KERN_CRIT
"wbuf was previously %08x-%08x\n",
680 c
->wbuf_ofs
, c
->wbuf_ofs
+c
->wbuf_len
);
684 /* Note outvecs[3] above. We know count is never greater than 2 */
686 printk(KERN_CRIT
"jffs2_flash_writev(): count is %ld\n", count
);
693 /* Fill writebuffer first, if already in use */
695 uint32_t invec_ofs
= 0;
697 /* adjust alignment offset */
698 if (c
->wbuf_len
!= PAGE_MOD(to
)) {
699 c
->wbuf_len
= PAGE_MOD(to
);
700 /* take care of alignment to next page */
702 c
->wbuf_len
= c
->wbuf_pagesize
;
705 while(c
->wbuf_len
< c
->wbuf_pagesize
) {
711 thislen
= c
->wbuf_pagesize
- c
->wbuf_len
;
713 if (thislen
>= invecs
[invec
].iov_len
)
714 thislen
= invecs
[invec
].iov_len
;
718 memcpy(c
->wbuf
+ c
->wbuf_len
, invecs
[invec
].iov_base
, thislen
);
719 c
->wbuf_len
+= thislen
;
721 /* Get next invec, if actual did not fill the buffer */
722 if (c
->wbuf_len
< c
->wbuf_pagesize
)
726 /* write buffer is full, flush buffer */
727 ret
= __jffs2_flush_wbuf(c
, NOPAD
);
729 /* the underlying layer has to check wbuf_len to do the cleanup */
730 D1(printk(KERN_WARNING
"jffs2_flush_wbuf() called from jffs2_flash_writev() failed %d\n", ret
));
731 /* Retlen zero to make sure our caller doesn't mark the space dirty.
732 We've already done everything that's necessary */
736 outvec_to
+= donelen
;
737 c
->wbuf_ofs
= outvec_to
;
739 /* All invecs done ? */
743 /* Set up the first outvec, containing the remainder of the
744 invec we partially used */
745 if (invecs
[invec
].iov_len
> invec_ofs
) {
746 outvecs
[0].iov_base
= invecs
[invec
].iov_base
+invec_ofs
;
747 totlen
= outvecs
[0].iov_len
= invecs
[invec
].iov_len
-invec_ofs
;
748 if (totlen
> c
->wbuf_pagesize
) {
750 split_ofs
= outvecs
[0].iov_len
- PAGE_MOD(totlen
);
757 /* OK, now we've flushed the wbuf and the start of the bits
758 we have been asked to write, now to write the rest.... */
760 /* totlen holds the amount of data still to be written */
762 for ( ; invec
< count
; invec
++,outvec
++ ) {
763 outvecs
[outvec
].iov_base
= invecs
[invec
].iov_base
;
764 totlen
+= outvecs
[outvec
].iov_len
= invecs
[invec
].iov_len
;
765 if (PAGE_DIV(totlen
) != PAGE_DIV(old_totlen
)) {
767 split_ofs
= outvecs
[outvec
].iov_len
- PAGE_MOD(totlen
);
772 /* Now the outvecs array holds all the remaining data to write */
773 /* Up to splitvec,split_ofs is to be written immediately. The rest
774 goes into the (now-empty) wbuf */
776 if (splitvec
!= -1) {
779 remainder
= outvecs
[splitvec
].iov_len
- split_ofs
;
780 outvecs
[splitvec
].iov_len
= split_ofs
;
782 /* We did cross a page boundary, so we write some now */
783 if (jffs2_cleanmarker_oob(c
))
784 ret
= c
->mtd
->writev_ecc(c
->mtd
, outvecs
, splitvec
+1, outvec_to
, &wbuf_retlen
, NULL
, c
->oobinfo
);
786 ret
= jffs2_flash_direct_writev(c
, outvecs
, splitvec
+1, outvec_to
, &wbuf_retlen
);
788 if (ret
< 0 || wbuf_retlen
!= PAGE_DIV(totlen
)) {
789 /* At this point we have no problem,
790 c->wbuf is empty. However refile nextblock to avoid
791 writing again to same address.
793 struct jffs2_eraseblock
*jeb
;
795 spin_lock(&c
->erase_completion_lock
);
797 jeb
= &c
->blocks
[outvec_to
/ c
->sector_size
];
798 jffs2_block_refile(c
, jeb
, REFILE_ANYWAY
);
801 spin_unlock(&c
->erase_completion_lock
);
805 donelen
+= wbuf_retlen
;
806 c
->wbuf_ofs
= PAGE_DIV(outvec_to
) + PAGE_DIV(totlen
);
809 outvecs
[splitvec
].iov_base
+= split_ofs
;
810 outvecs
[splitvec
].iov_len
= remainder
;
819 /* Now splitvec points to the start of the bits we have to copy
823 for ( ; splitvec
< outvec
; splitvec
++) {
824 /* Don't copy the wbuf into itself */
825 if (outvecs
[splitvec
].iov_base
== c
->wbuf
)
827 memcpy(wbuf_ptr
, outvecs
[splitvec
].iov_base
, outvecs
[splitvec
].iov_len
);
828 wbuf_ptr
+= outvecs
[splitvec
].iov_len
;
829 donelen
+= outvecs
[splitvec
].iov_len
;
831 c
->wbuf_len
= wbuf_ptr
- c
->wbuf
;
833 /* If there's a remainder in the wbuf and it's a non-GC write,
834 remember that the wbuf affects this ino */
838 if (c
->wbuf_len
&& ino
)
839 jffs2_wbuf_dirties_inode(c
, ino
);
844 up_write(&c
->wbuf_sem
);
849 * This is the entry for flash write.
850 * Check, if we work on NAND FLASH, if so build an kvec and write it via vritev
852 int jffs2_flash_write(struct jffs2_sb_info
*c
, loff_t ofs
, size_t len
, size_t *retlen
, const u_char
*buf
)
856 if (!jffs2_is_writebuffered(c
))
857 return c
->mtd
->write(c
->mtd
, ofs
, len
, retlen
, buf
);
859 vecs
[0].iov_base
= (unsigned char *) buf
;
860 vecs
[0].iov_len
= len
;
861 return jffs2_flash_writev(c
, vecs
, 1, ofs
, retlen
, 0);
865 Handle readback from writebuffer and ECC failure return
867 int jffs2_flash_read(struct jffs2_sb_info
*c
, loff_t ofs
, size_t len
, size_t *retlen
, u_char
*buf
)
869 loff_t orbf
= 0, owbf
= 0, lwbf
= 0;
872 if (!jffs2_is_writebuffered(c
))
873 return c
->mtd
->read(c
->mtd
, ofs
, len
, retlen
, buf
);
876 if (jffs2_cleanmarker_oob(c
))
877 ret
= c
->mtd
->read_ecc(c
->mtd
, ofs
, len
, retlen
, buf
, NULL
, c
->oobinfo
);
879 ret
= c
->mtd
->read(c
->mtd
, ofs
, len
, retlen
, buf
);
881 if ( (ret
== -EBADMSG
) && (*retlen
== len
) ) {
882 printk(KERN_WARNING
"mtd->read(0x%zx bytes from 0x%llx) returned ECC error\n",
885 * We have the raw data without ECC correction in the buffer, maybe
886 * we are lucky and all data or parts are correct. We check the node.
887 * If data are corrupted node check will sort it out.
888 * We keep this block, it will fail on write or erase and the we
889 * mark it bad. Or should we do that now? But we should give him a chance.
890 * Maybe we had a system crash or power loss before the ecc write or
891 * a erase was completed.
892 * So we return success. :)
897 /* if no writebuffer available or write buffer empty, return */
898 if (!c
->wbuf_pagesize
|| !c
->wbuf_len
)
901 /* if we read in a different block, return */
902 if (SECTOR_ADDR(ofs
) != SECTOR_ADDR(c
->wbuf_ofs
))
905 /* Lock only if we have reason to believe wbuf contains relevant data,
906 so that checking an erased block during wbuf recovery space allocation
907 does not deadlock. */
908 down_read(&c
->wbuf_sem
);
910 if (ofs
>= c
->wbuf_ofs
) {
911 owbf
= (ofs
- c
->wbuf_ofs
); /* offset in write buffer */
912 if (owbf
> c
->wbuf_len
) /* is read beyond write buffer ? */
914 lwbf
= c
->wbuf_len
- owbf
; /* number of bytes to copy */
918 orbf
= (c
->wbuf_ofs
- ofs
); /* offset in read buffer */
919 if (orbf
> len
) /* is write beyond write buffer ? */
921 lwbf
= len
- orbf
; /* number of bytes to copy */
922 if (lwbf
> c
->wbuf_len
)
926 memcpy(buf
+orbf
,c
->wbuf
+owbf
,lwbf
);
929 up_read(&c
->wbuf_sem
);
934 * Check, if the out of band area is empty
936 int jffs2_check_oob_empty( struct jffs2_sb_info
*c
, struct jffs2_eraseblock
*jeb
, int mode
)
944 /* allocate a buffer for all oob data in this sector */
945 oob_size
= c
->mtd
->oobsize
;
947 buf
= kmalloc(len
, GFP_KERNEL
);
949 printk(KERN_NOTICE
"jffs2_check_oob_empty(): allocation of temporary data buffer for oob check failed\n");
953 * if mode = 0, we scan for a total empty oob area, else we have
954 * to take care of the cleanmarker in the first page of the block
956 ret
= jffs2_flash_read_oob(c
, jeb
->offset
, len
, &retlen
, buf
);
958 D1(printk(KERN_WARNING
"jffs2_check_oob_empty(): Read OOB failed %d for block at %08x\n", ret
, jeb
->offset
));
963 D1(printk(KERN_WARNING
"jffs2_check_oob_empty(): Read OOB return short read "
964 "(%zd bytes not %d) for block at %08x\n", retlen
, len
, jeb
->offset
));
969 /* Special check for first page */
970 for(i
= 0; i
< oob_size
; i
++) {
971 /* Yeah, we know about the cleanmarker. */
972 if (mode
&& i
>= c
->fsdata_pos
&&
973 i
< c
->fsdata_pos
+ c
->fsdata_len
)
976 if (buf
[i
] != 0xFF) {
977 D2(printk(KERN_DEBUG
"Found %02x at %x in OOB for %08x\n",
978 buf
[page
+i
], page
+i
, jeb
->offset
));
984 /* we know, we are aligned :) */
985 for (page
= oob_size
; page
< len
; page
+= sizeof(long)) {
986 unsigned long dat
= *(unsigned long *)(&buf
[page
]);
1000 * Scan for a valid cleanmarker and for bad blocks
1001 * For virtual blocks (concatenated physical blocks) check the cleanmarker
1002 * only in the first page of the first physical block, but scan for bad blocks in all
1005 int jffs2_check_nand_cleanmarker (struct jffs2_sb_info
*c
, struct jffs2_eraseblock
*jeb
)
1007 struct jffs2_unknown_node n
;
1008 unsigned char buf
[2 * NAND_MAX_OOBSIZE
];
1010 int ret
, i
, cnt
, retval
= 0;
1011 size_t retlen
, offset
;
1014 offset
= jeb
->offset
;
1015 oob_size
= c
->mtd
->oobsize
;
1017 /* Loop through the physical blocks */
1018 for (cnt
= 0; cnt
< (c
->sector_size
/ c
->mtd
->erasesize
); cnt
++) {
1019 /* Check first if the block is bad. */
1020 if (c
->mtd
->block_isbad (c
->mtd
, offset
)) {
1021 D1 (printk (KERN_WARNING
"jffs2_check_nand_cleanmarker(): Bad block at %08x\n", jeb
->offset
));
1025 * We read oob data from page 0 and 1 of the block.
1026 * page 0 contains cleanmarker and badblock info
1027 * page 1 contains failure count of this block
1029 ret
= c
->mtd
->read_oob (c
->mtd
, offset
, oob_size
<< 1, &retlen
, buf
);
1032 D1 (printk (KERN_WARNING
"jffs2_check_nand_cleanmarker(): Read OOB failed %d for block at %08x\n", ret
, jeb
->offset
));
1035 if (retlen
< (oob_size
<< 1)) {
1036 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
));
1040 /* Check cleanmarker only on the first physical block */
1042 n
.magic
= cpu_to_je16 (JFFS2_MAGIC_BITMASK
);
1043 n
.nodetype
= cpu_to_je16 (JFFS2_NODETYPE_CLEANMARKER
);
1044 n
.totlen
= cpu_to_je32 (8);
1045 p
= (unsigned char *) &n
;
1047 for (i
= 0; i
< c
->fsdata_len
; i
++) {
1048 if (buf
[c
->fsdata_pos
+ i
] != p
[i
]) {
1052 D1(if (retval
== 1) {
1053 printk(KERN_WARNING
"jffs2_check_nand_cleanmarker(): Cleanmarker node not detected in block at %08x\n", jeb
->offset
);
1054 printk(KERN_WARNING
"OOB at %08x was ", offset
);
1055 for (i
=0; i
< oob_size
; i
++) {
1056 printk("%02x ", buf
[i
]);
1061 offset
+= c
->mtd
->erasesize
;
1066 int jffs2_write_nand_cleanmarker(struct jffs2_sb_info
*c
, struct jffs2_eraseblock
*jeb
)
1068 struct jffs2_unknown_node n
;
1072 n
.magic
= cpu_to_je16(JFFS2_MAGIC_BITMASK
);
1073 n
.nodetype
= cpu_to_je16(JFFS2_NODETYPE_CLEANMARKER
);
1074 n
.totlen
= cpu_to_je32(8);
1076 ret
= jffs2_flash_write_oob(c
, jeb
->offset
+ c
->fsdata_pos
, c
->fsdata_len
, &retlen
, (unsigned char *)&n
);
1079 D1(printk(KERN_WARNING
"jffs2_write_nand_cleanmarker(): Write failed for block at %08x: error %d\n", jeb
->offset
, ret
));
1082 if (retlen
!= c
->fsdata_len
) {
1083 D1(printk(KERN_WARNING
"jffs2_write_nand_cleanmarker(): Short write for block at %08x: %zd not %d\n", jeb
->offset
, retlen
, c
->fsdata_len
));
1090 * On NAND we try to mark this block bad. If the block was erased more
1091 * than MAX_ERASE_FAILURES we mark it finaly bad.
1092 * Don't care about failures. This block remains on the erase-pending
1093 * or badblock list as long as nobody manipulates the flash with
1094 * a bootloader or something like that.
1097 int jffs2_write_nand_badblock(struct jffs2_sb_info
*c
, struct jffs2_eraseblock
*jeb
, uint32_t bad_offset
)
1101 /* if the count is < max, we try to write the counter to the 2nd page oob area */
1102 if( ++jeb
->bad_count
< MAX_ERASE_FAILURES
)
1105 if (!c
->mtd
->block_markbad
)
1106 return 1; // What else can we do?
1108 D1(printk(KERN_WARNING
"jffs2_write_nand_badblock(): Marking bad block at %08x\n", bad_offset
));
1109 ret
= c
->mtd
->block_markbad(c
->mtd
, bad_offset
);
1112 D1(printk(KERN_WARNING
"jffs2_write_nand_badblock(): Write failed for block at %08x: error %d\n", jeb
->offset
, ret
));
1118 #define NAND_JFFS2_OOB16_FSDALEN 8
1120 static struct nand_oobinfo jffs2_oobinfo_docecc
= {
1121 .useecc
= MTD_NANDECC_PLACE
,
1123 .eccpos
= {0,1,2,3,4,5}
1127 static int jffs2_nand_set_oobinfo(struct jffs2_sb_info
*c
)
1129 struct nand_oobinfo
*oinfo
= &c
->mtd
->oobinfo
;
1131 /* Do this only, if we have an oob buffer */
1132 if (!c
->mtd
->oobsize
)
1135 /* Cleanmarker is out-of-band, so inline size zero */
1136 c
->cleanmarker_size
= 0;
1138 /* Should we use autoplacement ? */
1139 if (oinfo
&& oinfo
->useecc
== MTD_NANDECC_AUTOPLACE
) {
1140 D1(printk(KERN_DEBUG
"JFFS2 using autoplace on NAND\n"));
1141 /* Get the position of the free bytes */
1142 if (!oinfo
->oobfree
[0][1]) {
1143 printk (KERN_WARNING
"jffs2_nand_set_oobinfo(): Eeep. Autoplacement selected and no empty space in oob\n");
1146 c
->fsdata_pos
= oinfo
->oobfree
[0][0];
1147 c
->fsdata_len
= oinfo
->oobfree
[0][1];
1148 if (c
->fsdata_len
> 8)
1151 /* This is just a legacy fallback and should go away soon */
1152 switch(c
->mtd
->ecctype
) {
1153 case MTD_ECC_RS_DiskOnChip
:
1154 printk(KERN_WARNING
"JFFS2 using DiskOnChip hardware ECC without autoplacement. Fix it!\n");
1155 c
->oobinfo
= &jffs2_oobinfo_docecc
;
1157 c
->fsdata_len
= NAND_JFFS2_OOB16_FSDALEN
;
1158 c
->badblock_pos
= 15;
1162 D1(printk(KERN_DEBUG
"JFFS2 on NAND. No autoplacment info found\n"));
1169 int jffs2_nand_flash_setup(struct jffs2_sb_info
*c
)
1173 /* Initialise write buffer */
1174 init_rwsem(&c
->wbuf_sem
);
1175 c
->wbuf_pagesize
= c
->mtd
->oobblock
;
1176 c
->wbuf_ofs
= 0xFFFFFFFF;
1178 c
->wbuf
= kmalloc(c
->wbuf_pagesize
, GFP_KERNEL
);
1182 res
= jffs2_nand_set_oobinfo(c
);
1186 brokenbuf
= kmalloc(c
->wbuf_pagesize
, GFP_KERNEL
);
1191 memset(brokenbuf
, 0xdb, c
->wbuf_pagesize
);
1196 void jffs2_nand_flash_cleanup(struct jffs2_sb_info
*c
)
1201 #ifdef CONFIG_JFFS2_FS_DATAFLASH
1202 int jffs2_dataflash_setup(struct jffs2_sb_info
*c
) {
1203 c
->cleanmarker_size
= 0; /* No cleanmarkers needed */
1205 /* Initialize write buffer */
1206 init_rwsem(&c
->wbuf_sem
);
1207 c
->wbuf_pagesize
= c
->sector_size
;
1208 c
->wbuf_ofs
= 0xFFFFFFFF;
1210 c
->wbuf
= kmalloc(c
->wbuf_pagesize
, GFP_KERNEL
);
1214 printk(KERN_INFO
"JFFS2 write-buffering enabled (%i)\n", c
->wbuf_pagesize
);
1219 void jffs2_dataflash_cleanup(struct jffs2_sb_info
*c
) {
1224 #ifdef CONFIG_JFFS2_FS_NOR_ECC
1225 int jffs2_nor_ecc_flash_setup(struct jffs2_sb_info
*c
) {
1226 /* Cleanmarker is actually larger on the flashes */
1227 c
->cleanmarker_size
= 16;
1229 /* Initialize write buffer */
1230 init_rwsem(&c
->wbuf_sem
);
1231 c
->wbuf_pagesize
= c
->mtd
->eccsize
;
1232 c
->wbuf_ofs
= 0xFFFFFFFF;
1234 c
->wbuf
= kmalloc(c
->wbuf_pagesize
, GFP_KERNEL
);
1241 void jffs2_nor_ecc_flash_cleanup(struct jffs2_sb_info
*c
) {