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_move(&jeb->list, &c->erase_pending_list);
 499                 c->nr_erasing_blocks++;
 500                 jffs2_erase_pending_trigger(c);
 501         }
 502
 503         jffs2_dbg_acct_sanity_check_nolock(c, jeb);
 504         jffs2_dbg_acct_paranoia_check_nolock(c, jeb);
 505
 506         jffs2_dbg_acct_sanity_check_nolock(c, new_jeb);
 507         jffs2_dbg_acct_paranoia_check_nolock(c, new_jeb);
 508
 509         spin_unlock(&c->erase_completion_lock);
 510
 511         D1(printk(KERN_DEBUG "wbuf recovery completed OK. wbuf_ofs 0x%08x, len 0x%x\n", c->wbuf_ofs, c->wbuf_len));
 512
 513 }
 514
 515 /* Meaning of pad argument:
 516    0: Do not pad. Probably pointless - we only ever use this when we can't pad anyway.
 517    1: Pad, do not adjust nextblock free_size
 518    2: Pad, adjust nextblock free_size
 519 */
 520 #define NOPAD           0
 521 #define PAD_NOACCOUNT   1
 522 #define PAD_ACCOUNTING  2
 523
 524 static int __jffs2_flush_wbuf(struct jffs2_sb_info *c, int pad)
 525 {
 526         struct jffs2_eraseblock *wbuf_jeb;
 527         int ret;
 528         size_t retlen;
 529
 530         /* Nothing to do if not write-buffering the flash. In particular, we shouldn't
 531            del_timer() the timer we never initialised. */
 532         if (!jffs2_is_writebuffered(c))
 533                 return 0;
 534
 535         if (!down_trylock(&c->alloc_sem)) {
 536                 up(&c->alloc_sem);
 537                 printk(KERN_CRIT "jffs2_flush_wbuf() called with alloc_sem not locked!\n");
 538                 BUG();
 539         }
 540
 541         if (!c->wbuf_len)       /* already checked c->wbuf above */
 542                 return 0;
 543
 544         wbuf_jeb = &c->blocks[c->wbuf_ofs / c->sector_size];
 545         if (jffs2_prealloc_raw_node_refs(c, wbuf_jeb, c->nextblock->allocated_refs + 1))
 546                 return -ENOMEM;
 547
 548         /* claim remaining space on the page
 549            this happens, if we have a change to a new block,
 550            or if fsync forces us to flush the writebuffer.
 551            if we have a switch to next page, we will not have
 552            enough remaining space for this.
 553         */
 554         if (pad ) {
 555                 c->wbuf_len = PAD(c->wbuf_len);
 556
 557                 /* Pad with JFFS2_DIRTY_BITMASK initially.  this helps out ECC'd NOR
 558                    with 8 byte page size */
 559                 memset(c->wbuf + c->wbuf_len, 0, c->wbuf_pagesize - c->wbuf_len);
 560
 561                 if ( c->wbuf_len + sizeof(struct jffs2_unknown_node) < c->wbuf_pagesize) {
 562                         struct jffs2_unknown_node *padnode = (void *)(c->wbuf + c->wbuf_len);
 563                         padnode->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
 564                         padnode->nodetype = cpu_to_je16(JFFS2_NODETYPE_PADDING);
 565                         padnode->totlen = cpu_to_je32(c->wbuf_pagesize - c->wbuf_len);
 566                         padnode->hdr_crc = cpu_to_je32(crc32(0, padnode, sizeof(*padnode)-4));
 567                 }
 568         }
 569         /* else jffs2_flash_writev has actually filled in the rest of the
 570            buffer for us, and will deal with the node refs etc. later. */
 571
 572 #ifdef BREAKME
 573         static int breakme;
 574         if (breakme++ == 20) {
 575                 printk(KERN_NOTICE "Faking write error at 0x%08x\n", c->wbuf_ofs);
 576                 breakme = 0;
 577                 c->mtd->write(c->mtd, c->wbuf_ofs, c->wbuf_pagesize, &retlen,
 578                               brokenbuf);
 579                 ret = -EIO;
 580         } else
 581 #endif
 582
 583                 ret = c->mtd->write(c->mtd, c->wbuf_ofs, c->wbuf_pagesize, &retlen, c->wbuf);
 584
 585         if (ret || retlen != c->wbuf_pagesize) {
 586                 if (ret)
 587                         printk(KERN_WARNING "jffs2_flush_wbuf(): Write failed with %d\n",ret);
 588                 else {
 589                         printk(KERN_WARNING "jffs2_flush_wbuf(): Write was short: %zd instead of %d\n",
 590                                 retlen, c->wbuf_pagesize);
 591                         ret = -EIO;
 592                 }
 593
 594                 jffs2_wbuf_recover(c);
 595
 596                 return ret;
 597         }
 598
 599         /* Adjust free size of the block if we padded. */
 600         if (pad) {
 601                 uint32_t waste = c->wbuf_pagesize - c->wbuf_len;
 602
 603                 D1(printk(KERN_DEBUG "jffs2_flush_wbuf() adjusting free_size of %sblock at %08x\n",
 604                           (wbuf_jeb==c->nextblock)?"next":"", wbuf_jeb->offset));
 605
 606                 /* wbuf_pagesize - wbuf_len is the amount of space that's to be
 607                    padded. If there is less free space in the block than that,
 608                    something screwed up */
 609                 if (wbuf_jeb->free_size < waste) {
 610                         printk(KERN_CRIT "jffs2_flush_wbuf(): Accounting error. wbuf at 0x%08x has 0x%03x bytes, 0x%03x left.\n",
 611                                c->wbuf_ofs, c->wbuf_len, waste);
 612                         printk(KERN_CRIT "jffs2_flush_wbuf(): But free_size for block at 0x%08x is only 0x%08x\n",
 613                                wbuf_jeb->offset, wbuf_jeb->free_size);
 614                         BUG();
 615                 }
 616
 617                 spin_lock(&c->erase_completion_lock);
 618
 619                 jffs2_link_node_ref(c, wbuf_jeb, (c->wbuf_ofs + c->wbuf_len) | REF_OBSOLETE, waste, NULL);
 620                 /* FIXME: that made it count as dirty. Convert to wasted */
 621                 wbuf_jeb->dirty_size -= waste;
 622                 c->dirty_size -= waste;
 623                 wbuf_jeb->wasted_size += waste;
 624                 c->wasted_size += waste;
 625         } else
 626                 spin_lock(&c->erase_completion_lock);
 627
 628         /* Stick any now-obsoleted blocks on the erase_pending_list */
 629         jffs2_refile_wbuf_blocks(c);
 630         jffs2_clear_wbuf_ino_list(c);
 631         spin_unlock(&c->erase_completion_lock);
 632
 633         memset(c->wbuf,0xff,c->wbuf_pagesize);
 634         /* adjust write buffer offset, else we get a non contiguous write bug */
 635         c->wbuf_ofs += c->wbuf_pagesize;
 636         c->wbuf_len = 0;
 637         return 0;
 638 }
 639
 640 /* Trigger garbage collection to flush the write-buffer.
 641    If ino arg is zero, do it if _any_ real (i.e. not GC) writes are
 642    outstanding. If ino arg non-zero, do it only if a write for the
 643    given inode is outstanding. */
 644 int jffs2_flush_wbuf_gc(struct jffs2_sb_info *c, uint32_t ino)
 645 {
 646         uint32_t old_wbuf_ofs;
 647         uint32_t old_wbuf_len;
 648         int ret = 0;
 649
 650         D1(printk(KERN_DEBUG "jffs2_flush_wbuf_gc() called for ino #%u...\n", ino));
 651
 652         if (!c->wbuf)
 653                 return 0;
 654
 655         down(&c->alloc_sem);
 656         if (!jffs2_wbuf_pending_for_ino(c, ino)) {
 657                 D1(printk(KERN_DEBUG "Ino #%d not pending in wbuf. Returning\n", ino));
 658                 up(&c->alloc_sem);
 659                 return 0;
 660         }
 661
 662         old_wbuf_ofs = c->wbuf_ofs;
 663         old_wbuf_len = c->wbuf_len;
 664
 665         if (c->unchecked_size) {
 666                 /* GC won't make any progress for a while */
 667                 D1(printk(KERN_DEBUG "jffs2_flush_wbuf_gc() padding. Not finished checking\n"));
 668                 down_write(&c->wbuf_sem);
 669                 ret = __jffs2_flush_wbuf(c, PAD_ACCOUNTING);
 670                 /* retry flushing wbuf in case jffs2_wbuf_recover
 671                    left some data in the wbuf */
 672                 if (ret)
 673                         ret = __jffs2_flush_wbuf(c, PAD_ACCOUNTING);
 674                 up_write(&c->wbuf_sem);
 675         } else while (old_wbuf_len &&
 676                       old_wbuf_ofs == c->wbuf_ofs) {
 677
 678                 up(&c->alloc_sem);
 679
 680                 D1(printk(KERN_DEBUG "jffs2_flush_wbuf_gc() calls gc pass\n"));
 681
 682                 ret = jffs2_garbage_collect_pass(c);
 683                 if (ret) {
 684                         /* GC failed. Flush it with padding instead */
 685                         down(&c->alloc_sem);
 686                         down_write(&c->wbuf_sem);
 687                         ret = __jffs2_flush_wbuf(c, PAD_ACCOUNTING);
 688                         /* retry flushing wbuf in case jffs2_wbuf_recover
 689                            left some data in the wbuf */
 690                         if (ret)
 691                                 ret = __jffs2_flush_wbuf(c, PAD_ACCOUNTING);
 692                         up_write(&c->wbuf_sem);
 693                         break;
 694                 }
 695                 down(&c->alloc_sem);
 696         }
 697
 698         D1(printk(KERN_DEBUG "jffs2_flush_wbuf_gc() ends...\n"));
 699
 700         up(&c->alloc_sem);
 701         return ret;
 702 }
 703
 704 /* Pad write-buffer to end and write it, wasting space. */
 705 int jffs2_flush_wbuf_pad(struct jffs2_sb_info *c)
 706 {
 707         int ret;
 708
 709         if (!c->wbuf)
 710                 return 0;
 711
 712         down_write(&c->wbuf_sem);
 713         ret = __jffs2_flush_wbuf(c, PAD_NOACCOUNT);
 714         /* retry - maybe wbuf recover left some data in wbuf. */
 715         if (ret)
 716                 ret = __jffs2_flush_wbuf(c, PAD_NOACCOUNT);
 717         up_write(&c->wbuf_sem);
 718
 719         return ret;
 720 }
 721
 722 static size_t jffs2_fill_wbuf(struct jffs2_sb_info *c, const uint8_t *buf,
 723                               size_t len)
 724 {
 725         if (len && !c->wbuf_len && (len >= c->wbuf_pagesize))
 726                 return 0;
 727
 728         if (len > (c->wbuf_pagesize - c->wbuf_len))
 729                 len = c->wbuf_pagesize - c->wbuf_len;
 730         memcpy(c->wbuf + c->wbuf_len, buf, len);
 731         c->wbuf_len += (uint32_t) len;
 732         return len;
 733 }
 734
 735 int jffs2_flash_writev(struct jffs2_sb_info *c, const struct kvec *invecs,
 736                        unsigned long count, loff_t to, size_t *retlen,
 737                        uint32_t ino)
 738 {
 739         struct jffs2_eraseblock *jeb;
 740         size_t wbuf_retlen, donelen = 0;
 741         uint32_t outvec_to = to;
 742         int ret, invec;
 743
 744         /* If not writebuffered flash, don't bother */
 745         if (!jffs2_is_writebuffered(c))
 746                 return jffs2_flash_direct_writev(c, invecs, count, to, retlen);
 747
 748         down_write(&c->wbuf_sem);
 749
 750         /* If wbuf_ofs is not initialized, set it to target address */
 751         if (c->wbuf_ofs == 0xFFFFFFFF) {
 752                 c->wbuf_ofs = PAGE_DIV(to);
 753                 c->wbuf_len = PAGE_MOD(to);
 754                 memset(c->wbuf,0xff,c->wbuf_pagesize);
 755         }
 756
 757         /*
 758          * Sanity checks on target address.  It's permitted to write
 759          * at PAD(c->wbuf_len+c->wbuf_ofs), and it's permitted to
 760          * write at the beginning of a new erase block. Anything else,
 761          * and you die.  New block starts at xxx000c (0-b = block
 762          * header)
 763          */
 764         if (SECTOR_ADDR(to) != SECTOR_ADDR(c->wbuf_ofs)) {
 765                 /* It's a write to a new block */
 766                 if (c->wbuf_len) {
 767                         D1(printk(KERN_DEBUG "jffs2_flash_writev() to 0x%lx "
 768                                   "causes flush of wbuf at 0x%08x\n",
 769                                   (unsigned long)to, c->wbuf_ofs));
 770                         ret = __jffs2_flush_wbuf(c, PAD_NOACCOUNT);
 771                         if (ret)
 772                                 goto outerr;
 773                 }
 774                 /* set pointer to new block */
 775                 c->wbuf_ofs = PAGE_DIV(to);
 776                 c->wbuf_len = PAGE_MOD(to);
 777         }
 778
 779         if (to != PAD(c->wbuf_ofs + c->wbuf_len)) {
 780                 /* We're not writing immediately after the writebuffer. Bad. */
 781                 printk(KERN_CRIT "jffs2_flash_writev(): Non-contiguous write "
 782                        "to %08lx\n", (unsigned long)to);
 783                 if (c->wbuf_len)
 784                         printk(KERN_CRIT "wbuf was previously %08x-%08x\n",
 785                                c->wbuf_ofs, c->wbuf_ofs+c->wbuf_len);
 786                 BUG();
 787         }
 788
 789         /* adjust alignment offset */
 790         if (c->wbuf_len != PAGE_MOD(to)) {
 791                 c->wbuf_len = PAGE_MOD(to);
 792                 /* take care of alignment to next page */
 793                 if (!c->wbuf_len) {
 794                         c->wbuf_len = c->wbuf_pagesize;
 795                         ret = __jffs2_flush_wbuf(c, NOPAD);
 796                         if (ret)
 797                                 goto outerr;
 798                 }
 799         }
 800
 801         for (invec = 0; invec < count; invec++) {
 802                 int vlen = invecs[invec].iov_len;
 803                 uint8_t *v = invecs[invec].iov_base;
 804
 805                 wbuf_retlen = jffs2_fill_wbuf(c, v, vlen);
 806
 807                 if (c->wbuf_len == c->wbuf_pagesize) {
 808                         ret = __jffs2_flush_wbuf(c, NOPAD);
 809                         if (ret)
 810                                 goto outerr;
 811                 }
 812                 vlen -= wbuf_retlen;
 813                 outvec_to += wbuf_retlen;
 814                 donelen += wbuf_retlen;
 815                 v += wbuf_retlen;
 816
 817                 if (vlen >= c->wbuf_pagesize) {
 818                         ret = c->mtd->write(c->mtd, outvec_to, PAGE_DIV(vlen),
 819                                             &wbuf_retlen, v);
 820                         if (ret < 0 || wbuf_retlen != PAGE_DIV(vlen))
 821                                 goto outfile;
 822
 823                         vlen -= wbuf_retlen;
 824                         outvec_to += wbuf_retlen;
 825                         c->wbuf_ofs = outvec_to;
 826                         donelen += wbuf_retlen;
 827                         v += wbuf_retlen;
 828                 }
 829
 830                 wbuf_retlen = jffs2_fill_wbuf(c, v, vlen);
 831                 if (c->wbuf_len == c->wbuf_pagesize) {
 832                         ret = __jffs2_flush_wbuf(c, NOPAD);
 833                         if (ret)
 834                                 goto outerr;
 835                 }
 836
 837                 outvec_to += wbuf_retlen;
 838                 donelen += wbuf_retlen;
 839         }
 840
 841         /*
 842          * If there's a remainder in the wbuf and it's a non-GC write,
 843          * remember that the wbuf affects this ino
 844          */
 845         *retlen = donelen;
 846
 847         if (jffs2_sum_active()) {
 848                 int res = jffs2_sum_add_kvec(c, invecs, count, (uint32_t) to);
 849                 if (res)
 850                         return res;
 851         }
 852
 853         if (c->wbuf_len && ino)
 854                 jffs2_wbuf_dirties_inode(c, ino);
 855
 856         ret = 0;
 857         up_write(&c->wbuf_sem);
 858         return ret;
 859
 860 outfile:
 861         /*
 862          * At this point we have no problem, c->wbuf is empty. However
 863          * refile nextblock to avoid writing again to same address.
 864          */
 865
 866         spin_lock(&c->erase_completion_lock);
 867
 868         jeb = &c->blocks[outvec_to / c->sector_size];
 869         jffs2_block_refile(c, jeb, REFILE_ANYWAY);
 870
 871         spin_unlock(&c->erase_completion_lock);
 872
 873 outerr:
 874         *retlen = 0;
 875         up_write(&c->wbuf_sem);
 876         return ret;
 877 }
 878
 879 /*
 880  *      This is the entry for flash write.
 881  *      Check, if we work on NAND FLASH, if so build an kvec and write it via vritev
 882 */
 883 int jffs2_flash_write(struct jffs2_sb_info *c, loff_t ofs, size_t len,
 884                       size_t *retlen, const u_char *buf)
 885 {
 886         struct kvec vecs[1];
 887
 888         if (!jffs2_is_writebuffered(c))
 889                 return jffs2_flash_direct_write(c, ofs, len, retlen, buf);
 890
 891         vecs[0].iov_base = (unsigned char *) buf;
 892         vecs[0].iov_len = len;
 893         return jffs2_flash_writev(c, vecs, 1, ofs, retlen, 0);
 894 }
 895
 896 /*
 897         Handle readback from writebuffer and ECC failure return
 898 */
 899 int jffs2_flash_read(struct jffs2_sb_info *c, loff_t ofs, size_t len, size_t *retlen, u_char *buf)
 900 {
 901         loff_t  orbf = 0, owbf = 0, lwbf = 0;
 902         int     ret;
 903
 904         if (!jffs2_is_writebuffered(c))
 905                 return c->mtd->read(c->mtd, ofs, len, retlen, buf);
 906
 907         /* Read flash */
 908         down_read(&c->wbuf_sem);
 909         ret = c->mtd->read(c->mtd, ofs, len, retlen, buf);
 910
 911         if ( (ret == -EBADMSG || ret == -EUCLEAN) && (*retlen == len) ) {
 912                 if (ret == -EBADMSG)
 913                         printk(KERN_WARNING "mtd->read(0x%zx bytes from 0x%llx)"
 914                                " returned ECC error\n", len, ofs);
 915                 /*
 916                  * We have the raw data without ECC correction in the buffer,
 917                  * maybe we are lucky and all data or parts are correct. We
 918                  * check the node.  If data are corrupted node check will sort
 919                  * it out.  We keep this block, it will fail on write or erase
 920                  * and the we mark it bad. Or should we do that now? But we
 921                  * should give him a chance.  Maybe we had a system crash or
 922                  * power loss before the ecc write or a erase was completed.
 923                  * So we return success. :)
 924                  */
 925                 ret = 0;
 926         }
 927
 928         /* if no writebuffer available or write buffer empty, return */
 929         if (!c->wbuf_pagesize || !c->wbuf_len)
 930                 goto exit;
 931
 932         /* if we read in a different block, return */
 933         if (SECTOR_ADDR(ofs) != SECTOR_ADDR(c->wbuf_ofs))
 934                 goto exit;
 935
 936         if (ofs >= c->wbuf_ofs) {
 937                 owbf = (ofs - c->wbuf_ofs);     /* offset in write buffer */
 938                 if (owbf > c->wbuf_len)         /* is read beyond write buffer ? */
 939                         goto exit;
 940                 lwbf = c->wbuf_len - owbf;      /* number of bytes to copy */
 941                 if (lwbf > len)
 942                         lwbf = len;
 943         } else {
 944                 orbf = (c->wbuf_ofs - ofs);     /* offset in read buffer */
 945                 if (orbf > len)                 /* is write beyond write buffer ? */
 946                         goto exit;
 947                 lwbf = len - orbf;              /* number of bytes to copy */
 948                 if (lwbf > c->wbuf_len)
 949                         lwbf = c->wbuf_len;
 950         }
 951         if (lwbf > 0)
 952                 memcpy(buf+orbf,c->wbuf+owbf,lwbf);
 953
 954 exit:
 955         up_read(&c->wbuf_sem);
 956         return ret;
 957 }
 958
 959 #define NR_OOB_SCAN_PAGES       4
 960
 961 /*
 962  * Check, if the out of band area is empty
 963  */
 964 int jffs2_check_oob_empty(struct jffs2_sb_info *c,
 965                           struct jffs2_eraseblock *jeb, int mode)
 966 {
 967         int i, page, ret;
 968         int oobsize = c->mtd->oobsize;
 969         struct mtd_oob_ops ops;
 970
 971         ops.len = NR_OOB_SCAN_PAGES * oobsize;
 972         ops.ooblen = oobsize;
 973         ops.oobbuf = c->oobbuf;
 974         ops.ooboffs = 0;
 975         ops.datbuf = NULL;
 976         ops.mode = MTD_OOB_PLACE;
 977
 978         ret = c->mtd->read_oob(c->mtd, jeb->offset, &ops);
 979         if (ret) {
 980                 D1(printk(KERN_WARNING "jffs2_check_oob_empty(): Read OOB "
 981                           "failed %d for block at %08x\n", ret, jeb->offset));
 982                 return ret;
 983         }
 984
 985         if (ops.retlen < ops.len) {
 986                 D1(printk(KERN_WARNING "jffs2_check_oob_empty(): Read OOB "
 987                           "returned short read (%zd bytes not %d) for block "
 988                           "at %08x\n", ops.retlen, ops.len, jeb->offset));
 989                 return -EIO;
 990         }
 991
 992         /* Special check for first page */
 993         for(i = 0; i < oobsize ; i++) {
 994                 /* Yeah, we know about the cleanmarker. */
 995                 if (mode && i >= c->fsdata_pos &&
 996                     i < c->fsdata_pos + c->fsdata_len)
 997                         continue;
 998
 999                 if (ops.oobbuf[i] != 0xFF) {
1000                         D2(printk(KERN_DEBUG "Found %02x at %x in OOB for "
1001                                   "%08x\n", ops.oobbuf[i], i, jeb->offset));
1002                         return 1;
1003                 }
1004         }
1005
1006         /* we know, we are aligned :) */
1007         for (page = oobsize; page < ops.len; page += sizeof(long)) {
1008                 long dat = *(long *)(&ops.oobbuf[page]);
1009                 if(dat != -1)
1010                         return 1;
1011         }
1012         return 0;
1013 }
1014
1015 /*
1016  * Scan for a valid cleanmarker and for bad blocks
1017  */
1018 int jffs2_check_nand_cleanmarker (struct jffs2_sb_info *c,
1019                                   struct jffs2_eraseblock *jeb)
1020 {
1021         struct jffs2_unknown_node n;
1022         struct mtd_oob_ops ops;
1023         int oobsize = c->mtd->oobsize;
1024         unsigned char *p,*b;
1025         int i, ret;
1026         size_t offset = jeb->offset;
1027
1028         /* Check first if the block is bad. */
1029         if (c->mtd->block_isbad(c->mtd, offset)) {
1030                 D1 (printk(KERN_WARNING "jffs2_check_nand_cleanmarker()"
1031                            ": Bad block at %08x\n", jeb->offset));
1032                 return 2;
1033         }
1034
1035         ops.len = oobsize;
1036         ops.ooblen = oobsize;
1037         ops.oobbuf = c->oobbuf;
1038         ops.ooboffs = 0;
1039         ops.datbuf = NULL;
1040         ops.mode = MTD_OOB_PLACE;
1041
1042         ret = c->mtd->read_oob(c->mtd, offset, &ops);
1043         if (ret) {
1044                 D1 (printk(KERN_WARNING "jffs2_check_nand_cleanmarker(): "
1045                            "Read OOB failed %d for block at %08x\n",
1046                            ret, jeb->offset));
1047                 return ret;
1048         }
1049
1050         if (ops.retlen < ops.len) {
1051                 D1 (printk (KERN_WARNING "jffs2_check_nand_cleanmarker(): "
1052                             "Read OOB return short read (%zd bytes not %d) "
1053                             "for block at %08x\n", ops.retlen, ops.len,
1054                             jeb->offset));
1055                 return -EIO;
1056         }
1057
1058         n.magic = cpu_to_je16 (JFFS2_MAGIC_BITMASK);
1059         n.nodetype = cpu_to_je16 (JFFS2_NODETYPE_CLEANMARKER);
1060         n.totlen = cpu_to_je32 (8);
1061         p = (unsigned char *) &n;
1062         b = c->oobbuf + c->fsdata_pos;
1063
1064         for (i = c->fsdata_len; i; i--) {
1065                 if (*b++ != *p++)
1066                         ret = 1;
1067         }
1068
1069         D1(if (ret == 1) {
1070                 printk(KERN_WARNING "jffs2_check_nand_cleanmarker(): "
1071                        "Cleanmarker node not detected in block at %08x\n",
1072                        offset);
1073                 printk(KERN_WARNING "OOB at %08zx was ", offset);
1074                 for (i=0; i < oobsize; i++)
1075                         printk("%02x ", c->oobbuf[i]);
1076                 printk("\n");
1077         });
1078         return ret;
1079 }
1080
1081 int jffs2_write_nand_cleanmarker(struct jffs2_sb_info *c,
1082                                  struct jffs2_eraseblock *jeb)
1083 {
1084         struct jffs2_unknown_node n;
1085         int     ret;
1086         struct mtd_oob_ops ops;
1087
1088         n.magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
1089         n.nodetype = cpu_to_je16(JFFS2_NODETYPE_CLEANMARKER);
1090         n.totlen = cpu_to_je32(8);
1091
1092         ops.len = c->fsdata_len;
1093         ops.ooblen = c->fsdata_len;;
1094         ops.oobbuf = (uint8_t *)&n;
1095         ops.ooboffs = c->fsdata_pos;
1096         ops.datbuf = NULL;
1097         ops.mode = MTD_OOB_PLACE;
1098
1099         ret = c->mtd->write_oob(c->mtd, jeb->offset, &ops);
1100
1101         if (ret) {
1102                 D1(printk(KERN_WARNING "jffs2_write_nand_cleanmarker(): "
1103                           "Write failed for block at %08x: error %d\n",
1104                           jeb->offset, ret));
1105                 return ret;
1106         }
1107         if (ops.retlen != ops.len) {
1108                 D1(printk(KERN_WARNING "jffs2_write_nand_cleanmarker(): "
1109                           "Short write for block at %08x: %zd not %d\n",
1110                           jeb->offset, ops.retlen, ops.len));
1111                 return -EIO;
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 finaly 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         D1(printk(KERN_WARNING "jffs2_write_nand_badblock(): Marking bad block at %08x\n", 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 static int jffs2_nand_set_oobinfo(struct jffs2_sb_info *c)
1146 {
1147         struct nand_ecclayout *oinfo = c->mtd->ecclayout;
1148
1149         /* Do this only, if we have an oob buffer */
1150         if (!c->mtd->oobsize)
1151                 return 0;
1152
1153         /* Cleanmarker is out-of-band, so inline size zero */
1154         c->cleanmarker_size = 0;
1155
1156         /* Should we use autoplacement ? */
1157         if (!oinfo) {
1158                 D1(printk(KERN_DEBUG "JFFS2 on NAND. No autoplacment info found\n"));
1159                 return -EINVAL;
1160         }
1161
1162         D1(printk(KERN_DEBUG "JFFS2 using autoplace on NAND\n"));
1163         /* Get the position of the free bytes */
1164         if (!oinfo->oobfree[0].length) {
1165                 printk (KERN_WARNING "jffs2_nand_set_oobinfo(): Eeep."
1166                         " Autoplacement selected and no empty space in oob\n");
1167                 return -ENOSPC;
1168         }
1169         c->fsdata_pos = oinfo->oobfree[0].offset;
1170         c->fsdata_len = oinfo->oobfree[0].length;
1171         if (c->fsdata_len > 8)
1172                 c->fsdata_len = 8;
1173
1174         return 0;
1175 }
1176
1177 int jffs2_nand_flash_setup(struct jffs2_sb_info *c)
1178 {
1179         int res;
1180
1181         /* Initialise write buffer */
1182         init_rwsem(&c->wbuf_sem);
1183         c->wbuf_pagesize = c->mtd->writesize;
1184         c->wbuf_ofs = 0xFFFFFFFF;
1185
1186         c->wbuf = kmalloc(c->wbuf_pagesize, GFP_KERNEL);
1187         if (!c->wbuf)
1188                 return -ENOMEM;
1189
1190         c->oobbuf = kmalloc(NR_OOB_SCAN_PAGES * c->mtd->oobsize, GFP_KERNEL);
1191         if (!c->oobbuf)
1192                 return -ENOMEM;
1193
1194         res = jffs2_nand_set_oobinfo(c);
1195
1196 #ifdef BREAKME
1197         if (!brokenbuf)
1198                 brokenbuf = kmalloc(c->wbuf_pagesize, GFP_KERNEL);
1199         if (!brokenbuf) {
1200                 kfree(c->wbuf);
1201                 return -ENOMEM;
1202         }
1203         memset(brokenbuf, 0xdb, c->wbuf_pagesize);
1204 #endif
1205         return res;
1206 }
1207
1208 void jffs2_nand_flash_cleanup(struct jffs2_sb_info *c)
1209 {
1210         kfree(c->wbuf);
1211         kfree(c->oobbuf);
1212 }
1213
1214 int jffs2_dataflash_setup(struct jffs2_sb_info *c) {
1215         c->cleanmarker_size = 0;                /* No cleanmarkers needed */
1216
1217         /* Initialize write buffer */
1218         init_rwsem(&c->wbuf_sem);
1219
1220
1221         c->wbuf_pagesize =  c->mtd->erasesize;
1222
1223         /* Find a suitable c->sector_size
1224          * - Not too much sectors
1225          * - Sectors have to be at least 4 K + some bytes
1226          * - All known dataflashes have erase sizes of 528 or 1056
1227          * - we take at least 8 eraseblocks and want to have at least 8K size
1228          * - The concatenation should be a power of 2
1229         */
1230
1231         c->sector_size = 8 * c->mtd->erasesize;
1232
1233         while (c->sector_size < 8192) {
1234                 c->sector_size *= 2;
1235         }
1236
1237         /* It may be necessary to adjust the flash size */
1238         c->flash_size = c->mtd->size;
1239
1240         if ((c->flash_size % c->sector_size) != 0) {
1241                 c->flash_size = (c->flash_size / c->sector_size) * c->sector_size;
1242                 printk(KERN_WARNING "JFFS2 flash size adjusted to %dKiB\n", c->flash_size);
1243         };
1244
1245         c->wbuf_ofs = 0xFFFFFFFF;
1246         c->wbuf = kmalloc(c->wbuf_pagesize, GFP_KERNEL);
1247         if (!c->wbuf)
1248                 return -ENOMEM;
1249
1250         printk(KERN_INFO "JFFS2 write-buffering enabled buffer (%d) erasesize (%d)\n", c->wbuf_pagesize, c->sector_size);
1251
1252         return 0;
1253 }
1254
1255 void jffs2_dataflash_cleanup(struct jffs2_sb_info *c) {
1256         kfree(c->wbuf);
1257 }
1258
1259 int jffs2_nor_wbuf_flash_setup(struct jffs2_sb_info *c) {
1260         /* Cleanmarker currently occupies whole programming regions,
1261          * either one or 2 for 8Byte STMicro flashes. */
1262         c->cleanmarker_size = max(16u, c->mtd->writesize);
1263
1264         /* Initialize write buffer */
1265         init_rwsem(&c->wbuf_sem);
1266         c->wbuf_pagesize = c->mtd->writesize;
1267         c->wbuf_ofs = 0xFFFFFFFF;
1268
1269         c->wbuf = kmalloc(c->wbuf_pagesize, GFP_KERNEL);
1270         if (!c->wbuf)
1271                 return -ENOMEM;
1272
1273         return 0;
1274 }
1275
1276 void jffs2_nor_wbuf_flash_cleanup(struct jffs2_sb_info *c) {
1277         kfree(c->wbuf);
1278 }