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