blob: d1d4f27464baf879825eb72ac4ad4812acfaa0fd [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
14#include <linux/kernel.h>
15#include <linux/slab.h>
16#include <linux/mtd/mtd.h>
17#include <linux/crc32.h>
18#include <linux/mtd/nand.h>
Tim Schmielau4e57b682005-10-30 15:03:48 -080019#include <linux/jiffies.h>
Al Viro914e2632006-10-18 13:55:46 -040020#include <linux/sched.h>
Tim Schmielau4e57b682005-10-30 15:03:48 -080021
Linus Torvalds1da177e2005-04-16 15:20:36 -070022#include "nodelist.h"
23
24/* For testing write failures */
25#undef BREAKME
26#undef BREAKMEHEADER
27
28#ifdef BREAKME
29static unsigned char *brokenbuf;
30#endif
31
Artem B. Bityutskiydaba5cc2005-09-30 14:59:17 +010032#define PAGE_DIV(x) ( ((unsigned long)(x) / (unsigned long)(c->wbuf_pagesize)) * (unsigned long)(c->wbuf_pagesize) )
33#define PAGE_MOD(x) ( (unsigned long)(x) % (unsigned long)(c->wbuf_pagesize) )
34
Linus Torvalds1da177e2005-04-16 15:20:36 -070035/* max. erase failures before we mark a block bad */
36#define MAX_ERASE_FAILURES 2
37
Linus Torvalds1da177e2005-04-16 15:20:36 -070038struct jffs2_inodirty {
39 uint32_t ino;
40 struct jffs2_inodirty *next;
41};
42
43static struct jffs2_inodirty inodirty_nomem;
44
45static int jffs2_wbuf_pending_for_ino(struct jffs2_sb_info *c, uint32_t ino)
46{
47 struct jffs2_inodirty *this = c->wbuf_inodes;
48
49 /* If a malloc failed, consider _everything_ dirty */
50 if (this == &inodirty_nomem)
51 return 1;
52
53 /* If ino == 0, _any_ non-GC writes mean 'yes' */
54 if (this && !ino)
55 return 1;
56
57 /* Look to see if the inode in question is pending in the wbuf */
58 while (this) {
59 if (this->ino == ino)
60 return 1;
61 this = this->next;
62 }
63 return 0;
64}
65
66static void jffs2_clear_wbuf_ino_list(struct jffs2_sb_info *c)
67{
68 struct jffs2_inodirty *this;
69
70 this = c->wbuf_inodes;
71
72 if (this != &inodirty_nomem) {
73 while (this) {
74 struct jffs2_inodirty *next = this->next;
75 kfree(this);
76 this = next;
77 }
78 }
79 c->wbuf_inodes = NULL;
80}
81
82static void jffs2_wbuf_dirties_inode(struct jffs2_sb_info *c, uint32_t ino)
83{
84 struct jffs2_inodirty *new;
85
86 /* Mark the superblock dirty so that kupdated will flush... */
Artem B. Bityuckiy4d952702005-03-18 09:58:09 +000087 jffs2_erase_pending_trigger(c);
Linus Torvalds1da177e2005-04-16 15:20:36 -070088
89 if (jffs2_wbuf_pending_for_ino(c, ino))
90 return;
91
92 new = kmalloc(sizeof(*new), GFP_KERNEL);
93 if (!new) {
94 D1(printk(KERN_DEBUG "No memory to allocate inodirty. Fallback to all considered dirty\n"));
95 jffs2_clear_wbuf_ino_list(c);
96 c->wbuf_inodes = &inodirty_nomem;
97 return;
98 }
99 new->ino = ino;
100 new->next = c->wbuf_inodes;
101 c->wbuf_inodes = new;
102 return;
103}
104
105static inline void jffs2_refile_wbuf_blocks(struct jffs2_sb_info *c)
106{
107 struct list_head *this, *next;
108 static int n;
109
110 if (list_empty(&c->erasable_pending_wbuf_list))
111 return;
112
113 list_for_each_safe(this, next, &c->erasable_pending_wbuf_list) {
114 struct jffs2_eraseblock *jeb = list_entry(this, struct jffs2_eraseblock, list);
115
116 D1(printk(KERN_DEBUG "Removing eraseblock at 0x%08x from erasable_pending_wbuf_list...\n", jeb->offset));
117 list_del(this);
118 if ((jiffies + (n++)) & 127) {
119 /* Most of the time, we just erase it immediately. Otherwise we
120 spend ages scanning it on mount, etc. */
121 D1(printk(KERN_DEBUG "...and adding to erase_pending_list\n"));
122 list_add_tail(&jeb->list, &c->erase_pending_list);
123 c->nr_erasing_blocks++;
124 jffs2_erase_pending_trigger(c);
125 } else {
126 /* Sometimes, however, we leave it elsewhere so it doesn't get
127 immediately reused, and we spread the load a bit. */
128 D1(printk(KERN_DEBUG "...and adding to erasable_list\n"));
129 list_add_tail(&jeb->list, &c->erasable_list);
130 }
131 }
132}
133
Estelle Hammache7f716cf2005-01-24 21:24:18 +0000134#define REFILE_NOTEMPTY 0
135#define REFILE_ANYWAY 1
136
137static void jffs2_block_refile(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, int allow_empty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138{
139 D1(printk("About to refile bad block at %08x\n", jeb->offset));
140
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141 /* File the existing block on the bad_used_list.... */
142 if (c->nextblock == jeb)
143 c->nextblock = NULL;
144 else /* Not sure this should ever happen... need more coffee */
145 list_del(&jeb->list);
146 if (jeb->first_node) {
147 D1(printk("Refiling block at %08x to bad_used_list\n", jeb->offset));
148 list_add(&jeb->list, &c->bad_used_list);
149 } else {
Estelle Hammache9b88f472005-01-28 18:53:05 +0000150 BUG_ON(allow_empty == REFILE_NOTEMPTY);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151 /* It has to have had some nodes or we couldn't be here */
152 D1(printk("Refiling block at %08x to erase_pending_list\n", jeb->offset));
153 list_add(&jeb->list, &c->erase_pending_list);
154 c->nr_erasing_blocks++;
155 jffs2_erase_pending_trigger(c);
156 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157
David Woodhouse9bfeb692006-05-26 21:19:05 +0100158 if (!jffs2_prealloc_raw_node_refs(c, jeb, 1)) {
159 uint32_t oldfree = jeb->free_size;
160
161 jffs2_link_node_ref(c, jeb,
162 (jeb->offset+c->sector_size-oldfree) | REF_OBSOLETE,
163 oldfree, NULL);
164 /* convert to wasted */
165 c->wasted_size += oldfree;
166 jeb->wasted_size += oldfree;
167 c->dirty_size -= oldfree;
168 jeb->dirty_size -= oldfree;
169 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170
Artem B. Bityutskiye0c8e422005-07-24 16:14:17 +0100171 jffs2_dbg_dump_block_lists_nolock(c);
172 jffs2_dbg_acct_sanity_check_nolock(c,jeb);
173 jffs2_dbg_acct_paranoia_check_nolock(c, jeb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174}
175
David Woodhouse9bfeb692006-05-26 21:19:05 +0100176static struct jffs2_raw_node_ref **jffs2_incore_replace_raw(struct jffs2_sb_info *c,
177 struct jffs2_inode_info *f,
178 struct jffs2_raw_node_ref *raw,
179 union jffs2_node_union *node)
180{
181 struct jffs2_node_frag *frag;
182 struct jffs2_full_dirent *fd;
183
184 dbg_noderef("incore_replace_raw: node at %p is {%04x,%04x}\n",
185 node, je16_to_cpu(node->u.magic), je16_to_cpu(node->u.nodetype));
186
187 BUG_ON(je16_to_cpu(node->u.magic) != 0x1985 &&
188 je16_to_cpu(node->u.magic) != 0);
189
190 switch (je16_to_cpu(node->u.nodetype)) {
191 case JFFS2_NODETYPE_INODE:
David Woodhouseddc58bd2006-05-27 13:15:16 +0100192 if (f->metadata && f->metadata->raw == raw) {
193 dbg_noderef("Will replace ->raw in f->metadata at %p\n", f->metadata);
194 return &f->metadata->raw;
195 }
David Woodhouse9bfeb692006-05-26 21:19:05 +0100196 frag = jffs2_lookup_node_frag(&f->fragtree, je32_to_cpu(node->i.offset));
197 BUG_ON(!frag);
198 /* Find a frag which refers to the full_dnode we want to modify */
199 while (!frag->node || frag->node->raw != raw) {
200 frag = frag_next(frag);
201 BUG_ON(!frag);
202 }
203 dbg_noderef("Will replace ->raw in full_dnode at %p\n", frag->node);
204 return &frag->node->raw;
David Woodhouse9bfeb692006-05-26 21:19:05 +0100205
206 case JFFS2_NODETYPE_DIRENT:
207 for (fd = f->dents; fd; fd = fd->next) {
208 if (fd->raw == raw) {
209 dbg_noderef("Will replace ->raw in full_dirent at %p\n", fd);
210 return &fd->raw;
211 }
212 }
213 BUG();
David Woodhouseddc58bd2006-05-27 13:15:16 +0100214
David Woodhouse9bfeb692006-05-26 21:19:05 +0100215 default:
216 dbg_noderef("Don't care about replacing raw for nodetype %x\n",
217 je16_to_cpu(node->u.nodetype));
218 break;
219 }
220 return NULL;
221}
222
David Woodhousea6bc4322007-07-11 14:23:54 +0100223#ifdef CONFIG_JFFS2_FS_WBUF_VERIFY
224static int jffs2_verify_write(struct jffs2_sb_info *c, unsigned char *buf,
225 uint32_t ofs)
226{
227 int ret;
228 size_t retlen;
229 char *eccstr;
230
231 ret = c->mtd->read(c->mtd, ofs, c->wbuf_pagesize, &retlen, c->wbuf_verify);
232 if (ret && ret != -EUCLEAN && ret != -EBADMSG) {
233 printk(KERN_WARNING "jffs2_verify_write(): Read back of page at %08x failed: %d\n", c->wbuf_ofs, ret);
234 return ret;
235 } else if (retlen != c->wbuf_pagesize) {
236 printk(KERN_WARNING "jffs2_verify_write(): Read back of page at %08x gave short read: %zd not %d.\n", ofs, retlen, c->wbuf_pagesize);
237 return -EIO;
238 }
239 if (!memcmp(buf, c->wbuf_verify, c->wbuf_pagesize))
240 return 0;
241
242 if (ret == -EUCLEAN)
243 eccstr = "corrected";
244 else if (ret == -EBADMSG)
245 eccstr = "correction failed";
246 else
247 eccstr = "OK or unused";
248
249 printk(KERN_WARNING "Write verify error (ECC %s) at %08x. Wrote:\n",
250 eccstr, c->wbuf_ofs);
251 print_hex_dump(KERN_WARNING, "", DUMP_PREFIX_OFFSET, 16, 1,
252 c->wbuf, c->wbuf_pagesize, 0);
253
254 printk(KERN_WARNING "Read back:\n");
255 print_hex_dump(KERN_WARNING, "", DUMP_PREFIX_OFFSET, 16, 1,
256 c->wbuf_verify, c->wbuf_pagesize, 0);
257
258 return -EIO;
259}
260#else
261#define jffs2_verify_write(c,b,o) (0)
262#endif
263
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264/* Recover from failure to write wbuf. Recover the nodes up to the
265 * wbuf, not the one which we were starting to try to write. */
266
267static void jffs2_wbuf_recover(struct jffs2_sb_info *c)
268{
269 struct jffs2_eraseblock *jeb, *new_jeb;
David Woodhouse9bfeb692006-05-26 21:19:05 +0100270 struct jffs2_raw_node_ref *raw, *next, *first_raw = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271 size_t retlen;
272 int ret;
David Woodhouse9bfeb692006-05-26 21:19:05 +0100273 int nr_refile = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274 unsigned char *buf;
275 uint32_t start, end, ofs, len;
276
David Woodhouse046b8b92006-05-25 01:50:35 +0100277 jeb = &c->blocks[c->wbuf_ofs / c->sector_size];
278
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279 spin_lock(&c->erase_completion_lock);
Vitaly Wool180bfb32007-03-06 17:01:04 +0300280 if (c->wbuf_ofs % c->mtd->erasesize)
281 jffs2_block_refile(c, jeb, REFILE_NOTEMPTY);
282 else
283 jffs2_block_refile(c, jeb, REFILE_ANYWAY);
David Woodhouse9bfeb692006-05-26 21:19:05 +0100284 spin_unlock(&c->erase_completion_lock);
285
286 BUG_ON(!ref_obsolete(jeb->last_node));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287
288 /* Find the first node to be recovered, by skipping over every
289 node which ends before the wbuf starts, or which is obsolete. */
David Woodhouse9bfeb692006-05-26 21:19:05 +0100290 for (next = raw = jeb->first_node; next; raw = next) {
291 next = ref_next(raw);
292
293 if (ref_obsolete(raw) ||
294 (next && ref_offset(next) <= c->wbuf_ofs)) {
295 dbg_noderef("Skipping node at 0x%08x(%d)-0x%08x which is either before 0x%08x or obsolete\n",
296 ref_offset(raw), ref_flags(raw),
297 (ref_offset(raw) + ref_totlen(c, jeb, raw)),
298 c->wbuf_ofs);
299 continue;
300 }
301 dbg_noderef("First node to be recovered is at 0x%08x(%d)-0x%08x\n",
302 ref_offset(raw), ref_flags(raw),
303 (ref_offset(raw) + ref_totlen(c, jeb, raw)));
304
305 first_raw = raw;
306 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307 }
308
David Woodhouse9bfeb692006-05-26 21:19:05 +0100309 if (!first_raw) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310 /* All nodes were obsolete. Nothing to recover. */
311 D1(printk(KERN_DEBUG "No non-obsolete nodes to be recovered. Just filing block bad\n"));
David Woodhouse9bfeb692006-05-26 21:19:05 +0100312 c->wbuf_len = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313 return;
314 }
315
David Woodhouse9bfeb692006-05-26 21:19:05 +0100316 start = ref_offset(first_raw);
317 end = ref_offset(jeb->last_node);
318 nr_refile = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319
David Woodhouse9bfeb692006-05-26 21:19:05 +0100320 /* Count the number of refs which need to be copied */
321 while ((raw = ref_next(raw)) != jeb->last_node)
322 nr_refile++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323
David Woodhouse9bfeb692006-05-26 21:19:05 +0100324 dbg_noderef("wbuf recover %08x-%08x (%d bytes in %d nodes)\n",
325 start, end, end - start, nr_refile);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326
327 buf = NULL;
328 if (start < c->wbuf_ofs) {
329 /* First affected node was already partially written.
330 * Attempt to reread the old data into our buffer. */
331
332 buf = kmalloc(end - start, GFP_KERNEL);
333 if (!buf) {
334 printk(KERN_CRIT "Malloc failure in wbuf recovery. Data loss ensues.\n");
335
336 goto read_failed;
337 }
338
339 /* Do the read... */
Thomas Gleixner9223a452006-05-23 17:21:03 +0200340 ret = c->mtd->read(c->mtd, start, c->wbuf_ofs - start, &retlen, buf);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000341
Thomas Gleixner9a1fcdf2006-05-29 14:56:39 +0200342 /* ECC recovered ? */
343 if ((ret == -EUCLEAN || ret == -EBADMSG) &&
344 (retlen == c->wbuf_ofs - start))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345 ret = 0;
Thomas Gleixner9a1fcdf2006-05-29 14:56:39 +0200346
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347 if (ret || retlen != c->wbuf_ofs - start) {
348 printk(KERN_CRIT "Old data are already lost in wbuf recovery. Data loss ensues.\n");
349
350 kfree(buf);
351 buf = NULL;
352 read_failed:
David Woodhouse9bfeb692006-05-26 21:19:05 +0100353 first_raw = ref_next(first_raw);
354 nr_refile--;
355 while (first_raw && ref_obsolete(first_raw)) {
356 first_raw = ref_next(first_raw);
357 nr_refile--;
358 }
359
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360 /* If this was the only node to be recovered, give up */
David Woodhouse9bfeb692006-05-26 21:19:05 +0100361 if (!first_raw) {
362 c->wbuf_len = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363 return;
David Woodhouse9bfeb692006-05-26 21:19:05 +0100364 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365
366 /* It wasn't. Go on and try to recover nodes complete in the wbuf */
David Woodhouse9bfeb692006-05-26 21:19:05 +0100367 start = ref_offset(first_raw);
368 dbg_noderef("wbuf now recover %08x-%08x (%d bytes in %d nodes)\n",
369 start, end, end - start, nr_refile);
370
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371 } else {
372 /* Read succeeded. Copy the remaining data from the wbuf */
373 memcpy(buf + (c->wbuf_ofs - start), c->wbuf, end - c->wbuf_ofs);
374 }
375 }
376 /* OK... we're to rewrite (end-start) bytes of data from first_raw onwards.
377 Either 'buf' contains the data, or we find it in the wbuf */
378
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379 /* ... and get an allocation of space from a shiny new block instead */
David Woodhouse9fe48542006-05-23 00:38:06 +0100380 ret = jffs2_reserve_space_gc(c, end-start, &len, JFFS2_SUMMARY_NOSUM_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381 if (ret) {
382 printk(KERN_WARNING "Failed to allocate space for wbuf recovery. Data loss ensues.\n");
Estelle Hammache9b88f472005-01-28 18:53:05 +0000383 kfree(buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384 return;
385 }
David Woodhouse9bfeb692006-05-26 21:19:05 +0100386
Adrian Hunter7f762ab2007-04-04 13:47:53 +0300387 /* The summary is not recovered, so it must be disabled for this erase block */
388 jffs2_sum_disable_collecting(c->summary);
389
David Woodhouse9bfeb692006-05-26 21:19:05 +0100390 ret = jffs2_prealloc_raw_node_refs(c, c->nextblock, nr_refile);
391 if (ret) {
392 printk(KERN_WARNING "Failed to allocate node refs for wbuf recovery. Data loss ensues.\n");
393 kfree(buf);
394 return;
395 }
396
David Woodhouse9fe48542006-05-23 00:38:06 +0100397 ofs = write_ofs(c);
398
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399 if (end-start >= c->wbuf_pagesize) {
Estelle Hammache7f716cf2005-01-24 21:24:18 +0000400 /* Need to do another write immediately, but it's possible
Estelle Hammache9b88f472005-01-28 18:53:05 +0000401 that this is just because the wbuf itself is completely
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000402 full, and there's nothing earlier read back from the
403 flash. Hence 'buf' isn't necessarily what we're writing
Estelle Hammache9b88f472005-01-28 18:53:05 +0000404 from. */
Estelle Hammache7f716cf2005-01-24 21:24:18 +0000405 unsigned char *rewrite_buf = buf?:c->wbuf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406 uint32_t towrite = (end-start) - ((end-start)%c->wbuf_pagesize);
407
408 D1(printk(KERN_DEBUG "Write 0x%x bytes at 0x%08x in wbuf recover\n",
409 towrite, ofs));
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000410
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411#ifdef BREAKMEHEADER
412 static int breakme;
413 if (breakme++ == 20) {
414 printk(KERN_NOTICE "Faking write error at 0x%08x\n", ofs);
415 breakme = 0;
Thomas Gleixner9223a452006-05-23 17:21:03 +0200416 c->mtd->write(c->mtd, ofs, towrite, &retlen,
417 brokenbuf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418 ret = -EIO;
419 } else
420#endif
Thomas Gleixner9223a452006-05-23 17:21:03 +0200421 ret = c->mtd->write(c->mtd, ofs, towrite, &retlen,
422 rewrite_buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423
David Woodhousea6bc4322007-07-11 14:23:54 +0100424 if (ret || retlen != towrite || jffs2_verify_write(c, rewrite_buf, ofs)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425 /* Argh. We tried. Really we did. */
426 printk(KERN_CRIT "Recovery of wbuf failed due to a second write error\n");
Estelle Hammache9b88f472005-01-28 18:53:05 +0000427 kfree(buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428
David Woodhouse2f785402006-05-24 02:04:45 +0100429 if (retlen)
David Woodhouse9bfeb692006-05-26 21:19:05 +0100430 jffs2_add_physical_node_ref(c, ofs | REF_OBSOLETE, ref_totlen(c, jeb, first_raw), NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432 return;
433 }
434 printk(KERN_NOTICE "Recovery of wbuf succeeded to %08x\n", ofs);
435
436 c->wbuf_len = (end - start) - towrite;
437 c->wbuf_ofs = ofs + towrite;
Estelle Hammache7f716cf2005-01-24 21:24:18 +0000438 memmove(c->wbuf, rewrite_buf + towrite, c->wbuf_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439 /* Don't muck about with c->wbuf_inodes. False positives are harmless. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440 } else {
441 /* OK, now we're left with the dregs in whichever buffer we're using */
442 if (buf) {
443 memcpy(c->wbuf, buf, end-start);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444 } else {
445 memmove(c->wbuf, c->wbuf + (start - c->wbuf_ofs), end - start);
446 }
447 c->wbuf_ofs = ofs;
448 c->wbuf_len = end - start;
449 }
450
451 /* Now sort out the jffs2_raw_node_refs, moving them from the old to the next block */
452 new_jeb = &c->blocks[ofs / c->sector_size];
453
454 spin_lock(&c->erase_completion_lock);
David Woodhouse9bfeb692006-05-26 21:19:05 +0100455 for (raw = first_raw; raw != jeb->last_node; raw = ref_next(raw)) {
456 uint32_t rawlen = ref_totlen(c, jeb, raw);
457 struct jffs2_inode_cache *ic;
458 struct jffs2_raw_node_ref *new_ref;
459 struct jffs2_raw_node_ref **adjust_ref = NULL;
460 struct jffs2_inode_info *f = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461
462 D1(printk(KERN_DEBUG "Refiling block of %08x at %08x(%d) to %08x\n",
David Woodhouse9bfeb692006-05-26 21:19:05 +0100463 rawlen, ref_offset(raw), ref_flags(raw), ofs));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700464
David Woodhouse9bfeb692006-05-26 21:19:05 +0100465 ic = jffs2_raw_ref_to_ic(raw);
466
467 /* Ick. This XATTR mess should be fixed shortly... */
468 if (ic && ic->class == RAWNODE_CLASS_XATTR_DATUM) {
469 struct jffs2_xattr_datum *xd = (void *)ic;
470 BUG_ON(xd->node != raw);
471 adjust_ref = &xd->node;
472 raw->next_in_ino = NULL;
473 ic = NULL;
474 } else if (ic && ic->class == RAWNODE_CLASS_XATTR_REF) {
475 struct jffs2_xattr_datum *xr = (void *)ic;
476 BUG_ON(xr->node != raw);
477 adjust_ref = &xr->node;
478 raw->next_in_ino = NULL;
479 ic = NULL;
480 } else if (ic && ic->class == RAWNODE_CLASS_INODE_CACHE) {
481 struct jffs2_raw_node_ref **p = &ic->nodes;
482
483 /* Remove the old node from the per-inode list */
484 while (*p && *p != (void *)ic) {
485 if (*p == raw) {
486 (*p) = (raw->next_in_ino);
487 raw->next_in_ino = NULL;
488 break;
489 }
490 p = &((*p)->next_in_ino);
491 }
492
493 if (ic->state == INO_STATE_PRESENT && !ref_obsolete(raw)) {
494 /* If it's an in-core inode, then we have to adjust any
495 full_dirent or full_dnode structure to point to the
496 new version instead of the old */
497 f = jffs2_gc_fetch_inode(c, ic->ino, ic->nlink);
498 if (IS_ERR(f)) {
499 /* Should never happen; it _must_ be present */
500 JFFS2_ERROR("Failed to iget() ino #%u, err %ld\n",
501 ic->ino, PTR_ERR(f));
502 BUG();
503 }
504 /* We don't lock f->sem. There's a number of ways we could
505 end up in here with it already being locked, and nobody's
506 going to modify it on us anyway because we hold the
507 alloc_sem. We're only changing one ->raw pointer too,
508 which we can get away with without upsetting readers. */
509 adjust_ref = jffs2_incore_replace_raw(c, f, raw,
510 (void *)(buf?:c->wbuf) + (ref_offset(raw) - start));
511 } else if (unlikely(ic->state != INO_STATE_PRESENT &&
512 ic->state != INO_STATE_CHECKEDABSENT &&
513 ic->state != INO_STATE_GC)) {
514 JFFS2_ERROR("Inode #%u is in strange state %d!\n", ic->ino, ic->state);
515 BUG();
516 }
517 }
518
519 new_ref = jffs2_link_node_ref(c, new_jeb, ofs | ref_flags(raw), rawlen, ic);
520
521 if (adjust_ref) {
522 BUG_ON(*adjust_ref != raw);
523 *adjust_ref = new_ref;
524 }
525 if (f)
526 jffs2_gc_release_inode(c, f);
527
528 if (!ref_obsolete(raw)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529 jeb->dirty_size += rawlen;
530 jeb->used_size -= rawlen;
531 c->dirty_size += rawlen;
David Woodhouse9bfeb692006-05-26 21:19:05 +0100532 c->used_size -= rawlen;
533 raw->flash_offset = ref_offset(raw) | REF_OBSOLETE;
534 BUG_ON(raw->next_in_ino);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536 ofs += rawlen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537 }
538
David Woodhouse9bfeb692006-05-26 21:19:05 +0100539 kfree(buf);
540
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541 /* Fix up the original jeb now it's on the bad_list */
David Woodhouse9bfeb692006-05-26 21:19:05 +0100542 if (first_raw == jeb->first_node) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543 D1(printk(KERN_DEBUG "Failing block at %08x is now empty. Moving to erase_pending_list\n", jeb->offset));
Akinobu Mitaf1166292006-06-26 00:24:46 -0700544 list_move(&jeb->list, &c->erase_pending_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545 c->nr_erasing_blocks++;
546 jffs2_erase_pending_trigger(c);
547 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548
Artem B. Bityutskiye0c8e422005-07-24 16:14:17 +0100549 jffs2_dbg_acct_sanity_check_nolock(c, jeb);
David Woodhouse9bfeb692006-05-26 21:19:05 +0100550 jffs2_dbg_acct_paranoia_check_nolock(c, jeb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551
Artem B. Bityutskiye0c8e422005-07-24 16:14:17 +0100552 jffs2_dbg_acct_sanity_check_nolock(c, new_jeb);
David Woodhouse9bfeb692006-05-26 21:19:05 +0100553 jffs2_dbg_acct_paranoia_check_nolock(c, new_jeb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554
555 spin_unlock(&c->erase_completion_lock);
556
David Woodhouse9bfeb692006-05-26 21:19:05 +0100557 D1(printk(KERN_DEBUG "wbuf recovery completed OK. wbuf_ofs 0x%08x, len 0x%x\n", c->wbuf_ofs, c->wbuf_len));
558
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559}
560
561/* Meaning of pad argument:
562 0: Do not pad. Probably pointless - we only ever use this when we can't pad anyway.
563 1: Pad, do not adjust nextblock free_size
564 2: Pad, adjust nextblock free_size
565*/
566#define NOPAD 0
567#define PAD_NOACCOUNT 1
568#define PAD_ACCOUNTING 2
569
570static int __jffs2_flush_wbuf(struct jffs2_sb_info *c, int pad)
571{
David Woodhouse9bfeb692006-05-26 21:19:05 +0100572 struct jffs2_eraseblock *wbuf_jeb;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573 int ret;
574 size_t retlen;
575
Andrew Victor3be36672005-02-09 09:09:05 +0000576 /* Nothing to do if not write-buffering the flash. In particular, we shouldn't
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577 del_timer() the timer we never initialised. */
Andrew Victor3be36672005-02-09 09:09:05 +0000578 if (!jffs2_is_writebuffered(c))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579 return 0;
580
581 if (!down_trylock(&c->alloc_sem)) {
582 up(&c->alloc_sem);
583 printk(KERN_CRIT "jffs2_flush_wbuf() called with alloc_sem not locked!\n");
584 BUG();
585 }
586
Andrew Victor3be36672005-02-09 09:09:05 +0000587 if (!c->wbuf_len) /* already checked c->wbuf above */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588 return 0;
589
David Woodhouse9bfeb692006-05-26 21:19:05 +0100590 wbuf_jeb = &c->blocks[c->wbuf_ofs / c->sector_size];
591 if (jffs2_prealloc_raw_node_refs(c, wbuf_jeb, c->nextblock->allocated_refs + 1))
David Woodhouse2f785402006-05-24 02:04:45 +0100592 return -ENOMEM;
593
Linus Torvalds1da177e2005-04-16 15:20:36 -0700594 /* claim remaining space on the page
595 this happens, if we have a change to a new block,
596 or if fsync forces us to flush the writebuffer.
597 if we have a switch to next page, we will not have
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000598 enough remaining space for this.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599 */
Artem B. Bityutskiydaba5cc2005-09-30 14:59:17 +0100600 if (pad ) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601 c->wbuf_len = PAD(c->wbuf_len);
602
603 /* Pad with JFFS2_DIRTY_BITMASK initially. this helps out ECC'd NOR
604 with 8 byte page size */
605 memset(c->wbuf + c->wbuf_len, 0, c->wbuf_pagesize - c->wbuf_len);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000606
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607 if ( c->wbuf_len + sizeof(struct jffs2_unknown_node) < c->wbuf_pagesize) {
608 struct jffs2_unknown_node *padnode = (void *)(c->wbuf + c->wbuf_len);
609 padnode->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
610 padnode->nodetype = cpu_to_je16(JFFS2_NODETYPE_PADDING);
611 padnode->totlen = cpu_to_je32(c->wbuf_pagesize - c->wbuf_len);
612 padnode->hdr_crc = cpu_to_je32(crc32(0, padnode, sizeof(*padnode)-4));
613 }
614 }
615 /* else jffs2_flash_writev has actually filled in the rest of the
616 buffer for us, and will deal with the node refs etc. later. */
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000617
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618#ifdef BREAKME
619 static int breakme;
620 if (breakme++ == 20) {
621 printk(KERN_NOTICE "Faking write error at 0x%08x\n", c->wbuf_ofs);
622 breakme = 0;
Thomas Gleixner9223a452006-05-23 17:21:03 +0200623 c->mtd->write(c->mtd, c->wbuf_ofs, c->wbuf_pagesize, &retlen,
624 brokenbuf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625 ret = -EIO;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000626 } else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627#endif
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000628
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629 ret = c->mtd->write(c->mtd, c->wbuf_ofs, c->wbuf_pagesize, &retlen, c->wbuf);
630
David Woodhousea6bc4322007-07-11 14:23:54 +0100631 if (ret) {
632 printk(KERN_WARNING "jffs2_flush_wbuf(): Write failed with %d\n", ret);
633 goto wfail;
634 } else if (retlen != c->wbuf_pagesize) {
635 printk(KERN_WARNING "jffs2_flush_wbuf(): Write was short: %zd instead of %d\n",
636 retlen, c->wbuf_pagesize);
637 ret = -EIO;
638 goto wfail;
639 } else if ((ret = jffs2_verify_write(c, c->wbuf, c->wbuf_ofs))) {
640 wfail:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700641 jffs2_wbuf_recover(c);
642
643 return ret;
644 }
645
Linus Torvalds1da177e2005-04-16 15:20:36 -0700646 /* Adjust free size of the block if we padded. */
Artem B. Bityutskiydaba5cc2005-09-30 14:59:17 +0100647 if (pad) {
David Woodhouse0bcc0992006-05-21 13:00:54 +0100648 uint32_t waste = c->wbuf_pagesize - c->wbuf_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650 D1(printk(KERN_DEBUG "jffs2_flush_wbuf() adjusting free_size of %sblock at %08x\n",
David Woodhouse9bfeb692006-05-26 21:19:05 +0100651 (wbuf_jeb==c->nextblock)?"next":"", wbuf_jeb->offset));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000653 /* wbuf_pagesize - wbuf_len is the amount of space that's to be
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654 padded. If there is less free space in the block than that,
655 something screwed up */
David Woodhouse9bfeb692006-05-26 21:19:05 +0100656 if (wbuf_jeb->free_size < waste) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657 printk(KERN_CRIT "jffs2_flush_wbuf(): Accounting error. wbuf at 0x%08x has 0x%03x bytes, 0x%03x left.\n",
David Woodhouse0bcc0992006-05-21 13:00:54 +0100658 c->wbuf_ofs, c->wbuf_len, waste);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700659 printk(KERN_CRIT "jffs2_flush_wbuf(): But free_size for block at 0x%08x is only 0x%08x\n",
David Woodhouse9bfeb692006-05-26 21:19:05 +0100660 wbuf_jeb->offset, wbuf_jeb->free_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661 BUG();
662 }
David Woodhouse0bcc0992006-05-21 13:00:54 +0100663
664 spin_lock(&c->erase_completion_lock);
665
David Woodhouse9bfeb692006-05-26 21:19:05 +0100666 jffs2_link_node_ref(c, wbuf_jeb, (c->wbuf_ofs + c->wbuf_len) | REF_OBSOLETE, waste, NULL);
David Woodhouse0bcc0992006-05-21 13:00:54 +0100667 /* FIXME: that made it count as dirty. Convert to wasted */
David Woodhouse9bfeb692006-05-26 21:19:05 +0100668 wbuf_jeb->dirty_size -= waste;
David Woodhouse0bcc0992006-05-21 13:00:54 +0100669 c->dirty_size -= waste;
David Woodhouse9bfeb692006-05-26 21:19:05 +0100670 wbuf_jeb->wasted_size += waste;
David Woodhouse0bcc0992006-05-21 13:00:54 +0100671 c->wasted_size += waste;
672 } else
673 spin_lock(&c->erase_completion_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674
675 /* Stick any now-obsoleted blocks on the erase_pending_list */
676 jffs2_refile_wbuf_blocks(c);
677 jffs2_clear_wbuf_ino_list(c);
678 spin_unlock(&c->erase_completion_lock);
679
680 memset(c->wbuf,0xff,c->wbuf_pagesize);
681 /* adjust write buffer offset, else we get a non contiguous write bug */
David Woodhouse3fddb6c2007-05-05 09:52:49 +0100682 if (SECTOR_ADDR(c->wbuf_ofs) == SECTOR_ADDR(c->wbuf_ofs+c->wbuf_pagesize))
683 c->wbuf_ofs += c->wbuf_pagesize;
684 else
685 c->wbuf_ofs = 0xffffffff;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686 c->wbuf_len = 0;
687 return 0;
688}
689
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000690/* Trigger garbage collection to flush the write-buffer.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691 If ino arg is zero, do it if _any_ real (i.e. not GC) writes are
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000692 outstanding. If ino arg non-zero, do it only if a write for the
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693 given inode is outstanding. */
694int jffs2_flush_wbuf_gc(struct jffs2_sb_info *c, uint32_t ino)
695{
696 uint32_t old_wbuf_ofs;
697 uint32_t old_wbuf_len;
698 int ret = 0;
699
700 D1(printk(KERN_DEBUG "jffs2_flush_wbuf_gc() called for ino #%u...\n", ino));
701
David Woodhouse8aee6ac2005-02-02 22:12:08 +0000702 if (!c->wbuf)
703 return 0;
704
Linus Torvalds1da177e2005-04-16 15:20:36 -0700705 down(&c->alloc_sem);
706 if (!jffs2_wbuf_pending_for_ino(c, ino)) {
707 D1(printk(KERN_DEBUG "Ino #%d not pending in wbuf. Returning\n", ino));
708 up(&c->alloc_sem);
709 return 0;
710 }
711
712 old_wbuf_ofs = c->wbuf_ofs;
713 old_wbuf_len = c->wbuf_len;
714
715 if (c->unchecked_size) {
716 /* GC won't make any progress for a while */
717 D1(printk(KERN_DEBUG "jffs2_flush_wbuf_gc() padding. Not finished checking\n"));
718 down_write(&c->wbuf_sem);
719 ret = __jffs2_flush_wbuf(c, PAD_ACCOUNTING);
Estelle Hammache7f716cf2005-01-24 21:24:18 +0000720 /* retry flushing wbuf in case jffs2_wbuf_recover
721 left some data in the wbuf */
722 if (ret)
Estelle Hammache7f716cf2005-01-24 21:24:18 +0000723 ret = __jffs2_flush_wbuf(c, PAD_ACCOUNTING);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724 up_write(&c->wbuf_sem);
725 } else while (old_wbuf_len &&
726 old_wbuf_ofs == c->wbuf_ofs) {
727
728 up(&c->alloc_sem);
729
730 D1(printk(KERN_DEBUG "jffs2_flush_wbuf_gc() calls gc pass\n"));
731
732 ret = jffs2_garbage_collect_pass(c);
733 if (ret) {
734 /* GC failed. Flush it with padding instead */
735 down(&c->alloc_sem);
736 down_write(&c->wbuf_sem);
737 ret = __jffs2_flush_wbuf(c, PAD_ACCOUNTING);
Estelle Hammache7f716cf2005-01-24 21:24:18 +0000738 /* retry flushing wbuf in case jffs2_wbuf_recover
739 left some data in the wbuf */
740 if (ret)
Estelle Hammache7f716cf2005-01-24 21:24:18 +0000741 ret = __jffs2_flush_wbuf(c, PAD_ACCOUNTING);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700742 up_write(&c->wbuf_sem);
743 break;
744 }
745 down(&c->alloc_sem);
746 }
747
748 D1(printk(KERN_DEBUG "jffs2_flush_wbuf_gc() ends...\n"));
749
750 up(&c->alloc_sem);
751 return ret;
752}
753
754/* Pad write-buffer to end and write it, wasting space. */
755int jffs2_flush_wbuf_pad(struct jffs2_sb_info *c)
756{
757 int ret;
758
David Woodhouse8aee6ac2005-02-02 22:12:08 +0000759 if (!c->wbuf)
760 return 0;
761
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762 down_write(&c->wbuf_sem);
763 ret = __jffs2_flush_wbuf(c, PAD_NOACCOUNT);
Estelle Hammache7f716cf2005-01-24 21:24:18 +0000764 /* retry - maybe wbuf recover left some data in wbuf. */
765 if (ret)
766 ret = __jffs2_flush_wbuf(c, PAD_NOACCOUNT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700767 up_write(&c->wbuf_sem);
768
769 return ret;
770}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771
Thomas Gleixnerdcb09322006-05-23 11:49:14 +0200772static size_t jffs2_fill_wbuf(struct jffs2_sb_info *c, const uint8_t *buf,
773 size_t len)
774{
775 if (len && !c->wbuf_len && (len >= c->wbuf_pagesize))
776 return 0;
777
778 if (len > (c->wbuf_pagesize - c->wbuf_len))
779 len = c->wbuf_pagesize - c->wbuf_len;
780 memcpy(c->wbuf + c->wbuf_len, buf, len);
781 c->wbuf_len += (uint32_t) len;
782 return len;
783}
784
785int jffs2_flash_writev(struct jffs2_sb_info *c, const struct kvec *invecs,
786 unsigned long count, loff_t to, size_t *retlen,
787 uint32_t ino)
788{
789 struct jffs2_eraseblock *jeb;
790 size_t wbuf_retlen, donelen = 0;
791 uint32_t outvec_to = to;
792 int ret, invec;
793
794 /* If not writebuffered flash, don't bother */
Andrew Victor3be36672005-02-09 09:09:05 +0000795 if (!jffs2_is_writebuffered(c))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700796 return jffs2_flash_direct_writev(c, invecs, count, to, retlen);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000797
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798 down_write(&c->wbuf_sem);
799
800 /* If wbuf_ofs is not initialized, set it to target address */
801 if (c->wbuf_ofs == 0xFFFFFFFF) {
802 c->wbuf_ofs = PAGE_DIV(to);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000803 c->wbuf_len = PAGE_MOD(to);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804 memset(c->wbuf,0xff,c->wbuf_pagesize);
805 }
806
Thomas Gleixnerdcb09322006-05-23 11:49:14 +0200807 /*
Thomas Gleixnerdcb09322006-05-23 11:49:14 +0200808 * Sanity checks on target address. It's permitted to write
809 * at PAD(c->wbuf_len+c->wbuf_ofs), and it's permitted to
810 * write at the beginning of a new erase block. Anything else,
811 * and you die. New block starts at xxx000c (0-b = block
812 * header)
813 */
Andrew Victor3be36672005-02-09 09:09:05 +0000814 if (SECTOR_ADDR(to) != SECTOR_ADDR(c->wbuf_ofs)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700815 /* It's a write to a new block */
816 if (c->wbuf_len) {
Thomas Gleixnerdcb09322006-05-23 11:49:14 +0200817 D1(printk(KERN_DEBUG "jffs2_flash_writev() to 0x%lx "
818 "causes flush of wbuf at 0x%08x\n",
819 (unsigned long)to, c->wbuf_ofs));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700820 ret = __jffs2_flush_wbuf(c, PAD_NOACCOUNT);
Thomas Gleixnerdcb09322006-05-23 11:49:14 +0200821 if (ret)
822 goto outerr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700823 }
824 /* set pointer to new block */
825 c->wbuf_ofs = PAGE_DIV(to);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000826 c->wbuf_len = PAGE_MOD(to);
827 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700828
829 if (to != PAD(c->wbuf_ofs + c->wbuf_len)) {
830 /* We're not writing immediately after the writebuffer. Bad. */
Thomas Gleixnerdcb09322006-05-23 11:49:14 +0200831 printk(KERN_CRIT "jffs2_flash_writev(): Non-contiguous write "
832 "to %08lx\n", (unsigned long)to);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700833 if (c->wbuf_len)
834 printk(KERN_CRIT "wbuf was previously %08x-%08x\n",
Thomas Gleixnerdcb09322006-05-23 11:49:14 +0200835 c->wbuf_ofs, c->wbuf_ofs+c->wbuf_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700836 BUG();
837 }
838
Thomas Gleixnerdcb09322006-05-23 11:49:14 +0200839 /* adjust alignment offset */
840 if (c->wbuf_len != PAGE_MOD(to)) {
841 c->wbuf_len = PAGE_MOD(to);
842 /* take care of alignment to next page */
843 if (!c->wbuf_len) {
844 c->wbuf_len = c->wbuf_pagesize;
845 ret = __jffs2_flush_wbuf(c, NOPAD);
846 if (ret)
847 goto outerr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848 }
849 }
850
Thomas Gleixnerdcb09322006-05-23 11:49:14 +0200851 for (invec = 0; invec < count; invec++) {
852 int vlen = invecs[invec].iov_len;
853 uint8_t *v = invecs[invec].iov_base;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700854
Thomas Gleixnerdcb09322006-05-23 11:49:14 +0200855 wbuf_retlen = jffs2_fill_wbuf(c, v, vlen);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700856
Thomas Gleixnerdcb09322006-05-23 11:49:14 +0200857 if (c->wbuf_len == c->wbuf_pagesize) {
858 ret = __jffs2_flush_wbuf(c, NOPAD);
859 if (ret)
860 goto outerr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861 }
Thomas Gleixnerdcb09322006-05-23 11:49:14 +0200862 vlen -= wbuf_retlen;
863 outvec_to += wbuf_retlen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864 donelen += wbuf_retlen;
Thomas Gleixnerdcb09322006-05-23 11:49:14 +0200865 v += wbuf_retlen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866
Thomas Gleixnerdcb09322006-05-23 11:49:14 +0200867 if (vlen >= c->wbuf_pagesize) {
868 ret = c->mtd->write(c->mtd, outvec_to, PAGE_DIV(vlen),
869 &wbuf_retlen, v);
870 if (ret < 0 || wbuf_retlen != PAGE_DIV(vlen))
871 goto outfile;
872
873 vlen -= wbuf_retlen;
874 outvec_to += wbuf_retlen;
875 c->wbuf_ofs = outvec_to;
876 donelen += wbuf_retlen;
877 v += wbuf_retlen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700878 }
879
Thomas Gleixnerdcb09322006-05-23 11:49:14 +0200880 wbuf_retlen = jffs2_fill_wbuf(c, v, vlen);
881 if (c->wbuf_len == c->wbuf_pagesize) {
882 ret = __jffs2_flush_wbuf(c, NOPAD);
883 if (ret)
884 goto outerr;
885 }
886
887 outvec_to += wbuf_retlen;
888 donelen += wbuf_retlen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700889 }
890
Thomas Gleixnerdcb09322006-05-23 11:49:14 +0200891 /*
892 * If there's a remainder in the wbuf and it's a non-GC write,
893 * remember that the wbuf affects this ino
894 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700895 *retlen = donelen;
896
Ferenc Havasie631ddb2005-09-07 09:35:26 +0100897 if (jffs2_sum_active()) {
898 int res = jffs2_sum_add_kvec(c, invecs, count, (uint32_t) to);
899 if (res)
900 return res;
901 }
902
Linus Torvalds1da177e2005-04-16 15:20:36 -0700903 if (c->wbuf_len && ino)
904 jffs2_wbuf_dirties_inode(c, ino);
905
906 ret = 0;
Thomas Gleixnerdcb09322006-05-23 11:49:14 +0200907 up_write(&c->wbuf_sem);
908 return ret;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000909
Thomas Gleixnerdcb09322006-05-23 11:49:14 +0200910outfile:
911 /*
912 * At this point we have no problem, c->wbuf is empty. However
913 * refile nextblock to avoid writing again to same address.
914 */
915
916 spin_lock(&c->erase_completion_lock);
917
918 jeb = &c->blocks[outvec_to / c->sector_size];
919 jffs2_block_refile(c, jeb, REFILE_ANYWAY);
920
921 spin_unlock(&c->erase_completion_lock);
922
923outerr:
924 *retlen = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700925 up_write(&c->wbuf_sem);
926 return ret;
927}
928
929/*
930 * This is the entry for flash write.
931 * Check, if we work on NAND FLASH, if so build an kvec and write it via vritev
932*/
David Woodhouse9bfeb692006-05-26 21:19:05 +0100933int jffs2_flash_write(struct jffs2_sb_info *c, loff_t ofs, size_t len,
934 size_t *retlen, const u_char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700935{
936 struct kvec vecs[1];
937
Andrew Victor3be36672005-02-09 09:09:05 +0000938 if (!jffs2_is_writebuffered(c))
Ferenc Havasie631ddb2005-09-07 09:35:26 +0100939 return jffs2_flash_direct_write(c, ofs, len, retlen, buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700940
941 vecs[0].iov_base = (unsigned char *) buf;
942 vecs[0].iov_len = len;
943 return jffs2_flash_writev(c, vecs, 1, ofs, retlen, 0);
944}
945
946/*
947 Handle readback from writebuffer and ECC failure return
948*/
949int jffs2_flash_read(struct jffs2_sb_info *c, loff_t ofs, size_t len, size_t *retlen, u_char *buf)
950{
951 loff_t orbf = 0, owbf = 0, lwbf = 0;
952 int ret;
953
Andrew Victor3be36672005-02-09 09:09:05 +0000954 if (!jffs2_is_writebuffered(c))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700955 return c->mtd->read(c->mtd, ofs, len, retlen, buf);
956
Andrew Victor3be36672005-02-09 09:09:05 +0000957 /* Read flash */
Artem B. Bityuckiy894214d2005-04-05 13:51:58 +0100958 down_read(&c->wbuf_sem);
Thomas Gleixner9223a452006-05-23 17:21:03 +0200959 ret = c->mtd->read(c->mtd, ofs, len, retlen, buf);
Andrew Victor3be36672005-02-09 09:09:05 +0000960
Thomas Gleixner9a1fcdf2006-05-29 14:56:39 +0200961 if ( (ret == -EBADMSG || ret == -EUCLEAN) && (*retlen == len) ) {
962 if (ret == -EBADMSG)
963 printk(KERN_WARNING "mtd->read(0x%zx bytes from 0x%llx)"
964 " returned ECC error\n", len, ofs);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000965 /*
Thomas Gleixner9a1fcdf2006-05-29 14:56:39 +0200966 * We have the raw data without ECC correction in the buffer,
967 * maybe we are lucky and all data or parts are correct. We
968 * check the node. If data are corrupted node check will sort
969 * it out. We keep this block, it will fail on write or erase
970 * and the we mark it bad. Or should we do that now? But we
971 * should give him a chance. Maybe we had a system crash or
972 * power loss before the ecc write or a erase was completed.
Andrew Victor3be36672005-02-09 09:09:05 +0000973 * So we return success. :)
974 */
Thomas Gleixner9a1fcdf2006-05-29 14:56:39 +0200975 ret = 0;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000976 }
Andrew Victor3be36672005-02-09 09:09:05 +0000977
Linus Torvalds1da177e2005-04-16 15:20:36 -0700978 /* if no writebuffer available or write buffer empty, return */
979 if (!c->wbuf_pagesize || !c->wbuf_len)
Artem B. Bityuckiy894214d2005-04-05 13:51:58 +0100980 goto exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700981
982 /* if we read in a different block, return */
Andrew Victor3be36672005-02-09 09:09:05 +0000983 if (SECTOR_ADDR(ofs) != SECTOR_ADDR(c->wbuf_ofs))
Artem B. Bityuckiy894214d2005-04-05 13:51:58 +0100984 goto exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700985
986 if (ofs >= c->wbuf_ofs) {
987 owbf = (ofs - c->wbuf_ofs); /* offset in write buffer */
988 if (owbf > c->wbuf_len) /* is read beyond write buffer ? */
989 goto exit;
990 lwbf = c->wbuf_len - owbf; /* number of bytes to copy */
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000991 if (lwbf > len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700992 lwbf = len;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000993 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700994 orbf = (c->wbuf_ofs - ofs); /* offset in read buffer */
995 if (orbf > len) /* is write beyond write buffer ? */
996 goto exit;
Thomas Gleixner9a1fcdf2006-05-29 14:56:39 +0200997 lwbf = len - orbf; /* number of bytes to copy */
Thomas Gleixner182ec4e2005-11-07 11:16:07 +0000998 if (lwbf > c->wbuf_len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700999 lwbf = c->wbuf_len;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +00001000 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001001 if (lwbf > 0)
1002 memcpy(buf+orbf,c->wbuf+owbf,lwbf);
1003
1004exit:
1005 up_read(&c->wbuf_sem);
1006 return ret;
1007}
1008
Artem Bityutskiya7a6ace12007-01-31 11:38:53 +02001009#define NR_OOB_SCAN_PAGES 4
1010
David Woodhouse09b3fba2007-08-09 17:28:20 +08001011/* For historical reasons we use only 8 bytes for OOB clean marker */
1012#define OOB_CM_SIZE 8
Artem Bityutskiya7a6ace12007-01-31 11:38:53 +02001013
1014static const struct jffs2_unknown_node oob_cleanmarker =
1015{
David Woodhouse566865a2007-04-23 12:07:17 +01001016 .magic = constant_cpu_to_je16(JFFS2_MAGIC_BITMASK),
1017 .nodetype = constant_cpu_to_je16(JFFS2_NODETYPE_CLEANMARKER),
1018 .totlen = constant_cpu_to_je32(8)
Artem Bityutskiya7a6ace12007-01-31 11:38:53 +02001019};
Thomas Gleixner8593fbc2006-05-29 03:26:58 +02001020
Linus Torvalds1da177e2005-04-16 15:20:36 -07001021/*
Artem Bityutskiya7a6ace12007-01-31 11:38:53 +02001022 * Check, if the out of band area is empty. This function knows about the clean
1023 * marker and if it is present in OOB, treats the OOB as empty anyway.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001024 */
Thomas Gleixner8593fbc2006-05-29 03:26:58 +02001025int jffs2_check_oob_empty(struct jffs2_sb_info *c,
1026 struct jffs2_eraseblock *jeb, int mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001027{
Artem Bityutskiya7a6ace12007-01-31 11:38:53 +02001028 int i, ret;
1029 int cmlen = min_t(int, c->oobavail, OOB_CM_SIZE);
Thomas Gleixner8593fbc2006-05-29 03:26:58 +02001030 struct mtd_oob_ops ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001031
Artem Bityutskiya7a6ace12007-01-31 11:38:53 +02001032 ops.mode = MTD_OOB_AUTO;
1033 ops.ooblen = NR_OOB_SCAN_PAGES * c->oobavail;
Thomas Gleixner8593fbc2006-05-29 03:26:58 +02001034 ops.oobbuf = c->oobbuf;
Artem Bityutskiya7a6ace12007-01-31 11:38:53 +02001035 ops.len = ops.ooboffs = ops.retlen = ops.oobretlen = 0;
Thomas Gleixner8593fbc2006-05-29 03:26:58 +02001036 ops.datbuf = NULL;
Thomas Gleixner8593fbc2006-05-29 03:26:58 +02001037
1038 ret = c->mtd->read_oob(c->mtd, jeb->offset, &ops);
Artem Bityutskiya7a6ace12007-01-31 11:38:53 +02001039 if (ret || ops.oobretlen != ops.ooblen) {
Andrew Morton7be26bfb2007-02-17 16:02:10 -08001040 printk(KERN_ERR "cannot read OOB for EB at %08x, requested %zd"
1041 " bytes, read %zd bytes, error %d\n",
1042 jeb->offset, ops.ooblen, ops.oobretlen, ret);
Artem Bityutskiya7a6ace12007-01-31 11:38:53 +02001043 if (!ret)
1044 ret = -EIO;
Thomas Gleixner8593fbc2006-05-29 03:26:58 +02001045 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001046 }
Thomas Gleixner182ec4e2005-11-07 11:16:07 +00001047
Artem Bityutskiya7a6ace12007-01-31 11:38:53 +02001048 for(i = 0; i < ops.ooblen; i++) {
1049 if (mode && i < cmlen)
1050 /* Yeah, we know about the cleanmarker */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001051 continue;
1052
Thomas Gleixner8593fbc2006-05-29 03:26:58 +02001053 if (ops.oobbuf[i] != 0xFF) {
1054 D2(printk(KERN_DEBUG "Found %02x at %x in OOB for "
1055 "%08x\n", ops.oobbuf[i], i, jeb->offset));
1056 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001057 }
1058 }
1059
Thomas Gleixner8593fbc2006-05-29 03:26:58 +02001060 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001061}
1062
1063/*
Artem Bityutskiya7a6ace12007-01-31 11:38:53 +02001064 * Check for a valid cleanmarker.
1065 * Returns: 0 if a valid cleanmarker was found
David Woodhouseef53cb02007-07-10 10:01:22 +01001066 * 1 if no cleanmarker was found
1067 * negative error code if an error occurred
Thomas Gleixner8593fbc2006-05-29 03:26:58 +02001068 */
Artem Bityutskiya7a6ace12007-01-31 11:38:53 +02001069int jffs2_check_nand_cleanmarker(struct jffs2_sb_info *c,
1070 struct jffs2_eraseblock *jeb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001071{
Thomas Gleixner8593fbc2006-05-29 03:26:58 +02001072 struct mtd_oob_ops ops;
Artem Bityutskiya7a6ace12007-01-31 11:38:53 +02001073 int ret, cmlen = min_t(int, c->oobavail, OOB_CM_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001074
Artem Bityutskiya7a6ace12007-01-31 11:38:53 +02001075 ops.mode = MTD_OOB_AUTO;
1076 ops.ooblen = cmlen;
Thomas Gleixner8593fbc2006-05-29 03:26:58 +02001077 ops.oobbuf = c->oobbuf;
Artem Bityutskiya7a6ace12007-01-31 11:38:53 +02001078 ops.len = ops.ooboffs = ops.retlen = ops.oobretlen = 0;
Thomas Gleixner8593fbc2006-05-29 03:26:58 +02001079 ops.datbuf = NULL;
Thomas Gleixner8593fbc2006-05-29 03:26:58 +02001080
Artem Bityutskiya7a6ace12007-01-31 11:38:53 +02001081 ret = c->mtd->read_oob(c->mtd, jeb->offset, &ops);
1082 if (ret || ops.oobretlen != ops.ooblen) {
Andrew Morton7be26bfb2007-02-17 16:02:10 -08001083 printk(KERN_ERR "cannot read OOB for EB at %08x, requested %zd"
1084 " bytes, read %zd bytes, error %d\n",
1085 jeb->offset, ops.ooblen, ops.oobretlen, ret);
Artem Bityutskiya7a6ace12007-01-31 11:38:53 +02001086 if (!ret)
1087 ret = -EIO;
Thomas Gleixner8593fbc2006-05-29 03:26:58 +02001088 return ret;
1089 }
1090
Artem Bityutskiya7a6ace12007-01-31 11:38:53 +02001091 return !!memcmp(&oob_cleanmarker, c->oobbuf, cmlen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001092}
1093
Thomas Gleixner8593fbc2006-05-29 03:26:58 +02001094int jffs2_write_nand_cleanmarker(struct jffs2_sb_info *c,
1095 struct jffs2_eraseblock *jeb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001096{
Artem Bityutskiya7a6ace12007-01-31 11:38:53 +02001097 int ret;
Thomas Gleixner8593fbc2006-05-29 03:26:58 +02001098 struct mtd_oob_ops ops;
Artem Bityutskiya7a6ace12007-01-31 11:38:53 +02001099 int cmlen = min_t(int, c->oobavail, OOB_CM_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001100
Artem Bityutskiya7a6ace12007-01-31 11:38:53 +02001101 ops.mode = MTD_OOB_AUTO;
1102 ops.ooblen = cmlen;
1103 ops.oobbuf = (uint8_t *)&oob_cleanmarker;
1104 ops.len = ops.ooboffs = ops.retlen = ops.oobretlen = 0;
Thomas Gleixner8593fbc2006-05-29 03:26:58 +02001105 ops.datbuf = NULL;
Thomas Gleixner8593fbc2006-05-29 03:26:58 +02001106
1107 ret = c->mtd->write_oob(c->mtd, jeb->offset, &ops);
Artem Bityutskiya7a6ace12007-01-31 11:38:53 +02001108 if (ret || ops.oobretlen != ops.ooblen) {
Andrew Morton7be26bfb2007-02-17 16:02:10 -08001109 printk(KERN_ERR "cannot write OOB for EB at %08x, requested %zd"
1110 " bytes, read %zd bytes, error %d\n",
1111 jeb->offset, ops.ooblen, ops.oobretlen, ret);
Artem Bityutskiya7a6ace12007-01-31 11:38:53 +02001112 if (!ret)
1113 ret = -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001114 return ret;
1115 }
Artem Bityutskiya7a6ace12007-01-31 11:38:53 +02001116
Linus Torvalds1da177e2005-04-16 15:20:36 -07001117 return 0;
1118}
1119
Thomas Gleixner182ec4e2005-11-07 11:16:07 +00001120/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001121 * On NAND we try to mark this block bad. If the block was erased more
1122 * than MAX_ERASE_FAILURES we mark it finaly bad.
1123 * Don't care about failures. This block remains on the erase-pending
1124 * or badblock list as long as nobody manipulates the flash with
1125 * a bootloader or something like that.
1126 */
1127
1128int jffs2_write_nand_badblock(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, uint32_t bad_offset)
1129{
1130 int ret;
1131
1132 /* if the count is < max, we try to write the counter to the 2nd page oob area */
1133 if( ++jeb->bad_count < MAX_ERASE_FAILURES)
1134 return 0;
1135
1136 if (!c->mtd->block_markbad)
1137 return 1; // What else can we do?
1138
Artem Bityutskiy0feba822007-03-08 10:35:10 +02001139 printk(KERN_WARNING "JFFS2: marking eraseblock at %08x\n as bad", bad_offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001140 ret = c->mtd->block_markbad(c->mtd, bad_offset);
Thomas Gleixner182ec4e2005-11-07 11:16:07 +00001141
Linus Torvalds1da177e2005-04-16 15:20:36 -07001142 if (ret) {
1143 D1(printk(KERN_WARNING "jffs2_write_nand_badblock(): Write failed for block at %08x: error %d\n", jeb->offset, ret));
1144 return ret;
1145 }
1146 return 1;
1147}
1148
Artem Bityutskiya7a6ace12007-01-31 11:38:53 +02001149int jffs2_nand_flash_setup(struct jffs2_sb_info *c)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001150{
Thomas Gleixner5bd34c02006-05-27 22:16:10 +02001151 struct nand_ecclayout *oinfo = c->mtd->ecclayout;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001152
Linus Torvalds1da177e2005-04-16 15:20:36 -07001153 if (!c->mtd->oobsize)
1154 return 0;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +00001155
Linus Torvalds1da177e2005-04-16 15:20:36 -07001156 /* Cleanmarker is out-of-band, so inline size zero */
1157 c->cleanmarker_size = 0;
1158
Artem Bityutskiya7a6ace12007-01-31 11:38:53 +02001159 if (!oinfo || oinfo->oobavail == 0) {
1160 printk(KERN_ERR "inconsistent device description\n");
Thomas Gleixner5bd34c02006-05-27 22:16:10 +02001161 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001162 }
Thomas Gleixner5bd34c02006-05-27 22:16:10 +02001163
Artem Bityutskiya7a6ace12007-01-31 11:38:53 +02001164 D1(printk(KERN_DEBUG "JFFS2 using OOB on NAND\n"));
Thomas Gleixner5bd34c02006-05-27 22:16:10 +02001165
Artem Bityutskiya7a6ace12007-01-31 11:38:53 +02001166 c->oobavail = oinfo->oobavail;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001167
1168 /* Initialise write buffer */
1169 init_rwsem(&c->wbuf_sem);
Joern Engel28318772006-05-22 23:18:05 +02001170 c->wbuf_pagesize = c->mtd->writesize;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001171 c->wbuf_ofs = 0xFFFFFFFF;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +00001172
Linus Torvalds1da177e2005-04-16 15:20:36 -07001173 c->wbuf = kmalloc(c->wbuf_pagesize, GFP_KERNEL);
1174 if (!c->wbuf)
1175 return -ENOMEM;
1176
Artem Bityutskiya7a6ace12007-01-31 11:38:53 +02001177 c->oobbuf = kmalloc(NR_OOB_SCAN_PAGES * c->oobavail, GFP_KERNEL);
1178 if (!c->oobbuf) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001179 kfree(c->wbuf);
1180 return -ENOMEM;
1181 }
Artem Bityutskiya7a6ace12007-01-31 11:38:53 +02001182
David Woodhousea6bc4322007-07-11 14:23:54 +01001183#ifdef CONFIG_JFFS2_FS_WBUF_VERIFY
1184 c->wbuf_verify = kmalloc(c->wbuf_pagesize, GFP_KERNEL);
1185 if (!c->wbuf_verify) {
1186 kfree(c->oobbuf);
1187 kfree(c->wbuf);
1188 return -ENOMEM;
1189 }
1190#endif
Artem Bityutskiya7a6ace12007-01-31 11:38:53 +02001191 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001192}
1193
1194void jffs2_nand_flash_cleanup(struct jffs2_sb_info *c)
1195{
David Woodhousea6bc4322007-07-11 14:23:54 +01001196#ifdef CONFIG_JFFS2_FS_WBUF_VERIFY
1197 kfree(c->wbuf_verify);
1198#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001199 kfree(c->wbuf);
Thomas Gleixner8593fbc2006-05-29 03:26:58 +02001200 kfree(c->oobbuf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001201}
1202
Andrew Victor8f15fd52005-02-09 09:17:45 +00001203int jffs2_dataflash_setup(struct jffs2_sb_info *c) {
1204 c->cleanmarker_size = 0; /* No cleanmarkers needed */
Thomas Gleixner182ec4e2005-11-07 11:16:07 +00001205
Andrew Victor8f15fd52005-02-09 09:17:45 +00001206 /* Initialize write buffer */
1207 init_rwsem(&c->wbuf_sem);
Andrew Victor8f15fd52005-02-09 09:17:45 +00001208
Thomas Gleixner182ec4e2005-11-07 11:16:07 +00001209
Artem B. Bityutskiydaba5cc2005-09-30 14:59:17 +01001210 c->wbuf_pagesize = c->mtd->erasesize;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +00001211
Artem B. Bityutskiydaba5cc2005-09-30 14:59:17 +01001212 /* Find a suitable c->sector_size
1213 * - Not too much sectors
1214 * - Sectors have to be at least 4 K + some bytes
1215 * - All known dataflashes have erase sizes of 528 or 1056
1216 * - we take at least 8 eraseblocks and want to have at least 8K size
1217 * - The concatenation should be a power of 2
1218 */
Andrew Victor8f15fd52005-02-09 09:17:45 +00001219
Artem B. Bityutskiydaba5cc2005-09-30 14:59:17 +01001220 c->sector_size = 8 * c->mtd->erasesize;
Thomas Gleixner182ec4e2005-11-07 11:16:07 +00001221
Artem B. Bityutskiydaba5cc2005-09-30 14:59:17 +01001222 while (c->sector_size < 8192) {
1223 c->sector_size *= 2;
1224 }
Thomas Gleixner182ec4e2005-11-07 11:16:07 +00001225
Artem B. Bityutskiydaba5cc2005-09-30 14:59:17 +01001226 /* It may be necessary to adjust the flash size */
1227 c->flash_size = c->mtd->size;
1228
1229 if ((c->flash_size % c->sector_size) != 0) {
1230 c->flash_size = (c->flash_size / c->sector_size) * c->sector_size;
1231 printk(KERN_WARNING "JFFS2 flash size adjusted to %dKiB\n", c->flash_size);
1232 };
Thomas Gleixner182ec4e2005-11-07 11:16:07 +00001233
Artem B. Bityutskiydaba5cc2005-09-30 14:59:17 +01001234 c->wbuf_ofs = 0xFFFFFFFF;
Andrew Victor8f15fd52005-02-09 09:17:45 +00001235 c->wbuf = kmalloc(c->wbuf_pagesize, GFP_KERNEL);
1236 if (!c->wbuf)
1237 return -ENOMEM;
1238
Artem B. Bityutskiydaba5cc2005-09-30 14:59:17 +01001239 printk(KERN_INFO "JFFS2 write-buffering enabled buffer (%d) erasesize (%d)\n", c->wbuf_pagesize, c->sector_size);
Andrew Victor8f15fd52005-02-09 09:17:45 +00001240
1241 return 0;
1242}
1243
1244void jffs2_dataflash_cleanup(struct jffs2_sb_info *c) {
1245 kfree(c->wbuf);
1246}
Andrew Victor8f15fd52005-02-09 09:17:45 +00001247
Nicolas Pitre59da7212005-08-06 05:51:33 +01001248int jffs2_nor_wbuf_flash_setup(struct jffs2_sb_info *c) {
Joern Engelc8b229d2006-05-22 23:18:12 +02001249 /* Cleanmarker currently occupies whole programming regions,
1250 * either one or 2 for 8Byte STMicro flashes. */
1251 c->cleanmarker_size = max(16u, c->mtd->writesize);
Nicolas Pitre59da7212005-08-06 05:51:33 +01001252
1253 /* Initialize write buffer */
1254 init_rwsem(&c->wbuf_sem);
Joern Engel28318772006-05-22 23:18:05 +02001255 c->wbuf_pagesize = c->mtd->writesize;
Nicolas Pitre59da7212005-08-06 05:51:33 +01001256 c->wbuf_ofs = 0xFFFFFFFF;
1257
1258 c->wbuf = kmalloc(c->wbuf_pagesize, GFP_KERNEL);
1259 if (!c->wbuf)
1260 return -ENOMEM;
1261
1262 return 0;
1263}
1264
1265void jffs2_nor_wbuf_flash_cleanup(struct jffs2_sb_info *c) {
1266 kfree(c->wbuf);
1267}
Artem Bityutskiy0029da32006-10-04 19:15:21 +03001268
1269int jffs2_ubivol_setup(struct jffs2_sb_info *c) {
1270 c->cleanmarker_size = 0;
1271
1272 if (c->mtd->writesize == 1)
1273 /* We do not need write-buffer */
1274 return 0;
1275
1276 init_rwsem(&c->wbuf_sem);
1277
1278 c->wbuf_pagesize = c->mtd->writesize;
1279 c->wbuf_ofs = 0xFFFFFFFF;
1280 c->wbuf = kmalloc(c->wbuf_pagesize, GFP_KERNEL);
1281 if (!c->wbuf)
1282 return -ENOMEM;
1283
1284 printk(KERN_INFO "JFFS2 write-buffering enabled buffer (%d) erasesize (%d)\n", c->wbuf_pagesize, c->sector_size);
1285
1286 return 0;
1287}
1288
1289void jffs2_ubivol_cleanup(struct jffs2_sb_info *c) {
1290 kfree(c->wbuf);
1291}