blob: a6597d60d76de751224243ddfe6d990cd6de7e87 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * JFFS2 -- Journalling Flash File System, Version 2.
3 *
David Woodhousec00c3102007-04-25 14:16:47 +01004 * Copyright © 2001-2007 Red Hat, Inc.
5 * Copyright © 2004 Thomas Gleixner <tglx@linutronix.de>
Linus Torvalds1da177e2005-04-16 15:20:36 -07006 *
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 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070012 */
13
Joe Perches5a528952012-02-15 15:56:45 -080014#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
15
Linus Torvalds1da177e2005-04-16 15:20:36 -070016#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>
Tim Schmielau4e57b682005-10-30 15:03:48 -080021#include <linux/jiffies.h>
Al Viro914e2632006-10-18 13:55:46 -040022#include <linux/sched.h>
Artem Bityutskiy8bdc81c2012-05-07 19:56:53 +030023#include <linux/writeback.h>
Tim Schmielau4e57b682005-10-30 15:03:48 -080024
Linus Torvalds1da177e2005-04-16 15:20:36 -070025#include "nodelist.h"
26
27/* For testing write failures */
28#undef BREAKME
29#undef BREAKMEHEADER
30
31#ifdef BREAKME
32static unsigned char *brokenbuf;
33#endif
34
Artem B. Bityutskiydaba5cc2005-09-30 14:59:17 +010035#define PAGE_DIV(x) ( ((unsigned long)(x) / (unsigned long)(c->wbuf_pagesize)) * (unsigned long)(c->wbuf_pagesize) )
36#define PAGE_MOD(x) ( (unsigned long)(x) % (unsigned long)(c->wbuf_pagesize) )
37
Linus Torvalds1da177e2005-04-16 15:20:36 -070038/* max. erase failures before we mark a block bad */
39#define MAX_ERASE_FAILURES 2
40
Linus Torvalds1da177e2005-04-16 15:20:36 -070041struct jffs2_inodirty {
42 uint32_t ino;
43 struct jffs2_inodirty *next;
44};
45
46static struct jffs2_inodirty inodirty_nomem;
47
48static int jffs2_wbuf_pending_for_ino(struct jffs2_sb_info *c, uint32_t ino)
49{
50 struct jffs2_inodirty *this = c->wbuf_inodes;
51
52 /* If a malloc failed, consider _everything_ dirty */
53 if (this == &inodirty_nomem)
54 return 1;
55
56 /* If ino == 0, _any_ non-GC writes mean 'yes' */
57 if (this && !ino)
58 return 1;
59
60 /* Look to see if the inode in question is pending in the wbuf */
61 while (this) {
62 if (this->ino == ino)
63 return 1;
64 this = this->next;
65 }
66 return 0;
67}
68
69static void jffs2_clear_wbuf_ino_list(struct jffs2_sb_info *c)
70{
71 struct jffs2_inodirty *this;
72
73 this = c->wbuf_inodes;
74
75 if (this != &inodirty_nomem) {
76 while (this) {
77 struct jffs2_inodirty *next = this->next;
78 kfree(this);
79 this = next;
80 }
81 }
82 c->wbuf_inodes = NULL;
83}
84
85static void jffs2_wbuf_dirties_inode(struct jffs2_sb_info *c, uint32_t ino)
86{
87 struct jffs2_inodirty *new;
88
Artem Bityutskiy8bdc81c2012-05-07 19:56:53 +030089 /* Schedule delayed write-buffer write-out */
Joakim Tjernlund64a5c2e2010-05-19 17:13:19 +010090 jffs2_dirty_trigger(c);
Linus Torvalds1da177e2005-04-16 15:20:36 -070091
92 if (jffs2_wbuf_pending_for_ino(c, ino))
93 return;
94
95 new = kmalloc(sizeof(*new), GFP_KERNEL);
96 if (!new) {
Joe Perches9c261b32012-02-15 15:56:43 -080097 jffs2_dbg(1, "No memory to allocate inodirty. Fallback to all considered dirty\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -070098 jffs2_clear_wbuf_ino_list(c);
99 c->wbuf_inodes = &inodirty_nomem;
100 return;
101 }
102 new->ino = ino;
103 new->next = c->wbuf_inodes;
104 c->wbuf_inodes = new;
105 return;
106}
107
108static inline void jffs2_refile_wbuf_blocks(struct jffs2_sb_info *c)
109{
110 struct list_head *this, *next;
111 static int n;
112
113 if (list_empty(&c->erasable_pending_wbuf_list))
114 return;
115
116 list_for_each_safe(this, next, &c->erasable_pending_wbuf_list) {
117 struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list);
118
Joe Perches9c261b32012-02-15 15:56:43 -0800119 jffs2_dbg(1, "Removing eraseblock at 0x%08x from erasable_pending_wbuf_list...\n",
120 jeb->offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121 list_del(this);
122 if ((jiffies + (n++)) & 127) {
123 /* Most of the time, we just erase it immediately. Otherwise we
124 spend ages scanning it on mount, etc. */
Joe Perches9c261b32012-02-15 15:56:43 -0800125 jffs2_dbg(1, "...and adding to erase_pending_list\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126 list_add_tail(&jeb->list, &c->erase_pending_list);
127 c->nr_erasing_blocks++;
David Woodhouseae3b6ba2010-05-19 17:05:14 +0100128 jffs2_garbage_collect_trigger(c);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129 } else {
130 /* Sometimes, however, we leave it elsewhere so it doesn't get
131 immediately reused, and we spread the load a bit. */
Joe Perches9c261b32012-02-15 15:56:43 -0800132 jffs2_dbg(1, "...and adding to erasable_list\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133 list_add_tail(&jeb->list, &c->erasable_list);
134 }
135 }
136}
137
Estelle Hammache7f716cf2005-01-24 21:24:18 +0000138#define REFILE_NOTEMPTY 0
139#define REFILE_ANYWAY 1
140
141static void jffs2_block_refile(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, int allow_empty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142{
Joe Perches9c261b32012-02-15 15:56:43 -0800143 jffs2_dbg(1, "About to refile bad block at %08x\n", jeb->offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145 /* File the existing block on the bad_used_list.... */
146 if (c->nextblock == jeb)
147 c->nextblock = NULL;
148 else /* Not sure this should ever happen... need more coffee */
149 list_del(&jeb->list);
150 if (jeb->first_node) {
Joe Perches9c261b32012-02-15 15:56:43 -0800151 jffs2_dbg(1, "Refiling block at %08x to bad_used_list\n",
152 jeb->offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153 list_add(&jeb->list, &c->bad_used_list);
154 } else {
Estelle Hammache9b88f472005-01-28 18:53:05 +0000155 BUG_ON(allow_empty == REFILE_NOTEMPTY);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156 /* It has to have had some nodes or we couldn't be here */
Joe Perches9c261b32012-02-15 15:56:43 -0800157 jffs2_dbg(1, "Refiling block at %08x to erase_pending_list\n",
158 jeb->offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159 list_add(&jeb->list, &c->erase_pending_list);
160 c->nr_erasing_blocks++;
David Woodhouseae3b6ba2010-05-19 17:05:14 +0100161 jffs2_garbage_collect_trigger(c);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163
David Woodhouse9bfeb692006-05-26 21:19:05 +0100164 if (!jffs2_prealloc_raw_node_refs(c, jeb, 1)) {
165 uint32_t oldfree = jeb->free_size;
166
167 jffs2_link_node_ref(c, jeb,
168 (jeb->offset+c->sector_size-oldfree) | REF_OBSOLETE,
169 oldfree, NULL);
170 /* convert to wasted */
171 c->wasted_size += oldfree;
172 jeb->wasted_size += oldfree;
173 c->dirty_size -= oldfree;
174 jeb->dirty_size -= oldfree;
175 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176
Artem B. Bityutskiye0c8e422005-07-24 16:14:17 +0100177 jffs2_dbg_dump_block_lists_nolock(c);
178 jffs2_dbg_acct_sanity_check_nolock(c,jeb);
179 jffs2_dbg_acct_paranoia_check_nolock(c, jeb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180}
181
David Woodhouse9bfeb692006-05-26 21:19:05 +0100182static struct jffs2_raw_node_ref **jffs2_incore_replace_raw(struct jffs2_sb_info *c,
183 struct jffs2_inode_info *f,
184 struct jffs2_raw_node_ref *raw,
185 union jffs2_node_union *node)
186{
187 struct jffs2_node_frag *frag;
188 struct jffs2_full_dirent *fd;
189
190 dbg_noderef("incore_replace_raw: node at %p is {%04x,%04x}\n",
191 node, je16_to_cpu(node->u.magic), je16_to_cpu(node->u.nodetype));
192
193 BUG_ON(je16_to_cpu(node->u.magic) != 0x1985 &&
194 je16_to_cpu(node->u.magic) != 0);
195
196 switch (je16_to_cpu(node->u.nodetype)) {
197 case JFFS2_NODETYPE_INODE:
David Woodhouseddc58bd2006-05-27 13:15:16 +0100198 if (f->metadata && f->metadata->raw == raw) {
199 dbg_noderef("Will replace ->raw in f->metadata at %p\n", f->metadata);
200 return &f->metadata->raw;
201 }
David Woodhouse9bfeb692006-05-26 21:19:05 +0100202 frag = jffs2_lookup_node_frag(&f->fragtree, je32_to_cpu(node->i.offset));
203 BUG_ON(!frag);
204 /* Find a frag which refers to the full_dnode we want to modify */
205 while (!frag->node || frag->node->raw != raw) {
206 frag = frag_next(frag);
207 BUG_ON(!frag);
208 }
209 dbg_noderef("Will replace ->raw in full_dnode at %p\n", frag->node);
210 return &frag->node->raw;
David Woodhouse9bfeb692006-05-26 21:19:05 +0100211
212 case JFFS2_NODETYPE_DIRENT:
213 for (fd = f->dents; fd; fd = fd->next) {
214 if (fd->raw == raw) {
215 dbg_noderef("Will replace ->raw in full_dirent at %p\n", fd);
216 return &fd->raw;
217 }
218 }
219 BUG();
David Woodhouseddc58bd2006-05-27 13:15:16 +0100220
David Woodhouse9bfeb692006-05-26 21:19:05 +0100221 default:
222 dbg_noderef("Don't care about replacing raw for nodetype %x\n",
223 je16_to_cpu(node->u.nodetype));
224 break;
225 }
226 return NULL;
227}
228
David Woodhousea6bc4322007-07-11 14:23:54 +0100229#ifdef CONFIG_JFFS2_FS_WBUF_VERIFY
230static int jffs2_verify_write(struct jffs2_sb_info *c, unsigned char *buf,
231 uint32_t ofs)
232{
233 int ret;
234 size_t retlen;
235 char *eccstr;
236
Artem Bityutskiy329ad392011-12-23 17:30:16 +0200237 ret = mtd_read(c->mtd, ofs, c->wbuf_pagesize, &retlen, c->wbuf_verify);
David Woodhousea6bc4322007-07-11 14:23:54 +0100238 if (ret && ret != -EUCLEAN && ret != -EBADMSG) {
Joe Perchesda320f02012-02-15 15:56:44 -0800239 pr_warn("%s(): Read back of page at %08x failed: %d\n",
240 __func__, c->wbuf_ofs, ret);
David Woodhousea6bc4322007-07-11 14:23:54 +0100241 return ret;
242 } else if (retlen != c->wbuf_pagesize) {
Joe Perchesda320f02012-02-15 15:56:44 -0800243 pr_warn("%s(): Read back of page at %08x gave short read: %zd not %d\n",
244 __func__, ofs, retlen, c->wbuf_pagesize);
David Woodhousea6bc4322007-07-11 14:23:54 +0100245 return -EIO;
246 }
247 if (!memcmp(buf, c->wbuf_verify, c->wbuf_pagesize))
248 return 0;
249
250 if (ret == -EUCLEAN)
251 eccstr = "corrected";
252 else if (ret == -EBADMSG)
253 eccstr = "correction failed";
254 else
255 eccstr = "OK or unused";
256
Joe Perchesda320f02012-02-15 15:56:44 -0800257 pr_warn("Write verify error (ECC %s) at %08x. Wrote:\n",
258 eccstr, c->wbuf_ofs);
David Woodhousea6bc4322007-07-11 14:23:54 +0100259 print_hex_dump(KERN_WARNING, "", DUMP_PREFIX_OFFSET, 16, 1,
260 c->wbuf, c->wbuf_pagesize, 0);
261
Joe Perchesda320f02012-02-15 15:56:44 -0800262 pr_warn("Read back:\n");
David Woodhousea6bc4322007-07-11 14:23:54 +0100263 print_hex_dump(KERN_WARNING, "", DUMP_PREFIX_OFFSET, 16, 1,
264 c->wbuf_verify, c->wbuf_pagesize, 0);
265
266 return -EIO;
267}
268#else
269#define jffs2_verify_write(c,b,o) (0)
270#endif
271
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272/* Recover from failure to write wbuf. Recover the nodes up to the
273 * wbuf, not the one which we were starting to try to write. */
274
275static void jffs2_wbuf_recover(struct jffs2_sb_info *c)
276{
277 struct jffs2_eraseblock *jeb, *new_jeb;
David Woodhouse9bfeb692006-05-26 21:19:05 +0100278 struct jffs2_raw_node_ref *raw, *next, *first_raw = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279 size_t retlen;
280 int ret;
David Woodhouse9bfeb692006-05-26 21:19:05 +0100281 int nr_refile = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282 unsigned char *buf;
283 uint32_t start, end, ofs, len;
284
David Woodhouse046b8b92006-05-25 01:50:35 +0100285 jeb = &c->blocks[c->wbuf_ofs / c->sector_size];
286
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287 spin_lock(&c->erase_completion_lock);
Vitaly Wool180bfb32007-03-06 17:01:04 +0300288 if (c->wbuf_ofs % c->mtd->erasesize)
289 jffs2_block_refile(c, jeb, REFILE_NOTEMPTY);
290 else
291 jffs2_block_refile(c, jeb, REFILE_ANYWAY);
David Woodhouse9bfeb692006-05-26 21:19:05 +0100292 spin_unlock(&c->erase_completion_lock);
293
294 BUG_ON(!ref_obsolete(jeb->last_node));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295
296 /* Find the first node to be recovered, by skipping over every
297 node which ends before the wbuf starts, or which is obsolete. */
David Woodhouse9bfeb692006-05-26 21:19:05 +0100298 for (next = raw = jeb->first_node; next; raw = next) {
299 next = ref_next(raw);
300
301 if (ref_obsolete(raw) ||
302 (next && ref_offset(next) <= c->wbuf_ofs)) {
303 dbg_noderef("Skipping node at 0x%08x(%d)-0x%08x which is either before 0x%08x or obsolete\n",
304 ref_offset(raw), ref_flags(raw),
305 (ref_offset(raw) + ref_totlen(c, jeb, raw)),
306 c->wbuf_ofs);
307 continue;
308 }
309 dbg_noderef("First node to be recovered is at 0x%08x(%d)-0x%08x\n",
310 ref_offset(raw), ref_flags(raw),
311 (ref_offset(raw) + ref_totlen(c, jeb, raw)));
312
313 first_raw = raw;
314 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315 }
316
David Woodhouse9bfeb692006-05-26 21:19:05 +0100317 if (!first_raw) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318 /* All nodes were obsolete. Nothing to recover. */
Joe Perches9c261b32012-02-15 15:56:43 -0800319 jffs2_dbg(1, "No non-obsolete nodes to be recovered. Just filing block bad\n");
David Woodhouse9bfeb692006-05-26 21:19:05 +0100320 c->wbuf_len = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321 return;
322 }
323
David Woodhouse9bfeb692006-05-26 21:19:05 +0100324 start = ref_offset(first_raw);
325 end = ref_offset(jeb->last_node);
326 nr_refile = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327
David Woodhouse9bfeb692006-05-26 21:19:05 +0100328 /* Count the number of refs which need to be copied */
329 while ((raw = ref_next(raw)) != jeb->last_node)
330 nr_refile++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331
David Woodhouse9bfeb692006-05-26 21:19:05 +0100332 dbg_noderef("wbuf recover %08x-%08x (%d bytes in %d nodes)\n",
333 start, end, end - start, nr_refile);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334
335 buf = NULL;
336 if (start < c->wbuf_ofs) {
337 /* First affected node was already partially written.
338 * Attempt to reread the old data into our buffer. */
339
340 buf = kmalloc(end - start, GFP_KERNEL);
341 if (!buf) {
Joe Perchesda320f02012-02-15 15:56:44 -0800342 pr_crit("Malloc failure in wbuf recovery. Data loss ensues.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343
344 goto read_failed;
345 }
346
347 /* Do the read... */
Artem Bityutskiy329ad392011-12-23 17:30:16 +0200348 ret = mtd_read(c->mtd, start, c->wbuf_ofs - start, &retlen,
349 buf);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000350
Thomas Gleixner9a1fcdf2006-05-29 14:56:39 +0200351 /* ECC recovered ? */
352 if ((ret == -EUCLEAN || ret == -EBADMSG) &&
353 (retlen == c->wbuf_ofs - start))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354 ret = 0;
Thomas Gleixner9a1fcdf2006-05-29 14:56:39 +0200355
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356 if (ret || retlen != c->wbuf_ofs - start) {
Joe Perchesda320f02012-02-15 15:56:44 -0800357 pr_crit("Old data are already lost in wbuf recovery. Data loss ensues.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358
359 kfree(buf);
360 buf = NULL;
361 read_failed:
David Woodhouse9bfeb692006-05-26 21:19:05 +0100362 first_raw = ref_next(first_raw);
363 nr_refile--;
364 while (first_raw && ref_obsolete(first_raw)) {
365 first_raw = ref_next(first_raw);
366 nr_refile--;
367 }
368
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369 /* If this was the only node to be recovered, give up */
David Woodhouse9bfeb692006-05-26 21:19:05 +0100370 if (!first_raw) {
371 c->wbuf_len = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372 return;
David Woodhouse9bfeb692006-05-26 21:19:05 +0100373 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374
375 /* It wasn't. Go on and try to recover nodes complete in the wbuf */
David Woodhouse9bfeb692006-05-26 21:19:05 +0100376 start = ref_offset(first_raw);
377 dbg_noderef("wbuf now recover %08x-%08x (%d bytes in %d nodes)\n",
378 start, end, end - start, nr_refile);
379
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380 } else {
381 /* Read succeeded. Copy the remaining data from the wbuf */
382 memcpy(buf + (c->wbuf_ofs - start), c->wbuf, end - c->wbuf_ofs);
383 }
384 }
385 /* OK... we're to rewrite (end-start) bytes of data from first_raw onwards.
386 Either 'buf' contains the data, or we find it in the wbuf */
387
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388 /* ... and get an allocation of space from a shiny new block instead */
David Woodhouse9fe48542006-05-23 00:38:06 +0100389 ret = jffs2_reserve_space_gc(c, end-start, &len, JFFS2_SUMMARY_NOSUM_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390 if (ret) {
Joe Perchesda320f02012-02-15 15:56:44 -0800391 pr_warn("Failed to allocate space for wbuf recovery. Data loss ensues.\n");
Estelle Hammache9b88f472005-01-28 18:53:05 +0000392 kfree(buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393 return;
394 }
David Woodhouse9bfeb692006-05-26 21:19:05 +0100395
Adrian Hunter7f762ab2007-04-04 13:47:53 +0300396 /* The summary is not recovered, so it must be disabled for this erase block */
397 jffs2_sum_disable_collecting(c->summary);
398
David Woodhouse9bfeb692006-05-26 21:19:05 +0100399 ret = jffs2_prealloc_raw_node_refs(c, c->nextblock, nr_refile);
400 if (ret) {
Joe Perchesda320f02012-02-15 15:56:44 -0800401 pr_warn("Failed to allocate node refs for wbuf recovery. Data loss ensues.\n");
David Woodhouse9bfeb692006-05-26 21:19:05 +0100402 kfree(buf);
403 return;
404 }
405
David Woodhouse9fe48542006-05-23 00:38:06 +0100406 ofs = write_ofs(c);
407
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408 if (end-start >= c->wbuf_pagesize) {
Estelle Hammache7f716cf2005-01-24 21:24:18 +0000409 /* Need to do another write immediately, but it's possible
Estelle Hammache9b88f472005-01-28 18:53:05 +0000410 that this is just because the wbuf itself is completely
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000411 full, and there's nothing earlier read back from the
412 flash. Hence 'buf' isn't necessarily what we're writing
Estelle Hammache9b88f472005-01-28 18:53:05 +0000413 from. */
Estelle Hammache7f716cf2005-01-24 21:24:18 +0000414 unsigned char *rewrite_buf = buf?:c->wbuf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415 uint32_t towrite = (end-start) - ((end-start)%c->wbuf_pagesize);
416
Joe Perches9c261b32012-02-15 15:56:43 -0800417 jffs2_dbg(1, "Write 0x%x bytes at 0x%08x in wbuf recover\n",
418 towrite, ofs);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000419
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420#ifdef BREAKMEHEADER
421 static int breakme;
422 if (breakme++ == 20) {
Joe Perchesda320f02012-02-15 15:56:44 -0800423 pr_notice("Faking write error at 0x%08x\n", ofs);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424 breakme = 0;
Artem Bityutskiyeda95cb2011-12-23 17:35:41 +0200425 mtd_write(c->mtd, ofs, towrite, &retlen, brokenbuf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426 ret = -EIO;
427 } else
428#endif
Artem Bityutskiyeda95cb2011-12-23 17:35:41 +0200429 ret = mtd_write(c->mtd, ofs, towrite, &retlen,
430 rewrite_buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431
David Woodhousea6bc4322007-07-11 14:23:54 +0100432 if (ret || retlen != towrite || jffs2_verify_write(c, rewrite_buf, ofs)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433 /* Argh. We tried. Really we did. */
Joe Perchesda320f02012-02-15 15:56:44 -0800434 pr_crit("Recovery of wbuf failed due to a second write error\n");
Estelle Hammache9b88f472005-01-28 18:53:05 +0000435 kfree(buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436
David Woodhouse2f785402006-05-24 02:04:45 +0100437 if (retlen)
David Woodhouse9bfeb692006-05-26 21:19:05 +0100438 jffs2_add_physical_node_ref(c, ofs | REF_OBSOLETE, ref_totlen(c, jeb, first_raw), NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440 return;
441 }
Joe Perchesda320f02012-02-15 15:56:44 -0800442 pr_notice("Recovery of wbuf succeeded to %08x\n", ofs);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443
444 c->wbuf_len = (end - start) - towrite;
445 c->wbuf_ofs = ofs + towrite;
Estelle Hammache7f716cf2005-01-24 21:24:18 +0000446 memmove(c->wbuf, rewrite_buf + towrite, c->wbuf_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447 /* Don't muck about with c->wbuf_inodes. False positives are harmless. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 } else {
449 /* OK, now we're left with the dregs in whichever buffer we're using */
450 if (buf) {
451 memcpy(c->wbuf, buf, end-start);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452 } else {
453 memmove(c->wbuf, c->wbuf + (start - c->wbuf_ofs), end - start);
454 }
455 c->wbuf_ofs = ofs;
456 c->wbuf_len = end - start;
457 }
458
459 /* Now sort out the jffs2_raw_node_refs, moving them from the old to the next block */
460 new_jeb = &c->blocks[ofs / c->sector_size];
461
462 spin_lock(&c->erase_completion_lock);
David Woodhouse9bfeb692006-05-26 21:19:05 +0100463 for (raw = first_raw; raw != jeb->last_node; raw = ref_next(raw)) {
464 uint32_t rawlen = ref_totlen(c, jeb, raw);
465 struct jffs2_inode_cache *ic;
466 struct jffs2_raw_node_ref *new_ref;
467 struct jffs2_raw_node_ref **adjust_ref = NULL;
468 struct jffs2_inode_info *f = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469
Joe Perches9c261b32012-02-15 15:56:43 -0800470 jffs2_dbg(1, "Refiling block of %08x at %08x(%d) to %08x\n",
471 rawlen, ref_offset(raw), ref_flags(raw), ofs);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472
David Woodhouse9bfeb692006-05-26 21:19:05 +0100473 ic = jffs2_raw_ref_to_ic(raw);
474
475 /* Ick. This XATTR mess should be fixed shortly... */
476 if (ic && ic->class == RAWNODE_CLASS_XATTR_DATUM) {
477 struct jffs2_xattr_datum *xd = (void *)ic;
478 BUG_ON(xd->node != raw);
479 adjust_ref = &xd->node;
480 raw->next_in_ino = NULL;
481 ic = NULL;
482 } else if (ic && ic->class == RAWNODE_CLASS_XATTR_REF) {
483 struct jffs2_xattr_datum *xr = (void *)ic;
484 BUG_ON(xr->node != raw);
485 adjust_ref = &xr->node;
486 raw->next_in_ino = NULL;
487 ic = NULL;
488 } else if (ic && ic->class == RAWNODE_CLASS_INODE_CACHE) {
489 struct jffs2_raw_node_ref **p = &ic->nodes;
490
491 /* Remove the old node from the per-inode list */
492 while (*p && *p != (void *)ic) {
493 if (*p == raw) {
494 (*p) = (raw->next_in_ino);
495 raw->next_in_ino = NULL;
496 break;
497 }
498 p = &((*p)->next_in_ino);
499 }
500
501 if (ic->state == INO_STATE_PRESENT && !ref_obsolete(raw)) {
502 /* If it's an in-core inode, then we have to adjust any
503 full_dirent or full_dnode structure to point to the
504 new version instead of the old */
David Woodhouse27c72b02008-05-01 18:47:17 +0100505 f = jffs2_gc_fetch_inode(c, ic->ino, !ic->pino_nlink);
David Woodhouse9bfeb692006-05-26 21:19:05 +0100506 if (IS_ERR(f)) {
507 /* Should never happen; it _must_ be present */
508 JFFS2_ERROR("Failed to iget() ino #%u, err %ld\n",
509 ic->ino, PTR_ERR(f));
510 BUG();
511 }
512 /* We don't lock f->sem. There's a number of ways we could
513 end up in here with it already being locked, and nobody's
514 going to modify it on us anyway because we hold the
515 alloc_sem. We're only changing one ->raw pointer too,
516 which we can get away with without upsetting readers. */
517 adjust_ref = jffs2_incore_replace_raw(c, f, raw,
518 (void *)(buf?:c->wbuf) + (ref_offset(raw) - start));
519 } else if (unlikely(ic->state != INO_STATE_PRESENT &&
520 ic->state != INO_STATE_CHECKEDABSENT &&
521 ic->state != INO_STATE_GC)) {
522 JFFS2_ERROR("Inode #%u is in strange state %d!\n", ic->ino, ic->state);
523 BUG();
524 }
525 }
526
527 new_ref = jffs2_link_node_ref(c, new_jeb, ofs | ref_flags(raw), rawlen, ic);
528
529 if (adjust_ref) {
530 BUG_ON(*adjust_ref != raw);
531 *adjust_ref = new_ref;
532 }
533 if (f)
534 jffs2_gc_release_inode(c, f);
535
536 if (!ref_obsolete(raw)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537 jeb->dirty_size += rawlen;
538 jeb->used_size -= rawlen;
539 c->dirty_size += rawlen;
David Woodhouse9bfeb692006-05-26 21:19:05 +0100540 c->used_size -= rawlen;
541 raw->flash_offset = ref_offset(raw) | REF_OBSOLETE;
542 BUG_ON(raw->next_in_ino);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544 ofs += rawlen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545 }
546
David Woodhouse9bfeb692006-05-26 21:19:05 +0100547 kfree(buf);
548
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549 /* Fix up the original jeb now it's on the bad_list */
David Woodhouse9bfeb692006-05-26 21:19:05 +0100550 if (first_raw == jeb->first_node) {
Joe Perches9c261b32012-02-15 15:56:43 -0800551 jffs2_dbg(1, "Failing block at %08x is now empty. Moving to erase_pending_list\n",
552 jeb->offset);
Akinobu Mitaf1166292006-06-26 00:24:46 -0700553 list_move(&jeb->list, &c->erase_pending_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554 c->nr_erasing_blocks++;
David Woodhouseae3b6ba2010-05-19 17:05:14 +0100555 jffs2_garbage_collect_trigger(c);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557
Artem B. Bityutskiye0c8e422005-07-24 16:14:17 +0100558 jffs2_dbg_acct_sanity_check_nolock(c, jeb);
David Woodhouse9bfeb692006-05-26 21:19:05 +0100559 jffs2_dbg_acct_paranoia_check_nolock(c, jeb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560
Artem B. Bityutskiye0c8e422005-07-24 16:14:17 +0100561 jffs2_dbg_acct_sanity_check_nolock(c, new_jeb);
David Woodhouse9bfeb692006-05-26 21:19:05 +0100562 jffs2_dbg_acct_paranoia_check_nolock(c, new_jeb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563
564 spin_unlock(&c->erase_completion_lock);
565
Joe Perches9c261b32012-02-15 15:56:43 -0800566 jffs2_dbg(1, "wbuf recovery completed OK. wbuf_ofs 0x%08x, len 0x%x\n",
567 c->wbuf_ofs, c->wbuf_len);
David Woodhouse9bfeb692006-05-26 21:19:05 +0100568
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569}
570
571/* Meaning of pad argument:
572 0: Do not pad. Probably pointless - we only ever use this when we can't pad anyway.
573 1: Pad, do not adjust nextblock free_size
574 2: Pad, adjust nextblock free_size
575*/
576#define NOPAD 0
577#define PAD_NOACCOUNT 1
578#define PAD_ACCOUNTING 2
579
580static int __jffs2_flush_wbuf(struct jffs2_sb_info *c, int pad)
581{
David Woodhouse9bfeb692006-05-26 21:19:05 +0100582 struct jffs2_eraseblock *wbuf_jeb;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700583 int ret;
584 size_t retlen;
585
Andrew Victor3be36672005-02-09 09:09:05 +0000586 /* Nothing to do if not write-buffering the flash. In particular, we shouldn't
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587 del_timer() the timer we never initialised. */
Andrew Victor3be36672005-02-09 09:09:05 +0000588 if (!jffs2_is_writebuffered(c))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589 return 0;
590
Alexey Khoroshilov51b11e32011-06-28 00:21:30 +0400591 if (!mutex_is_locked(&c->alloc_sem)) {
Joe Perchesda320f02012-02-15 15:56:44 -0800592 pr_crit("jffs2_flush_wbuf() called with alloc_sem not locked!\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593 BUG();
594 }
595
Andrew Victor3be36672005-02-09 09:09:05 +0000596 if (!c->wbuf_len) /* already checked c->wbuf above */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597 return 0;
598
David Woodhouse9bfeb692006-05-26 21:19:05 +0100599 wbuf_jeb = &c->blocks[c->wbuf_ofs / c->sector_size];
600 if (jffs2_prealloc_raw_node_refs(c, wbuf_jeb, c->nextblock->allocated_refs + 1))
David Woodhouse2f785402006-05-24 02:04:45 +0100601 return -ENOMEM;
602
Linus Torvalds1da177e2005-04-16 15:20:36 -0700603 /* claim remaining space on the page
604 this happens, if we have a change to a new block,
605 or if fsync forces us to flush the writebuffer.
606 if we have a switch to next page, we will not have
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000607 enough remaining space for this.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608 */
Artem B. Bityutskiydaba5cc2005-09-30 14:59:17 +0100609 if (pad ) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610 c->wbuf_len = PAD(c->wbuf_len);
611
612 /* Pad with JFFS2_DIRTY_BITMASK initially. this helps out ECC'd NOR
613 with 8 byte page size */
614 memset(c->wbuf + c->wbuf_len, 0, c->wbuf_pagesize - c->wbuf_len);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000615
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616 if ( c->wbuf_len + sizeof(struct jffs2_unknown_node) < c->wbuf_pagesize) {
617 struct jffs2_unknown_node *padnode = (void *)(c->wbuf + c->wbuf_len);
618 padnode->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
619 padnode->nodetype = cpu_to_je16(JFFS2_NODETYPE_PADDING);
620 padnode->totlen = cpu_to_je32(c->wbuf_pagesize - c->wbuf_len);
621 padnode->hdr_crc = cpu_to_je32(crc32(0, padnode, sizeof(*padnode)-4));
622 }
623 }
624 /* else jffs2_flash_writev has actually filled in the rest of the
625 buffer for us, and will deal with the node refs etc. later. */
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000626
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627#ifdef BREAKME
628 static int breakme;
629 if (breakme++ == 20) {
Joe Perchesda320f02012-02-15 15:56:44 -0800630 pr_notice("Faking write error at 0x%08x\n", c->wbuf_ofs);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631 breakme = 0;
Artem Bityutskiyeda95cb2011-12-23 17:35:41 +0200632 mtd_write(c->mtd, c->wbuf_ofs, c->wbuf_pagesize, &retlen,
633 brokenbuf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700634 ret = -EIO;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000635 } else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700636#endif
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000637
Artem Bityutskiyeda95cb2011-12-23 17:35:41 +0200638 ret = mtd_write(c->mtd, c->wbuf_ofs, c->wbuf_pagesize,
639 &retlen, c->wbuf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640
David Woodhousea6bc4322007-07-11 14:23:54 +0100641 if (ret) {
Joe Perchesda320f02012-02-15 15:56:44 -0800642 pr_warn("jffs2_flush_wbuf(): Write failed with %d\n", ret);
David Woodhousea6bc4322007-07-11 14:23:54 +0100643 goto wfail;
644 } else if (retlen != c->wbuf_pagesize) {
Joe Perchesda320f02012-02-15 15:56:44 -0800645 pr_warn("jffs2_flush_wbuf(): Write was short: %zd instead of %d\n",
646 retlen, c->wbuf_pagesize);
David Woodhousea6bc4322007-07-11 14:23:54 +0100647 ret = -EIO;
648 goto wfail;
649 } else if ((ret = jffs2_verify_write(c, c->wbuf, c->wbuf_ofs))) {
650 wfail:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651 jffs2_wbuf_recover(c);
652
653 return ret;
654 }
655
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656 /* Adjust free size of the block if we padded. */
Artem B. Bityutskiydaba5cc2005-09-30 14:59:17 +0100657 if (pad) {
David Woodhouse0bcc0992006-05-21 13:00:54 +0100658 uint32_t waste = c->wbuf_pagesize - c->wbuf_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700659
Joe Perches9c261b32012-02-15 15:56:43 -0800660 jffs2_dbg(1, "jffs2_flush_wbuf() adjusting free_size of %sblock at %08x\n",
661 (wbuf_jeb == c->nextblock) ? "next" : "",
662 wbuf_jeb->offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000664 /* wbuf_pagesize - wbuf_len is the amount of space that's to be
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665 padded. If there is less free space in the block than that,
666 something screwed up */
David Woodhouse9bfeb692006-05-26 21:19:05 +0100667 if (wbuf_jeb->free_size < waste) {
Joe Perchesda320f02012-02-15 15:56:44 -0800668 pr_crit("jffs2_flush_wbuf(): Accounting error. wbuf at 0x%08x has 0x%03x bytes, 0x%03x left.\n",
669 c->wbuf_ofs, c->wbuf_len, waste);
670 pr_crit("jffs2_flush_wbuf(): But free_size for block at 0x%08x is only 0x%08x\n",
671 wbuf_jeb->offset, wbuf_jeb->free_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672 BUG();
673 }
David Woodhouse0bcc0992006-05-21 13:00:54 +0100674
675 spin_lock(&c->erase_completion_lock);
676
David Woodhouse9bfeb692006-05-26 21:19:05 +0100677 jffs2_link_node_ref(c, wbuf_jeb, (c->wbuf_ofs + c->wbuf_len) | REF_OBSOLETE, waste, NULL);
David Woodhouse0bcc0992006-05-21 13:00:54 +0100678 /* FIXME: that made it count as dirty. Convert to wasted */
David Woodhouse9bfeb692006-05-26 21:19:05 +0100679 wbuf_jeb->dirty_size -= waste;
David Woodhouse0bcc0992006-05-21 13:00:54 +0100680 c->dirty_size -= waste;
David Woodhouse9bfeb692006-05-26 21:19:05 +0100681 wbuf_jeb->wasted_size += waste;
David Woodhouse0bcc0992006-05-21 13:00:54 +0100682 c->wasted_size += waste;
683 } else
684 spin_lock(&c->erase_completion_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685
686 /* Stick any now-obsoleted blocks on the erase_pending_list */
687 jffs2_refile_wbuf_blocks(c);
688 jffs2_clear_wbuf_ino_list(c);
689 spin_unlock(&c->erase_completion_lock);
690
691 memset(c->wbuf,0xff,c->wbuf_pagesize);
692 /* adjust write buffer offset, else we get a non contiguous write bug */
Alexander Belyakov5bf17232008-10-17 19:19:13 +0400693 c->wbuf_ofs += c->wbuf_pagesize;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694 c->wbuf_len = 0;
695 return 0;
696}
697
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000698/* Trigger garbage collection to flush the write-buffer.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699 If ino arg is zero, do it if _any_ real (i.e. not GC) writes are
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000700 outstanding. If ino arg non-zero, do it only if a write for the
Linus Torvalds1da177e2005-04-16 15:20:36 -0700701 given inode is outstanding. */
702int jffs2_flush_wbuf_gc(struct jffs2_sb_info *c, uint32_t ino)
703{
704 uint32_t old_wbuf_ofs;
705 uint32_t old_wbuf_len;
706 int ret = 0;
707
Joe Perches9c261b32012-02-15 15:56:43 -0800708 jffs2_dbg(1, "jffs2_flush_wbuf_gc() called for ino #%u...\n", ino);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709
David Woodhouse8aee6ac2005-02-02 22:12:08 +0000710 if (!c->wbuf)
711 return 0;
712
David Woodhouseced22072008-04-22 15:13:40 +0100713 mutex_lock(&c->alloc_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714 if (!jffs2_wbuf_pending_for_ino(c, ino)) {
Joe Perches9c261b32012-02-15 15:56:43 -0800715 jffs2_dbg(1, "Ino #%d not pending in wbuf. Returning\n", ino);
David Woodhouseced22072008-04-22 15:13:40 +0100716 mutex_unlock(&c->alloc_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717 return 0;
718 }
719
720 old_wbuf_ofs = c->wbuf_ofs;
721 old_wbuf_len = c->wbuf_len;
722
723 if (c->unchecked_size) {
724 /* GC won't make any progress for a while */
Joe Perches9c261b32012-02-15 15:56:43 -0800725 jffs2_dbg(1, "%s(): padding. Not finished checking\n",
726 __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700727 down_write(&c->wbuf_sem);
728 ret = __jffs2_flush_wbuf(c, PAD_ACCOUNTING);
Estelle Hammache7f716cf2005-01-24 21:24:18 +0000729 /* retry flushing wbuf in case jffs2_wbuf_recover
730 left some data in the wbuf */
731 if (ret)
Estelle Hammache7f716cf2005-01-24 21:24:18 +0000732 ret = __jffs2_flush_wbuf(c, PAD_ACCOUNTING);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733 up_write(&c->wbuf_sem);
734 } else while (old_wbuf_len &&
735 old_wbuf_ofs == c->wbuf_ofs) {
736
David Woodhouseced22072008-04-22 15:13:40 +0100737 mutex_unlock(&c->alloc_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738
Joe Perches9c261b32012-02-15 15:56:43 -0800739 jffs2_dbg(1, "%s(): calls gc pass\n", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740
741 ret = jffs2_garbage_collect_pass(c);
742 if (ret) {
743 /* GC failed. Flush it with padding instead */
David Woodhouseced22072008-04-22 15:13:40 +0100744 mutex_lock(&c->alloc_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700745 down_write(&c->wbuf_sem);
746 ret = __jffs2_flush_wbuf(c, PAD_ACCOUNTING);
Estelle Hammache7f716cf2005-01-24 21:24:18 +0000747 /* retry flushing wbuf in case jffs2_wbuf_recover
748 left some data in the wbuf */
749 if (ret)
Estelle Hammache7f716cf2005-01-24 21:24:18 +0000750 ret = __jffs2_flush_wbuf(c, PAD_ACCOUNTING);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751 up_write(&c->wbuf_sem);
752 break;
753 }
David Woodhouseced22072008-04-22 15:13:40 +0100754 mutex_lock(&c->alloc_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700755 }
756
Joe Perches9c261b32012-02-15 15:56:43 -0800757 jffs2_dbg(1, "%s(): ends...\n", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700758
David Woodhouseced22072008-04-22 15:13:40 +0100759 mutex_unlock(&c->alloc_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760 return ret;
761}
762
763/* Pad write-buffer to end and write it, wasting space. */
764int jffs2_flush_wbuf_pad(struct jffs2_sb_info *c)
765{
766 int ret;
767
David Woodhouse8aee6ac2005-02-02 22:12:08 +0000768 if (!c->wbuf)
769 return 0;
770
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771 down_write(&c->wbuf_sem);
772 ret = __jffs2_flush_wbuf(c, PAD_NOACCOUNT);
Estelle Hammache7f716cf2005-01-24 21:24:18 +0000773 /* retry - maybe wbuf recover left some data in wbuf. */
774 if (ret)
775 ret = __jffs2_flush_wbuf(c, PAD_NOACCOUNT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776 up_write(&c->wbuf_sem);
777
778 return ret;
779}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700780
Thomas Gleixnerdcb09322006-05-23 11:49:14 +0200781static size_t jffs2_fill_wbuf(struct jffs2_sb_info *c, const uint8_t *buf,
782 size_t len)
783{
784 if (len && !c->wbuf_len && (len >= c->wbuf_pagesize))
785 return 0;
786
787 if (len > (c->wbuf_pagesize - c->wbuf_len))
788 len = c->wbuf_pagesize - c->wbuf_len;
789 memcpy(c->wbuf + c->wbuf_len, buf, len);
790 c->wbuf_len += (uint32_t) len;
791 return len;
792}
793
794int jffs2_flash_writev(struct jffs2_sb_info *c, const struct kvec *invecs,
795 unsigned long count, loff_t to, size_t *retlen,
796 uint32_t ino)
797{
798 struct jffs2_eraseblock *jeb;
799 size_t wbuf_retlen, donelen = 0;
800 uint32_t outvec_to = to;
801 int ret, invec;
802
803 /* If not writebuffered flash, don't bother */
Andrew Victor3be36672005-02-09 09:09:05 +0000804 if (!jffs2_is_writebuffered(c))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700805 return jffs2_flash_direct_writev(c, invecs, count, to, retlen);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000806
Linus Torvalds1da177e2005-04-16 15:20:36 -0700807 down_write(&c->wbuf_sem);
808
809 /* If wbuf_ofs is not initialized, set it to target address */
810 if (c->wbuf_ofs == 0xFFFFFFFF) {
811 c->wbuf_ofs = PAGE_DIV(to);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000812 c->wbuf_len = PAGE_MOD(to);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813 memset(c->wbuf,0xff,c->wbuf_pagesize);
814 }
815
Thomas Gleixnerdcb09322006-05-23 11:49:14 +0200816 /*
Thomas Gleixnerdcb09322006-05-23 11:49:14 +0200817 * Sanity checks on target address. It's permitted to write
818 * at PAD(c->wbuf_len+c->wbuf_ofs), and it's permitted to
819 * write at the beginning of a new erase block. Anything else,
820 * and you die. New block starts at xxx000c (0-b = block
821 * header)
822 */
Andrew Victor3be36672005-02-09 09:09:05 +0000823 if (SECTOR_ADDR(to) != SECTOR_ADDR(c->wbuf_ofs)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824 /* It's a write to a new block */
825 if (c->wbuf_len) {
Joe Perches9c261b32012-02-15 15:56:43 -0800826 jffs2_dbg(1, "%s(): to 0x%lx causes flush of wbuf at 0x%08x\n",
827 __func__, (unsigned long)to, c->wbuf_ofs);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700828 ret = __jffs2_flush_wbuf(c, PAD_NOACCOUNT);
Thomas Gleixnerdcb09322006-05-23 11:49:14 +0200829 if (ret)
830 goto outerr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700831 }
832 /* set pointer to new block */
833 c->wbuf_ofs = PAGE_DIV(to);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000834 c->wbuf_len = PAGE_MOD(to);
835 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700836
837 if (to != PAD(c->wbuf_ofs + c->wbuf_len)) {
838 /* We're not writing immediately after the writebuffer. Bad. */
Joe Perchesda320f02012-02-15 15:56:44 -0800839 pr_crit("%s(): Non-contiguous write to %08lx\n",
840 __func__, (unsigned long)to);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841 if (c->wbuf_len)
Joe Perchesda320f02012-02-15 15:56:44 -0800842 pr_crit("wbuf was previously %08x-%08x\n",
843 c->wbuf_ofs, c->wbuf_ofs + c->wbuf_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844 BUG();
845 }
846
Thomas Gleixnerdcb09322006-05-23 11:49:14 +0200847 /* adjust alignment offset */
848 if (c->wbuf_len != PAGE_MOD(to)) {
849 c->wbuf_len = PAGE_MOD(to);
850 /* take care of alignment to next page */
851 if (!c->wbuf_len) {
852 c->wbuf_len = c->wbuf_pagesize;
853 ret = __jffs2_flush_wbuf(c, NOPAD);
854 if (ret)
855 goto outerr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700856 }
857 }
858
Thomas Gleixnerdcb09322006-05-23 11:49:14 +0200859 for (invec = 0; invec < count; invec++) {
860 int vlen = invecs[invec].iov_len;
861 uint8_t *v = invecs[invec].iov_base;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700862
Thomas Gleixnerdcb09322006-05-23 11:49:14 +0200863 wbuf_retlen = jffs2_fill_wbuf(c, v, vlen);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864
Thomas Gleixnerdcb09322006-05-23 11:49:14 +0200865 if (c->wbuf_len == c->wbuf_pagesize) {
866 ret = __jffs2_flush_wbuf(c, NOPAD);
867 if (ret)
868 goto outerr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869 }
Thomas Gleixnerdcb09322006-05-23 11:49:14 +0200870 vlen -= wbuf_retlen;
871 outvec_to += wbuf_retlen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700872 donelen += wbuf_retlen;
Thomas Gleixnerdcb09322006-05-23 11:49:14 +0200873 v += wbuf_retlen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700874
Thomas Gleixnerdcb09322006-05-23 11:49:14 +0200875 if (vlen >= c->wbuf_pagesize) {
Artem Bityutskiyeda95cb2011-12-23 17:35:41 +0200876 ret = mtd_write(c->mtd, outvec_to, PAGE_DIV(vlen),
877 &wbuf_retlen, v);
Thomas Gleixnerdcb09322006-05-23 11:49:14 +0200878 if (ret < 0 || wbuf_retlen != PAGE_DIV(vlen))
879 goto outfile;
880
881 vlen -= wbuf_retlen;
882 outvec_to += wbuf_retlen;
883 c->wbuf_ofs = outvec_to;
884 donelen += wbuf_retlen;
885 v += wbuf_retlen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700886 }
887
Thomas Gleixnerdcb09322006-05-23 11:49:14 +0200888 wbuf_retlen = jffs2_fill_wbuf(c, v, vlen);
889 if (c->wbuf_len == c->wbuf_pagesize) {
890 ret = __jffs2_flush_wbuf(c, NOPAD);
891 if (ret)
892 goto outerr;
893 }
894
895 outvec_to += wbuf_retlen;
896 donelen += wbuf_retlen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700897 }
898
Thomas Gleixnerdcb09322006-05-23 11:49:14 +0200899 /*
900 * If there's a remainder in the wbuf and it's a non-GC write,
901 * remember that the wbuf affects this ino
902 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700903 *retlen = donelen;
904
Ferenc Havasie631ddb2005-09-07 09:35:26 +0100905 if (jffs2_sum_active()) {
906 int res = jffs2_sum_add_kvec(c, invecs, count, (uint32_t) to);
907 if (res)
908 return res;
909 }
910
Linus Torvalds1da177e2005-04-16 15:20:36 -0700911 if (c->wbuf_len && ino)
912 jffs2_wbuf_dirties_inode(c, ino);
913
914 ret = 0;
Thomas Gleixnerdcb09322006-05-23 11:49:14 +0200915 up_write(&c->wbuf_sem);
916 return ret;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000917
Thomas Gleixnerdcb09322006-05-23 11:49:14 +0200918outfile:
919 /*
920 * At this point we have no problem, c->wbuf is empty. However
921 * refile nextblock to avoid writing again to same address.
922 */
923
924 spin_lock(&c->erase_completion_lock);
925
926 jeb = &c->blocks[outvec_to / c->sector_size];
927 jffs2_block_refile(c, jeb, REFILE_ANYWAY);
928
929 spin_unlock(&c->erase_completion_lock);
930
931outerr:
932 *retlen = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700933 up_write(&c->wbuf_sem);
934 return ret;
935}
936
937/*
938 * This is the entry for flash write.
939 * Check, if we work on NAND FLASH, if so build an kvec and write it via vritev
940*/
David Woodhouse9bfeb692006-05-26 21:19:05 +0100941int jffs2_flash_write(struct jffs2_sb_info *c, loff_t ofs, size_t len,
942 size_t *retlen, const u_char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700943{
944 struct kvec vecs[1];
945
Andrew Victor3be36672005-02-09 09:09:05 +0000946 if (!jffs2_is_writebuffered(c))
Ferenc Havasie631ddb2005-09-07 09:35:26 +0100947 return jffs2_flash_direct_write(c, ofs, len, retlen, buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700948
949 vecs[0].iov_base = (unsigned char *) buf;
950 vecs[0].iov_len = len;
951 return jffs2_flash_writev(c, vecs, 1, ofs, retlen, 0);
952}
953
954/*
955 Handle readback from writebuffer and ECC failure return
956*/
957int jffs2_flash_read(struct jffs2_sb_info *c, loff_t ofs, size_t len, size_t *retlen, u_char *buf)
958{
959 loff_t orbf = 0, owbf = 0, lwbf = 0;
960 int ret;
961
Andrew Victor3be36672005-02-09 09:09:05 +0000962 if (!jffs2_is_writebuffered(c))
Artem Bityutskiy329ad392011-12-23 17:30:16 +0200963 return mtd_read(c->mtd, ofs, len, retlen, buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700964
Andrew Victor3be36672005-02-09 09:09:05 +0000965 /* Read flash */
Artem B. Bityuckiy894214d2005-04-05 13:51:58 +0100966 down_read(&c->wbuf_sem);
Artem Bityutskiy329ad392011-12-23 17:30:16 +0200967 ret = mtd_read(c->mtd, ofs, len, retlen, buf);
Andrew Victor3be36672005-02-09 09:09:05 +0000968
Thomas Gleixner9a1fcdf2006-05-29 14:56:39 +0200969 if ( (ret == -EBADMSG || ret == -EUCLEAN) && (*retlen == len) ) {
970 if (ret == -EBADMSG)
Joe Perchesda320f02012-02-15 15:56:44 -0800971 pr_warn("mtd->read(0x%zx bytes from 0x%llx) returned ECC error\n",
972 len, ofs);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000973 /*
Thomas Gleixner9a1fcdf2006-05-29 14:56:39 +0200974 * We have the raw data without ECC correction in the buffer,
975 * maybe we are lucky and all data or parts are correct. We
976 * check the node. If data are corrupted node check will sort
977 * it out. We keep this block, it will fail on write or erase
978 * and the we mark it bad. Or should we do that now? But we
979 * should give him a chance. Maybe we had a system crash or
980 * power loss before the ecc write or a erase was completed.
Andrew Victor3be36672005-02-09 09:09:05 +0000981 * So we return success. :)
982 */
Thomas Gleixner9a1fcdf2006-05-29 14:56:39 +0200983 ret = 0;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000984 }
Andrew Victor3be36672005-02-09 09:09:05 +0000985
Linus Torvalds1da177e2005-04-16 15:20:36 -0700986 /* if no writebuffer available or write buffer empty, return */
987 if (!c->wbuf_pagesize || !c->wbuf_len)
Artem B. Bityuckiy894214d2005-04-05 13:51:58 +0100988 goto exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700989
990 /* if we read in a different block, return */
Andrew Victor3be36672005-02-09 09:09:05 +0000991 if (SECTOR_ADDR(ofs) != SECTOR_ADDR(c->wbuf_ofs))
Artem B. Bityuckiy894214d2005-04-05 13:51:58 +0100992 goto exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700993
994 if (ofs >= c->wbuf_ofs) {
995 owbf = (ofs - c->wbuf_ofs); /* offset in write buffer */
996 if (owbf > c->wbuf_len) /* is read beyond write buffer ? */
997 goto exit;
998 lwbf = c->wbuf_len - owbf; /* number of bytes to copy */
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000999 if (lwbf > len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001000 lwbf = len;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +00001001 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001002 orbf = (c->wbuf_ofs - ofs); /* offset in read buffer */
1003 if (orbf > len) /* is write beyond write buffer ? */
1004 goto exit;
Thomas Gleixner9a1fcdf2006-05-29 14:56:39 +02001005 lwbf = len - orbf; /* number of bytes to copy */
Thomas Gleixner182ec4e2005-11-07 11:16:07 +00001006 if (lwbf > c->wbuf_len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001007 lwbf = c->wbuf_len;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +00001008 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001009 if (lwbf > 0)
1010 memcpy(buf+orbf,c->wbuf+owbf,lwbf);
1011
1012exit:
1013 up_read(&c->wbuf_sem);
1014 return ret;
1015}
1016
Artem Bityutskiya7a6ace12007-01-31 11:38:53 +02001017#define NR_OOB_SCAN_PAGES 4
1018
David Woodhouse09b3fba2007-08-09 17:28:20 +08001019/* For historical reasons we use only 8 bytes for OOB clean marker */
1020#define OOB_CM_SIZE 8
Artem Bityutskiya7a6ace12007-01-31 11:38:53 +02001021
1022static const struct jffs2_unknown_node oob_cleanmarker =
1023{
David Woodhouse566865a2007-04-23 12:07:17 +01001024 .magic = constant_cpu_to_je16(JFFS2_MAGIC_BITMASK),
1025 .nodetype = constant_cpu_to_je16(JFFS2_NODETYPE_CLEANMARKER),
1026 .totlen = constant_cpu_to_je32(8)
Artem Bityutskiya7a6ace12007-01-31 11:38:53 +02001027};
Thomas Gleixner8593fbc2006-05-29 03:26:58 +02001028
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029/*
Artem Bityutskiya7a6ace12007-01-31 11:38:53 +02001030 * Check, if the out of band area is empty. This function knows about the clean
1031 * marker and if it is present in OOB, treats the OOB as empty anyway.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001032 */
Thomas Gleixner8593fbc2006-05-29 03:26:58 +02001033int jffs2_check_oob_empty(struct jffs2_sb_info *c,
1034 struct jffs2_eraseblock *jeb, int mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001035{
Artem Bityutskiya7a6ace12007-01-31 11:38:53 +02001036 int i, ret;
1037 int cmlen = min_t(int, c->oobavail, OOB_CM_SIZE);
Thomas Gleixner8593fbc2006-05-29 03:26:58 +02001038 struct mtd_oob_ops ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001039
Brian Norris0612b9d2011-08-30 18:45:40 -07001040 ops.mode = MTD_OPS_AUTO_OOB;
Artem Bityutskiya7a6ace12007-01-31 11:38:53 +02001041 ops.ooblen = NR_OOB_SCAN_PAGES * c->oobavail;
Thomas Gleixner8593fbc2006-05-29 03:26:58 +02001042 ops.oobbuf = c->oobbuf;
Artem Bityutskiya7a6ace12007-01-31 11:38:53 +02001043 ops.len = ops.ooboffs = ops.retlen = ops.oobretlen = 0;
Thomas Gleixner8593fbc2006-05-29 03:26:58 +02001044 ops.datbuf = NULL;
Thomas Gleixner8593fbc2006-05-29 03:26:58 +02001045
Artem Bityutskiyfd2819b2011-12-23 18:27:05 +02001046 ret = mtd_read_oob(c->mtd, jeb->offset, &ops);
Brian Norris74d83be2012-08-31 15:01:19 -07001047 if ((ret && !mtd_is_bitflip(ret)) || ops.oobretlen != ops.ooblen) {
Joe Perchesda320f02012-02-15 15:56:44 -08001048 pr_err("cannot read OOB for EB at %08x, requested %zd bytes, read %zd bytes, error %d\n",
1049 jeb->offset, ops.ooblen, ops.oobretlen, ret);
Brian Norris74d83be2012-08-31 15:01:19 -07001050 if (!ret || mtd_is_bitflip(ret))
Artem Bityutskiya7a6ace12007-01-31 11:38:53 +02001051 ret = -EIO;
Thomas Gleixner8593fbc2006-05-29 03:26:58 +02001052 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001053 }
Thomas Gleixner182ec4e2005-11-07 11:16:07 +00001054
Artem Bityutskiya7a6ace12007-01-31 11:38:53 +02001055 for(i = 0; i < ops.ooblen; i++) {
1056 if (mode && i < cmlen)
1057 /* Yeah, we know about the cleanmarker */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001058 continue;
1059
Thomas Gleixner8593fbc2006-05-29 03:26:58 +02001060 if (ops.oobbuf[i] != 0xFF) {
Joe Perches9c261b32012-02-15 15:56:43 -08001061 jffs2_dbg(2, "Found %02x at %x in OOB for "
1062 "%08x\n", ops.oobbuf[i], i, jeb->offset);
Thomas Gleixner8593fbc2006-05-29 03:26:58 +02001063 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001064 }
1065 }
1066
Thomas Gleixner8593fbc2006-05-29 03:26:58 +02001067 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001068}
1069
1070/*
Artem Bityutskiya7a6ace12007-01-31 11:38:53 +02001071 * Check for a valid cleanmarker.
1072 * Returns: 0 if a valid cleanmarker was found
David Woodhouseef53cb02007-07-10 10:01:22 +01001073 * 1 if no cleanmarker was found
1074 * negative error code if an error occurred
Thomas Gleixner8593fbc2006-05-29 03:26:58 +02001075 */
Artem Bityutskiya7a6ace12007-01-31 11:38:53 +02001076int jffs2_check_nand_cleanmarker(struct jffs2_sb_info *c,
1077 struct jffs2_eraseblock *jeb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001078{
Thomas Gleixner8593fbc2006-05-29 03:26:58 +02001079 struct mtd_oob_ops ops;
Artem Bityutskiya7a6ace12007-01-31 11:38:53 +02001080 int ret, cmlen = min_t(int, c->oobavail, OOB_CM_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001081
Brian Norris0612b9d2011-08-30 18:45:40 -07001082 ops.mode = MTD_OPS_AUTO_OOB;
Artem Bityutskiya7a6ace12007-01-31 11:38:53 +02001083 ops.ooblen = cmlen;
Thomas Gleixner8593fbc2006-05-29 03:26:58 +02001084 ops.oobbuf = c->oobbuf;
Artem Bityutskiya7a6ace12007-01-31 11:38:53 +02001085 ops.len = ops.ooboffs = ops.retlen = ops.oobretlen = 0;
Thomas Gleixner8593fbc2006-05-29 03:26:58 +02001086 ops.datbuf = NULL;
Thomas Gleixner8593fbc2006-05-29 03:26:58 +02001087
Artem Bityutskiyfd2819b2011-12-23 18:27:05 +02001088 ret = mtd_read_oob(c->mtd, jeb->offset, &ops);
Brian Norris74d83be2012-08-31 15:01:19 -07001089 if ((ret && !mtd_is_bitflip(ret)) || ops.oobretlen != ops.ooblen) {
Joe Perchesda320f02012-02-15 15:56:44 -08001090 pr_err("cannot read OOB for EB at %08x, requested %zd bytes, read %zd bytes, error %d\n",
1091 jeb->offset, ops.ooblen, ops.oobretlen, ret);
Brian Norris74d83be2012-08-31 15:01:19 -07001092 if (!ret || mtd_is_bitflip(ret))
Artem Bityutskiya7a6ace12007-01-31 11:38:53 +02001093 ret = -EIO;
Thomas Gleixner8593fbc2006-05-29 03:26:58 +02001094 return ret;
1095 }
1096
Artem Bityutskiya7a6ace12007-01-31 11:38:53 +02001097 return !!memcmp(&oob_cleanmarker, c->oobbuf, cmlen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001098}
1099
Thomas Gleixner8593fbc2006-05-29 03:26:58 +02001100int jffs2_write_nand_cleanmarker(struct jffs2_sb_info *c,
1101 struct jffs2_eraseblock *jeb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001102{
Artem Bityutskiya7a6ace12007-01-31 11:38:53 +02001103 int ret;
Thomas Gleixner8593fbc2006-05-29 03:26:58 +02001104 struct mtd_oob_ops ops;
Artem Bityutskiya7a6ace12007-01-31 11:38:53 +02001105 int cmlen = min_t(int, c->oobavail, OOB_CM_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001106
Brian Norris0612b9d2011-08-30 18:45:40 -07001107 ops.mode = MTD_OPS_AUTO_OOB;
Artem Bityutskiya7a6ace12007-01-31 11:38:53 +02001108 ops.ooblen = cmlen;
1109 ops.oobbuf = (uint8_t *)&oob_cleanmarker;
1110 ops.len = ops.ooboffs = ops.retlen = ops.oobretlen = 0;
Thomas Gleixner8593fbc2006-05-29 03:26:58 +02001111 ops.datbuf = NULL;
Thomas Gleixner8593fbc2006-05-29 03:26:58 +02001112
Artem Bityutskiya2cc5ba2011-12-23 18:29:55 +02001113 ret = mtd_write_oob(c->mtd, jeb->offset, &ops);
Artem Bityutskiya7a6ace12007-01-31 11:38:53 +02001114 if (ret || ops.oobretlen != ops.ooblen) {
Joe Perchesda320f02012-02-15 15:56:44 -08001115 pr_err("cannot write OOB for EB at %08x, requested %zd bytes, read %zd bytes, error %d\n",
1116 jeb->offset, ops.ooblen, ops.oobretlen, ret);
Artem Bityutskiya7a6ace12007-01-31 11:38:53 +02001117 if (!ret)
1118 ret = -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001119 return ret;
1120 }
Artem Bityutskiya7a6ace12007-01-31 11:38:53 +02001121
Linus Torvalds1da177e2005-04-16 15:20:36 -07001122 return 0;
1123}
1124
Thomas Gleixner182ec4e2005-11-07 11:16:07 +00001125/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001126 * On NAND we try to mark this block bad. If the block was erased more
Lucas De Marchi25985ed2011-03-30 22:57:33 -03001127 * than MAX_ERASE_FAILURES we mark it finally bad.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001128 * Don't care about failures. This block remains on the erase-pending
1129 * or badblock list as long as nobody manipulates the flash with
1130 * a bootloader or something like that.
1131 */
1132
1133int jffs2_write_nand_badblock(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, uint32_t bad_offset)
1134{
1135 int ret;
1136
1137 /* if the count is < max, we try to write the counter to the 2nd page oob area */
1138 if( ++jeb->bad_count < MAX_ERASE_FAILURES)
1139 return 0;
1140
Joe Perches5a528952012-02-15 15:56:45 -08001141 pr_warn("marking eraseblock at %08x as bad\n", bad_offset);
Artem Bityutskiy5942ddb2011-12-23 19:37:38 +02001142 ret = mtd_block_markbad(c->mtd, bad_offset);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +00001143
Linus Torvalds1da177e2005-04-16 15:20:36 -07001144 if (ret) {
Joe Perches9c261b32012-02-15 15:56:43 -08001145 jffs2_dbg(1, "%s(): Write failed for block at %08x: error %d\n",
1146 __func__, jeb->offset, ret);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001147 return ret;
1148 }
1149 return 1;
1150}
1151
Artem Bityutskiy8bdc81c2012-05-07 19:56:53 +03001152static struct jffs2_sb_info *work_to_sb(struct work_struct *work)
1153{
1154 struct delayed_work *dwork;
1155
1156 dwork = container_of(work, struct delayed_work, work);
1157 return container_of(dwork, struct jffs2_sb_info, wbuf_dwork);
1158}
1159
1160static void delayed_wbuf_sync(struct work_struct *work)
1161{
1162 struct jffs2_sb_info *c = work_to_sb(work);
1163 struct super_block *sb = OFNI_BS_2SFFJ(c);
1164
1165 spin_lock(&c->wbuf_dwork_lock);
1166 c->wbuf_queued = 0;
1167 spin_unlock(&c->wbuf_dwork_lock);
1168
1169 if (!(sb->s_flags & MS_RDONLY)) {
1170 jffs2_dbg(1, "%s()\n", __func__);
1171 jffs2_flush_wbuf_gc(c, 0);
1172 }
1173}
1174
1175void jffs2_dirty_trigger(struct jffs2_sb_info *c)
1176{
1177 struct super_block *sb = OFNI_BS_2SFFJ(c);
1178 unsigned long delay;
1179
1180 if (sb->s_flags & MS_RDONLY)
1181 return;
1182
1183 spin_lock(&c->wbuf_dwork_lock);
1184 if (!c->wbuf_queued) {
1185 jffs2_dbg(1, "%s()\n", __func__);
1186 delay = msecs_to_jiffies(dirty_writeback_interval * 10);
1187 queue_delayed_work(system_long_wq, &c->wbuf_dwork, delay);
1188 c->wbuf_queued = 1;
1189 }
1190 spin_unlock(&c->wbuf_dwork_lock);
1191}
1192
Artem Bityutskiya7a6ace12007-01-31 11:38:53 +02001193int jffs2_nand_flash_setup(struct jffs2_sb_info *c)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001194{
Thomas Gleixner5bd34c02006-05-27 22:16:10 +02001195 struct nand_ecclayout *oinfo = c->mtd->ecclayout;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001196
Linus Torvalds1da177e2005-04-16 15:20:36 -07001197 if (!c->mtd->oobsize)
1198 return 0;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +00001199
Linus Torvalds1da177e2005-04-16 15:20:36 -07001200 /* Cleanmarker is out-of-band, so inline size zero */
1201 c->cleanmarker_size = 0;
1202
Artem Bityutskiya7a6ace12007-01-31 11:38:53 +02001203 if (!oinfo || oinfo->oobavail == 0) {
Joe Perchesda320f02012-02-15 15:56:44 -08001204 pr_err("inconsistent device description\n");
Thomas Gleixner5bd34c02006-05-27 22:16:10 +02001205 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001206 }
Thomas Gleixner5bd34c02006-05-27 22:16:10 +02001207
Joe Perches5a528952012-02-15 15:56:45 -08001208 jffs2_dbg(1, "using OOB on NAND\n");
Thomas Gleixner5bd34c02006-05-27 22:16:10 +02001209
Artem Bityutskiya7a6ace12007-01-31 11:38:53 +02001210 c->oobavail = oinfo->oobavail;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001211
1212 /* Initialise write buffer */
1213 init_rwsem(&c->wbuf_sem);
Artem Bityutskiy8bdc81c2012-05-07 19:56:53 +03001214 spin_lock_init(&c->wbuf_dwork_lock);
1215 INIT_DELAYED_WORK(&c->wbuf_dwork, delayed_wbuf_sync);
Joern Engel28318772006-05-22 23:18:05 +02001216 c->wbuf_pagesize = c->mtd->writesize;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001217 c->wbuf_ofs = 0xFFFFFFFF;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +00001218
Linus Torvalds1da177e2005-04-16 15:20:36 -07001219 c->wbuf = kmalloc(c->wbuf_pagesize, GFP_KERNEL);
1220 if (!c->wbuf)
1221 return -ENOMEM;
1222
Artem Bityutskiya7a6ace12007-01-31 11:38:53 +02001223 c->oobbuf = kmalloc(NR_OOB_SCAN_PAGES * c->oobavail, GFP_KERNEL);
1224 if (!c->oobbuf) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001225 kfree(c->wbuf);
1226 return -ENOMEM;
1227 }
Artem Bityutskiya7a6ace12007-01-31 11:38:53 +02001228
David Woodhousea6bc4322007-07-11 14:23:54 +01001229#ifdef CONFIG_JFFS2_FS_WBUF_VERIFY
1230 c->wbuf_verify = kmalloc(c->wbuf_pagesize, GFP_KERNEL);
1231 if (!c->wbuf_verify) {
1232 kfree(c->oobbuf);
1233 kfree(c->wbuf);
1234 return -ENOMEM;
1235 }
1236#endif
Artem Bityutskiya7a6ace12007-01-31 11:38:53 +02001237 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001238}
1239
1240void jffs2_nand_flash_cleanup(struct jffs2_sb_info *c)
1241{
David Woodhousea6bc4322007-07-11 14:23:54 +01001242#ifdef CONFIG_JFFS2_FS_WBUF_VERIFY
1243 kfree(c->wbuf_verify);
1244#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001245 kfree(c->wbuf);
Thomas Gleixner8593fbc2006-05-29 03:26:58 +02001246 kfree(c->oobbuf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001247}
1248
Andrew Victor8f15fd52005-02-09 09:17:45 +00001249int jffs2_dataflash_setup(struct jffs2_sb_info *c) {
1250 c->cleanmarker_size = 0; /* No cleanmarkers needed */
Thomas Gleixner182ec4e2005-11-07 11:16:07 +00001251
Andrew Victor8f15fd52005-02-09 09:17:45 +00001252 /* Initialize write buffer */
1253 init_rwsem(&c->wbuf_sem);
Artem Bityutskiy8bdc81c2012-05-07 19:56:53 +03001254 spin_lock_init(&c->wbuf_dwork_lock);
1255 INIT_DELAYED_WORK(&c->wbuf_dwork, delayed_wbuf_sync);
Artem B. Bityutskiydaba5cc2005-09-30 14:59:17 +01001256 c->wbuf_pagesize = c->mtd->erasesize;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +00001257
Artem B. Bityutskiydaba5cc2005-09-30 14:59:17 +01001258 /* Find a suitable c->sector_size
1259 * - Not too much sectors
1260 * - Sectors have to be at least 4 K + some bytes
1261 * - All known dataflashes have erase sizes of 528 or 1056
1262 * - we take at least 8 eraseblocks and want to have at least 8K size
1263 * - The concatenation should be a power of 2
1264 */
Andrew Victor8f15fd52005-02-09 09:17:45 +00001265
Artem B. Bityutskiydaba5cc2005-09-30 14:59:17 +01001266 c->sector_size = 8 * c->mtd->erasesize;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +00001267
Artem B. Bityutskiydaba5cc2005-09-30 14:59:17 +01001268 while (c->sector_size < 8192) {
1269 c->sector_size *= 2;
1270 }
Thomas Gleixner182ec4e2005-11-07 11:16:07 +00001271
Artem B. Bityutskiydaba5cc2005-09-30 14:59:17 +01001272 /* It may be necessary to adjust the flash size */
1273 c->flash_size = c->mtd->size;
1274
1275 if ((c->flash_size % c->sector_size) != 0) {
1276 c->flash_size = (c->flash_size / c->sector_size) * c->sector_size;
Joe Perches5a528952012-02-15 15:56:45 -08001277 pr_warn("flash size adjusted to %dKiB\n", c->flash_size);
Artem B. Bityutskiydaba5cc2005-09-30 14:59:17 +01001278 };
Thomas Gleixner182ec4e2005-11-07 11:16:07 +00001279
Artem B. Bityutskiydaba5cc2005-09-30 14:59:17 +01001280 c->wbuf_ofs = 0xFFFFFFFF;
Andrew Victor8f15fd52005-02-09 09:17:45 +00001281 c->wbuf = kmalloc(c->wbuf_pagesize, GFP_KERNEL);
1282 if (!c->wbuf)
1283 return -ENOMEM;
1284
michaelcca15842008-04-18 13:44:17 -07001285#ifdef CONFIG_JFFS2_FS_WBUF_VERIFY
1286 c->wbuf_verify = kmalloc(c->wbuf_pagesize, GFP_KERNEL);
1287 if (!c->wbuf_verify) {
1288 kfree(c->oobbuf);
1289 kfree(c->wbuf);
1290 return -ENOMEM;
1291 }
1292#endif
1293
Joe Perches5a528952012-02-15 15:56:45 -08001294 pr_info("write-buffering enabled buffer (%d) erasesize (%d)\n",
Joe Perchesda320f02012-02-15 15:56:44 -08001295 c->wbuf_pagesize, c->sector_size);
Andrew Victor8f15fd52005-02-09 09:17:45 +00001296
1297 return 0;
1298}
1299
1300void jffs2_dataflash_cleanup(struct jffs2_sb_info *c) {
michaelcca15842008-04-18 13:44:17 -07001301#ifdef CONFIG_JFFS2_FS_WBUF_VERIFY
1302 kfree(c->wbuf_verify);
1303#endif
Andrew Victor8f15fd52005-02-09 09:17:45 +00001304 kfree(c->wbuf);
1305}
Andrew Victor8f15fd52005-02-09 09:17:45 +00001306
Nicolas Pitre59da7212005-08-06 05:51:33 +01001307int jffs2_nor_wbuf_flash_setup(struct jffs2_sb_info *c) {
Joern Engelc8b229d2006-05-22 23:18:12 +02001308 /* Cleanmarker currently occupies whole programming regions,
1309 * either one or 2 for 8Byte STMicro flashes. */
1310 c->cleanmarker_size = max(16u, c->mtd->writesize);
Nicolas Pitre59da7212005-08-06 05:51:33 +01001311
1312 /* Initialize write buffer */
1313 init_rwsem(&c->wbuf_sem);
Artem Bityutskiy8bdc81c2012-05-07 19:56:53 +03001314 spin_lock_init(&c->wbuf_dwork_lock);
1315 INIT_DELAYED_WORK(&c->wbuf_dwork, delayed_wbuf_sync);
1316
Joern Engel28318772006-05-22 23:18:05 +02001317 c->wbuf_pagesize = c->mtd->writesize;
Nicolas Pitre59da7212005-08-06 05:51:33 +01001318 c->wbuf_ofs = 0xFFFFFFFF;
1319
1320 c->wbuf = kmalloc(c->wbuf_pagesize, GFP_KERNEL);
1321 if (!c->wbuf)
1322 return -ENOMEM;
1323
Massimo Cirillobc8cec02009-08-27 10:44:09 +02001324#ifdef CONFIG_JFFS2_FS_WBUF_VERIFY
1325 c->wbuf_verify = kmalloc(c->wbuf_pagesize, GFP_KERNEL);
1326 if (!c->wbuf_verify) {
1327 kfree(c->wbuf);
1328 return -ENOMEM;
1329 }
1330#endif
Nicolas Pitre59da7212005-08-06 05:51:33 +01001331 return 0;
1332}
1333
1334void jffs2_nor_wbuf_flash_cleanup(struct jffs2_sb_info *c) {
Massimo Cirillobc8cec02009-08-27 10:44:09 +02001335#ifdef CONFIG_JFFS2_FS_WBUF_VERIFY
1336 kfree(c->wbuf_verify);
1337#endif
Nicolas Pitre59da7212005-08-06 05:51:33 +01001338 kfree(c->wbuf);
1339}
Artem Bityutskiy0029da32006-10-04 19:15:21 +03001340
1341int jffs2_ubivol_setup(struct jffs2_sb_info *c) {
1342 c->cleanmarker_size = 0;
1343
1344 if (c->mtd->writesize == 1)
1345 /* We do not need write-buffer */
1346 return 0;
1347
1348 init_rwsem(&c->wbuf_sem);
Artem Bityutskiy8bdc81c2012-05-07 19:56:53 +03001349 spin_lock_init(&c->wbuf_dwork_lock);
1350 INIT_DELAYED_WORK(&c->wbuf_dwork, delayed_wbuf_sync);
Artem Bityutskiy0029da32006-10-04 19:15:21 +03001351
1352 c->wbuf_pagesize = c->mtd->writesize;
1353 c->wbuf_ofs = 0xFFFFFFFF;
1354 c->wbuf = kmalloc(c->wbuf_pagesize, GFP_KERNEL);
1355 if (!c->wbuf)
1356 return -ENOMEM;
1357
Joe Perches5a528952012-02-15 15:56:45 -08001358 pr_info("write-buffering enabled buffer (%d) erasesize (%d)\n",
Joe Perchesda320f02012-02-15 15:56:44 -08001359 c->wbuf_pagesize, c->sector_size);
Artem Bityutskiy0029da32006-10-04 19:15:21 +03001360
1361 return 0;
1362}
1363
1364void jffs2_ubivol_cleanup(struct jffs2_sb_info *c) {
1365 kfree(c->wbuf);
1366}