embox

1
/*
2
 * JFFS2 -- Journalling Flash File System, Version 2.
3
 *
4
 * Copyright (C) 2001-2003 Red Hat, Inc.
5
 *
6
 * Created by David Woodhouse <dwmw2@infradead.org>
7
 *
8
 * For licensing information, see the file 'LICENCE' in this directory.
9
 *
10
 * $Id: erase.c,v 1.83 2005/07/22 10:32:08 dedekind Exp $
11
 *
12
 */
13

14
#include <linux/kernel.h>
15
#include <linux/slab.h>
16
#include <linux/mtd/mtd.h>
17
#include <linux/compiler.h>
18
#include <linux/crc32.h>
19
#include <linux/sched.h>
20
#include <linux/pagemap.h>
21
#include "nodelist.h"
22

23
struct erase_priv_struct {
24
	struct jffs2_eraseblock *jeb;
25
	struct jffs2_sb_info *c;
26
};
27

28
static void jffs2_erase_failed(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, uint32_t bad_offset);
29
static void jffs2_erase_succeeded(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb);
30
static void jffs2_free_all_node_refs(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb);
31
static void jffs2_mark_erased_block(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb);
32

33
static void jffs2_erase_block(struct jffs2_sb_info *c,
34
			      struct jffs2_eraseblock *jeb) {
35
	int ret;
36
	uint32_t bad_offset;
37

38
	ret = jffs2_flash_erase(c, jeb);
39
	if (!ret) {
40
		jffs2_erase_succeeded(c, jeb);
41
		return;
42
	}
43
	bad_offset = jeb->offset;
44

45
	if (ret == -ENOMEM || ret == -EAGAIN) {
46
		/* Erase failed immediately. Refile it on the list */
47
		D1(printk( "Erase at 0x%08x failed: %d. Refiling on erase_pending_list\n", jeb->offset, ret));
48
		spin_lock(&c->erase_completion_lock);
49
		list_del(&jeb->list);
50
		list_add(&jeb->list, &c->erase_pending_list);
51
		c->erasing_size -= c->sector_size;
52
		c->dirty_size += c->sector_size;
53
		jeb->dirty_size = c->sector_size;
54
		spin_unlock(&c->erase_completion_lock);
55
		return;
56
	}
57

58
	if (ret == -EROFS) {
59
		D1(printk("Erase at 0x%08x failed immediately: -EROFS. Is the sector locked?\n", jeb->offset));
60
	} else {
61
		D1(printk("Erase at 0x%08x failed immediately: errno %d\n", jeb->offset, ret));
62
	}
63

64
	jffs2_erase_failed(c, jeb, bad_offset);
65
}
66

67
void jffs2_erase_pending_blocks(struct jffs2_sb_info *c, int count) {
68
	struct jffs2_eraseblock *jeb;
69

70
	down(&c->erase_free_sem);
71

72
	spin_lock(&c->erase_completion_lock);
73

74
	while (!list_empty(&c->erase_complete_list) ||
75
	       !list_empty(&c->erase_pending_list)) {
76

77
		if (!list_empty(&c->erase_complete_list)) {
78
			jeb = list_entry(c->erase_complete_list.next, struct jffs2_eraseblock, list);
79
			list_del(&jeb->list);
80
			spin_unlock(&c->erase_completion_lock);
81
			jffs2_mark_erased_block(c, jeb);
82

83
			if (!--count) {
84
				D1(printk( "Count reached. jffs2_erase_pending_blocks leaving\n"));
85
				goto done;
86
			}
87

88
		} else if (!list_empty(&c->erase_pending_list)) {
89
			jeb = list_entry(c->erase_pending_list.next, struct jffs2_eraseblock, list);
90
			D1(printk( "Starting erase of pending block 0x%08x\n", jeb->offset));
91
			list_del(&jeb->list);
92
			c->erasing_size += c->sector_size;
93
			c->wasted_size -= jeb->wasted_size;
94
			c->free_size -= jeb->free_size;
95
			c->used_size -= jeb->used_size;
96
			c->dirty_size -= jeb->dirty_size;
97
			jeb->wasted_size = jeb->used_size = jeb->dirty_size = jeb->free_size = 0;
98
			jffs2_free_all_node_refs(c, jeb);
99
			list_add(&jeb->list, &c->erasing_list);
100
			spin_unlock(&c->erase_completion_lock);
101

102
			jffs2_erase_block(c, jeb);
103

104
		} else {
105
			BUG();
106
		}
107

108
		/* Be nice */
109
		cond_resched();
110
		spin_lock(&c->erase_completion_lock);
111
	}
112

113
	spin_unlock(&c->erase_completion_lock);
114
 done:
115
	D1(printk( "jffs2_erase_pending_blocks completed\n"));
116

117
	up(&c->erase_free_sem);
118
}
119

