git.oblomov.eu Git - linux-2.6/blob - fs/jffs2/wbuf.c

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