]> pilppa.org Git - linux-2.6-omap-h63xx.git/blob - fs/jffs2/wbuf.c
Merge master.kernel.org:/pub/scm/linux/kernel/git/jejb/scsi-misc-2.6
[linux-2.6-omap-h63xx.git] / fs / jffs2 / wbuf.c
1 /*
2  * JFFS2 -- Journalling Flash File System, Version 2.
3  *
4  * Copyright © 2001-2007 Red Hat, Inc.
5  * Copyright © 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  */
13
14 #include <linux/kernel.h>
15 #include <linux/slab.h>
16 #include <linux/mtd/mtd.h>
17 #include <linux/crc32.h>
18 #include <linux/mtd/nand.h>
19 #include <linux/jiffies.h>
20 #include <linux/sched.h>
21
22 #include "nodelist.h"
23
24 /* For testing write failures */
25 #undef BREAKME
26 #undef BREAKMEHEADER
27
28 #ifdef BREAKME
29 static unsigned char *brokenbuf;
30 #endif
31
32 #define PAGE_DIV(x) ( ((unsigned long)(x) / (unsigned long)(c->wbuf_pagesize)) * (unsigned long)(c->wbuf_pagesize) )
33 #define PAGE_MOD(x) ( (unsigned long)(x) % (unsigned long)(c->wbuf_pagesize) )
34
35 /* max. erase failures before we mark a block bad */
36 #define MAX_ERASE_FAILURES      2
37
38 struct jffs2_inodirty {
39         uint32_t ino;
40         struct jffs2_inodirty *next;
41 };
42
43 static struct jffs2_inodirty inodirty_nomem;
44
45 static int jffs2_wbuf_pending_for_ino(struct jffs2_sb_info *c, uint32_t ino)
46 {
47         struct jffs2_inodirty *this = c->wbuf_inodes;
48
49         /* If a malloc failed, consider _everything_ dirty */
50         if (this == &inodirty_nomem)
51                 return 1;
52
53         /* If ino == 0, _any_ non-GC writes mean 'yes' */
54         if (this && !ino)
55                 return 1;
56
57         /* Look to see if the inode in question is pending in the wbuf */
58         while (this) {
59                 if (this->ino == ino)
60                         return 1;
61                 this = this->next;
62         }
63         return 0;
64 }
65
66 static void jffs2_clear_wbuf_ino_list(struct jffs2_sb_info *c)
67 {
68         struct jffs2_inodirty *this;
69
70         this = c->wbuf_inodes;
71
72         if (this != &inodirty_nomem) {
73                 while (this) {
74                         struct jffs2_inodirty *next = this->next;
75                         kfree(this);
76                         this = next;
77                 }
78         }
79         c->wbuf_inodes = NULL;
80 }
81
82 static void jffs2_wbuf_dirties_inode(struct jffs2_sb_info *c, uint32_t ino)
83 {
84         struct jffs2_inodirty *new;
85
86         /* Mark the superblock dirty so that kupdated will flush... */
87         jffs2_erase_pending_trigger(c);
88
89         if (jffs2_wbuf_pending_for_ino(c, ino))
90                 return;
91
92         new = kmalloc(sizeof(*new), GFP_KERNEL);
93         if (!new) {
94                 D1(printk(KERN_DEBUG "No memory to allocate inodirty. Fallback to all considered dirty\n"));
95                 jffs2_clear_wbuf_ino_list(c);
96                 c->wbuf_inodes = &inodirty_nomem;
97                 return;
98         }
99         new->ino = ino;
100         new->next = c->wbuf_inodes;
101         c->wbuf_inodes = new;
102         return;
103 }
104
105 static inline void jffs2_refile_wbuf_blocks(struct jffs2_sb_info *c)
106 {
107         struct list_head *this, *next;
108         static int n;
109
110         if (list_empty(&c->erasable_pending_wbuf_list))
111                 return;
112
113         list_for_each_safe(this, next, &c->erasable_pending_wbuf_list) {
114                 struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list);
115
116                 D1(printk(KERN_DEBUG "Removing eraseblock at 0x%08x from erasable_pending_wbuf_list...\n", jeb->offset));
117                 list_del(this);
118                 if ((jiffies + (n++)) & 127) {
119                         /* Most of the time, we just erase it immediately. Otherwise we
120                            spend ages scanning it on mount, etc. */
121                         D1(printk(KERN_DEBUG "...and adding to erase_pending_list\n"));
122                         list_add_tail(&jeb->list, &c->erase_pending_list);
123                         c->nr_erasing_blocks++;
124                         jffs2_erase_pending_trigger(c);
125                 } else {
126                         /* Sometimes, however, we leave it elsewhere so it doesn't get
127                            immediately reused, and we spread the load a bit. */
128                         D1(printk(KERN_DEBUG "...and adding to erasable_list\n"));
129                         list_add_tail(&jeb->list, &c->erasable_list);
130                 }
131         }
132 }
133
134 #define REFILE_NOTEMPTY 0
135 #define REFILE_ANYWAY   1
136
137 static void jffs2_block_refile(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, int allow_empty)
138 {
139         D1(printk("About to refile bad block at %08x\n", jeb->offset));
140
141         /* File the existing block on the bad_used_list.... */
142         if (c->nextblock == jeb)
143                 c->nextblock = NULL;
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);
149         } else {
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);
156         }
157
158         if (!jffs2_prealloc_raw_node_refs(c, jeb, 1)) {
159                 uint32_t oldfree = jeb->free_size;
160
161                 jffs2_link_node_ref(c, jeb, 
162                                     (jeb->offset+c->sector_size-oldfree) | REF_OBSOLETE,
163                                     oldfree, NULL);
164                 /* convert to wasted */
165                 c->wasted_size += oldfree;
166                 jeb->wasted_size += oldfree;
167                 c->dirty_size -= oldfree;
168                 jeb->dirty_size -= oldfree;
169         }
170
171         jffs2_dbg_dump_block_lists_nolock(c);
172         jffs2_dbg_acct_sanity_check_nolock(c,jeb);
173         jffs2_dbg_acct_paranoia_check_nolock(c, jeb);
174 }
175
176 static struct jffs2_raw_node_ref **jffs2_incore_replace_raw(struct jffs2_sb_info *c,
177                                                             struct jffs2_inode_info *f,
178                                                             struct jffs2_raw_node_ref *raw,
179                                                             union jffs2_node_union *node)
180 {
181         struct jffs2_node_frag *frag;
182         struct jffs2_full_dirent *fd;
183
184         dbg_noderef("incore_replace_raw: node at %p is {%04x,%04x}\n",
185                     node, je16_to_cpu(node->u.magic), je16_to_cpu(node->u.nodetype));
186
187         BUG_ON(je16_to_cpu(node->u.magic) != 0x1985 &&
188                je16_to_cpu(node->u.magic) != 0);
189
190         switch (je16_to_cpu(node->u.nodetype)) {
191         case JFFS2_NODETYPE_INODE:
192                 if (f->metadata && f->metadata->raw == raw) {
193                         dbg_noderef("Will replace ->raw in f->metadata at %p\n", f->metadata);
194                         return &f->metadata->raw;
195                 }
196                 frag = jffs2_lookup_node_frag(&f->fragtree, je32_to_cpu(node->i.offset));
197                 BUG_ON(!frag);
198                 /* Find a frag which refers to the full_dnode we want to modify */
199                 while (!frag->node || frag->node->raw != raw) {
200                         frag = frag_next(frag);
201                         BUG_ON(!frag);
202                 }
203                 dbg_noderef("Will replace ->raw in full_dnode at %p\n", frag->node);
204                 return &frag->node->raw;
205
206         case JFFS2_NODETYPE_DIRENT:
207                 for (fd = f->dents; fd; fd = fd->next) {
208                         if (fd->raw == raw) {
209                                 dbg_noderef("Will replace ->raw in full_dirent at %p\n", fd);
210                                 return &fd->raw;
211                         }
212                 }
213                 BUG();
214
215         default:
216                 dbg_noderef("Don't care about replacing raw for nodetype %x\n",
217                             je16_to_cpu(node->u.nodetype));
218                 break;
219         }
220         return NULL;
221 }
222
223 /* Recover from failure to write wbuf. Recover the nodes up to the
224  * wbuf, not the one which we were starting to try to write. */
225
226 static void jffs2_wbuf_recover(struct jffs2_sb_info *c)
227 {
228         struct jffs2_eraseblock *jeb, *new_jeb;
229         struct jffs2_raw_node_ref *raw, *next, *first_raw = NULL;
230         size_t retlen;
231         int ret;
232         int nr_refile = 0;
233         unsigned char *buf;
234         uint32_t start, end, ofs, len;
235
236         jeb = &c->blocks[c->wbuf_ofs / c->sector_size];
237
238         spin_lock(&c->erase_completion_lock);
239         if (c->wbuf_ofs % c->mtd->erasesize)
240                 jffs2_block_refile(c, jeb, REFILE_NOTEMPTY);
241         else
242                 jffs2_block_refile(c, jeb, REFILE_ANYWAY);
243         spin_unlock(&c->erase_completion_lock);
244
245         BUG_ON(!ref_obsolete(jeb->last_node));
246
247         /* Find the first node to be recovered, by skipping over every
248            node which ends before the wbuf starts, or which is obsolete. */
249         for (next = raw = jeb->first_node; next; raw = next) {
250                 next = ref_next(raw);
251
252                 if (ref_obsolete(raw) || 
253                     (next && ref_offset(next) <= c->wbuf_ofs)) {
254                         dbg_noderef("Skipping node at 0x%08x(%d)-0x%08x which is either before 0x%08x or obsolete\n",
255                                     ref_offset(raw), ref_flags(raw),
256                                     (ref_offset(raw) + ref_totlen(c, jeb, raw)),
257                                     c->wbuf_ofs);
258                         continue;
259                 }
260                 dbg_noderef("First node to be recovered is at 0x%08x(%d)-0x%08x\n",
261                             ref_offset(raw), ref_flags(raw),
262                             (ref_offset(raw) + ref_totlen(c, jeb, raw)));
263
264                 first_raw = raw;
265                 break;
266         }
267
268         if (!first_raw) {
269                 /* All nodes were obsolete. Nothing to recover. */
270                 D1(printk(KERN_DEBUG "No non-obsolete nodes to be recovered. Just filing block bad\n"));
271                 c->wbuf_len = 0;
272                 return;
273         }
274
275         start = ref_offset(first_raw);
276         end = ref_offset(jeb->last_node);
277         nr_refile = 1;
278
279         /* Count the number of refs which need to be copied */
280         while ((raw = ref_next(raw)) != jeb->last_node)
281                 nr_refile++;
282
283         dbg_noderef("wbuf recover %08x-%08x (%d bytes in %d nodes)\n",
284                     start, end, end - start, nr_refile);
285
286         buf = NULL;
287         if (start < c->wbuf_ofs) {
288                 /* First affected node was already partially written.
289                  * Attempt to reread the old data into our buffer. */
290
291                 buf = kmalloc(end - start, GFP_KERNEL);
292                 if (!buf) {
293                         printk(KERN_CRIT "Malloc failure in wbuf recovery. Data loss ensues.\n");
294
295                         goto read_failed;
296                 }
297
298                 /* Do the read... */
299                 ret = c->mtd->read(c->mtd, start, c->wbuf_ofs - start, &retlen, buf);
300
301                 /* ECC recovered ? */
302                 if ((ret == -EUCLEAN || ret == -EBADMSG) &&
303                     (retlen == c->wbuf_ofs - start))
304                         ret = 0;
305
306                 if (ret || retlen != c->wbuf_ofs - start) {
307                         printk(KERN_CRIT "Old data are already lost in wbuf recovery. Data loss ensues.\n");
308
309                         kfree(buf);
310                         buf = NULL;
311                 read_failed:
312                         first_raw = ref_next(first_raw);
313                         nr_refile--;
314                         while (first_raw && ref_obsolete(first_raw)) {
315                                 first_raw = ref_next(first_raw);
316                                 nr_refile--;
317                         }
318
319                         /* If this was the only node to be recovered, give up */
320                         if (!first_raw) {
321                                 c->wbuf_len = 0;
322                                 return;
323                         }
324
325                         /* It wasn't. Go on and try to recover nodes complete in the wbuf */
326                         start = ref_offset(first_raw);
327                         dbg_noderef("wbuf now recover %08x-%08x (%d bytes in %d nodes)\n",
328                                     start, end, end - start, nr_refile);
329
330                 } else {
331                         /* Read succeeded. Copy the remaining data from the wbuf */
332                         memcpy(buf + (c->wbuf_ofs - start), c->wbuf, end - c->wbuf_ofs);
333                 }
334         }
335         /* OK... we're to rewrite (end-start) bytes of data from first_raw onwards.
336            Either 'buf' contains the data, or we find it in the wbuf */
337
338         /* ... and get an allocation of space from a shiny new block instead */
339         ret = jffs2_reserve_space_gc(c, end-start, &len, JFFS2_SUMMARY_NOSUM_SIZE);
340         if (ret) {
341                 printk(KERN_WARNING "Failed to allocate space for wbuf recovery. Data loss ensues.\n");
342                 kfree(buf);
343                 return;
344         }
345
346         /* The summary is not recovered, so it must be disabled for this erase block */
347         jffs2_sum_disable_collecting(c->summary);
348
349         ret = jffs2_prealloc_raw_node_refs(c, c->nextblock, nr_refile);
350         if (ret) {
351                 printk(KERN_WARNING "Failed to allocate node refs for wbuf recovery. Data loss ensues.\n");
352                 kfree(buf);
353                 return;
354         }
355
356         ofs = write_ofs(c);
357
358         if (end-start >= c->wbuf_pagesize) {
359                 /* Need to do another write immediately, but it's possible
360                    that this is just because the wbuf itself is completely
361                    full, and there's nothing earlier read back from the
362                    flash. Hence 'buf' isn't necessarily what we're writing
363                    from. */
364                 unsigned char *rewrite_buf = buf?:c->wbuf;
365                 uint32_t towrite = (end-start) - ((end-start)%c->wbuf_pagesize);
366
367                 D1(printk(KERN_DEBUG "Write 0x%x bytes at 0x%08x in wbuf recover\n",
368                           towrite, ofs));
369
370 #ifdef BREAKMEHEADER
371                 static int breakme;
372                 if (breakme++ == 20) {
373                         printk(KERN_NOTICE "Faking write error at 0x%08x\n", ofs);
374                         breakme = 0;
375                         c->mtd->write(c->mtd, ofs, towrite, &retlen,
376                                       brokenbuf);
377                         ret = -EIO;
378                 } else
379 #endif
380                         ret = c->mtd->write(c->mtd, ofs, towrite, &retlen,
381                                             rewrite_buf);
382
383                 if (ret || retlen != towrite) {
384                         /* Argh. We tried. Really we did. */
385                         printk(KERN_CRIT "Recovery of wbuf failed due to a second write error\n");
386                         kfree(buf);
387
388                         if (retlen)
389                                 jffs2_add_physical_node_ref(c, ofs | REF_OBSOLETE, ref_totlen(c, jeb, first_raw), NULL);
390
391                         return;
392                 }
393                 printk(KERN_NOTICE "Recovery of wbuf succeeded to %08x\n", ofs);
394
395                 c->wbuf_len = (end - start) - towrite;
396                 c->wbuf_ofs = ofs + towrite;
397                 memmove(c->wbuf, rewrite_buf + towrite, c->wbuf_len);
398                 /* Don't muck about with c->wbuf_inodes. False positives are harmless. */
399         } else {
400                 /* OK, now we're left with the dregs in whichever buffer we're using */
401                 if (buf) {
402                         memcpy(c->wbuf, buf, end-start);
403                 } else {
404                         memmove(c->wbuf, c->wbuf + (start - c->wbuf_ofs), end - start);
405                 }
406                 c->wbuf_ofs = ofs;
407                 c->wbuf_len = end - start;
408         }
409
410         /* Now sort out the jffs2_raw_node_refs, moving them from the old to the next block */
411         new_jeb = &c->blocks[ofs / c->sector_size];
412
413         spin_lock(&c->erase_completion_lock);
414         for (raw = first_raw; raw != jeb->last_node; raw = ref_next(raw)) {
415                 uint32_t rawlen = ref_totlen(c, jeb, raw);
416                 struct jffs2_inode_cache *ic;
417                 struct jffs2_raw_node_ref *new_ref;
418                 struct jffs2_raw_node_ref **adjust_ref = NULL;
419                 struct jffs2_inode_info *f = NULL;
420
421                 D1(printk(KERN_DEBUG "Refiling block of %08x at %08x(%d) to %08x\n",
422                           rawlen, ref_offset(raw), ref_flags(raw), ofs));
423
424                 ic = jffs2_raw_ref_to_ic(raw);
425
426                 /* Ick. This XATTR mess should be fixed shortly... */
427                 if (ic && ic->class == RAWNODE_CLASS_XATTR_DATUM) {
428                         struct jffs2_xattr_datum *xd = (void *)ic;
429                         BUG_ON(xd->node != raw);
430                         adjust_ref = &xd->node;
431                         raw->next_in_ino = NULL;
432                         ic = NULL;
433                 } else if (ic && ic->class == RAWNODE_CLASS_XATTR_REF) {
434                         struct jffs2_xattr_datum *xr = (void *)ic;
435                         BUG_ON(xr->node != raw);
436                         adjust_ref = &xr->node;
437                         raw->next_in_ino = NULL;
438                         ic = NULL;
439                 } else if (ic && ic->class == RAWNODE_CLASS_INODE_CACHE) {
440                         struct jffs2_raw_node_ref **p = &ic->nodes;
441
442                         /* Remove the old node from the per-inode list */
443                         while (*p && *p != (void *)ic) {
444                                 if (*p == raw) {
445                                         (*p) = (raw->next_in_ino);
446                                         raw->next_in_ino = NULL;
447                                         break;
448                                 }
449                                 p = &((*p)->next_in_ino);
450                         }
451
452                         if (ic->state == INO_STATE_PRESENT && !ref_obsolete(raw)) {
453                                 /* If it's an in-core inode, then we have to adjust any
454                                    full_dirent or full_dnode structure to point to the
455                                    new version instead of the old */
456                                 f = jffs2_gc_fetch_inode(c, ic->ino, ic->nlink);
457                                 if (IS_ERR(f)) {
458                                         /* Should never happen; it _must_ be present */
459                                         JFFS2_ERROR("Failed to iget() ino #%u, err %ld\n",
460                                                     ic->ino, PTR_ERR(f));
461                                         BUG();
462                                 }
463                                 /* We don't lock f->sem. There's a number of ways we could
464                                    end up in here with it already being locked, and nobody's
465                                    going to modify it on us anyway because we hold the
466                                    alloc_sem. We're only changing one ->raw pointer too,
467                                    which we can get away with without upsetting readers. */
468                                 adjust_ref = jffs2_incore_replace_raw(c, f, raw,
469                                                                       (void *)(buf?:c->wbuf) + (ref_offset(raw) - start));
470                         } else if (unlikely(ic->state != INO_STATE_PRESENT &&
471                                             ic->state != INO_STATE_CHECKEDABSENT &&
472                                             ic->state != INO_STATE_GC)) {
473                                 JFFS2_ERROR("Inode #%u is in strange state %d!\n", ic->ino, ic->state);
474                                 BUG();
475                         }
476                 }
477
478                 new_ref = jffs2_link_node_ref(c, new_jeb, ofs | ref_flags(raw), rawlen, ic);
479
480                 if (adjust_ref) {
481                         BUG_ON(*adjust_ref != raw);
482                         *adjust_ref = new_ref;
483                 }
484                 if (f)
485                         jffs2_gc_release_inode(c, f);
486
487                 if (!ref_obsolete(raw)) {
488                         jeb->dirty_size += rawlen;
489                         jeb->used_size  -= rawlen;
490                         c->dirty_size += rawlen;
491                         c->used_size -= rawlen;
492                         raw->flash_offset = ref_offset(raw) | REF_OBSOLETE;
493                         BUG_ON(raw->next_in_ino);
494                 }
495                 ofs += rawlen;
496         }
497
498         kfree(buf);
499
500         /* Fix up the original jeb now it's on the bad_list */
501         if (first_raw == jeb->first_node) {
502                 D1(printk(KERN_DEBUG "Failing block at %08x is now empty. Moving to erase_pending_list\n", jeb->offset));
503                 list_move(&jeb->list, &c->erase_pending_list);
504                 c->nr_erasing_blocks++;
505                 jffs2_erase_pending_trigger(c);
506         }
507
508         jffs2_dbg_acct_sanity_check_nolock(c, jeb);
509         jffs2_dbg_acct_paranoia_check_nolock(c, jeb);
510
511         jffs2_dbg_acct_sanity_check_nolock(c, new_jeb);
512         jffs2_dbg_acct_paranoia_check_nolock(c, new_jeb);
513
514         spin_unlock(&c->erase_completion_lock);
515
516         D1(printk(KERN_DEBUG "wbuf recovery completed OK. wbuf_ofs 0x%08x, len 0x%x\n", c->wbuf_ofs, c->wbuf_len));
517
518 }
519
520 /* Meaning of pad argument:
521    0: Do not pad. Probably pointless - we only ever use this when we can't pad anyway.
522    1: Pad, do not adjust nextblock free_size
523    2: Pad, adjust nextblock free_size
524 */
525 #define NOPAD           0
526 #define PAD_NOACCOUNT   1
527 #define PAD_ACCOUNTING  2
528
529 static int __jffs2_flush_wbuf(struct jffs2_sb_info *c, int pad)
530 {
531         struct jffs2_eraseblock *wbuf_jeb;
532         int ret;
533         size_t retlen;
534
535         /* Nothing to do if not write-buffering the flash. In particular, we shouldn't
536            del_timer() the timer we never initialised. */
537         if (!jffs2_is_writebuffered(c))
538                 return 0;
539
540         if (!down_trylock(&c->alloc_sem)) {
541                 up(&c->alloc_sem);
542                 printk(KERN_CRIT "jffs2_flush_wbuf() called with alloc_sem not locked!\n");
543                 BUG();
544         }
545
546         if (!c->wbuf_len)       /* already checked c->wbuf above */
547                 return 0;
548
549         wbuf_jeb = &c->blocks[c->wbuf_ofs / c->sector_size];
550         if (jffs2_prealloc_raw_node_refs(c, wbuf_jeb, c->nextblock->allocated_refs + 1))
551                 return -ENOMEM;
552
553         /* claim remaining space on the page
554            this happens, if we have a change to a new block,
555            or if fsync forces us to flush the writebuffer.
556            if we have a switch to next page, we will not have
557            enough remaining space for this.
558         */
559         if (pad ) {
560                 c->wbuf_len = PAD(c->wbuf_len);
561
562                 /* Pad with JFFS2_DIRTY_BITMASK initially.  this helps out ECC'd NOR
563                    with 8 byte page size */
564                 memset(c->wbuf + c->wbuf_len, 0, c->wbuf_pagesize - c->wbuf_len);
565
566                 if ( c->wbuf_len + sizeof(struct jffs2_unknown_node) < c->wbuf_pagesize) {
567                         struct jffs2_unknown_node *padnode = (void *)(c->wbuf + c->wbuf_len);
568                         padnode->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
569                         padnode->nodetype = cpu_to_je16(JFFS2_NODETYPE_PADDING);
570                         padnode->totlen = cpu_to_je32(c->wbuf_pagesize - c->wbuf_len);
571                         padnode->hdr_crc = cpu_to_je32(crc32(0, padnode, sizeof(*padnode)-4));
572                 }
573         }
574         /* else jffs2_flash_writev has actually filled in the rest of the
575            buffer for us, and will deal with the node refs etc. later. */
576
577 #ifdef BREAKME
578         static int breakme;
579         if (breakme++ == 20) {
580                 printk(KERN_NOTICE "Faking write error at 0x%08x\n", c->wbuf_ofs);
581                 breakme = 0;
582                 c->mtd->write(c->mtd, c->wbuf_ofs, c->wbuf_pagesize, &retlen,
583                               brokenbuf);
584                 ret = -EIO;
585         } else
586 #endif
587
588                 ret = c->mtd->write(c->mtd, c->wbuf_ofs, c->wbuf_pagesize, &retlen, c->wbuf);
589
590         if (ret || retlen != c->wbuf_pagesize) {
591                 if (ret)
592                         printk(KERN_WARNING "jffs2_flush_wbuf(): Write failed with %d\n",ret);
593                 else {
594                         printk(KERN_WARNING "jffs2_flush_wbuf(): Write was short: %zd instead of %d\n",
595                                 retlen, c->wbuf_pagesize);
596                         ret = -EIO;
597                 }
598
599                 jffs2_wbuf_recover(c);
600
601                 return ret;
602         }
603
604         /* Adjust free size of the block if we padded. */
605         if (pad) {
606                 uint32_t waste = c->wbuf_pagesize - c->wbuf_len;
607
608                 D1(printk(KERN_DEBUG "jffs2_flush_wbuf() adjusting free_size of %sblock at %08x\n",
609                           (wbuf_jeb==c->nextblock)?"next":"", wbuf_jeb->offset));
610
611                 /* wbuf_pagesize - wbuf_len is the amount of space that's to be
612                    padded. If there is less free space in the block than that,
613                    something screwed up */
614                 if (wbuf_jeb->free_size < waste) {
615                         printk(KERN_CRIT "jffs2_flush_wbuf(): Accounting error. wbuf at 0x%08x has 0x%03x bytes, 0x%03x left.\n",
616                                c->wbuf_ofs, c->wbuf_len, waste);
617                         printk(KERN_CRIT "jffs2_flush_wbuf(): But free_size for block at 0x%08x is only 0x%08x\n",
618                                wbuf_jeb->offset, wbuf_jeb->free_size);
619                         BUG();
620                 }
621
622                 spin_lock(&c->erase_completion_lock);
623
624                 jffs2_link_node_ref(c, wbuf_jeb, (c->wbuf_ofs + c->wbuf_len) | REF_OBSOLETE, waste, NULL);
625                 /* FIXME: that made it count as dirty. Convert to wasted */
626                 wbuf_jeb->dirty_size -= waste;
627                 c->dirty_size -= waste;
628                 wbuf_jeb->wasted_size += waste;
629                 c->wasted_size += waste;
630         } else
631                 spin_lock(&c->erase_completion_lock);
632
633         /* Stick any now-obsoleted blocks on the erase_pending_list */
634         jffs2_refile_wbuf_blocks(c);
635         jffs2_clear_wbuf_ino_list(c);
636         spin_unlock(&c->erase_completion_lock);
637
638         memset(c->wbuf,0xff,c->wbuf_pagesize);
639         /* adjust write buffer offset, else we get a non contiguous write bug */
640         c->wbuf_ofs += c->wbuf_pagesize;
641         c->wbuf_len = 0;
642         return 0;
643 }
644
645 /* Trigger garbage collection to flush the write-buffer.
646    If ino arg is zero, do it if _any_ real (i.e. not GC) writes are
647    outstanding. If ino arg non-zero, do it only if a write for the
648    given inode is outstanding. */
649 int jffs2_flush_wbuf_gc(struct jffs2_sb_info *c, uint32_t ino)
650 {
651         uint32_t old_wbuf_ofs;
652         uint32_t old_wbuf_len;
653         int ret = 0;
654
655         D1(printk(KERN_DEBUG "jffs2_flush_wbuf_gc() called for ino #%u...\n", ino));
656
657         if (!c->wbuf)
658                 return 0;
659
660         down(&c->alloc_sem);
661         if (!jffs2_wbuf_pending_for_ino(c, ino)) {
662                 D1(printk(KERN_DEBUG "Ino #%d not pending in wbuf. Returning\n", ino));
663                 up(&c->alloc_sem);
664                 return 0;
665         }
666
667         old_wbuf_ofs = c->wbuf_ofs;
668         old_wbuf_len = c->wbuf_len;
669
670         if (c->unchecked_size) {
671                 /* GC won't make any progress for a while */
672                 D1(printk(KERN_DEBUG "jffs2_flush_wbuf_gc() padding. Not finished checking\n"));
673                 down_write(&c->wbuf_sem);
674                 ret = __jffs2_flush_wbuf(c, PAD_ACCOUNTING);
675                 /* retry flushing wbuf in case jffs2_wbuf_recover
676                    left some data in the wbuf */
677                 if (ret)
678                         ret = __jffs2_flush_wbuf(c, PAD_ACCOUNTING);
679                 up_write(&c->wbuf_sem);
680         } else while (old_wbuf_len &&
681                       old_wbuf_ofs == c->wbuf_ofs) {
682
683                 up(&c->alloc_sem);
684
685                 D1(printk(KERN_DEBUG "jffs2_flush_wbuf_gc() calls gc pass\n"));
686
687                 ret = jffs2_garbage_collect_pass(c);
688                 if (ret) {
689                         /* GC failed. Flush it with padding instead */
690                         down(&c->alloc_sem);
691                         down_write(&c->wbuf_sem);
692                         ret = __jffs2_flush_wbuf(c, PAD_ACCOUNTING);
693                         /* retry flushing wbuf in case jffs2_wbuf_recover
694                            left some data in the wbuf */
695                         if (ret)
696                                 ret = __jffs2_flush_wbuf(c, PAD_ACCOUNTING);
697                         up_write(&c->wbuf_sem);
698                         break;
699                 }
700                 down(&c->alloc_sem);
701         }
702
703         D1(printk(KERN_DEBUG "jffs2_flush_wbuf_gc() ends...\n"));
704
705         up(&c->alloc_sem);
706         return ret;
707 }
708
709 /* Pad write-buffer to end and write it, wasting space. */
710 int jffs2_flush_wbuf_pad(struct jffs2_sb_info *c)
711 {
712         int ret;
713
714         if (!c->wbuf)
715                 return 0;
716
717         down_write(&c->wbuf_sem);
718         ret = __jffs2_flush_wbuf(c, PAD_NOACCOUNT);
719         /* retry - maybe wbuf recover left some data in wbuf. */
720         if (ret)
721                 ret = __jffs2_flush_wbuf(c, PAD_NOACCOUNT);
722         up_write(&c->wbuf_sem);
723
724         return ret;
725 }
726
727 static size_t jffs2_fill_wbuf(struct jffs2_sb_info *c, const uint8_t *buf,
728                               size_t len)
729 {
730         if (len && !c->wbuf_len && (len >= c->wbuf_pagesize))
731                 return 0;
732
733         if (len > (c->wbuf_pagesize - c->wbuf_len))
734                 len = c->wbuf_pagesize - c->wbuf_len;
735         memcpy(c->wbuf + c->wbuf_len, buf, len);
736         c->wbuf_len += (uint32_t) len;
737         return len;
738 }
739
740 int jffs2_flash_writev(struct jffs2_sb_info *c, const struct kvec *invecs,
741                        unsigned long count, loff_t to, size_t *retlen,
742                        uint32_t ino)
743 {
744         struct jffs2_eraseblock *jeb;
745         size_t wbuf_retlen, donelen = 0;
746         uint32_t outvec_to = to;
747         int ret, invec;
748
749         /* If not writebuffered flash, don't bother */
750         if (!jffs2_is_writebuffered(c))
751                 return jffs2_flash_direct_writev(c, invecs, count, to, retlen);
752
753         down_write(&c->wbuf_sem);
754
755         /* If wbuf_ofs is not initialized, set it to target address */
756         if (c->wbuf_ofs == 0xFFFFFFFF) {
757                 c->wbuf_ofs = PAGE_DIV(to);
758                 c->wbuf_len = PAGE_MOD(to);
759                 memset(c->wbuf,0xff,c->wbuf_pagesize);
760         }
761
762         /*
763          * Sanity checks on target address.  It's permitted to write
764          * at PAD(c->wbuf_len+c->wbuf_ofs), and it's permitted to
765          * write at the beginning of a new erase block. Anything else,
766          * and you die.  New block starts at xxx000c (0-b = block
767          * header)
768          */
769         if (SECTOR_ADDR(to) != SECTOR_ADDR(c->wbuf_ofs)) {
770                 /* It's a write to a new block */
771                 if (c->wbuf_len) {
772                         D1(printk(KERN_DEBUG "jffs2_flash_writev() to 0x%lx "
773                                   "causes flush of wbuf at 0x%08x\n",
774                                   (unsigned long)to, c->wbuf_ofs));
775                         ret = __jffs2_flush_wbuf(c, PAD_NOACCOUNT);
776                         if (ret)
777                                 goto outerr;
778                 }
779                 /* set pointer to new block */
780                 c->wbuf_ofs = PAGE_DIV(to);
781                 c->wbuf_len = PAGE_MOD(to);
782         }
783
784         if (to != PAD(c->wbuf_ofs + c->wbuf_len)) {
785                 /* We're not writing immediately after the writebuffer. Bad. */
786                 printk(KERN_CRIT "jffs2_flash_writev(): Non-contiguous write "
787                        "to %08lx\n", (unsigned long)to);
788                 if (c->wbuf_len)
789                         printk(KERN_CRIT "wbuf was previously %08x-%08x\n",
790                                c->wbuf_ofs, c->wbuf_ofs+c->wbuf_len);
791                 BUG();
792         }
793
794         /* adjust alignment offset */
795         if (c->wbuf_len != PAGE_MOD(to)) {
796                 c->wbuf_len = PAGE_MOD(to);
797                 /* take care of alignment to next page */
798                 if (!c->wbuf_len) {
799                         c->wbuf_len = c->wbuf_pagesize;
800                         ret = __jffs2_flush_wbuf(c, NOPAD);
801                         if (ret)
802                                 goto outerr;
803                 }
804         }
805
806         for (invec = 0; invec < count; invec++) {
807                 int vlen = invecs[invec].iov_len;
808                 uint8_t *v = invecs[invec].iov_base;
809
810                 wbuf_retlen = jffs2_fill_wbuf(c, v, vlen);
811
812                 if (c->wbuf_len == c->wbuf_pagesize) {
813                         ret = __jffs2_flush_wbuf(c, NOPAD);
814                         if (ret)
815                                 goto outerr;
816                 }
817                 vlen -= wbuf_retlen;
818                 outvec_to += wbuf_retlen;
819                 donelen += wbuf_retlen;
820                 v += wbuf_retlen;
821
822                 if (vlen >= c->wbuf_pagesize) {
823                         ret = c->mtd->write(c->mtd, outvec_to, PAGE_DIV(vlen),
824                                             &wbuf_retlen, v);
825                         if (ret < 0 || wbuf_retlen != PAGE_DIV(vlen))
826                                 goto outfile;
827
828                         vlen -= wbuf_retlen;
829                         outvec_to += wbuf_retlen;
830                         c->wbuf_ofs = outvec_to;
831                         donelen += wbuf_retlen;
832                         v += wbuf_retlen;
833                 }
834
835                 wbuf_retlen = jffs2_fill_wbuf(c, v, vlen);
836                 if (c->wbuf_len == c->wbuf_pagesize) {
837                         ret = __jffs2_flush_wbuf(c, NOPAD);
838                         if (ret)
839                                 goto outerr;
840                 }
841
842                 outvec_to += wbuf_retlen;
843                 donelen += wbuf_retlen;
844         }
845
846         /*
847          * If there's a remainder in the wbuf and it's a non-GC write,
848          * remember that the wbuf affects this ino
849          */
850         *retlen = donelen;
851
852         if (jffs2_sum_active()) {
853                 int res = jffs2_sum_add_kvec(c, invecs, count, (uint32_t) to);
854                 if (res)
855                         return res;
856         }
857
858         if (c->wbuf_len && ino)
859                 jffs2_wbuf_dirties_inode(c, ino);
860
861         ret = 0;
862         up_write(&c->wbuf_sem);
863         return ret;
864
865 outfile:
866         /*
867          * At this point we have no problem, c->wbuf is empty. However
868          * refile nextblock to avoid writing again to same address.
869          */
870
871         spin_lock(&c->erase_completion_lock);
872
873         jeb = &c->blocks[outvec_to / c->sector_size];
874         jffs2_block_refile(c, jeb, REFILE_ANYWAY);
875
876         spin_unlock(&c->erase_completion_lock);
877
878 outerr:
879         *retlen = 0;
880         up_write(&c->wbuf_sem);
881         return ret;
882 }
883
884 /*
885  *      This is the entry for flash write.
886  *      Check, if we work on NAND FLASH, if so build an kvec and write it via vritev
887 */
888 int jffs2_flash_write(struct jffs2_sb_info *c, loff_t ofs, size_t len,
889                       size_t *retlen, const u_char *buf)
890 {
891         struct kvec vecs[1];
892
893         if (!jffs2_is_writebuffered(c))
894                 return jffs2_flash_direct_write(c, ofs, len, retlen, buf);
895
896         vecs[0].iov_base = (unsigned char *) buf;
897         vecs[0].iov_len = len;
898         return jffs2_flash_writev(c, vecs, 1, ofs, retlen, 0);
899 }
900
901 /*
902         Handle readback from writebuffer and ECC failure return
903 */
904 int jffs2_flash_read(struct jffs2_sb_info *c, loff_t ofs, size_t len, size_t *retlen, u_char *buf)
905 {
906         loff_t  orbf = 0, owbf = 0, lwbf = 0;
907         int     ret;
908
909         if (!jffs2_is_writebuffered(c))
910                 return c->mtd->read(c->mtd, ofs, len, retlen, buf);
911
912         /* Read flash */
913         down_read(&c->wbuf_sem);
914         ret = c->mtd->read(c->mtd, ofs, len, retlen, buf);
915
916         if ( (ret == -EBADMSG || ret == -EUCLEAN) && (*retlen == len) ) {
917                 if (ret == -EBADMSG)
918                         printk(KERN_WARNING "mtd->read(0x%zx bytes from 0x%llx)"
919                                " returned ECC error\n", len, ofs);
920                 /*
921                  * We have the raw data without ECC correction in the buffer,
922                  * maybe we are lucky and all data or parts are correct. We
923                  * check the node.  If data are corrupted node check will sort
924                  * it out.  We keep this block, it will fail on write or erase
925                  * and the we mark it bad. Or should we do that now? But we
926                  * should give him a chance.  Maybe we had a system crash or
927                  * power loss before the ecc write or a erase was completed.
928                  * So we return success. :)
929                  */
930                 ret = 0;
931         }
932
933         /* if no writebuffer available or write buffer empty, return */
934         if (!c->wbuf_pagesize || !c->wbuf_len)
935                 goto exit;
936
937         /* if we read in a different block, return */
938         if (SECTOR_ADDR(ofs) != SECTOR_ADDR(c->wbuf_ofs))
939                 goto exit;
940
941         if (ofs >= c->wbuf_ofs) {
942                 owbf = (ofs - c->wbuf_ofs);     /* offset in write buffer */
943                 if (owbf > c->wbuf_len)         /* is read beyond write buffer ? */
944                         goto exit;
945                 lwbf = c->wbuf_len - owbf;      /* number of bytes to copy */
946                 if (lwbf > len)
947                         lwbf = len;
948         } else {
949                 orbf = (c->wbuf_ofs - ofs);     /* offset in read buffer */
950                 if (orbf > len)                 /* is write beyond write buffer ? */
951                         goto exit;
952                 lwbf = len - orbf;              /* number of bytes to copy */
953                 if (lwbf > c->wbuf_len)
954                         lwbf = c->wbuf_len;
955         }
956         if (lwbf > 0)
957                 memcpy(buf+orbf,c->wbuf+owbf,lwbf);
958
959 exit:
960         up_read(&c->wbuf_sem);
961         return ret;
962 }
963
964 #define NR_OOB_SCAN_PAGES 4
965
966 /* For historical reasons we use only 12 bytes for OOB clean marker */
967 #define OOB_CM_SIZE 12
968
969 static const struct jffs2_unknown_node oob_cleanmarker =
970 {
971         .magic = constant_cpu_to_je16(JFFS2_MAGIC_BITMASK),
972         .nodetype = constant_cpu_to_je16(JFFS2_NODETYPE_CLEANMARKER),
973         .totlen = constant_cpu_to_je32(8)
974 };
975
976 /*
977  * Check, if the out of band area is empty. This function knows about the clean
978  * marker and if it is present in OOB, treats the OOB as empty anyway.
979  */
980 int jffs2_check_oob_empty(struct jffs2_sb_info *c,
981                           struct jffs2_eraseblock *jeb, int mode)
982 {
983         int i, ret;
984         int cmlen = min_t(int, c->oobavail, OOB_CM_SIZE);
985         struct mtd_oob_ops ops;
986
987         ops.mode = MTD_OOB_AUTO;
988         ops.ooblen = NR_OOB_SCAN_PAGES * c->oobavail;
989         ops.oobbuf = c->oobbuf;
990         ops.len = ops.ooboffs = ops.retlen = ops.oobretlen = 0;
991         ops.datbuf = NULL;
992
993         ret = c->mtd->read_oob(c->mtd, jeb->offset, &ops);
994         if (ret || ops.oobretlen != ops.ooblen) {
995                 printk(KERN_ERR "cannot read OOB for EB at %08x, requested %zd"
996                                 " bytes, read %zd bytes, error %d\n",
997                                 jeb->offset, ops.ooblen, ops.oobretlen, ret);
998                 if (!ret)
999                         ret = -EIO;
1000                 return ret;
1001         }
1002
1003         for(i = 0; i < ops.ooblen; i++) {
1004                 if (mode && i < cmlen)
1005                         /* Yeah, we know about the cleanmarker */
1006                         continue;
1007
1008                 if (ops.oobbuf[i] != 0xFF) {
1009                         D2(printk(KERN_DEBUG "Found %02x at %x in OOB for "
1010                                   "%08x\n", ops.oobbuf[i], i, jeb->offset));
1011                         return 1;
1012                 }
1013         }
1014
1015         return 0;
1016 }
1017
1018 /*
1019  * Check for a valid cleanmarker.
1020  * Returns: 0 if a valid cleanmarker was found
1021  *          1 if no cleanmarker was found
1022  *          negative error code if an error occurred
1023  */
1024 int jffs2_check_nand_cleanmarker(struct jffs2_sb_info *c,
1025                                  struct jffs2_eraseblock *jeb)
1026 {
1027         struct mtd_oob_ops ops;
1028         int ret, cmlen = min_t(int, c->oobavail, OOB_CM_SIZE);
1029
1030         ops.mode = MTD_OOB_AUTO;
1031         ops.ooblen = cmlen;
1032         ops.oobbuf = c->oobbuf;
1033         ops.len = ops.ooboffs = ops.retlen = ops.oobretlen = 0;
1034         ops.datbuf = NULL;
1035
1036         ret = c->mtd->read_oob(c->mtd, jeb->offset, &ops);
1037         if (ret || ops.oobretlen != ops.ooblen) {
1038                 printk(KERN_ERR "cannot read OOB for EB at %08x, requested %zd"
1039                                 " bytes, read %zd bytes, error %d\n",
1040                                 jeb->offset, ops.ooblen, ops.oobretlen, ret);
1041                 if (!ret)
1042                         ret = -EIO;
1043                 return ret;
1044         }
1045
1046         return !!memcmp(&oob_cleanmarker, c->oobbuf, cmlen);
1047 }
1048
1049 int jffs2_write_nand_cleanmarker(struct jffs2_sb_info *c,
1050                                  struct jffs2_eraseblock *jeb)
1051 {
1052         int ret;
1053         struct mtd_oob_ops ops;
1054         int cmlen = min_t(int, c->oobavail, OOB_CM_SIZE);
1055
1056         ops.mode = MTD_OOB_AUTO;
1057         ops.ooblen = cmlen;
1058         ops.oobbuf = (uint8_t *)&oob_cleanmarker;
1059         ops.len = ops.ooboffs = ops.retlen = ops.oobretlen = 0;
1060         ops.datbuf = NULL;
1061
1062         ret = c->mtd->write_oob(c->mtd, jeb->offset, &ops);
1063         if (ret || ops.oobretlen != ops.ooblen) {
1064                 printk(KERN_ERR "cannot write OOB for EB at %08x, requested %zd"
1065                                 " bytes, read %zd bytes, error %d\n",
1066                                 jeb->offset, ops.ooblen, ops.oobretlen, ret);
1067                 if (!ret)
1068                         ret = -EIO;
1069                 return ret;
1070         }
1071
1072         return 0;
1073 }
1074
1075 /*
1076  * On NAND we try to mark this block bad. If the block was erased more
1077  * than MAX_ERASE_FAILURES we mark it finaly bad.
1078  * Don't care about failures. This block remains on the erase-pending
1079  * or badblock list as long as nobody manipulates the flash with
1080  * a bootloader or something like that.
1081  */
1082
1083 int jffs2_write_nand_badblock(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, uint32_t bad_offset)
1084 {
1085         int     ret;
1086
1087         /* if the count is < max, we try to write the counter to the 2nd page oob area */
1088         if( ++jeb->bad_count < MAX_ERASE_FAILURES)
1089                 return 0;
1090
1091         if (!c->mtd->block_markbad)
1092                 return 1; // What else can we do?
1093
1094         printk(KERN_WARNING "JFFS2: marking eraseblock at %08x\n as bad", bad_offset);
1095         ret = c->mtd->block_markbad(c->mtd, bad_offset);
1096
1097         if (ret) {
1098                 D1(printk(KERN_WARNING "jffs2_write_nand_badblock(): Write failed for block at %08x: error %d\n", jeb->offset, ret));
1099                 return ret;
1100         }
1101         return 1;
1102 }
1103
1104 int jffs2_nand_flash_setup(struct jffs2_sb_info *c)
1105 {
1106         struct nand_ecclayout *oinfo = c->mtd->ecclayout;
1107
1108         if (!c->mtd->oobsize)
1109                 return 0;
1110
1111         /* Cleanmarker is out-of-band, so inline size zero */
1112         c->cleanmarker_size = 0;
1113
1114         if (!oinfo || oinfo->oobavail == 0) {
1115                 printk(KERN_ERR "inconsistent device description\n");
1116                 return -EINVAL;
1117         }
1118
1119         D1(printk(KERN_DEBUG "JFFS2 using OOB on NAND\n"));
1120
1121         c->oobavail = oinfo->oobavail;
1122
1123         /* Initialise write buffer */
1124         init_rwsem(&c->wbuf_sem);
1125         c->wbuf_pagesize = c->mtd->writesize;
1126         c->wbuf_ofs = 0xFFFFFFFF;
1127
1128         c->wbuf = kmalloc(c->wbuf_pagesize, GFP_KERNEL);
1129         if (!c->wbuf)
1130                 return -ENOMEM;
1131
1132         c->oobbuf = kmalloc(NR_OOB_SCAN_PAGES * c->oobavail, GFP_KERNEL);
1133         if (!c->oobbuf) {
1134                 kfree(c->wbuf);
1135                 return -ENOMEM;
1136         }
1137
1138         return 0;
1139 }
1140
1141 void jffs2_nand_flash_cleanup(struct jffs2_sb_info *c)
1142 {
1143         kfree(c->wbuf);
1144         kfree(c->oobbuf);
1145 }
1146
1147 int jffs2_dataflash_setup(struct jffs2_sb_info *c) {
1148         c->cleanmarker_size = 0;                /* No cleanmarkers needed */
1149
1150         /* Initialize write buffer */
1151         init_rwsem(&c->wbuf_sem);
1152
1153
1154         c->wbuf_pagesize =  c->mtd->erasesize;
1155
1156         /* Find a suitable c->sector_size
1157          * - Not too much sectors
1158          * - Sectors have to be at least 4 K + some bytes
1159          * - All known dataflashes have erase sizes of 528 or 1056
1160          * - we take at least 8 eraseblocks and want to have at least 8K size
1161          * - The concatenation should be a power of 2
1162         */
1163
1164         c->sector_size = 8 * c->mtd->erasesize;
1165
1166         while (c->sector_size < 8192) {
1167                 c->sector_size *= 2;
1168         }
1169
1170         /* It may be necessary to adjust the flash size */
1171         c->flash_size = c->mtd->size;
1172
1173         if ((c->flash_size % c->sector_size) != 0) {
1174                 c->flash_size = (c->flash_size / c->sector_size) * c->sector_size;
1175                 printk(KERN_WARNING "JFFS2 flash size adjusted to %dKiB\n", c->flash_size);
1176         };
1177
1178         c->wbuf_ofs = 0xFFFFFFFF;
1179         c->wbuf = kmalloc(c->wbuf_pagesize, GFP_KERNEL);
1180         if (!c->wbuf)
1181                 return -ENOMEM;
1182
1183         printk(KERN_INFO "JFFS2 write-buffering enabled buffer (%d) erasesize (%d)\n", c->wbuf_pagesize, c->sector_size);
1184
1185         return 0;
1186 }
1187
1188 void jffs2_dataflash_cleanup(struct jffs2_sb_info *c) {
1189         kfree(c->wbuf);
1190 }
1191
1192 int jffs2_nor_wbuf_flash_setup(struct jffs2_sb_info *c) {
1193         /* Cleanmarker currently occupies whole programming regions,
1194          * either one or 2 for 8Byte STMicro flashes. */
1195         c->cleanmarker_size = max(16u, c->mtd->writesize);
1196
1197         /* Initialize write buffer */
1198         init_rwsem(&c->wbuf_sem);
1199         c->wbuf_pagesize = c->mtd->writesize;
1200         c->wbuf_ofs = 0xFFFFFFFF;
1201
1202         c->wbuf = kmalloc(c->wbuf_pagesize, GFP_KERNEL);
1203         if (!c->wbuf)
1204                 return -ENOMEM;
1205
1206         return 0;
1207 }
1208
1209 void jffs2_nor_wbuf_flash_cleanup(struct jffs2_sb_info *c) {
1210         kfree(c->wbuf);
1211 }
1212
1213 int jffs2_ubivol_setup(struct jffs2_sb_info *c) {
1214         c->cleanmarker_size = 0;
1215
1216         if (c->mtd->writesize == 1)
1217                 /* We do not need write-buffer */
1218                 return 0;
1219
1220         init_rwsem(&c->wbuf_sem);
1221
1222         c->wbuf_pagesize =  c->mtd->writesize;
1223         c->wbuf_ofs = 0xFFFFFFFF;
1224         c->wbuf = kmalloc(c->wbuf_pagesize, GFP_KERNEL);
1225         if (!c->wbuf)
1226                 return -ENOMEM;
1227
1228         printk(KERN_INFO "JFFS2 write-buffering enabled buffer (%d) erasesize (%d)\n", c->wbuf_pagesize, c->sector_size);
1229
1230         return 0;
1231 }
1232
1233 void jffs2_ubivol_cleanup(struct jffs2_sb_info *c) {
1234         kfree(c->wbuf);
1235 }