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 }