/* * JFFS2 -- Journalling Flash File System, Version 2. * * Copyright (C) 2001-2003 Red Hat, Inc. * * Created by David Woodhouse * * For licensing information, see the file 'LICENCE' in this directory. * * $Id: wbuf.c,v 1.53 2003/10/11 11:46:09 dwmw2 Exp $ * */ #include #include #include #include #include #include "nodelist.h" /* For testing write failures */ #undef BREAKME #undef BREAKMEHEADER #ifdef BREAKME static unsigned char *brokenbuf; #endif /* max. erase failures before we mark a block bad */ #define MAX_ERASE_FAILURES 5 /* two seconds timeout for timed wbuf-flushing */ #define WBUF_FLUSH_TIMEOUT 2 * HZ struct jffs2_inodirty { uint32_t ino; struct jffs2_inodirty *next; }; static struct jffs2_inodirty inodirty_nomem; static int jffs2_wbuf_pending_for_ino(struct jffs2_sb_info *c, uint32_t ino) { struct jffs2_inodirty *this = c->wbuf_inodes; /* If a malloc failed, consider _everything_ dirty */ if (this == &inodirty_nomem) return 1; /* If ino == 0, _any_ non-GC writes mean 'yes' */ if (this && !ino) return 1; /* Look to see if the inode in question is pending in the wbuf */ while (this) { if (this->ino == ino) return 1; this = this->next; } return 0; } static void jffs2_clear_wbuf_ino_list(struct jffs2_sb_info *c) { struct jffs2_inodirty *this; this = c->wbuf_inodes; if (this != &inodirty_nomem) { while (this) { struct jffs2_inodirty *next = this->next; kfree(this); this = next; } } c->wbuf_inodes = NULL; } static void jffs2_wbuf_dirties_inode(struct jffs2_sb_info *c, uint32_t ino) { struct jffs2_inodirty *new; /* Mark the superblock dirty so that kupdated will flush... */ OFNI_BS_2SFFJ(c)->s_dirt = 1; if (jffs2_wbuf_pending_for_ino(c, ino)) return; new = kmalloc(sizeof(*new), GFP_KERNEL); if (!new) { D1(printk(KERN_DEBUG "No memory to allocate inodirty. Fallback to all considered dirty\n")); jffs2_clear_wbuf_ino_list(c); c->wbuf_inodes = &inodirty_nomem; return; } new->ino = ino; new->next = c->wbuf_inodes; c->wbuf_inodes = new; return; } static inline void jffs2_refile_wbuf_blocks(struct jffs2_sb_info *c) { struct list_head *this, *next; static int n; if (list_empty(&c->erasable_pending_wbuf_list)) return; list_for_each_safe(this, next, &c->erasable_pending_wbuf_list) { struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list); D1(printk(KERN_DEBUG "Removing eraseblock at 0x%08x from erasable_pending_wbuf_list...\n", jeb->offset)); list_del(this); if ((jiffies + (n++)) & 127) { /* Most of the time, we just erase it immediately. Otherwise we spend ages scanning it on mount, etc. */ D1(printk(KERN_DEBUG "...and adding to erase_pending_list\n")); list_add_tail(&jeb->list, &c->erase_pending_list); c->nr_erasing_blocks++; jffs2_erase_pending_trigger(c); } else { /* Sometimes, however, we leave it elsewhere so it doesn't get immediately reused, and we spread the load a bit. */ D1(printk(KERN_DEBUG "...and adding to erasable_list\n")); list_add_tail(&jeb->list, &c->erasable_list); } } } /* Recover from failure to write wbuf. Recover the nodes up to the * wbuf, not the one which we were starting to try to write. */ static void jffs2_wbuf_recover(struct jffs2_sb_info *c) { struct jffs2_eraseblock *jeb, *new_jeb; struct jffs2_raw_node_ref **first_raw, **raw; size_t retlen; int ret; unsigned char *buf; uint32_t start, end, ofs, len; spin_lock(&c->erase_completion_lock); jeb = &c->blocks[c->wbuf_ofs / c->sector_size]; D1(printk("About to refile bad block at %08x\n", jeb->offset)); D2(jffs2_dump_block_lists(c)); /* File the existing block on the bad_used_list.... */ if (c->nextblock == jeb) c->nextblock = NULL; else /* Not sure this should ever happen... need more coffee */ list_del(&jeb->list); if (jeb->first_node) { D1(printk("Refiling block at %08x to bad_used_list\n", jeb->offset)); list_add(&jeb->list, &c->bad_used_list); } else { BUG(); /* It has to have had some nodes or we couldn't be here */ D1(printk("Refiling block at %08x to erase_pending_list\n", jeb->offset)); list_add(&jeb->list, &c->erase_pending_list); c->nr_erasing_blocks++; jffs2_erase_pending_trigger(c); } D2(jffs2_dump_block_lists(c)); /* Adjust its size counts accordingly */ c->wasted_size += jeb->free_size; c->free_size -= jeb->free_size; jeb->wasted_size += jeb->free_size; jeb->free_size = 0; ACCT_SANITY_CHECK(c,jeb); D1(ACCT_PARANOIA_CHECK(jeb)); /* Find the first node to be recovered, by skipping over every node which ends before the wbuf starts, or which is obsolete. */ first_raw = &jeb->first_node; while (*first_raw && (ref_obsolete(*first_raw) || (ref_offset(*first_raw) + (*first_raw)->totlen) < c->wbuf_ofs)) { D1(printk(KERN_DEBUG "Skipping node at 0x%08x(%d)-0x%08x which is either before 0x%08x or obsolete\n", ref_offset(*first_raw), ref_flags(*first_raw), (ref_offset(*first_raw) + (*first_raw)->totlen), c->wbuf_ofs)); first_raw = &(*first_raw)->next_phys; } if (!*first_raw) { /* All nodes were obsolete. Nothing to recover. */ D1(printk(KERN_DEBUG "No non-obsolete nodes to be recovered. Just filing block bad\n")); spin_unlock(&c->erase_completion_lock); return; } start = ref_offset(*first_raw); end = ref_offset(*first_raw) + (*first_raw)->totlen; /* Find the last node to be recovered */ raw = first_raw; while ((*raw)) { if (!ref_obsolete(*raw)) end = ref_offset(*raw) + (*raw)->totlen; raw = &(*raw)->next_phys; } spin_unlock(&c->erase_completion_lock); D1(printk(KERN_DEBUG "wbuf recover %08x-%08x\n", start, end)); buf = NULL; if (start < c->wbuf_ofs) { /* First affected node was already partially written. * Attempt to reread the old data into our buffer. */ buf = kmalloc(end - start, GFP_KERNEL); if (!buf) { printk(KERN_CRIT "Malloc failure in wbuf recovery. Data loss ensues.\n"); goto read_failed; } /* Do the read... */ ret = c->mtd->read_ecc(c->mtd, start, c->wbuf_ofs - start, &retlen, buf, NULL, c->oobinfo); if (ret == -EIO && retlen == c->wbuf_ofs - start) { /* ECC recovered */ ret = 0; } if (ret || retlen != c->wbuf_ofs - start) { printk(KERN_CRIT "Old data are already lost in wbuf recovery. Data loss ensues.\n"); kfree(buf); buf = NULL; read_failed: first_raw = &(*first_raw)->next_phys; /* If this was the only node to be recovered, give up */ if (!(*first_raw)) return; /* It wasn't. Go on and try to recover nodes complete in the wbuf */ start = ref_offset(*first_raw); } else { /* Read succeeded. Copy the remaining data from the wbuf */ memcpy(buf + (c->wbuf_ofs - start), c->wbuf, end - c->wbuf_ofs); } } /* OK... we're to rewrite (end-start) bytes of data from first_raw onwards. Either 'buf' contains the data, or we find it in the wbuf */ /* ... and get an allocation of space from a shiny new block instead */ ret = jffs2_reserve_space_gc(c, end-start, &ofs, &len); if (ret) { printk(KERN_WARNING "Failed to allocate space for wbuf recovery. Data loss ensues.\n"); if (buf) kfree(buf); return; } if (end-start >= c->wbuf_pagesize) { /* Need to do another write immediately. This, btw, means that we'll be writing from 'buf' and not from the wbuf. Since if we're writing from the wbuf there won't be more than a wbuf full of data, now will there? :) */ uint32_t towrite = (end-start) - ((end-start)%c->wbuf_pagesize); D1(printk(KERN_DEBUG "Write 0x%x bytes at 0x%08x in wbuf recover\n", towrite, ofs)); #ifdef BREAKMEHEADER static int breakme; if (breakme++ == 20) { printk(KERN_NOTICE "Faking write error at 0x%08x\n", ofs); breakme = 0; c->mtd->write_ecc(c->mtd, ofs, towrite, &retlen, brokenbuf, NULL, c->oobinfo); ret = -EIO; } else #endif ret = c->mtd->write_ecc(c->mtd, ofs, towrite, &retlen, buf, NULL, c->oobinfo); if (ret || retlen != towrite) { /* Argh. We tried. Really we did. */ printk(KERN_CRIT "Recovery of wbuf failed due to a second write error\n"); kfree(buf); if (retlen) { struct jffs2_raw_node_ref *raw2; raw2 = jffs2_alloc_raw_node_ref(); if (!raw2) return; raw2->flash_offset = ofs | REF_OBSOLETE; raw2->totlen = (*first_raw)->totlen; raw2->next_phys = NULL; raw2->next_in_ino = NULL; jffs2_add_physical_node_ref(c, raw2); } return; } printk(KERN_NOTICE "Recovery of wbuf succeeded to %08x\n", ofs); c->wbuf_len = (end - start) - towrite; c->wbuf_ofs = ofs + towrite; memcpy(c->wbuf, buf + towrite, c->wbuf_len); /* Don't muck about with c->wbuf_inodes. False positives are harmless. */ kfree(buf); } else { /* OK, now we're left with the dregs in whichever buffer we're using */ if (buf) { memcpy(c->wbuf, buf, end-start); kfree(buf); } else { memmove(c->wbuf, c->wbuf + (start - c->wbuf_ofs), end - start); } c->wbuf_ofs = ofs; c->wbuf_len = end - start; } /* Now sort out the jffs2_raw_node_refs, moving them from the old to the next block */ new_jeb = &c->blocks[ofs / c->sector_size]; spin_lock(&c->erase_completion_lock); if (new_jeb->first_node) { /* Odd, but possible with ST flash later maybe */ new_jeb->last_node->next_phys = *first_raw; } else { new_jeb->first_node = *first_raw; } raw = first_raw; while (*raw) { D1(printk(KERN_DEBUG "Refiling block of %08x at %08x(%d) to %08x\n", (*raw)->totlen, ref_offset(*raw), ref_flags(*raw), ofs)); if (ref_obsolete(*raw)) { /* Shouldn't really happen much */ new_jeb->dirty_size += (*raw)->totlen; new_jeb->free_size -= (*raw)->totlen; c->dirty_size += (*raw)->totlen; } else { new_jeb->used_size += (*raw)->totlen; new_jeb->free_size -= (*raw)->totlen; jeb->dirty_size += (*raw)->totlen; jeb->used_size -= (*raw)->totlen; c->dirty_size += (*raw)->totlen; } c->free_size -= (*raw)->totlen; (*raw)->flash_offset = ofs | ref_flags(*raw); ofs += (*raw)->totlen; new_jeb->last_node = *raw; raw = &(*raw)->next_phys; } /* Fix up the original jeb now it's on the bad_list */ *first_raw = NULL; if (first_raw == &jeb->first_node) { jeb->last_node = NULL; D1(printk(KERN_DEBUG "Failing block at %08x is now empty. Moving to erase_pending_list\n", jeb->offset)); list_del(&jeb->list); list_add(&jeb->list, &c->erase_pending_list); c->nr_erasing_blocks++; jffs2_erase_pending_trigger(c); } else jeb->last_node = container_of(first_raw, struct jffs2_raw_node_ref, next_phys); ACCT_SANITY_CHECK(c,jeb); D1(ACCT_PARANOIA_CHECK(jeb)); ACCT_SANITY_CHECK(c,new_jeb); D1(ACCT_PARANOIA_CHECK(new_jeb)); spin_unlock(&c->erase_completion_lock); D1(printk(KERN_DEBUG "wbuf recovery completed OK\n")); } /* Meaning of pad argument: 0: Do not pad. Probably pointless - we only ever use this when we can't pad anyway. 1: Pad, do not adjust nextblock free_size 2: Pad, adjust nextblock free_size */ static int __jffs2_flush_wbuf(struct jffs2_sb_info *c, int pad) { int ret; size_t retlen; /* Nothing to do if not NAND flash. In particular, we shouldn't del_timer() the timer we never initialised. */ if (jffs2_can_mark_obsolete(c)) return 0; if (!down_trylock(&c->alloc_sem)) { up(&c->alloc_sem); printk(KERN_CRIT "jffs2_flush_wbuf() called with alloc_sem not locked!\n"); BUG(); } if(!c->wbuf || !c->wbuf_len) return 0; /* claim remaining space on the page this happens, if we have a change to a new block, or if fsync forces us to flush the writebuffer. if we have a switch to next page, we will not have enough remaining space for this. */ if (pad) { c->wbuf_len = PAD(c->wbuf_len); if ( c->wbuf_len + sizeof(struct jffs2_unknown_node) < c->wbuf_pagesize) { struct jffs2_unknown_node *padnode = (void *)(c->wbuf + c->wbuf_len); padnode->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK); padnode->nodetype = cpu_to_je16(JFFS2_NODETYPE_PADDING); padnode->totlen = cpu_to_je32(c->wbuf_pagesize - c->wbuf_len); padnode->hdr_crc = cpu_to_je32(crc32(0, padnode, sizeof(*padnode)-4)); } } /* else jffs2_flash_writev has actually filled in the rest of the buffer for us, and will deal with the node refs etc. later. */ #ifdef BREAKME static int breakme; if (breakme++ == 20) { printk(KERN_NOTICE "Faking write error at 0x%08x\n", c->wbuf_ofs); breakme = 0; c->mtd->write_ecc(c->mtd, c->wbuf_ofs, c->wbuf_pagesize, &retlen, brokenbuf, NULL, c->oobinfo); ret = -EIO; } else #endif ret = c->mtd->write_ecc(c->mtd, c->wbuf_ofs, c->wbuf_pagesize, &retlen, c->wbuf, NULL, c->oobinfo); if (ret || retlen != c->wbuf_pagesize) { if (ret) printk(KERN_WARNING "jffs2_flush_wbuf(): Write failed with %d\n",ret); else { printk(KERN_WARNING "jffs2_flush_wbuf(): Write was short: %zd instead of %d\n", retlen, c->wbuf_pagesize); ret = -EIO; } jffs2_wbuf_recover(c); return ret; } /* Adjusting free size of next block only, if it's called from fsync ! */ if (pad == 2) { D1(printk(KERN_DEBUG "jffs2_flush_wbuf() adjusting free_size of c->nextblock\n")); spin_lock(&c->erase_completion_lock); if (!c->nextblock) BUG(); /* wbuf_pagesize - wbuf_len is the amount of space that's to be padded. If there is less free space in the block than that, something screwed up */ if (c->nextblock->free_size < (c->wbuf_pagesize - c->wbuf_len)) { printk(KERN_CRIT "jffs2_flush_wbuf(): Accounting error. wbuf at 0x%08x has 0x%03x bytes, 0x%03x left.\n", c->wbuf_ofs, c->wbuf_len, c->wbuf_pagesize-c->wbuf_len); printk(KERN_CRIT "jffs2_flush_wbuf(): But free_size for block at 0x%08x is only 0x%08x\n", c->nextblock->offset, c->nextblock->free_size); BUG(); } c->nextblock->free_size -= (c->wbuf_pagesize - c->wbuf_len); c->free_size -= (c->wbuf_pagesize - c->wbuf_len); c->nextblock->wasted_size += (c->wbuf_pagesize - c->wbuf_len); c->wasted_size += (c->wbuf_pagesize - c->wbuf_len); spin_unlock(&c->erase_completion_lock); } /* Stick any now-obsoleted blocks on the erase_pending_list */ spin_lock(&c->erase_completion_lock); jffs2_refile_wbuf_blocks(c); jffs2_clear_wbuf_ino_list(c); spin_unlock(&c->erase_completion_lock); memset(c->wbuf,0xff,c->wbuf_pagesize); /* adjust write buffer offset, else we get a non contiguous write bug */ c->wbuf_ofs += c->wbuf_pagesize; c->wbuf_len = 0; return 0; } /* Trigger garbage collection to flush the write-buffer. If ino arg is zero, do it if _any_ real (i.e. not GC) writes are outstanding. If ino arg non-zero, do it only if a write for the given inode is outstanding. */ int jffs2_flush_wbuf_gc(struct jffs2_sb_info *c, uint32_t ino) { uint32_t old_wbuf_ofs; uint32_t old_wbuf_len; int ret = 0; D1(printk(KERN_DEBUG "jffs2_flush_wbuf_gc() called for ino #%u...\n", ino)); down(&c->alloc_sem); if (!jffs2_wbuf_pending_for_ino(c, ino)) { D1(printk(KERN_DEBUG "Ino #%d not pending in wbuf. Returning\n", ino)); up(&c->alloc_sem); return 0; } old_wbuf_ofs = c->wbuf_ofs; old_wbuf_len = c->wbuf_len; while (old_wbuf_len && old_wbuf_ofs == c->wbuf_ofs) { up(&c->alloc_sem); D1(printk(KERN_DEBUG "jffs2_flush_wbuf_gc() calls gc pass\n")); ret = jffs2_garbage_collect_pass(c); if (ret) { /* GC failed. Flush it with padding instead */ down(&c->alloc_sem); ret = __jffs2_flush_wbuf(c, 2); break; } down(&c->alloc_sem); } D1(printk(KERN_DEBUG "jffs2_flush_wbuf_gc() ends...\n")); up(&c->alloc_sem); return ret; } /* Pad write-buffer to end and write it, wasting space. */ int jffs2_flush_wbuf_pad(struct jffs2_sb_info *c) { return __jffs2_flush_wbuf(c, 1); } #define PAGE_DIV(x) ( (x) & (~(c->wbuf_pagesize - 1)) ) #define PAGE_MOD(x) ( (x) & (c->wbuf_pagesize - 1) ) int jffs2_flash_writev(struct jffs2_sb_info *c, const struct iovec *invecs, unsigned long count, loff_t to, size_t *retlen, uint32_t ino) { struct iovec outvecs[3]; uint32_t totlen = 0; uint32_t split_ofs = 0; uint32_t old_totlen; int ret, splitvec = -1; int invec, outvec; size_t wbuf_retlen; unsigned char *wbuf_ptr; size_t donelen = 0; uint32_t outvec_to = to; /* If not NAND flash, don't bother */ if (!c->wbuf) return jffs2_flash_direct_writev(c, invecs, count, to, retlen); /* If wbuf_ofs is not initialized, set it to target address */ if (c->wbuf_ofs == 0xFFFFFFFF) { c->wbuf_ofs = PAGE_DIV(to); c->wbuf_len = PAGE_MOD(to); memset(c->wbuf,0xff,c->wbuf_pagesize); } /* Sanity checks on target address. It's permitted to write at PAD(c->wbuf_len+c->wbuf_ofs), and it's permitted to write at the beginning of a new erase block. Anything else, and you die. New block starts at xxx000c (0-b = block header) */ if ( (to & ~(c->sector_size-1)) != (c->wbuf_ofs & ~(c->sector_size-1)) ) { /* It's a write to a new block */ if (c->wbuf_len) { D1(printk(KERN_DEBUG "jffs2_flash_writev() to 0x%lx causes flush of wbuf at 0x%08x\n", (unsigned long)to, c->wbuf_ofs)); ret = jffs2_flush_wbuf_pad(c); if (ret) { /* the underlying layer has to check wbuf_len to do the cleanup */ D1(printk(KERN_WARNING "jffs2_flush_wbuf() called from jffs2_flash_writev() failed %d\n", ret)); *retlen = 0; return ret; } } /* set pointer to new block */ c->wbuf_ofs = PAGE_DIV(to); c->wbuf_len = PAGE_MOD(to); } if (to != PAD(c->wbuf_ofs + c->wbuf_len)) { /* We're not writing immediately after the writebuffer. Bad. */ printk(KERN_CRIT "jffs2_flash_writev(): Non-contiguous write to %08lx\n", (unsigned long)to); if (c->wbuf_len) printk(KERN_CRIT "wbuf was previously %08x-%08x\n", c->wbuf_ofs, c->wbuf_ofs+c->wbuf_len); BUG(); } /* Note outvecs[3] above. We know count is never greater than 2 */ if (count > 2) { printk(KERN_CRIT "jffs2_flash_writev(): count is %ld\n", count); BUG(); } invec = 0; outvec = 0; /* Fill writebuffer first, if already in use */ if (c->wbuf_len) { uint32_t invec_ofs = 0; /* adjust alignment offset */ if (c->wbuf_len != PAGE_MOD(to)) { c->wbuf_len = PAGE_MOD(to); /* take care of alignment to next page */ if (!c->wbuf_len) c->wbuf_len = c->wbuf_pagesize; } while(c->wbuf_len < c->wbuf_pagesize) { uint32_t thislen; if (invec == count) goto alldone; thislen = c->wbuf_pagesize - c->wbuf_len; if (thislen >= invecs[invec].iov_len) thislen = invecs[invec].iov_len; invec_ofs = thislen; memcpy(c->wbuf + c->wbuf_len, invecs[invec].iov_base, thislen); c->wbuf_len += thislen; donelen += thislen; /* Get next invec, if actual did not fill the buffer */ if (c->wbuf_len < c->wbuf_pagesize) invec++; } /* write buffer is full, flush buffer */ ret = __jffs2_flush_wbuf(c, 0); if (ret) { /* the underlying layer has to check wbuf_len to do the cleanup */ D1(printk(KERN_WARNING "jffs2_flush_wbuf() called from jffs2_flash_writev() failed %d\n", ret)); /* Retlen zero to make sure our caller doesn't mark the space dirty. We've already done everything that's necessary */ *retlen = 0; return ret; } outvec_to += donelen; c->wbuf_ofs = outvec_to; /* All invecs done ? */ if (invec == count) goto alldone; /* Set up the first outvec, containing the remainder of the invec we partially used */ if (invecs[invec].iov_len > invec_ofs) { outvecs[0].iov_base = invecs[invec].iov_base+invec_ofs; totlen = outvecs[0].iov_len = invecs[invec].iov_len-invec_ofs; if (totlen > c->wbuf_pagesize) { splitvec = outvec; split_ofs = outvecs[0].iov_len - PAGE_MOD(totlen); } outvec++; } invec++; } /* OK, now we've flushed the wbuf and the start of the bits we have been asked to write, now to write the rest.... */ /* totlen holds the amount of data still to be written */ old_totlen = totlen; for ( ; invec < count; invec++,outvec++ ) { outvecs[outvec].iov_base = invecs[invec].iov_base; totlen += outvecs[outvec].iov_len = invecs[invec].iov_len; if (PAGE_DIV(totlen) != PAGE_DIV(old_totlen)) { splitvec = outvec; split_ofs = outvecs[outvec].iov_len - PAGE_MOD(totlen); old_totlen = totlen; } } /* Now the outvecs array holds all the remaining data to write */ /* Up to splitvec,split_ofs is to be written immediately. The rest goes into the (now-empty) wbuf */ if (splitvec != -1) { uint32_t remainder; int ret; remainder = outvecs[splitvec].iov_len - split_ofs; outvecs[splitvec].iov_len = split_ofs; /* We did cross a page boundary, so we write some now */ ret = c->mtd->writev_ecc(c->mtd, outvecs, splitvec+1, outvec_to, &wbuf_retlen, NULL, c->oobinfo); if (ret < 0 || wbuf_retlen != PAGE_DIV(totlen)) { /* At this point we have no problem, c->wbuf is empty. */ *retlen = donelen; return ret; } donelen += wbuf_retlen; c->wbuf_ofs = PAGE_DIV(outvec_to) + PAGE_DIV(totlen); if (remainder) { outvecs[splitvec].iov_base += split_ofs; outvecs[splitvec].iov_len = remainder; } else { splitvec++; } } else { splitvec = 0; } /* Now splitvec points to the start of the bits we have to copy into the wbuf */ wbuf_ptr = c->wbuf; for ( ; splitvec < outvec; splitvec++) { /* Don't copy the wbuf into itself */ if (outvecs[splitvec].iov_base == c->wbuf) continue; memcpy(wbuf_ptr, outvecs[splitvec].iov_base, outvecs[splitvec].iov_len); wbuf_ptr += outvecs[splitvec].iov_len; donelen += outvecs[splitvec].iov_len; } c->wbuf_len = wbuf_ptr - c->wbuf; /* If there's a remainder in the wbuf and it's a non-GC write, remember that the wbuf affects this ino */ alldone: *retlen = donelen; if (c->wbuf_len && ino) jffs2_wbuf_dirties_inode(c, ino); return 0; } /* * This is the entry for flash write. * Check, if we work on NAND FLASH, if so build an iovec and write it via vritev */ int jffs2_flash_write(struct jffs2_sb_info *c, loff_t ofs, size_t len, size_t *retlen, const u_char *buf) { struct iovec vecs[1]; if (jffs2_can_mark_obsolete(c)) return c->mtd->write(c->mtd, ofs, len, retlen, buf); vecs[0].iov_base = (unsigned char *) buf; vecs[0].iov_len = len; return jffs2_flash_writev(c, vecs, 1, ofs, retlen, 0); } /* Handle readback from writebuffer and ECC failure return */ int jffs2_flash_read(struct jffs2_sb_info *c, loff_t ofs, size_t len, size_t *retlen, u_char *buf) { loff_t orbf = 0, owbf = 0, lwbf = 0; int ret; /* Read flash */ if (!jffs2_can_mark_obsolete(c)) { ret = c->mtd->read_ecc(c->mtd, ofs, len, retlen, buf, NULL, c->oobinfo); if ( (ret == -EIO) && (*retlen == len) ) { printk(KERN_WARNING "mtd->read(0x%zx bytes from 0x%llx) returned ECC error\n", len, ofs); /* * We have the raw data without ECC correction in the buffer, maybe * we are lucky and all data or parts are correct. We check the node. * If data are corrupted node check will sort it out. * We keep this block, it will fail on write or erase and the we * mark it bad. Or should we do that now? But we should give him a chance. * Maybe we had a system crash or power loss before the ecc write or * a erase was completed. * So we return success. :) */ ret = 0; } } else return c->mtd->read(c->mtd, ofs, len, retlen, buf); /* if no writebuffer available or write buffer empty, return */ if (!c->wbuf_pagesize || !c->wbuf_len) return ret; /* if we read in a different block, return */ if ( (ofs & ~(c->sector_size-1)) != (c->wbuf_ofs & ~(c->sector_size-1)) ) return ret; if (ofs >= c->wbuf_ofs) { owbf = (ofs - c->wbuf_ofs); /* offset in write buffer */ if (owbf > c->wbuf_len) /* is read beyond write buffer ? */ return ret; lwbf = c->wbuf_len - owbf; /* number of bytes to copy */ if (lwbf > len) lwbf = len; } else { orbf = (c->wbuf_ofs - ofs); /* offset in read buffer */ if (orbf > len) /* is write beyond write buffer ? */ return ret; lwbf = len - orbf; /* number of bytes to copy */ if (lwbf > c->wbuf_len) lwbf = c->wbuf_len; } if (lwbf > 0) memcpy(buf+orbf,c->wbuf+owbf,lwbf); return ret; } /* * Check, if the out of band area is empty */ int jffs2_check_oob_empty( struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, int mode) { unsigned char *buf; int ret = 0; int i,len,page; size_t retlen; int oob_size; oob_size = c->mtd->oobsize; /* allocate a buffer for all oob data in this sector */ len = 4 * oob_size; buf = kmalloc(len, GFP_KERNEL); if (!buf) { printk(KERN_NOTICE "jffs2_check_oob_empty(): allocation of temporary data buffer for oob check failed\n"); return -ENOMEM; } /* * if mode = 0, we scan for a total empty oob area, else we have * to take care of the cleanmarker in the first page of the block */ ret = jffs2_flash_read_oob(c, jeb->offset, len , &retlen, buf); if (ret) { D1(printk(KERN_WARNING "jffs2_check_oob_empty(): Read OOB failed %d for block at %08x\n", ret, jeb->offset)); goto out; } if (retlen < len) { D1(printk(KERN_WARNING "jffs2_check_oob_empty(): Read OOB return short read " "(%zd bytes not %d) for block at %08x\n", retlen, len, jeb->offset)); ret = -EIO; goto out; } /* Special check for first two pages */ for (page = 0; page < 2 * oob_size; page += oob_size) { /* Check for bad block marker */ if (buf[page+c->badblock_pos] != 0xff) { D1(printk(KERN_WARNING "jffs2_check_oob_empty(): Bad or failed block at %08x\n",jeb->offset)); /* Return 2 for bad and 3 for failed block bad goes to list_bad and failed to list_erase */ ret = (!page) ? 2 : 3; goto out; } for(i = 0; i < oob_size ; i++) { /* Yeah, we know about the cleanmarker. */ if (mode && i >= c->fsdata_pos && i < c->fsdata_pos+c->fsdata_len) continue; if (buf[page+i] != 0xFF) { D2(printk(KERN_DEBUG "Found %02x at %x in OOB for %08x\n", buf[page+i], page+i, jeb->offset)); ret = 1; goto out; } } /* only the first page can contain a cleanmarker !*/ mode = 0; } /* we know, we are aligned :) */ for (; page < len; page += sizeof(long)) { unsigned long dat = *(unsigned long *)(&buf[page]); if(dat != -1) { ret = 1; goto out; } } out: kfree(buf); return ret; } /* * Scan for a valid cleanmarker and for bad blocks * For virtual blocks (concatenated physical blocks) check the cleanmarker * only in the first page of the first physical block, but scan for bad blocks in all * physical blocks */ int jffs2_check_nand_cleanmarker (struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb) { struct jffs2_unknown_node n; unsigned char buf[32]; unsigned char *p; int ret, i, cnt, retval = 0; size_t retlen, offset; int oob_size; offset = jeb->offset; oob_size = c->mtd->oobsize; /* Loop through the physical blocks */ for (cnt = 0; cnt < (c->sector_size / c->mtd->erasesize); cnt++) { /* * We read oob data from page 0 and 1 of the block. * page 0 contains cleanmarker and badblock info * page 1 contains failure count of this block */ ret = c->mtd->read_oob (c->mtd, offset, oob_size << 1, &retlen, buf); if (ret) { D1 (printk (KERN_WARNING "jffs2_check_nand_cleanmarker(): Read OOB failed %d for block at %08x\n", ret, jeb->offset)); return ret; } if (retlen < (oob_size << 1)) { D1 (printk (KERN_WARNING "jffs2_check_nand_cleanmarker(): Read OOB return short read (%zd bytes not %d) for block at %08x\n", retlen, oob_size << 1, jeb->offset)); return -EIO; } /* Check for bad block marker */ if (buf[c->badblock_pos] != 0xff) { D1 (printk (KERN_WARNING "jffs2_check_nand_cleanmarker(): Bad block at %08x (has %02x %02x in badblock_pos %d\n", jeb->offset, buf[c->badblock_pos], buf[c->badblock_pos + oob_size], c->badblock_pos)); return 2; } /* Check for failure counter in the second page */ if (buf[c->badblock_pos + oob_size] != 0xff) { D1 (printk (KERN_WARNING "jffs2_check_nand_cleanmarker(): Block marked as failed at %08x, fail count:%d\n", jeb->offset, buf[c->badblock_pos + oob_size])); return 3; } /* Check cleanmarker only on the first physical block */ if (!cnt) { n.magic = cpu_to_je16 (JFFS2_MAGIC_BITMASK); n.nodetype = cpu_to_je16 (JFFS2_NODETYPE_CLEANMARKER); n.totlen = cpu_to_je32 (8); p = (unsigned char *) &n; for (i = 0; i < c->fsdata_len; i++) { if (buf[c->fsdata_pos + i] != p[i]) { retval = 1; } } D1(if (retval == 1) { printk(KERN_WARNING "jffs2_check_nand_cleanmarker(): Cleanmarker node not detected in block at %08x\n", jeb->offset); printk(KERN_WARNING "OOB at %08x was ", offset); for (i=0; i < oob_size; i++) { printk("%02x ", buf[i]); } printk("\n"); }) } offset += c->mtd->erasesize; } return retval; } int jffs2_write_nand_cleanmarker(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb) { struct jffs2_unknown_node n; int ret; size_t retlen; n.magic = cpu_to_je16(JFFS2_MAGIC_BITMASK); n.nodetype = cpu_to_je16(JFFS2_NODETYPE_CLEANMARKER); n.totlen = cpu_to_je32(8); ret = jffs2_flash_write_oob(c, jeb->offset + c->fsdata_pos, c->fsdata_len, &retlen, (unsigned char *)&n); if (ret) { D1(printk(KERN_WARNING "jffs2_write_nand_cleanmarker(): Write failed for block at %08x: error %d\n", jeb->offset, ret)); return ret; } if (retlen != c->fsdata_len) { D1(printk(KERN_WARNING "jffs2_write_nand_cleanmarker(): Short write for block at %08x: %zd not %d\n", jeb->offset, retlen, c->fsdata_len)); return ret; } return 0; } /* * We try to get the failure count of this block. */ int jffs2_nand_read_failcnt(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb) { unsigned char buf[16]; int ret; size_t retlen; int oob_size; oob_size = c->mtd->oobsize; ret = c->mtd->read_oob(c->mtd, jeb->offset + c->mtd->oobblock, oob_size , &retlen, buf); if (ret) { D1(printk(KERN_WARNING "jffs2_nand_read_failcnt(): Read OOB failed %d for block at %08x\n", ret, jeb->offset)); return ret; } if (retlen < oob_size) { D1(printk(KERN_WARNING "jffs2_nand_read_failcnt(): Read OOB return short read (%zd bytes not %d) for block at %08x\n", retlen, oob_size, jeb->offset)); return -EIO; } jeb->bad_count = buf[c->badblock_pos]; return 0; } /* * On NAND we try to mark this block bad. We try to write how often * the block was erased and mark it finaly bad, if the count * is > MAX_ERASE_FAILURES. We read this information on mount ! * jeb->bad_count contains the count before this erase. * Don't care about failures. This block remains on the erase-pending * or badblock list as long as nobody manipulates the flash with * a bootloader or something like that. */ int jffs2_write_nand_badblock(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb) { unsigned char buf = 0x0; int ret; size_t retlen; /* if the count is < max, we try to write the counter to the 2nd page oob area */ if( ++jeb->bad_count < MAX_ERASE_FAILURES) { buf = (unsigned char)jeb->bad_count; c->badblock_pos += c->mtd->oobblock; } ret = jffs2_flash_write_oob(c, jeb->offset + c->badblock_pos, 1, &retlen, &buf); if (ret) { D1(printk(KERN_WARNING "jffs2_write_nand_badblock(): Write failed for block at %08x: error %d\n", jeb->offset, ret)); return ret; } if (retlen != 1) { D1(printk(KERN_WARNING "jffs2_write_nand_badblock(): Short write for block at %08x: %zd not 1\n", jeb->offset, retlen)); return ret; } return 0; } #define JFFS2_OOB_ECCPOS0 0 #define JFFS2_OOB_ECCPOS1 1 #define JFFS2_OOB_ECCPOS2 2 #define JFFS2_OOB_ECCPOS3 3 #define JFFS2_OOB_ECCPOS4 6 #define JFFS2_OOB_ECCPOS5 7 #define NAND_JFFS2_OOB8_FSDAPOS 6 #define NAND_JFFS2_OOB16_FSDAPOS 8 #define NAND_JFFS2_OOB8_FSDALEN 2 #define NAND_JFFS2_OOB16_FSDALEN 8 static struct nand_oobinfo jffs2_oobinfo_swecc = { .useecc = 1, .eccpos = {JFFS2_OOB_ECCPOS0, JFFS2_OOB_ECCPOS1, JFFS2_OOB_ECCPOS2, JFFS2_OOB_ECCPOS3, JFFS2_OOB_ECCPOS4, JFFS2_OOB_ECCPOS5} }; static struct nand_oobinfo jffs2_oobinfo_docecc = { .useecc = 1, .eccpos = {0,1,2,3,4,5} }; int jffs2_nand_flash_setup(struct jffs2_sb_info *c) { /* Cleanmarker is out-of-band, so inline size zero */ c->cleanmarker_size = 0; /* Initialise write buffer */ c->wbuf_pagesize = c->mtd->oobblock; c->wbuf_ofs = 0xFFFFFFFF; /* FIXME: If we had a generic way of describing the hardware's use of OOB area, we could perhaps make this generic too. */ switch(c->mtd->ecctype) { case MTD_ECC_SW: D1(printk(KERN_DEBUG "JFFS2 using software ECC\n")); c->oobinfo = &jffs2_oobinfo_swecc; if (c->mtd->oobsize == 8) { c->fsdata_pos = NAND_JFFS2_OOB8_FSDAPOS; c->fsdata_len = NAND_JFFS2_OOB8_FSDALEN; } else { c->fsdata_pos = NAND_JFFS2_OOB16_FSDAPOS; c->fsdata_len = NAND_JFFS2_OOB16_FSDALEN; } c->badblock_pos = NAND_BADBLOCK_POS; break; case MTD_ECC_RS_DiskOnChip: D1(printk(KERN_DEBUG "JFFS2 using DiskOnChip hardware ECC\n")); c->oobinfo = &jffs2_oobinfo_docecc; c->fsdata_pos = 6; c->fsdata_len = NAND_JFFS2_OOB16_FSDALEN; c->badblock_pos = 15; break; default: printk("JFFS2 doesn't yet know how to handle ECC type %d\n", c->mtd->ecctype); return -EINVAL; } c->wbuf = kmalloc(c->wbuf_pagesize, GFP_KERNEL); if (!c->wbuf) return -ENOMEM; #ifdef BREAKME if (!brokenbuf) brokenbuf = kmalloc(c->wbuf_pagesize, GFP_KERNEL); if (!brokenbuf) { kfree(c->wbuf); return -ENOMEM; } memset(brokenbuf, 0xdb, c->wbuf_pagesize); #endif return 0; } void jffs2_nand_flash_cleanup(struct jffs2_sb_info *c) { kfree(c->wbuf); }