ia64/linux-2.6.18-xen.hg

view fs/jffs2/wbuf.c @ 524:7f8b544237bf

netfront: Allow netfront in domain 0.

This is useful if your physical network device is in a utility domain.

Signed-off-by: Ian Campbell <ian.campbell@citrix.com>
author Keir Fraser <keir.fraser@citrix.com>
date Tue Apr 15 15:18:58 2008 +0100 (2008-04-15)
parents 831230e53067
children
line source
1 /*
2 * JFFS2 -- Journalling Flash File System, Version 2.
3 *
4 * Copyright (C) 2001-2003 Red Hat, Inc.
5 * Copyright (C) 2004 Thomas Gleixner <tglx@linutronix.de>
6 *
7 * Created by David Woodhouse <dwmw2@infradead.org>
8 * Modified debugged and enhanced by Thomas Gleixner <tglx@linutronix.de>
9 *
10 * For licensing information, see the file 'LICENCE' in this directory.
11 *
12 * $Id: wbuf.c,v 1.100 2005/09/30 13:59:13 dedekind Exp $
13 *
14 */
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>
23 #include "nodelist.h"
25 /* For testing write failures */
26 #undef BREAKME
27 #undef BREAKMEHEADER
29 #ifdef BREAKME
30 static unsigned char *brokenbuf;
31 #endif
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 {
40 uint32_t ino;
41 struct jffs2_inodirty *next;
42 };
44 static struct jffs2_inodirty inodirty_nomem;
46 static int jffs2_wbuf_pending_for_ino(struct jffs2_sb_info *c, uint32_t ino)
47 {
48 struct jffs2_inodirty *this = c->wbuf_inodes;
50 /* If a malloc failed, consider _everything_ dirty */
51 if (this == &inodirty_nomem)
52 return 1;
54 /* If ino == 0, _any_ non-GC writes mean 'yes' */
55 if (this && !ino)
56 return 1;
58 /* Look to see if the inode in question is pending in the wbuf */
59 while (this) {
60 if (this->ino == ino)
61 return 1;
62 this = this->next;
63 }
64 return 0;
65 }
67 static void jffs2_clear_wbuf_ino_list(struct jffs2_sb_info *c)
68 {
69 struct jffs2_inodirty *this;
71 this = c->wbuf_inodes;
73 if (this != &inodirty_nomem) {
74 while (this) {
75 struct jffs2_inodirty *next = this->next;
76 kfree(this);
77 this = next;
78 }
79 }
80 c->wbuf_inodes = NULL;
81 }
83 static void jffs2_wbuf_dirties_inode(struct jffs2_sb_info *c, uint32_t ino)
84 {
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))
91 return;
93 new = kmalloc(sizeof(*new), GFP_KERNEL);
94 if (!new) {
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;
98 return;
99 }
100 new->ino = ino;
101 new->next = c->wbuf_inodes;
102 c->wbuf_inodes = new;
103 return;
104 }
106 static inline void jffs2_refile_wbuf_blocks(struct jffs2_sb_info *c)
107 {
108 struct list_head *this, *next;
109 static int n;
111 if (list_empty(&c->erasable_pending_wbuf_list))
112 return;
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));
118 list_del(this);
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);
126 } else {
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);
131 }
132 }
133 }
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)
139 {
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)
144 c->nextblock = NULL;
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);
150 } else {
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);
157 }
159 if (!jffs2_prealloc_raw_node_refs(c, jeb, 1)) {
160 uint32_t oldfree = jeb->free_size;
162 jffs2_link_node_ref(c, jeb,
163 (jeb->offset+c->sector_size-oldfree) | REF_OBSOLETE,
164 oldfree, NULL);
165 /* convert to wasted */
166 c->wasted_size += oldfree;
167 jeb->wasted_size += oldfree;
168 c->dirty_size -= oldfree;
169 jeb->dirty_size -= oldfree;
170 }
172 jffs2_dbg_dump_block_lists_nolock(c);
173 jffs2_dbg_acct_sanity_check_nolock(c,jeb);
174 jffs2_dbg_acct_paranoia_check_nolock(c, jeb);
175 }
177 static struct jffs2_raw_node_ref **jffs2_incore_replace_raw(struct jffs2_sb_info *c,
178 struct jffs2_inode_info *f,
179 struct jffs2_raw_node_ref *raw,
180 union jffs2_node_union *node)
181 {
182 struct jffs2_node_frag *frag;
183 struct jffs2_full_dirent *fd;
185 dbg_noderef("incore_replace_raw: node at %p is {%04x,%04x}\n",
186 node, je16_to_cpu(node->u.magic), je16_to_cpu(node->u.nodetype));
188 BUG_ON(je16_to_cpu(node->u.magic) != 0x1985 &&
189 je16_to_cpu(node->u.magic) != 0);
191 switch (je16_to_cpu(node->u.nodetype)) {
192 case JFFS2_NODETYPE_INODE:
193 if (f->metadata && f->metadata->raw == raw) {
194 dbg_noderef("Will replace ->raw in f->metadata at %p\n", f->metadata);
195 return &f->metadata->raw;
196 }
197 frag = jffs2_lookup_node_frag(&f->fragtree, je32_to_cpu(node->i.offset));
198 BUG_ON(!frag);
199 /* Find a frag which refers to the full_dnode we want to modify */
200 while (!frag->node || frag->node->raw != raw) {
201 frag = frag_next(frag);
202 BUG_ON(!frag);
203 }
204 dbg_noderef("Will replace ->raw in full_dnode at %p\n", frag->node);
205 return &frag->node->raw;
207 case JFFS2_NODETYPE_DIRENT:
208 for (fd = f->dents; fd; fd = fd->next) {
209 if (fd->raw == raw) {
210 dbg_noderef("Will replace ->raw in full_dirent at %p\n", fd);
211 return &fd->raw;
212 }
213 }
214 BUG();
216 default:
217 dbg_noderef("Don't care about replacing raw for nodetype %x\n",
218 je16_to_cpu(node->u.nodetype));
219 break;
220 }
221 return NULL;
222 }
224 /* Recover from failure to write wbuf. Recover the nodes up to the
225 * wbuf, not the one which we were starting to try to write. */
227 static void jffs2_wbuf_recover(struct jffs2_sb_info *c)
228 {
229 struct jffs2_eraseblock *jeb, *new_jeb;
230 struct jffs2_raw_node_ref *raw, *next, *first_raw = NULL;
231 size_t retlen;
232 int ret;
233 int nr_refile = 0;
234 unsigned char *buf;
235 uint32_t start, end, ofs, len;
237 jeb = &c->blocks[c->wbuf_ofs / c->sector_size];
239 spin_lock(&c->erase_completion_lock);
240 jffs2_block_refile(c, jeb, REFILE_NOTEMPTY);
241 spin_unlock(&c->erase_completion_lock);
243 BUG_ON(!ref_obsolete(jeb->last_node));
245 /* Find the first node to be recovered, by skipping over every
246 node which ends before the wbuf starts, or which is obsolete. */
247 for (next = raw = jeb->first_node; next; raw = next) {
248 next = ref_next(raw);
250 if (ref_obsolete(raw) ||
251 (next && ref_offset(next) <= c->wbuf_ofs)) {
252 dbg_noderef("Skipping node at 0x%08x(%d)-0x%08x which is either before 0x%08x or obsolete\n",
253 ref_offset(raw), ref_flags(raw),
254 (ref_offset(raw) + ref_totlen(c, jeb, raw)),
255 c->wbuf_ofs);
256 continue;
257 }
258 dbg_noderef("First node to be recovered is at 0x%08x(%d)-0x%08x\n",
259 ref_offset(raw), ref_flags(raw),
260 (ref_offset(raw) + ref_totlen(c, jeb, raw)));
262 first_raw = raw;
263 break;
264 }
266 if (!first_raw) {
267 /* All nodes were obsolete. Nothing to recover. */
268 D1(printk(KERN_DEBUG "No non-obsolete nodes to be recovered. Just filing block bad\n"));
269 c->wbuf_len = 0;
270 return;
271 }
273 start = ref_offset(first_raw);
274 end = ref_offset(jeb->last_node);
275 nr_refile = 1;
277 /* Count the number of refs which need to be copied */
278 while ((raw = ref_next(raw)) != jeb->last_node)
279 nr_refile++;
281 dbg_noderef("wbuf recover %08x-%08x (%d bytes in %d nodes)\n",
282 start, end, end - start, nr_refile);
284 buf = NULL;
285 if (start < c->wbuf_ofs) {
286 /* First affected node was already partially written.
287 * Attempt to reread the old data into our buffer. */
289 buf = kmalloc(end - start, GFP_KERNEL);
290 if (!buf) {
291 printk(KERN_CRIT "Malloc failure in wbuf recovery. Data loss ensues.\n");
293 goto read_failed;
294 }
296 /* Do the read... */
297 ret = c->mtd->read(c->mtd, start, c->wbuf_ofs - start, &retlen, buf);
299 /* ECC recovered ? */
300 if ((ret == -EUCLEAN || ret == -EBADMSG) &&
301 (retlen == c->wbuf_ofs - start))
302 ret = 0;
304 if (ret || retlen != c->wbuf_ofs - start) {
305 printk(KERN_CRIT "Old data are already lost in wbuf recovery. Data loss ensues.\n");
307 kfree(buf);
308 buf = NULL;
309 read_failed:
310 first_raw = ref_next(first_raw);
311 nr_refile--;
312 while (first_raw && ref_obsolete(first_raw)) {
313 first_raw = ref_next(first_raw);
314 nr_refile--;
315 }
317 /* If this was the only node to be recovered, give up */
318 if (!first_raw) {
319 c->wbuf_len = 0;
320 return;
321 }
323 /* It wasn't. Go on and try to recover nodes complete in the wbuf */
324 start = ref_offset(first_raw);
325 dbg_noderef("wbuf now recover %08x-%08x (%d bytes in %d nodes)\n",
326 start, end, end - start, nr_refile);
328 } else {
329 /* Read succeeded. Copy the remaining data from the wbuf */
330 memcpy(buf + (c->wbuf_ofs - start), c->wbuf, end - c->wbuf_ofs);
331 }
332 }
333 /* OK... we're to rewrite (end-start) bytes of data from first_raw onwards.
334 Either 'buf' contains the data, or we find it in the wbuf */
336 /* ... and get an allocation of space from a shiny new block instead */
337 ret = jffs2_reserve_space_gc(c, end-start, &len, JFFS2_SUMMARY_NOSUM_SIZE);
338 if (ret) {
339 printk(KERN_WARNING "Failed to allocate space for wbuf recovery. Data loss ensues.\n");
340 kfree(buf);
341 return;
342 }
344 ret = jffs2_prealloc_raw_node_refs(c, c->nextblock, nr_refile);
345 if (ret) {
346 printk(KERN_WARNING "Failed to allocate node refs for wbuf recovery. Data loss ensues.\n");
347 kfree(buf);
348 return;
349 }
351 ofs = write_ofs(c);
353 if (end-start >= c->wbuf_pagesize) {
354 /* Need to do another write immediately, but it's possible
355 that this is just because the wbuf itself is completely
356 full, and there's nothing earlier read back from the
357 flash. Hence 'buf' isn't necessarily what we're writing
358 from. */
359 unsigned char *rewrite_buf = buf?:c->wbuf;
360 uint32_t towrite = (end-start) - ((end-start)%c->wbuf_pagesize);
362 D1(printk(KERN_DEBUG "Write 0x%x bytes at 0x%08x in wbuf recover\n",
363 towrite, ofs));
365 #ifdef BREAKMEHEADER
366 static int breakme;
367 if (breakme++ == 20) {
368 printk(KERN_NOTICE "Faking write error at 0x%08x\n", ofs);
369 breakme = 0;
370 c->mtd->write(c->mtd, ofs, towrite, &retlen,
371 brokenbuf);
372 ret = -EIO;
373 } else
374 #endif
375 ret = c->mtd->write(c->mtd, ofs, towrite, &retlen,
376 rewrite_buf);
378 if (ret || retlen != towrite) {
379 /* Argh. We tried. Really we did. */
380 printk(KERN_CRIT "Recovery of wbuf failed due to a second write error\n");
381 kfree(buf);
383 if (retlen)
384 jffs2_add_physical_node_ref(c, ofs | REF_OBSOLETE, ref_totlen(c, jeb, first_raw), NULL);
386 return;
387 }
388 printk(KERN_NOTICE "Recovery of wbuf succeeded to %08x\n", ofs);
390 c->wbuf_len = (end - start) - towrite;
391 c->wbuf_ofs = ofs + towrite;
392 memmove(c->wbuf, rewrite_buf + towrite, c->wbuf_len);
393 /* Don't muck about with c->wbuf_inodes. False positives are harmless. */
394 } else {
395 /* OK, now we're left with the dregs in whichever buffer we're using */
396 if (buf) {
397 memcpy(c->wbuf, buf, end-start);
398 } else {
399 memmove(c->wbuf, c->wbuf + (start - c->wbuf_ofs), end - start);
400 }
401 c->wbuf_ofs = ofs;
402 c->wbuf_len = end - start;
403 }
405 /* Now sort out the jffs2_raw_node_refs, moving them from the old to the next block */
406 new_jeb = &c->blocks[ofs / c->sector_size];
408 spin_lock(&c->erase_completion_lock);
409 for (raw = first_raw; raw != jeb->last_node; raw = ref_next(raw)) {
410 uint32_t rawlen = ref_totlen(c, jeb, raw);
411 struct jffs2_inode_cache *ic;
412 struct jffs2_raw_node_ref *new_ref;
413 struct jffs2_raw_node_ref **adjust_ref = NULL;
414 struct jffs2_inode_info *f = NULL;
416 D1(printk(KERN_DEBUG "Refiling block of %08x at %08x(%d) to %08x\n",
417 rawlen, ref_offset(raw), ref_flags(raw), ofs));
419 ic = jffs2_raw_ref_to_ic(raw);
421 /* Ick. This XATTR mess should be fixed shortly... */
422 if (ic && ic->class == RAWNODE_CLASS_XATTR_DATUM) {
423 struct jffs2_xattr_datum *xd = (void *)ic;
424 BUG_ON(xd->node != raw);
425 adjust_ref = &xd->node;
426 raw->next_in_ino = NULL;
427 ic = NULL;
428 } else if (ic && ic->class == RAWNODE_CLASS_XATTR_REF) {
429 struct jffs2_xattr_datum *xr = (void *)ic;
430 BUG_ON(xr->node != raw);
431 adjust_ref = &xr->node;
432 raw->next_in_ino = NULL;
433 ic = NULL;
434 } else if (ic && ic->class == RAWNODE_CLASS_INODE_CACHE) {
435 struct jffs2_raw_node_ref **p = &ic->nodes;
437 /* Remove the old node from the per-inode list */
438 while (*p && *p != (void *)ic) {
439 if (*p == raw) {
440 (*p) = (raw->next_in_ino);
441 raw->next_in_ino = NULL;
442 break;
443 }
444 p = &((*p)->next_in_ino);
445 }
447 if (ic->state == INO_STATE_PRESENT && !ref_obsolete(raw)) {
448 /* If it's an in-core inode, then we have to adjust any
449 full_dirent or full_dnode structure to point to the
450 new version instead of the old */
451 f = jffs2_gc_fetch_inode(c, ic->ino, ic->nlink);
452 if (IS_ERR(f)) {
453 /* Should never happen; it _must_ be present */
454 JFFS2_ERROR("Failed to iget() ino #%u, err %ld\n",
455 ic->ino, PTR_ERR(f));
456 BUG();
457 }
458 /* We don't lock f->sem. There's a number of ways we could
459 end up in here with it already being locked, and nobody's
460 going to modify it on us anyway because we hold the
461 alloc_sem. We're only changing one ->raw pointer too,
462 which we can get away with without upsetting readers. */
463 adjust_ref = jffs2_incore_replace_raw(c, f, raw,
464 (void *)(buf?:c->wbuf) + (ref_offset(raw) - start));
465 } else if (unlikely(ic->state != INO_STATE_PRESENT &&
466 ic->state != INO_STATE_CHECKEDABSENT &&
467 ic->state != INO_STATE_GC)) {
468 JFFS2_ERROR("Inode #%u is in strange state %d!\n", ic->ino, ic->state);
469 BUG();
470 }
471 }
473 new_ref = jffs2_link_node_ref(c, new_jeb, ofs | ref_flags(raw), rawlen, ic);
475 if (adjust_ref) {
476 BUG_ON(*adjust_ref != raw);
477 *adjust_ref = new_ref;
478 }
479 if (f)
480 jffs2_gc_release_inode(c, f);
482 if (!ref_obsolete(raw)) {
483 jeb->dirty_size += rawlen;
484 jeb->used_size -= rawlen;
485 c->dirty_size += rawlen;
486 c->used_size -= rawlen;
487 raw->flash_offset = ref_offset(raw) | REF_OBSOLETE;
488 BUG_ON(raw->next_in_ino);
489 }
490 ofs += rawlen;
491 }
493 kfree(buf);
495 /* Fix up the original jeb now it's on the bad_list */
496 if (first_raw == jeb->first_node) {
497 D1(printk(KERN_DEBUG "Failing block at %08x is now empty. Moving to erase_pending_list\n", jeb->offset));
498 list_move(&jeb->list, &c->erase_pending_list);
499 c->nr_erasing_blocks++;
500 jffs2_erase_pending_trigger(c);
501 }
503 jffs2_dbg_acct_sanity_check_nolock(c, jeb);
504 jffs2_dbg_acct_paranoia_check_nolock(c, jeb);
506 jffs2_dbg_acct_sanity_check_nolock(c, new_jeb);
507 jffs2_dbg_acct_paranoia_check_nolock(c, new_jeb);
509 spin_unlock(&c->erase_completion_lock);
511 D1(printk(KERN_DEBUG "wbuf recovery completed OK. wbuf_ofs 0x%08x, len 0x%x\n", c->wbuf_ofs, c->wbuf_len));
513 }
515 /* Meaning of pad argument:
516 0: Do not pad. Probably pointless - we only ever use this when we can't pad anyway.
517 1: Pad, do not adjust nextblock free_size
518 2: Pad, adjust nextblock free_size
519 */
520 #define NOPAD 0
521 #define PAD_NOACCOUNT 1
522 #define PAD_ACCOUNTING 2
524 static int __jffs2_flush_wbuf(struct jffs2_sb_info *c, int pad)
525 {
526 struct jffs2_eraseblock *wbuf_jeb;
527 int ret;
528 size_t retlen;
530 /* Nothing to do if not write-buffering the flash. In particular, we shouldn't
531 del_timer() the timer we never initialised. */
532 if (!jffs2_is_writebuffered(c))
533 return 0;
535 if (!down_trylock(&c->alloc_sem)) {
536 up(&c->alloc_sem);
537 printk(KERN_CRIT "jffs2_flush_wbuf() called with alloc_sem not locked!\n");
538 BUG();
539 }
541 if (!c->wbuf_len) /* already checked c->wbuf above */
542 return 0;
544 wbuf_jeb = &c->blocks[c->wbuf_ofs / c->sector_size];
545 if (jffs2_prealloc_raw_node_refs(c, wbuf_jeb, c->nextblock->allocated_refs + 1))
546 return -ENOMEM;
548 /* claim remaining space on the page
549 this happens, if we have a change to a new block,
550 or if fsync forces us to flush the writebuffer.
551 if we have a switch to next page, we will not have
552 enough remaining space for this.
553 */
554 if (pad ) {
555 c->wbuf_len = PAD(c->wbuf_len);
557 /* Pad with JFFS2_DIRTY_BITMASK initially. this helps out ECC'd NOR
558 with 8 byte page size */
559 memset(c->wbuf + c->wbuf_len, 0, c->wbuf_pagesize - c->wbuf_len);
561 if ( c->wbuf_len + sizeof(struct jffs2_unknown_node) < c->wbuf_pagesize) {
562 struct jffs2_unknown_node *padnode = (void *)(c->wbuf + c->wbuf_len);
563 padnode->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
564 padnode->nodetype = cpu_to_je16(JFFS2_NODETYPE_PADDING);
565 padnode->totlen = cpu_to_je32(c->wbuf_pagesize - c->wbuf_len);
566 padnode->hdr_crc = cpu_to_je32(crc32(0, padnode, sizeof(*padnode)-4));
567 }
568 }
569 /* else jffs2_flash_writev has actually filled in the rest of the
570 buffer for us, and will deal with the node refs etc. later. */
572 #ifdef BREAKME
573 static int breakme;
574 if (breakme++ == 20) {
575 printk(KERN_NOTICE "Faking write error at 0x%08x\n", c->wbuf_ofs);
576 breakme = 0;
577 c->mtd->write(c->mtd, c->wbuf_ofs, c->wbuf_pagesize, &retlen,
578 brokenbuf);
579 ret = -EIO;
580 } else
581 #endif
583 ret = c->mtd->write(c->mtd, c->wbuf_ofs, c->wbuf_pagesize, &retlen, c->wbuf);
585 if (ret || retlen != c->wbuf_pagesize) {
586 if (ret)
587 printk(KERN_WARNING "jffs2_flush_wbuf(): Write failed with %d\n",ret);
588 else {
589 printk(KERN_WARNING "jffs2_flush_wbuf(): Write was short: %zd instead of %d\n",
590 retlen, c->wbuf_pagesize);
591 ret = -EIO;
592 }
594 jffs2_wbuf_recover(c);
596 return ret;
597 }
599 /* Adjust free size of the block if we padded. */
600 if (pad) {
601 uint32_t waste = c->wbuf_pagesize - c->wbuf_len;
603 D1(printk(KERN_DEBUG "jffs2_flush_wbuf() adjusting free_size of %sblock at %08x\n",
604 (wbuf_jeb==c->nextblock)?"next":"", wbuf_jeb->offset));
606 /* wbuf_pagesize - wbuf_len is the amount of space that's to be
607 padded. If there is less free space in the block than that,
608 something screwed up */
609 if (wbuf_jeb->free_size < waste) {
610 printk(KERN_CRIT "jffs2_flush_wbuf(): Accounting error. wbuf at 0x%08x has 0x%03x bytes, 0x%03x left.\n",
611 c->wbuf_ofs, c->wbuf_len, waste);
612 printk(KERN_CRIT "jffs2_flush_wbuf(): But free_size for block at 0x%08x is only 0x%08x\n",
613 wbuf_jeb->offset, wbuf_jeb->free_size);
614 BUG();
615 }
617 spin_lock(&c->erase_completion_lock);
619 jffs2_link_node_ref(c, wbuf_jeb, (c->wbuf_ofs + c->wbuf_len) | REF_OBSOLETE, waste, NULL);
620 /* FIXME: that made it count as dirty. Convert to wasted */
621 wbuf_jeb->dirty_size -= waste;
622 c->dirty_size -= waste;
623 wbuf_jeb->wasted_size += waste;
624 c->wasted_size += waste;
625 } else
626 spin_lock(&c->erase_completion_lock);
628 /* Stick any now-obsoleted blocks on the erase_pending_list */
629 jffs2_refile_wbuf_blocks(c);
630 jffs2_clear_wbuf_ino_list(c);
631 spin_unlock(&c->erase_completion_lock);
633 memset(c->wbuf,0xff,c->wbuf_pagesize);
634 /* adjust write buffer offset, else we get a non contiguous write bug */
635 c->wbuf_ofs += c->wbuf_pagesize;
636 c->wbuf_len = 0;
637 return 0;
638 }
640 /* Trigger garbage collection to flush the write-buffer.
641 If ino arg is zero, do it if _any_ real (i.e. not GC) writes are
642 outstanding. If ino arg non-zero, do it only if a write for the
643 given inode is outstanding. */
644 int jffs2_flush_wbuf_gc(struct jffs2_sb_info *c, uint32_t ino)
645 {
646 uint32_t old_wbuf_ofs;
647 uint32_t old_wbuf_len;
648 int ret = 0;
650 D1(printk(KERN_DEBUG "jffs2_flush_wbuf_gc() called for ino #%u...\n", ino));
652 if (!c->wbuf)
653 return 0;
655 down(&c->alloc_sem);
656 if (!jffs2_wbuf_pending_for_ino(c, ino)) {
657 D1(printk(KERN_DEBUG "Ino #%d not pending in wbuf. Returning\n", ino));
658 up(&c->alloc_sem);
659 return 0;
660 }
662 old_wbuf_ofs = c->wbuf_ofs;
663 old_wbuf_len = c->wbuf_len;
665 if (c->unchecked_size) {
666 /* GC won't make any progress for a while */
667 D1(printk(KERN_DEBUG "jffs2_flush_wbuf_gc() padding. Not finished checking\n"));
668 down_write(&c->wbuf_sem);
669 ret = __jffs2_flush_wbuf(c, PAD_ACCOUNTING);
670 /* retry flushing wbuf in case jffs2_wbuf_recover
671 left some data in the wbuf */
672 if (ret)
673 ret = __jffs2_flush_wbuf(c, PAD_ACCOUNTING);
674 up_write(&c->wbuf_sem);
675 } else while (old_wbuf_len &&
676 old_wbuf_ofs == c->wbuf_ofs) {
678 up(&c->alloc_sem);
680 D1(printk(KERN_DEBUG "jffs2_flush_wbuf_gc() calls gc pass\n"));
682 ret = jffs2_garbage_collect_pass(c);
683 if (ret) {
684 /* GC failed. Flush it with padding instead */
685 down(&c->alloc_sem);
686 down_write(&c->wbuf_sem);
687 ret = __jffs2_flush_wbuf(c, PAD_ACCOUNTING);
688 /* retry flushing wbuf in case jffs2_wbuf_recover
689 left some data in the wbuf */
690 if (ret)
691 ret = __jffs2_flush_wbuf(c, PAD_ACCOUNTING);
692 up_write(&c->wbuf_sem);
693 break;
694 }
695 down(&c->alloc_sem);
696 }
698 D1(printk(KERN_DEBUG "jffs2_flush_wbuf_gc() ends...\n"));
700 up(&c->alloc_sem);
701 return ret;
702 }
704 /* Pad write-buffer to end and write it, wasting space. */
705 int jffs2_flush_wbuf_pad(struct jffs2_sb_info *c)
706 {
707 int ret;
709 if (!c->wbuf)
710 return 0;
712 down_write(&c->wbuf_sem);
713 ret = __jffs2_flush_wbuf(c, PAD_NOACCOUNT);
714 /* retry - maybe wbuf recover left some data in wbuf. */
715 if (ret)
716 ret = __jffs2_flush_wbuf(c, PAD_NOACCOUNT);
717 up_write(&c->wbuf_sem);
719 return ret;
720 }
722 static size_t jffs2_fill_wbuf(struct jffs2_sb_info *c, const uint8_t *buf,
723 size_t len)
724 {
725 if (len && !c->wbuf_len && (len >= c->wbuf_pagesize))
726 return 0;
728 if (len > (c->wbuf_pagesize - c->wbuf_len))
729 len = c->wbuf_pagesize - c->wbuf_len;
730 memcpy(c->wbuf + c->wbuf_len, buf, len);
731 c->wbuf_len += (uint32_t) len;
732 return len;
733 }
735 int jffs2_flash_writev(struct jffs2_sb_info *c, const struct kvec *invecs,
736 unsigned long count, loff_t to, size_t *retlen,
737 uint32_t ino)
738 {
739 struct jffs2_eraseblock *jeb;
740 size_t wbuf_retlen, donelen = 0;
741 uint32_t outvec_to = to;
742 int ret, invec;
744 /* If not writebuffered flash, don't bother */
745 if (!jffs2_is_writebuffered(c))
746 return jffs2_flash_direct_writev(c, invecs, count, to, retlen);
748 down_write(&c->wbuf_sem);
750 /* If wbuf_ofs is not initialized, set it to target address */
751 if (c->wbuf_ofs == 0xFFFFFFFF) {
752 c->wbuf_ofs = PAGE_DIV(to);
753 c->wbuf_len = PAGE_MOD(to);
754 memset(c->wbuf,0xff,c->wbuf_pagesize);
755 }
757 /*
758 * Sanity checks on target address. It's permitted to write
759 * at PAD(c->wbuf_len+c->wbuf_ofs), and it's permitted to
760 * write at the beginning of a new erase block. Anything else,
761 * and you die. New block starts at xxx000c (0-b = block
762 * header)
763 */
764 if (SECTOR_ADDR(to) != SECTOR_ADDR(c->wbuf_ofs)) {
765 /* It's a write to a new block */
766 if (c->wbuf_len) {
767 D1(printk(KERN_DEBUG "jffs2_flash_writev() to 0x%lx "
768 "causes flush of wbuf at 0x%08x\n",
769 (unsigned long)to, c->wbuf_ofs));
770 ret = __jffs2_flush_wbuf(c, PAD_NOACCOUNT);
771 if (ret)
772 goto outerr;
773 }
774 /* set pointer to new block */
775 c->wbuf_ofs = PAGE_DIV(to);
776 c->wbuf_len = PAGE_MOD(to);
777 }
779 if (to != PAD(c->wbuf_ofs + c->wbuf_len)) {
780 /* We're not writing immediately after the writebuffer. Bad. */
781 printk(KERN_CRIT "jffs2_flash_writev(): Non-contiguous write "
782 "to %08lx\n", (unsigned long)to);
783 if (c->wbuf_len)
784 printk(KERN_CRIT "wbuf was previously %08x-%08x\n",
785 c->wbuf_ofs, c->wbuf_ofs+c->wbuf_len);
786 BUG();
787 }
789 /* adjust alignment offset */
790 if (c->wbuf_len != PAGE_MOD(to)) {
791 c->wbuf_len = PAGE_MOD(to);
792 /* take care of alignment to next page */
793 if (!c->wbuf_len) {
794 c->wbuf_len = c->wbuf_pagesize;
795 ret = __jffs2_flush_wbuf(c, NOPAD);
796 if (ret)
797 goto outerr;
798 }
799 }
801 for (invec = 0; invec < count; invec++) {
802 int vlen = invecs[invec].iov_len;
803 uint8_t *v = invecs[invec].iov_base;
805 wbuf_retlen = jffs2_fill_wbuf(c, v, vlen);
807 if (c->wbuf_len == c->wbuf_pagesize) {
808 ret = __jffs2_flush_wbuf(c, NOPAD);
809 if (ret)
810 goto outerr;
811 }
812 vlen -= wbuf_retlen;
813 outvec_to += wbuf_retlen;
814 donelen += wbuf_retlen;
815 v += wbuf_retlen;
817 if (vlen >= c->wbuf_pagesize) {
818 ret = c->mtd->write(c->mtd, outvec_to, PAGE_DIV(vlen),
819 &wbuf_retlen, v);
820 if (ret < 0 || wbuf_retlen != PAGE_DIV(vlen))
821 goto outfile;
823 vlen -= wbuf_retlen;
824 outvec_to += wbuf_retlen;
825 c->wbuf_ofs = outvec_to;
826 donelen += wbuf_retlen;
827 v += wbuf_retlen;
828 }
830 wbuf_retlen = jffs2_fill_wbuf(c, v, vlen);
831 if (c->wbuf_len == c->wbuf_pagesize) {
832 ret = __jffs2_flush_wbuf(c, NOPAD);
833 if (ret)
834 goto outerr;
835 }
837 outvec_to += wbuf_retlen;
838 donelen += wbuf_retlen;
839 }
841 /*
842 * If there's a remainder in the wbuf and it's a non-GC write,
843 * remember that the wbuf affects this ino
844 */
845 *retlen = donelen;
847 if (jffs2_sum_active()) {
848 int res = jffs2_sum_add_kvec(c, invecs, count, (uint32_t) to);
849 if (res)
850 return res;
851 }
853 if (c->wbuf_len && ino)
854 jffs2_wbuf_dirties_inode(c, ino);
856 ret = 0;
857 up_write(&c->wbuf_sem);
858 return ret;
860 outfile:
861 /*
862 * At this point we have no problem, c->wbuf is empty. However
863 * refile nextblock to avoid writing again to same address.
864 */
866 spin_lock(&c->erase_completion_lock);
868 jeb = &c->blocks[outvec_to / c->sector_size];
869 jffs2_block_refile(c, jeb, REFILE_ANYWAY);
871 spin_unlock(&c->erase_completion_lock);
873 outerr:
874 *retlen = 0;
875 up_write(&c->wbuf_sem);
876 return ret;
877 }
879 /*
880 * This is the entry for flash write.
881 * Check, if we work on NAND FLASH, if so build an kvec and write it via vritev
882 */
883 int jffs2_flash_write(struct jffs2_sb_info *c, loff_t ofs, size_t len,
884 size_t *retlen, const u_char *buf)
885 {
886 struct kvec vecs[1];
888 if (!jffs2_is_writebuffered(c))
889 return jffs2_flash_direct_write(c, ofs, len, retlen, buf);
891 vecs[0].iov_base = (unsigned char *) buf;
892 vecs[0].iov_len = len;
893 return jffs2_flash_writev(c, vecs, 1, ofs, retlen, 0);
894 }
896 /*
897 Handle readback from writebuffer and ECC failure return
898 */
899 int jffs2_flash_read(struct jffs2_sb_info *c, loff_t ofs, size_t len, size_t *retlen, u_char *buf)
900 {
901 loff_t orbf = 0, owbf = 0, lwbf = 0;
902 int ret;
904 if (!jffs2_is_writebuffered(c))
905 return c->mtd->read(c->mtd, ofs, len, retlen, buf);
907 /* Read flash */
908 down_read(&c->wbuf_sem);
909 ret = c->mtd->read(c->mtd, ofs, len, retlen, buf);
911 if ( (ret == -EBADMSG || ret == -EUCLEAN) && (*retlen == len) ) {
912 if (ret == -EBADMSG)
913 printk(KERN_WARNING "mtd->read(0x%zx bytes from 0x%llx)"
914 " returned ECC error\n", len, ofs);
915 /*
916 * We have the raw data without ECC correction in the buffer,
917 * maybe we are lucky and all data or parts are correct. We
918 * check the node. If data are corrupted node check will sort
919 * it out. We keep this block, it will fail on write or erase
920 * and the we mark it bad. Or should we do that now? But we
921 * should give him a chance. Maybe we had a system crash or
922 * power loss before the ecc write or a erase was completed.
923 * So we return success. :)
924 */
925 ret = 0;
926 }
928 /* if no writebuffer available or write buffer empty, return */
929 if (!c->wbuf_pagesize || !c->wbuf_len)
930 goto exit;
932 /* if we read in a different block, return */
933 if (SECTOR_ADDR(ofs) != SECTOR_ADDR(c->wbuf_ofs))
934 goto exit;
936 if (ofs >= c->wbuf_ofs) {
937 owbf = (ofs - c->wbuf_ofs); /* offset in write buffer */
938 if (owbf > c->wbuf_len) /* is read beyond write buffer ? */
939 goto exit;
940 lwbf = c->wbuf_len - owbf; /* number of bytes to copy */
941 if (lwbf > len)
942 lwbf = len;
943 } else {
944 orbf = (c->wbuf_ofs - ofs); /* offset in read buffer */
945 if (orbf > len) /* is write beyond write buffer ? */
946 goto exit;
947 lwbf = len - orbf; /* number of bytes to copy */
948 if (lwbf > c->wbuf_len)
949 lwbf = c->wbuf_len;
950 }
951 if (lwbf > 0)
952 memcpy(buf+orbf,c->wbuf+owbf,lwbf);
954 exit:
955 up_read(&c->wbuf_sem);
956 return ret;
957 }
959 #define NR_OOB_SCAN_PAGES 4
961 /*
962 * Check, if the out of band area is empty
963 */
964 int jffs2_check_oob_empty(struct jffs2_sb_info *c,
965 struct jffs2_eraseblock *jeb, int mode)
966 {
967 int i, page, ret;
968 int oobsize = c->mtd->oobsize;
969 struct mtd_oob_ops ops;
971 ops.len = NR_OOB_SCAN_PAGES * oobsize;
972 ops.ooblen = oobsize;
973 ops.oobbuf = c->oobbuf;
974 ops.ooboffs = 0;
975 ops.datbuf = NULL;
976 ops.mode = MTD_OOB_PLACE;
978 ret = c->mtd->read_oob(c->mtd, jeb->offset, &ops);
979 if (ret) {
980 D1(printk(KERN_WARNING "jffs2_check_oob_empty(): Read OOB "
981 "failed %d for block at %08x\n", ret, jeb->offset));
982 return ret;
983 }
985 if (ops.retlen < ops.len) {
986 D1(printk(KERN_WARNING "jffs2_check_oob_empty(): Read OOB "
987 "returned short read (%zd bytes not %d) for block "
988 "at %08x\n", ops.retlen, ops.len, jeb->offset));
989 return -EIO;
990 }
992 /* Special check for first page */
993 for(i = 0; i < oobsize ; i++) {
994 /* Yeah, we know about the cleanmarker. */
995 if (mode && i >= c->fsdata_pos &&
996 i < c->fsdata_pos + c->fsdata_len)
997 continue;
999 if (ops.oobbuf[i] != 0xFF) {
1000 D2(printk(KERN_DEBUG "Found %02x at %x in OOB for "
1001 "%08x\n", ops.oobbuf[i], i, jeb->offset));
1002 return 1;
1006 /* we know, we are aligned :) */
1007 for (page = oobsize; page < ops.len; page += sizeof(long)) {
1008 long dat = *(long *)(&ops.oobbuf[page]);
1009 if(dat != -1)
1010 return 1;
1012 return 0;
1015 /*
1016 * Scan for a valid cleanmarker and for bad blocks
1017 */
1018 int jffs2_check_nand_cleanmarker (struct jffs2_sb_info *c,
1019 struct jffs2_eraseblock *jeb)
1021 struct jffs2_unknown_node n;
1022 struct mtd_oob_ops ops;
1023 int oobsize = c->mtd->oobsize;
1024 unsigned char *p,*b;
1025 int i, ret;
1026 size_t offset = jeb->offset;
1028 /* Check first if the block is bad. */
1029 if (c->mtd->block_isbad(c->mtd, offset)) {
1030 D1 (printk(KERN_WARNING "jffs2_check_nand_cleanmarker()"
1031 ": Bad block at %08x\n", jeb->offset));
1032 return 2;
1035 ops.len = oobsize;
1036 ops.ooblen = oobsize;
1037 ops.oobbuf = c->oobbuf;
1038 ops.ooboffs = 0;
1039 ops.datbuf = NULL;
1040 ops.mode = MTD_OOB_PLACE;
1042 ret = c->mtd->read_oob(c->mtd, offset, &ops);
1043 if (ret) {
1044 D1 (printk(KERN_WARNING "jffs2_check_nand_cleanmarker(): "
1045 "Read OOB failed %d for block at %08x\n",
1046 ret, jeb->offset));
1047 return ret;
1050 if (ops.retlen < ops.len) {
1051 D1 (printk (KERN_WARNING "jffs2_check_nand_cleanmarker(): "
1052 "Read OOB return short read (%zd bytes not %d) "
1053 "for block at %08x\n", ops.retlen, ops.len,
1054 jeb->offset));
1055 return -EIO;
1058 n.magic = cpu_to_je16 (JFFS2_MAGIC_BITMASK);
1059 n.nodetype = cpu_to_je16 (JFFS2_NODETYPE_CLEANMARKER);
1060 n.totlen = cpu_to_je32 (8);
1061 p = (unsigned char *) &n;
1062 b = c->oobbuf + c->fsdata_pos;
1064 for (i = c->fsdata_len; i; i--) {
1065 if (*b++ != *p++)
1066 ret = 1;
1069 D1(if (ret == 1) {
1070 printk(KERN_WARNING "jffs2_check_nand_cleanmarker(): "
1071 "Cleanmarker node not detected in block at %08x\n",
1072 offset);
1073 printk(KERN_WARNING "OOB at %08zx was ", offset);
1074 for (i=0; i < oobsize; i++)
1075 printk("%02x ", c->oobbuf[i]);
1076 printk("\n");
1077 });
1078 return ret;
1081 int jffs2_write_nand_cleanmarker(struct jffs2_sb_info *c,
1082 struct jffs2_eraseblock *jeb)
1084 struct jffs2_unknown_node n;
1085 int ret;
1086 struct mtd_oob_ops ops;
1088 n.magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
1089 n.nodetype = cpu_to_je16(JFFS2_NODETYPE_CLEANMARKER);
1090 n.totlen = cpu_to_je32(8);
1092 ops.len = c->fsdata_len;
1093 ops.ooblen = c->fsdata_len;;
1094 ops.oobbuf = (uint8_t *)&n;
1095 ops.ooboffs = c->fsdata_pos;
1096 ops.datbuf = NULL;
1097 ops.mode = MTD_OOB_PLACE;
1099 ret = c->mtd->write_oob(c->mtd, jeb->offset, &ops);
1101 if (ret) {
1102 D1(printk(KERN_WARNING "jffs2_write_nand_cleanmarker(): "
1103 "Write failed for block at %08x: error %d\n",
1104 jeb->offset, ret));
1105 return ret;
1107 if (ops.retlen != ops.len) {
1108 D1(printk(KERN_WARNING "jffs2_write_nand_cleanmarker(): "
1109 "Short write for block at %08x: %zd not %d\n",
1110 jeb->offset, ops.retlen, ops.len));
1111 return -EIO;
1113 return 0;
1116 /*
1117 * On NAND we try to mark this block bad. If the block was erased more
1118 * than MAX_ERASE_FAILURES we mark it finaly bad.
1119 * Don't care about failures. This block remains on the erase-pending
1120 * or badblock list as long as nobody manipulates the flash with
1121 * a bootloader or something like that.
1122 */
1124 int jffs2_write_nand_badblock(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, uint32_t bad_offset)
1126 int ret;
1128 /* if the count is < max, we try to write the counter to the 2nd page oob area */
1129 if( ++jeb->bad_count < MAX_ERASE_FAILURES)
1130 return 0;
1132 if (!c->mtd->block_markbad)
1133 return 1; // What else can we do?
1135 D1(printk(KERN_WARNING "jffs2_write_nand_badblock(): Marking bad block at %08x\n", bad_offset));
1136 ret = c->mtd->block_markbad(c->mtd, bad_offset);
1138 if (ret) {
1139 D1(printk(KERN_WARNING "jffs2_write_nand_badblock(): Write failed for block at %08x: error %d\n", jeb->offset, ret));
1140 return ret;
1142 return 1;
1145 static int jffs2_nand_set_oobinfo(struct jffs2_sb_info *c)
1147 struct nand_ecclayout *oinfo = c->mtd->ecclayout;
1149 /* Do this only, if we have an oob buffer */
1150 if (!c->mtd->oobsize)
1151 return 0;
1153 /* Cleanmarker is out-of-band, so inline size zero */
1154 c->cleanmarker_size = 0;
1156 /* Should we use autoplacement ? */
1157 if (!oinfo) {
1158 D1(printk(KERN_DEBUG "JFFS2 on NAND. No autoplacment info found\n"));
1159 return -EINVAL;
1162 D1(printk(KERN_DEBUG "JFFS2 using autoplace on NAND\n"));
1163 /* Get the position of the free bytes */
1164 if (!oinfo->oobfree[0].length) {
1165 printk (KERN_WARNING "jffs2_nand_set_oobinfo(): Eeep."
1166 " Autoplacement selected and no empty space in oob\n");
1167 return -ENOSPC;
1169 c->fsdata_pos = oinfo->oobfree[0].offset;
1170 c->fsdata_len = oinfo->oobfree[0].length;
1171 if (c->fsdata_len > 8)
1172 c->fsdata_len = 8;
1174 return 0;
1177 int jffs2_nand_flash_setup(struct jffs2_sb_info *c)
1179 int res;
1181 /* Initialise write buffer */
1182 init_rwsem(&c->wbuf_sem);
1183 c->wbuf_pagesize = c->mtd->writesize;
1184 c->wbuf_ofs = 0xFFFFFFFF;
1186 c->wbuf = kmalloc(c->wbuf_pagesize, GFP_KERNEL);
1187 if (!c->wbuf)
1188 return -ENOMEM;
1190 c->oobbuf = kmalloc(NR_OOB_SCAN_PAGES * c->mtd->oobsize, GFP_KERNEL);
1191 if (!c->oobbuf)
1192 return -ENOMEM;
1194 res = jffs2_nand_set_oobinfo(c);
1196 #ifdef BREAKME
1197 if (!brokenbuf)
1198 brokenbuf = kmalloc(c->wbuf_pagesize, GFP_KERNEL);
1199 if (!brokenbuf) {
1200 kfree(c->wbuf);
1201 return -ENOMEM;
1203 memset(brokenbuf, 0xdb, c->wbuf_pagesize);
1204 #endif
1205 return res;
1208 void jffs2_nand_flash_cleanup(struct jffs2_sb_info *c)
1210 kfree(c->wbuf);
1211 kfree(c->oobbuf);
1214 int jffs2_dataflash_setup(struct jffs2_sb_info *c) {
1215 c->cleanmarker_size = 0; /* No cleanmarkers needed */
1217 /* Initialize write buffer */
1218 init_rwsem(&c->wbuf_sem);
1221 c->wbuf_pagesize = c->mtd->erasesize;
1223 /* Find a suitable c->sector_size
1224 * - Not too much sectors
1225 * - Sectors have to be at least 4 K + some bytes
1226 * - All known dataflashes have erase sizes of 528 or 1056
1227 * - we take at least 8 eraseblocks and want to have at least 8K size
1228 * - The concatenation should be a power of 2
1229 */
1231 c->sector_size = 8 * c->mtd->erasesize;
1233 while (c->sector_size < 8192) {
1234 c->sector_size *= 2;
1237 /* It may be necessary to adjust the flash size */
1238 c->flash_size = c->mtd->size;
1240 if ((c->flash_size % c->sector_size) != 0) {
1241 c->flash_size = (c->flash_size / c->sector_size) * c->sector_size;
1242 printk(KERN_WARNING "JFFS2 flash size adjusted to %dKiB\n", c->flash_size);
1243 };
1245 c->wbuf_ofs = 0xFFFFFFFF;
1246 c->wbuf = kmalloc(c->wbuf_pagesize, GFP_KERNEL);
1247 if (!c->wbuf)
1248 return -ENOMEM;
1250 printk(KERN_INFO "JFFS2 write-buffering enabled buffer (%d) erasesize (%d)\n", c->wbuf_pagesize, c->sector_size);
1252 return 0;
1255 void jffs2_dataflash_cleanup(struct jffs2_sb_info *c) {
1256 kfree(c->wbuf);
1259 int jffs2_nor_wbuf_flash_setup(struct jffs2_sb_info *c) {
1260 /* Cleanmarker currently occupies whole programming regions,
1261 * either one or 2 for 8Byte STMicro flashes. */
1262 c->cleanmarker_size = max(16u, c->mtd->writesize);
1264 /* Initialize write buffer */
1265 init_rwsem(&c->wbuf_sem);
1266 c->wbuf_pagesize = c->mtd->writesize;
1267 c->wbuf_ofs = 0xFFFFFFFF;
1269 c->wbuf = kmalloc(c->wbuf_pagesize, GFP_KERNEL);
1270 if (!c->wbuf)
1271 return -ENOMEM;
1273 return 0;
1276 void jffs2_nor_wbuf_flash_cleanup(struct jffs2_sb_info *c) {
1277 kfree(c->wbuf);