err.no Git - linux-2.6/blob - 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 }