]> err.no Git - linux-2.6/blob - fs/jffs2/wbuf.c
Pull thermal into release branch
[linux-2.6] / 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         if (SECTOR_ADDR(c->wbuf_ofs) == SECTOR_ADDR(c->wbuf_ofs+c->wbuf_pagesize))
641                 c->wbuf_ofs += c->wbuf_pagesize;
642         else
643                 c->wbuf_ofs = 0xffffffff;
644         c->wbuf_len = 0;
645         return 0;
646 }
647
648 /* Trigger garbage collection to flush the write-buffer.
649    If ino arg is zero, do it if _any_ real (i.e. not GC) writes are
650    outstanding. If ino arg non-zero, do it only if a write for the
651    given inode is outstanding. */
652 int jffs2_flush_wbuf_gc(struct jffs2_sb_info *c, uint32_t ino)
653 {
654         uint32_t old_wbuf_ofs;
655         uint32_t old_wbuf_len;
656         int ret = 0;
657
658         D1(printk(KERN_DEBUG "jffs2_flush_wbuf_gc() called for ino #%u...\n", ino));
659
660         if (!c->wbuf)
661                 return 0;
662
663         down(&c->alloc_sem);
664         if (!jffs2_wbuf_pending_for_ino(c, ino)) {
665                 D1(printk(KERN_DEBUG "Ino #%d not pending in wbuf. Returning\n", ino));
666                 up(&c->alloc_sem);
667                 return 0;
668         }
669
670         old_wbuf_ofs = c->wbuf_ofs;
671         old_wbuf_len = c->wbuf_len;
672
673         if (c->unchecked_size) {
674                 /* GC won't make any progress for a while */
675                 D1(printk(KERN_DEBUG "jffs2_flush_wbuf_gc() padding. Not finished checking\n"));
676                 down_write(&c->wbuf_sem);
677                 ret = __jffs2_flush_wbuf(c, PAD_ACCOUNTING);
678                 /* retry flushing wbuf in case jffs2_wbuf_recover
679                    left some data in the wbuf */
680                 if (ret)
681                         ret = __jffs2_flush_wbuf(c, PAD_ACCOUNTING);
682                 up_write(&c->wbuf_sem);
683         } else while (old_wbuf_len &&
684                       old_wbuf_ofs == c->wbuf_ofs) {
685
686                 up(&c->alloc_sem);
687
688                 D1(printk(KERN_DEBUG "jffs2_flush_wbuf_gc() calls gc pass\n"));
689
690                 ret = jffs2_garbage_collect_pass(c);
691                 if (ret) {
692                         /* GC failed. Flush it with padding instead */
693                         down(&c->alloc_sem);
694                         down_write(&c->wbuf_sem);
695                         ret = __jffs2_flush_wbuf(c, PAD_ACCOUNTING);
696                         /* retry flushing wbuf in case jffs2_wbuf_recover
697                            left some data in the wbuf */
698                         if (ret)
699                                 ret = __jffs2_flush_wbuf(c, PAD_ACCOUNTING);
700                         up_write(&c->wbuf_sem);
701                         break;
702                 }
703                 down(&c->alloc_sem);
704         }
705
706         D1(printk(KERN_DEBUG "jffs2_flush_wbuf_gc() ends...\n"));
707
708         up(&c->alloc_sem);
709         return ret;
710 }
711
712 /* Pad write-buffer to end and write it, wasting space. */
713 int jffs2_flush_wbuf_pad(struct jffs2_sb_info *c)
714 {
715         int ret;
716
717         if (!c->wbuf)
718                 return 0;
719
720         down_write(&c->wbuf_sem);
721         ret = __jffs2_flush_wbuf(c, PAD_NOACCOUNT);
722         /* retry - maybe wbuf recover left some data in wbuf. */
723         if (ret)
724                 ret = __jffs2_flush_wbuf(c, PAD_NOACCOUNT);
725         up_write(&c->wbuf_sem);
726
727         return ret;
728 }
729
730 static size_t jffs2_fill_wbuf(struct jffs2_sb_info *c, const uint8_t *buf,
731                               size_t len)
732 {
733         if (len && !c->wbuf_len && (len >= c->wbuf_pagesize))
734                 return 0;
735
736         if (len > (c->wbuf_pagesize - c->wbuf_len))
737                 len = c->wbuf_pagesize - c->wbuf_len;
738         memcpy(c->wbuf + c->wbuf_len, buf, len);
739         c->wbuf_len += (uint32_t) len;
740         return len;
741 }
742
743 int jffs2_flash_writev(struct jffs2_sb_info *c, const struct kvec *invecs,
744                        unsigned long count, loff_t to, size_t *retlen,
745                        uint32_t ino)
746 {
747         struct jffs2_eraseblock *jeb;
748         size_t wbuf_retlen, donelen = 0;
749         uint32_t outvec_to = to;
750         int ret, invec;
751
752         /* If not writebuffered flash, don't bother */
753         if (!jffs2_is_writebuffered(c))
754                 return jffs2_flash_direct_writev(c, invecs, count, to, retlen);
755
756         down_write(&c->wbuf_sem);
757
758         /* If wbuf_ofs is not initialized, set it to target address */
759         if (c->wbuf_ofs == 0xFFFFFFFF) {
760                 c->wbuf_ofs = PAGE_DIV(to);
761                 c->wbuf_len = PAGE_MOD(to);
762                 memset(c->wbuf,0xff,c->wbuf_pagesize);
763         }
764
765         /*
766          * Sanity checks on target address.  It's permitted to write
767          * at PAD(c->wbuf_len+c->wbuf_ofs), and it's permitted to
768          * write at the beginning of a new erase block. Anything else,
769          * and you die.  New block starts at xxx000c (0-b = block
770          * header)
771          */
772         if (SECTOR_ADDR(to) != SECTOR_ADDR(c->wbuf_ofs)) {
773                 /* It's a write to a new block */
774                 if (c->wbuf_len) {
775                         D1(printk(KERN_DEBUG "jffs2_flash_writev() to 0x%lx "
776                                   "causes flush of wbuf at 0x%08x\n",
777                                   (unsigned long)to, c->wbuf_ofs));
778                         ret = __jffs2_flush_wbuf(c, PAD_NOACCOUNT);
779                         if (ret)
780                                 goto outerr;
781                 }
782                 /* set pointer to new block */
783                 c->wbuf_ofs = PAGE_DIV(to);
784                 c->wbuf_len = PAGE_MOD(to);
785         }
786
787         if (to != PAD(c->wbuf_ofs + c->wbuf_len)) {
788                 /* We're not writing immediately after the writebuffer. Bad. */
789                 printk(KERN_CRIT "jffs2_flash_writev(): Non-contiguous write "
790                        "to %08lx\n", (unsigned long)to);
791                 if (c->wbuf_len)
792                         printk(KERN_CRIT "wbuf was previously %08x-%08x\n",
793                                c->wbuf_ofs, c->wbuf_ofs+c->wbuf_len);
794                 BUG();
795         }
796
797         /* adjust alignment offset */
798         if (c->wbuf_len != PAGE_MOD(to)) {
799                 c->wbuf_len = PAGE_MOD(to);
800                 /* take care of alignment to next page */
801                 if (!c->wbuf_len) {
802                         c->wbuf_len = c->wbuf_pagesize;
803                         ret = __jffs2_flush_wbuf(c, NOPAD);
804                         if (ret)
805                                 goto outerr;
806                 }
807         }
808
809         for (invec = 0; invec < count; invec++) {
810                 int vlen = invecs[invec].iov_len;
811                 uint8_t *v = invecs[invec].iov_base;
812
813                 wbuf_retlen = jffs2_fill_wbuf(c, v, vlen);
814
815                 if (c->wbuf_len == c->wbuf_pagesize) {
816                         ret = __jffs2_flush_wbuf(c, NOPAD);
817                         if (ret)
818                                 goto outerr;
819                 }
820                 vlen -= wbuf_retlen;
821                 outvec_to += wbuf_retlen;
822                 donelen += wbuf_retlen;
823                 v += wbuf_retlen;
824
825                 if (vlen >= c->wbuf_pagesize) {
826                         ret = c->mtd->write(c->mtd, outvec_to, PAGE_DIV(vlen),
827                                             &wbuf_retlen, v);
828                         if (ret < 0 || wbuf_retlen != PAGE_DIV(vlen))
829                                 goto outfile;
830
831                         vlen -= wbuf_retlen;
832                         outvec_to += wbuf_retlen;
833                         c->wbuf_ofs = outvec_to;
834                         donelen += wbuf_retlen;
835                         v += wbuf_retlen;
836                 }
837
838                 wbuf_retlen = jffs2_fill_wbuf(c, v, vlen);
839                 if (c->wbuf_len == c->wbuf_pagesize) {
840                         ret = __jffs2_flush_wbuf(c, NOPAD);
841                         if (ret)
842                                 goto outerr;
843                 }
844
845                 outvec_to += wbuf_retlen;
846                 donelen += wbuf_retlen;
847         }
848
849         /*
850          * If there's a remainder in the wbuf and it's a non-GC write,
851          * remember that the wbuf affects this ino
852          */
853         *retlen = donelen;
854
855         if (jffs2_sum_active()) {
856                 int res = jffs2_sum_add_kvec(c, invecs, count, (uint32_t) to);
857                 if (res)
858                         return res;
859         }
860
861         if (c->wbuf_len && ino)
862                 jffs2_wbuf_dirties_inode(c, ino);
863
864         ret = 0;
865         up_write(&c->wbuf_sem);
866         return ret;
867
868 outfile:
869         /*
870          * At this point we have no problem, c->wbuf is empty. However
871          * refile nextblock to avoid writing again to same address.
872          */
873
874         spin_lock(&c->erase_completion_lock);
875
876         jeb = &c->blocks[outvec_to / c->sector_size];
877         jffs2_block_refile(c, jeb, REFILE_ANYWAY);
878
879         spin_unlock(&c->erase_completion_lock);
880
881 outerr:
882         *retlen = 0;
883         up_write(&c->wbuf_sem);
884         return ret;
885 }
886
887 /*
888  *      This is the entry for flash write.
889  *      Check, if we work on NAND FLASH, if so build an kvec and write it via vritev
890 */
891 int jffs2_flash_write(struct jffs2_sb_info *c, loff_t ofs, size_t len,
892                       size_t *retlen, const u_char *buf)
893 {
894         struct kvec vecs[1];
895
896         if (!jffs2_is_writebuffered(c))
897                 return jffs2_flash_direct_write(c, ofs, len, retlen, buf);
898
899         vecs[0].iov_base = (unsigned char *) buf;
900         vecs[0].iov_len = len;
901         return jffs2_flash_writev(c, vecs, 1, ofs, retlen, 0);
902 }
903
904 /*
905         Handle readback from writebuffer and ECC failure return
906 */
907 int jffs2_flash_read(struct jffs2_sb_info *c, loff_t ofs, size_t len, size_t *retlen, u_char *buf)
908 {
909         loff_t  orbf = 0, owbf = 0, lwbf = 0;
910         int     ret;
911
912         if (!jffs2_is_writebuffered(c))
913                 return c->mtd->read(c->mtd, ofs, len, retlen, buf);
914
915         /* Read flash */
916         down_read(&c->wbuf_sem);
917         ret = c->mtd->read(c->mtd, ofs, len, retlen, buf);
918
919         if ( (ret == -EBADMSG || ret == -EUCLEAN) && (*retlen == len) ) {
920                 if (ret == -EBADMSG)
921                         printk(KERN_WARNING "mtd->read(0x%zx bytes from 0x%llx)"
922                                " returned ECC error\n", len, ofs);
923                 /*
924                  * We have the raw data without ECC correction in the buffer,
925                  * maybe we are lucky and all data or parts are correct. We
926                  * check the node.  If data are corrupted node check will sort
927                  * it out.  We keep this block, it will fail on write or erase
928                  * and the we mark it bad. Or should we do that now? But we
929                  * should give him a chance.  Maybe we had a system crash or
930                  * power loss before the ecc write or a erase was completed.
931                  * So we return success. :)
932                  */
933                 ret = 0;
934         }
935
936         /* if no writebuffer available or write buffer empty, return */
937         if (!c->wbuf_pagesize || !c->wbuf_len)
938                 goto exit;
939
940         /* if we read in a different block, return */
941         if (SECTOR_ADDR(ofs) != SECTOR_ADDR(c->wbuf_ofs))
942                 goto exit;
943
944         if (ofs >= c->wbuf_ofs) {
945                 owbf = (ofs - c->wbuf_ofs);     /* offset in write buffer */
946                 if (owbf > c->wbuf_len)         /* is read beyond write buffer ? */
947                         goto exit;
948                 lwbf = c->wbuf_len - owbf;      /* number of bytes to copy */
949                 if (lwbf > len)
950                         lwbf = len;
951         } else {
952                 orbf = (c->wbuf_ofs - ofs);     /* offset in read buffer */
953                 if (orbf > len)                 /* is write beyond write buffer ? */
954                         goto exit;
955                 lwbf = len - orbf;              /* number of bytes to copy */
956                 if (lwbf > c->wbuf_len)
957                         lwbf = c->wbuf_len;
958         }
959         if (lwbf > 0)
960                 memcpy(buf+orbf,c->wbuf+owbf,lwbf);
961
962 exit:
963         up_read(&c->wbuf_sem);
964         return ret;
965 }
966
967 #define NR_OOB_SCAN_PAGES 4
968
969 /* For historical reasons we use only 12 bytes for OOB clean marker */
970 #define OOB_CM_SIZE 12
971
972 static const struct jffs2_unknown_node oob_cleanmarker =
973 {
974         .magic = constant_cpu_to_je16(JFFS2_MAGIC_BITMASK),
975         .nodetype = constant_cpu_to_je16(JFFS2_NODETYPE_CLEANMARKER),
976         .totlen = constant_cpu_to_je32(8)
977 };
978
979 /*
980  * Check, if the out of band area is empty. This function knows about the clean
981  * marker and if it is present in OOB, treats the OOB as empty anyway.
982  */
983 int jffs2_check_oob_empty(struct jffs2_sb_info *c,
984                           struct jffs2_eraseblock *jeb, int mode)
985 {
986         int i, ret;
987         int cmlen = min_t(int, c->oobavail, OOB_CM_SIZE);
988         struct mtd_oob_ops ops;
989
990         ops.mode = MTD_OOB_AUTO;
991         ops.ooblen = NR_OOB_SCAN_PAGES * c->oobavail;
992         ops.oobbuf = c->oobbuf;
993         ops.len = ops.ooboffs = ops.retlen = ops.oobretlen = 0;
994         ops.datbuf = NULL;
995
996         ret = c->mtd->read_oob(c->mtd, jeb->offset, &ops);
997         if (ret || ops.oobretlen != ops.ooblen) {
998                 printk(KERN_ERR "cannot read OOB for EB at %08x, requested %zd"
999                                 " bytes, read %zd bytes, error %d\n",
1000                                 jeb->offset, ops.ooblen, ops.oobretlen, ret);
1001                 if (!ret)
1002                         ret = -EIO;
1003                 return ret;
1004         }
1005
1006         for(i = 0; i < ops.ooblen; i++) {
1007                 if (mode && i < cmlen)
1008                         /* Yeah, we know about the cleanmarker */
1009                         continue;
1010
1011                 if (ops.oobbuf[i] != 0xFF) {
1012                         D2(printk(KERN_DEBUG "Found %02x at %x in OOB for "
1013                                   "%08x\n", ops.oobbuf[i], i, jeb->offset));
1014                         return 1;
1015                 }
1016         }
1017
1018         return 0;
1019 }
1020
1021 /*
1022  * Check for a valid cleanmarker.
1023  * Returns: 0 if a valid cleanmarker was found
1024  *          1 if no cleanmarker was found
1025  *          negative error code if an error occurred
1026  */
1027 int jffs2_check_nand_cleanmarker(struct jffs2_sb_info *c,
1028                                  struct jffs2_eraseblock *jeb)
1029 {
1030         struct mtd_oob_ops ops;
1031         int ret, cmlen = min_t(int, c->oobavail, OOB_CM_SIZE);
1032
1033         ops.mode = MTD_OOB_AUTO;
1034         ops.ooblen = cmlen;
1035         ops.oobbuf = c->oobbuf;
1036         ops.len = ops.ooboffs = ops.retlen = ops.oobretlen = 0;
1037         ops.datbuf = NULL;
1038
1039         ret = c->mtd->read_oob(c->mtd, jeb->offset, &ops);
1040         if (ret || ops.oobretlen != ops.ooblen) {
1041                 printk(KERN_ERR "cannot read OOB for EB at %08x, requested %zd"
1042                                 " bytes, read %zd bytes, error %d\n",
1043                                 jeb->offset, ops.ooblen, ops.oobretlen, ret);
1044                 if (!ret)
1045                         ret = -EIO;
1046                 return ret;
1047         }
1048
1049         return !!memcmp(&oob_cleanmarker, c->oobbuf, cmlen);
1050 }
1051
1052 int jffs2_write_nand_cleanmarker(struct jffs2_sb_info *c,
1053                                  struct jffs2_eraseblock *jeb)
1054 {
1055         int ret;
1056         struct mtd_oob_ops ops;
1057         int cmlen = min_t(int, c->oobavail, OOB_CM_SIZE);
1058
1059         ops.mode = MTD_OOB_AUTO;
1060         ops.ooblen = cmlen;
1061         ops.oobbuf = (uint8_t *)&oob_cleanmarker;
1062         ops.len = ops.ooboffs = ops.retlen = ops.oobretlen = 0;
1063         ops.datbuf = NULL;
1064
1065         ret = c->mtd->write_oob(c->mtd, jeb->offset, &ops);
1066         if (ret || ops.oobretlen != ops.ooblen) {
1067                 printk(KERN_ERR "cannot write OOB for EB at %08x, requested %zd"
1068                                 " bytes, read %zd bytes, error %d\n",
1069                                 jeb->offset, ops.ooblen, ops.oobretlen, ret);
1070                 if (!ret)
1071                         ret = -EIO;
1072                 return ret;
1073         }
1074
1075         return 0;
1076 }
1077
1078 /*
1079  * On NAND we try to mark this block bad. If the block was erased more
1080  * than MAX_ERASE_FAILURES we mark it finaly bad.
1081  * Don't care about failures. This block remains on the erase-pending
1082  * or badblock list as long as nobody manipulates the flash with
1083  * a bootloader or something like that.
1084  */
1085
1086 int jffs2_write_nand_badblock(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, uint32_t bad_offset)
1087 {
1088         int     ret;
1089
1090         /* if the count is < max, we try to write the counter to the 2nd page oob area */
1091         if( ++jeb->bad_count < MAX_ERASE_FAILURES)
1092                 return 0;
1093
1094         if (!c->mtd->block_markbad)
1095                 return 1; // What else can we do?
1096
1097         printk(KERN_WARNING "JFFS2: marking eraseblock at %08x\n as bad", bad_offset);
1098         ret = c->mtd->block_markbad(c->mtd, bad_offset);
1099
1100         if (ret) {
1101                 D1(printk(KERN_WARNING "jffs2_write_nand_badblock(): Write failed for block at %08x: error %d\n", jeb->offset, ret));
1102                 return ret;
1103         }
1104         return 1;
1105 }
1106
1107 int jffs2_nand_flash_setup(struct jffs2_sb_info *c)
1108 {
1109         struct nand_ecclayout *oinfo = c->mtd->ecclayout;
1110
1111         if (!c->mtd->oobsize)
1112                 return 0;
1113
1114         /* Cleanmarker is out-of-band, so inline size zero */
1115         c->cleanmarker_size = 0;
1116
1117         if (!oinfo || oinfo->oobavail == 0) {
1118                 printk(KERN_ERR "inconsistent device description\n");
1119                 return -EINVAL;
1120         }
1121
1122         D1(printk(KERN_DEBUG "JFFS2 using OOB on NAND\n"));
1123
1124         c->oobavail = oinfo->oobavail;
1125
1126         /* Initialise write buffer */
1127         init_rwsem(&c->wbuf_sem);
1128         c->wbuf_pagesize = c->mtd->writesize;
1129         c->wbuf_ofs = 0xFFFFFFFF;
1130
1131         c->wbuf = kmalloc(c->wbuf_pagesize, GFP_KERNEL);
1132         if (!c->wbuf)
1133                 return -ENOMEM;
1134
1135         c->oobbuf = kmalloc(NR_OOB_SCAN_PAGES * c->oobavail, GFP_KERNEL);
1136         if (!c->oobbuf) {
1137                 kfree(c->wbuf);
1138                 return -ENOMEM;
1139         }
1140
1141         return 0;
1142 }
1143
1144 void jffs2_nand_flash_cleanup(struct jffs2_sb_info *c)
1145 {
1146         kfree(c->wbuf);
1147         kfree(c->oobbuf);
1148 }
1149
1150 int jffs2_dataflash_setup(struct jffs2_sb_info *c) {
1151         c->cleanmarker_size = 0;                /* No cleanmarkers needed */
1152
1153         /* Initialize write buffer */
1154         init_rwsem(&c->wbuf_sem);
1155
1156
1157         c->wbuf_pagesize =  c->mtd->erasesize;
1158
1159         /* Find a suitable c->sector_size
1160          * - Not too much sectors
1161          * - Sectors have to be at least 4 K + some bytes
1162          * - All known dataflashes have erase sizes of 528 or 1056
1163          * - we take at least 8 eraseblocks and want to have at least 8K size
1164          * - The concatenation should be a power of 2
1165         */
1166
1167         c->sector_size = 8 * c->mtd->erasesize;
1168
1169         while (c->sector_size < 8192) {
1170                 c->sector_size *= 2;
1171         }
1172
1173         /* It may be necessary to adjust the flash size */
1174         c->flash_size = c->mtd->size;
1175
1176         if ((c->flash_size % c->sector_size) != 0) {
1177                 c->flash_size = (c->flash_size / c->sector_size) * c->sector_size;
1178                 printk(KERN_WARNING "JFFS2 flash size adjusted to %dKiB\n", c->flash_size);
1179         };
1180
1181         c->wbuf_ofs = 0xFFFFFFFF;
1182         c->wbuf = kmalloc(c->wbuf_pagesize, GFP_KERNEL);
1183         if (!c->wbuf)
1184                 return -ENOMEM;
1185
1186         printk(KERN_INFO "JFFS2 write-buffering enabled buffer (%d) erasesize (%d)\n", c->wbuf_pagesize, c->sector_size);
1187
1188         return 0;
1189 }
1190
1191 void jffs2_dataflash_cleanup(struct jffs2_sb_info *c) {
1192         kfree(c->wbuf);
1193 }
1194
1195 int jffs2_nor_wbuf_flash_setup(struct jffs2_sb_info *c) {
1196         /* Cleanmarker currently occupies whole programming regions,
1197          * either one or 2 for 8Byte STMicro flashes. */
1198         c->cleanmarker_size = max(16u, c->mtd->writesize);
1199
1200         /* Initialize write buffer */
1201         init_rwsem(&c->wbuf_sem);
1202         c->wbuf_pagesize = c->mtd->writesize;
1203         c->wbuf_ofs = 0xFFFFFFFF;
1204
1205         c->wbuf = kmalloc(c->wbuf_pagesize, GFP_KERNEL);
1206         if (!c->wbuf)
1207                 return -ENOMEM;
1208
1209         return 0;
1210 }
1211
1212 void jffs2_nor_wbuf_flash_cleanup(struct jffs2_sb_info *c) {
1213         kfree(c->wbuf);
1214 }
1215
1216 int jffs2_ubivol_setup(struct jffs2_sb_info *c) {
1217         c->cleanmarker_size = 0;
1218
1219         if (c->mtd->writesize == 1)
1220                 /* We do not need write-buffer */
1221                 return 0;
1222
1223         init_rwsem(&c->wbuf_sem);
1224
1225         c->wbuf_pagesize =  c->mtd->writesize;
1226         c->wbuf_ofs = 0xFFFFFFFF;
1227         c->wbuf = kmalloc(c->wbuf_pagesize, GFP_KERNEL);
1228         if (!c->wbuf)
1229                 return -ENOMEM;
1230
1231         printk(KERN_INFO "JFFS2 write-buffering enabled buffer (%d) erasesize (%d)\n", c->wbuf_pagesize, c->sector_size);
1232
1233         return 0;
1234 }
1235
1236 void jffs2_ubivol_cleanup(struct jffs2_sb_info *c) {
1237         kfree(c->wbuf);
1238 }