120
static void jffs2_erase_succeeded(struct jffs2_sb_info *c,
121
								struct jffs2_eraseblock *jeb) {
122
	D1(printk( "Erase completed successfully at 0x%08x\n", jeb->offset));
123
	spin_lock(&c->erase_completion_lock);
124
	list_del(&jeb->list);
125
	list_add_tail(&jeb->list, &c->erase_complete_list);
126
	spin_unlock(&c->erase_completion_lock);
127
	/* Ensure that kupdated calls us again to mark them clean */
128
	jffs2_erase_pending_trigger(c);
129
}
130

131
static void jffs2_erase_failed(struct jffs2_sb_info *c,
132
		struct jffs2_eraseblock *jeb, uint32_t bad_offset) {
133
	/* For NAND, if the failure did not occur at the device level for a
134
	 * specific physical page, don't bother updating the bad block table.
135
	 */
136
	if (jffs2_cleanmarker_oob(c) && (bad_offset != 0xffffffff)) {
137
		/* We had a device-level failure to erase.  Let's see if we've
138
		 * failed too many times.
139
		 */
140
		if (!jffs2_write_nand_badblock(c, jeb, bad_offset)) {
141
			/* We'd like to give this block another try. */
142
			spin_lock(&c->erase_completion_lock);
143
			list_del(&jeb->list);
144
			list_add(&jeb->list, &c->erase_pending_list);
145
			c->erasing_size -= c->sector_size;
146
			c->dirty_size += c->sector_size;
147
			jeb->dirty_size = c->sector_size;
148
			spin_unlock(&c->erase_completion_lock);
149
			return;
150
		}
151
	}
152

153
	spin_lock(&c->erase_completion_lock);
154
	c->erasing_size -= c->sector_size;
155
	c->bad_size += c->sector_size;
156
	list_del(&jeb->list);
157
	list_add(&jeb->list, &c->bad_list);
158
	c->nr_erasing_blocks--;
159
	spin_unlock(&c->erase_completion_lock);
160
	wake_up(&c->erase_wait);
161
}
162

163
static inline void jffs2_remove_node_refs_from_ino_list(
164
		struct jffs2_sb_info *c, struct jffs2_raw_node_ref *ref,
165
		struct jffs2_eraseblock *jeb) {
166
	struct jffs2_inode_cache *ic = NULL;
167
	struct jffs2_raw_node_ref **prev;
168
	struct jffs2_raw_node_ref *this;
169

170
	prev = &ref->next_in_ino;
171

172
	/* Walk the inode's list once, removing any nodes from this eraseblock */
173
	while (1) {
174
		if (!(*prev)->next_in_ino) {
175
			/* We're looking at the jffs2_inode_cache, which is
176
			 * at the end of the linked list. Stash it and continue
177
			 * from the beginning of the list
178
			 */
179
			ic = (struct jffs2_inode_cache *)(*prev);
180
			prev = &ic->nodes;
181
			continue;
182
		}
183

184
		if (SECTOR_ADDR((*prev)->flash_offset) == jeb->offset) {
185
			/* It's in the block we're erasing */
186
			this = *prev;
187
			*prev = this->next_in_ino;
188
			this->next_in_ino = NULL;
189

190
			if (this == ref) {
191
				break;
192
			}
193
			continue;
194
		}
195
		/* Not to be deleted. Skip */
196
		prev = &((*prev)->next_in_ino);
197
	}
198

199
	/* PARANOIA */
200
	if (!ic) {
201
		printk(KERN_WARNING "inode_cache not found in remove_node_refs()!!\n");
202
		return;
203
	}
204

205
	D1(printk( "Removed nodes in range 0x%08x-0x%08x from ino #%u\n",
206
		  jeb->offset, jeb->offset + c->sector_size, ic->ino));
207

208
	D2({
209
		int i=0;
210
		struct jffs2_raw_node_ref *this;
211
		printk( "After remove_node_refs_from_ino_list: \n" KERN_DEBUG);
212

213
		this = ic->nodes;
214

215
		while(this) {
216
			printk( "0x%08x(%d)->", ref_offset(this), ref_flags(this));
217
			if (++i == 5) {
218
				printk("\n" );
219
				i=0;
220
			}
221
			this = this->next_in_ino;
222
		}
223
		printk("\n");
224
	});
225

226
	if (ic->nodes == (void *)ic && ic->nlink == 0) {
227
		jffs2_del_ino_cache(c, ic);
228
	}
229
}
230

