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