231
static void jffs2_free_all_node_refs(struct jffs2_sb_info *c,
232
								struct jffs2_eraseblock *jeb) {
233
	struct jffs2_raw_node_ref *ref;
234
	D1(printk( "Freeing all node refs for eraseblock offset 0x%08x\n", jeb->offset));
235
	while(jeb->first_node) {
236
		ref = jeb->first_node;
237
		jeb->first_node = ref->next_phys;
238

239
		/* Remove from the inode-list */
240
		if (ref->next_in_ino) {
241
			jffs2_remove_node_refs_from_ino_list(c, ref, jeb);
242
		}
243
		/* else it was a non-inode node or already removed, so don't bother */
244

245
		jffs2_free_raw_node_ref(ref);
246
	}
247
	jeb->last_node = NULL;
248
}
249

250
static int jffs2_block_check_erase(struct jffs2_sb_info *c,
251
		struct jffs2_eraseblock *jeb, uint32_t *bad_offset) {
252
	void *ebuf;
253
	uint32_t ofs;
254
	size_t retlen;
255
	uint32_t readlen;
256
	int i;
257
	unsigned long *datum;
258

259
	int ret = -EIO;
260

261
	ebuf = kmalloc(PAGE_SIZE(), GFP_KERNEL);
262
	if (!ebuf) {
263
		printk(KERN_WARNING "Failed to allocate page buffer for verifying erase at 0x%08x. Refiling\n", jeb->offset);
264
		return -EAGAIN;
265
	}
266

267
	D1(printk( "Verifying erase at 0x%08x\n", jeb->offset));
268

269
	for (ofs = jeb->offset; ofs < jeb->offset + c->sector_size; ) {
270
		readlen = min((uint32_t)PAGE_SIZE(), jeb->offset + c->sector_size - ofs);
271

272
		*bad_offset = ofs;
273

274
		ret = jffs2_flash_read(c, ofs, readlen, &retlen, ebuf);
275
		if (ret) {
276
			printk(KERN_WARNING "Read of newly-erased block at 0x%08x failed: %d. Putting on bad_list\n", ofs, ret);
277
			goto fail;
278
		}
279
		if (retlen != readlen) {
280
			printk(KERN_WARNING "Short read from newly-erased block at 0x%08x. Wanted %d, got %zd\n", ofs, readlen, retlen);
281
			goto fail;
282
		}
283
		for (i=0; i<readlen; i += sizeof(unsigned long)) {
284
			/* It's OK. We know it's properly aligned */
285
			datum = ebuf + i;
286
			if (*datum + 1) {
287
				*bad_offset += i;
288
				printk(KERN_WARNING "Newly-erased block contained word 0x%lx at offset 0x%08x\n", *datum, *bad_offset);
289
				goto fail;
290
			}
291
		}
292
		ofs += readlen;
293
		cond_resched();
294
	}
295
	ret = 0;
296
fail:
297
	kfree(ebuf);
298
	return ret;
299
}
300

301
static void jffs2_mark_erased_block(struct jffs2_sb_info *c,
302
								struct jffs2_eraseblock *jeb) {
303
	struct jffs2_raw_node_ref *marker_ref = NULL;
304
	size_t retlen;
305
	int ret;
306
	uint32_t bad_offset;
307
	struct iovec vecs[1];
308

309
	switch (jffs2_block_check_erase(c, jeb, &bad_offset)) {
310
	case -EAGAIN:
311
		goto refile;
312
	case -EIO:
313
		goto filebad;
314
	}
315

316
	/* Write the erase complete marker */
317
	D1(printk( "Writing erased marker to block at 0x%08x\n", jeb->offset));
318
	bad_offset = jeb->offset;
319

320
	/* Cleanmarker in oob area or no cleanmarker at all ? */
321
	if (jffs2_cleanmarker_oob(c) || c->cleanmarker_size == 0) {
322
		if (jffs2_cleanmarker_oob(c)) {
323
			if (jffs2_write_nand_cleanmarker(c, jeb)) {
324
				goto filebad;
325
			}
326
		}
327

328
		jeb->first_node = jeb->last_node = NULL;
329
		jeb->free_size = c->sector_size;
330
		jeb->used_size = 0;
331
		jeb->dirty_size = 0;
332
		jeb->wasted_size = 0;
333

334
	} else {
335
		struct jffs2_unknown_node marker = {
336
			.magic =	cpu_to_je16(JFFS2_MAGIC_BITMASK),
337
			.nodetype =	cpu_to_je16(JFFS2_NODETYPE_CLEANMARKER),
338
			.totlen =	cpu_to_je32(c->cleanmarker_size)
339
		};
340

341
		marker_ref = jffs2_alloc_raw_node_ref();
342
		if (!marker_ref) {
343
			printk(KERN_WARNING "Failed to allocate raw node ref for clean marker. Refiling\n");
344
			goto refile;
345
		}
346

347
		marker.hdr_crc = cpu_to_je32(crc32(0, &marker, sizeof(struct jffs2_unknown_node)-4));
348

349
		vecs[0].iov_base = (unsigned char *) &marker;
350
		vecs[0].iov_len = sizeof(marker);
351
		ret = jffs2_flash_direct_writev(c, vecs, 1, jeb->offset, &retlen);
352

353
		if (ret || retlen != sizeof(marker)) {
354
			if (ret) {
355
				printk(KERN_WARNING "Write clean marker to block at 0x%08x failed: %d\n",
356
				       jeb->offset, ret);
357
			} else {
358
				printk(KERN_WARNING "Short write to newly-erased block at 0x%08x: Wanted %zd, got %zd\n",
359
				       jeb->offset, sizeof(marker), retlen);
360
			}
361
			jffs2_free_raw_node_ref(marker_ref);
362
			goto filebad;
363
		}
364

365
		marker_ref->next_in_ino = NULL;
366
		marker_ref->next_phys = NULL;
367
		marker_ref->flash_offset = jeb->offset | REF_NORMAL;
368
		marker_ref->__totlen = c->cleanmarker_size;
369

370
		jeb->first_node = jeb->last_node = marker_ref;
371

372
		jeb->free_size = c->sector_size - c->cleanmarker_size;
373
		jeb->used_size = c->cleanmarker_size;
374
		jeb->dirty_size = 0;
375
		jeb->wasted_size = 0;
376
	}
377

378
	spin_lock(&c->erase_completion_lock);
379
	c->erasing_size -= c->sector_size;
380
	c->free_size += jeb->free_size;
381
	c->used_size += jeb->used_size;
382

383
	jffs2_dbg_acct_sanity_check_nolock(c,jeb);
384
	jffs2_dbg_acct_paranoia_check_nolock(c, jeb);
385

386
	list_add_tail(&jeb->list, &c->free_list);
387
	c->nr_erasing_blocks--;
388
	c->nr_free_blocks++;
389
	spin_unlock(&c->erase_completion_lock);
390
	wake_up(&c->erase_wait);
391
	return;
392

393
filebad:
394
	spin_lock(&c->erase_completion_lock);
395
	/* Stick it on a list (any list) so erase_failed can take it
396
	 * right off again.  Silly, but shouldn't happen often.
397
	 */
398
	list_add(&jeb->list, &c->erasing_list);
399
	spin_unlock(&c->erase_completion_lock);
400
	jffs2_erase_failed(c, jeb, bad_offset);
401
	return;
402

403
refile:
404
	/* Stick it back on the list from whence it came and come back later */
405
	jffs2_erase_pending_trigger(c);
406
	spin_lock(&c->erase_completion_lock);
407
	list_add(&jeb->list, &c->erase_complete_list);
408
	spin_unlock(&c->erase_completion_lock);
409
	return;
410
}
411