Context Navigation

source: rtems/cpukit/libfs/src/jffs2/src/scan.c @ 6ac6a5c8

5

Last change on this file since 6ac6a5c8 was 6ac6a5c8, checked in by Sebastian Huber <sebastian.huber@…>, on 03/27/18 at 11:01:56

jffs2: Do not use command line defines

Update #3375.

Property mode set to 100644

File size: 35.1 KB

Line
1	#include "rtems-jffs2-config.h"
2
3	/*
4	* JFFS2 -- Journalling Flash File System, Version 2.
5	*
6	* Copyright Â© 2001-2007 Red Hat, Inc.
7	*
8	* Created by David Woodhouse <dwmw2@infradead.org>
9	*
10	* For licensing information, see the file 'LICENCE' in this directory.
11	*
12	*/
13
14	#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
15
16	#include <linux/kernel.h>
17	#include <linux/sched.h>
18	#include <linux/slab.h>
19	#include <linux/mtd/mtd.h>
20	#include <linux/pagemap.h>
21	#include <linux/crc32.h>
22	#include <linux/compiler.h>
23	#include "nodelist.h"
24	#include "summary.h"
25	#include "debug.h"
26
27	#define DEFAULT_EMPTY_SCAN_SIZE 256
28
29	#define noisy_printk(noise, fmt, ...) \
30	do { \
31	if (*(noise)) { \
32	pr_notice(fmt, ##__VA_ARGS__); \
33	(*(noise))--; \
34	if (!(*(noise))) \
35	pr_notice("Further such events for this erase block will not be printed\n"); \
36	} \
37	} while (0)
38
39	static uint32_t pseudo_random;
40
41	static int jffs2_scan_eraseblock (struct jffs2_sb_info c, struct jffs2_eraseblock jeb,
42	unsigned char buf, uint32_t buf_size, struct jffs2_summary s);
43
44	/* These helper functions _must_ increase ofs and also do the dirty/used space accounting.
45	* Returning an error will abort the mount - bad checksums etc. should just mark the space
46	* as dirty.
47	*/
48	static int jffs2_scan_inode_node(struct jffs2_sb_info c, struct jffs2_eraseblock jeb,
49	struct jffs2_raw_inode ri, uint32_t ofs, struct jffs2_summary s);
50	static int jffs2_scan_dirent_node(struct jffs2_sb_info c, struct jffs2_eraseblock jeb,
51	struct jffs2_raw_dirent rd, uint32_t ofs, struct jffs2_summary s);
52
53	static inline int min_free(struct jffs2_sb_info *c)
54	{
55	uint32_t min = 2 * sizeof(struct jffs2_raw_inode);
56	#ifdef CONFIG_JFFS2_FS_WRITEBUFFER
57	if (!jffs2_can_mark_obsolete(c) && min < c->wbuf_pagesize)
58	return c->wbuf_pagesize;
59	#endif
60	return min;
61
62	}
63
64	static inline uint32_t EMPTY_SCAN_SIZE(uint32_t sector_size) {
65	if (sector_size < DEFAULT_EMPTY_SCAN_SIZE)
66	return sector_size;
67	else
68	return DEFAULT_EMPTY_SCAN_SIZE;
69	}
70
71	static int file_dirty(struct jffs2_sb_info c, struct jffs2_eraseblock jeb)
72	{
73	int ret;
74
75	if ((ret = jffs2_prealloc_raw_node_refs(c, jeb, 1)))
76	return ret;
77	if ((ret = jffs2_scan_dirty_space(c, jeb, jeb->free_size)))
78	return ret;
79	/* Turned wasted size into dirty, since we apparently
80	think it's recoverable now. */
81	jeb->dirty_size += jeb->wasted_size;
82	c->dirty_size += jeb->wasted_size;
83	c->wasted_size -= jeb->wasted_size;
84	jeb->wasted_size = 0;
85	if (VERYDIRTY(c, jeb->dirty_size)) {
86	list_add(&jeb->list, &c->very_dirty_list);
87	} else {
88	list_add(&jeb->list, &c->dirty_list);
89	}
90	return 0;
91	}
92
93	int jffs2_scan_medium(struct jffs2_sb_info *c)
94	{
95	int i, ret;
96	uint32_t empty_blocks = 0, bad_blocks = 0;
97	unsigned char *flashbuf = NULL;
98	uint32_t buf_size = 0;
99	struct jffs2_summary s = NULL; / summary info collected by the scan process */
100	size_t try_size;
101	#ifndef __ECOS
102	size_t pointlen;
103
104	ret = mtd_point(c->mtd, 0, c->mtd->size, &pointlen,
105	(void **)&flashbuf, NULL);
106	if (!ret && pointlen < c->mtd->size) {
107	/* Don't muck about if it won't let us point to the whole flash */
108	jffs2_dbg(1, "MTD point returned len too short: 0x%zx\n",
109	pointlen);
110	mtd_unpoint(c->mtd, 0, pointlen);
111	flashbuf = NULL;
112	}
113	if (ret && ret != -EOPNOTSUPP)
114	jffs2_dbg(1, "MTD point failed %d\n", ret);
115	#endif
116	if (!flashbuf) {
117	/* For NAND it's quicker to read a whole eraseblock at a time,
118	apparently */
119	if (jffs2_cleanmarker_oob(c))
120	try_size = c->sector_size;
121	else
122	try_size = PAGE_SIZE;
123
124	jffs2_dbg(1, "Trying to allocate readbuf of %zu "
125	"bytes\n", try_size);
126
127	flashbuf = mtd_kmalloc_up_to(c->mtd, &try_size);
128	if (!flashbuf)
129	return -ENOMEM;
130
131	jffs2_dbg(1, "Allocated readbuf of %zu bytes\n",
132	try_size);
133
134	buf_size = (uint32_t)try_size;
135	}
136
137	if (jffs2_sum_active()) {
138	s = kzalloc(sizeof(struct jffs2_summary), GFP_KERNEL);
139	if (!s) {
140	JFFS2_WARNING("Can't allocate memory for summary\n");
141	ret = -ENOMEM;
142	goto out;
143	}
144	}
145
146	for (i=0; i<c->nr_blocks; i++) {
147	struct jffs2_eraseblock *jeb = &c->blocks[i];
148
149	cond_resched();
150
151	/* reset summary info for next eraseblock scan */
152	jffs2_sum_reset_collected(s);
153
154	ret = jffs2_scan_eraseblock(c, jeb, buf_size?flashbuf:(flashbuf+jeb->offset),
155	buf_size, s);
156
157	if (ret < 0)
158	goto out;
159
160	jffs2_dbg_acct_paranoia_check_nolock(c, jeb);
161
162	/* Now decide which list to put it on */
163	switch(ret) {
164	case BLK_STATE_ALLFF:
165	/*
166	* Empty block. Since we can't be sure it
167	* was entirely erased, we just queue it for erase
168	* again. It will be marked as such when the erase
169	* is complete. Meanwhile we still count it as empty
170	* for later checks.
171	*/
172	empty_blocks++;
173	list_add(&jeb->list, &c->erase_pending_list);
174	c->nr_erasing_blocks++;
175	break;
176
177	case BLK_STATE_CLEANMARKER:
178	/* Only a CLEANMARKER node is valid */
179	if (!jeb->dirty_size) {
180	/* It's actually free */
181	list_add(&jeb->list, &c->free_list);
182	c->nr_free_blocks++;
183	} else {
184	/* Dirt */
185	jffs2_dbg(1, "Adding all-dirty block at 0x%08x to erase_pending_list\n",
186	jeb->offset);
187	list_add(&jeb->list, &c->erase_pending_list);
188	c->nr_erasing_blocks++;
189	}
190	break;
191
192	case BLK_STATE_CLEAN:
193	/* Full (or almost full) of clean data. Clean list */
194	list_add(&jeb->list, &c->clean_list);
195	break;
196
197	case BLK_STATE_PARTDIRTY:
198	/* Some data, but not full. Dirty list. */
199	/* We want to remember the block with most free space
200	and stick it in the 'nextblock' position to start writing to it. */
201	if (jeb->free_size > min_free(c) &&
202	(!c->nextblock \|\| c->nextblock->free_size < jeb->free_size)) {
203	/* Better candidate for the next writes to go to */
204	if (c->nextblock) {
205	ret = file_dirty(c, c->nextblock);
206	if (ret)
207	goto out;
208	/* deleting summary information of the old nextblock */
209	jffs2_sum_reset_collected(c->summary);
210	}
211	/* update collected summary information for the current nextblock */
212	jffs2_sum_move_collected(c, s);
213	jffs2_dbg(1, "%s(): new nextblock = 0x%08x\n",
214	__func__, jeb->offset);
215	c->nextblock = jeb;
216	} else {
217	ret = file_dirty(c, jeb);
218	if (ret)
219	goto out;
220	}
221	break;
222
223	case BLK_STATE_ALLDIRTY:
224	/* Nothing valid - not even a clean marker. Needs erasing. */
225	/* For now we just put it on the erasing list. We'll start the erases later */
226	jffs2_dbg(1, "Erase block at 0x%08x is not formatted. It will be erased\n",
227	jeb->offset);
228	list_add(&jeb->list, &c->erase_pending_list);
229	c->nr_erasing_blocks++;
230	break;
231
232	case BLK_STATE_BADBLOCK:
233	jffs2_dbg(1, "Block at 0x%08x is bad\n", jeb->offset);
234	list_add(&jeb->list, &c->bad_list);
235	c->bad_size += c->sector_size;
236	c->free_size -= c->sector_size;
237	bad_blocks++;
238	break;
239	default:
240	pr_warn("%s(): unknown block state\n", __func__);
241	BUG();
242	}
243	}
244
245	/* Nextblock dirty is always seen as wasted, because we cannot recycle it now */
246	if (c->nextblock && (c->nextblock->dirty_size)) {
247	c->nextblock->wasted_size += c->nextblock->dirty_size;
248	c->wasted_size += c->nextblock->dirty_size;
249	c->dirty_size -= c->nextblock->dirty_size;
250	c->nextblock->dirty_size = 0;
251	}
252	#ifdef CONFIG_JFFS2_FS_WRITEBUFFER
253	if (!jffs2_can_mark_obsolete(c) && c->wbuf_pagesize && c->nextblock && (c->nextblock->free_size % c->wbuf_pagesize)) {
254	/* If we're going to start writing into a block which already
255	contains data, and the end of the data isn't page-aligned,
256	skip a little and align it. */
257
258	uint32_t skip = c->nextblock->free_size % c->wbuf_pagesize;
259
260	jffs2_dbg(1, "%s(): Skipping %d bytes in nextblock to ensure page alignment\n",
261	__func__, skip);
262	jffs2_prealloc_raw_node_refs(c, c->nextblock, 1);
263	jffs2_scan_dirty_space(c, c->nextblock, skip);
264	}
265	#endif
266	if (c->nr_erasing_blocks) {
267	if ( !c->used_size && ((c->nr_free_blocks+empty_blocks+bad_blocks)!= c->nr_blocks \|\| bad_blocks == c->nr_blocks) ) {
268	pr_notice("Cowardly refusing to erase blocks on filesystem with no valid JFFS2 nodes\n");
269	pr_notice("empty_blocks %d, bad_blocks %d, c->nr_blocks %d\n",
270	empty_blocks, bad_blocks, c->nr_blocks);
271	ret = -EIO;
272	goto out;
273	}
274	spin_lock(&c->erase_completion_lock);
275	jffs2_garbage_collect_trigger(c);
276	spin_unlock(&c->erase_completion_lock);
277	}
278	ret = 0;
279	out:
280	if (buf_size)
281	kfree(flashbuf);
282	#ifndef __ECOS
283	else
284	mtd_unpoint(c->mtd, 0, c->mtd->size);
285	#endif
286	kfree(s);
287	return ret;
288	}
289
290	static int jffs2_fill_scan_buf(struct jffs2_sb_info c, void buf,
291	uint32_t ofs, uint32_t len)
292	{
293	int ret;
294	size_t retlen;
295
296	ret = jffs2_flash_read(c, ofs, len, &retlen, buf);
297	if (ret) {
298	jffs2_dbg(1, "mtd->read(0x%x bytes from 0x%x) returned %d\n",
299	len, ofs, ret);
300	return ret;
301	}
302	if (retlen < len) {
303	jffs2_dbg(1, "Read at 0x%x gave only 0x%zx bytes\n",
304	ofs, retlen);
305	return -EIO;
306	}
307	return 0;
308	}
309
310	int jffs2_scan_classify_jeb(struct jffs2_sb_info c, struct jffs2_eraseblock jeb)
311	{
312	if ((jeb->used_size + jeb->unchecked_size) == PAD(c->cleanmarker_size) && !jeb->dirty_size
313	&& (!jeb->first_node \|\| !ref_next(jeb->first_node)) )
314	return BLK_STATE_CLEANMARKER;
315
316	/* move blocks with max 4 byte dirty space to cleanlist */
317	else if (!ISDIRTY(c->sector_size - (jeb->used_size + jeb->unchecked_size))) {
318	c->dirty_size -= jeb->dirty_size;
319	c->wasted_size += jeb->dirty_size;
320	jeb->wasted_size += jeb->dirty_size;
321	jeb->dirty_size = 0;
322	return BLK_STATE_CLEAN;
323	} else if (jeb->used_size \|\| jeb->unchecked_size)
324	return BLK_STATE_PARTDIRTY;
325	else
326	return BLK_STATE_ALLDIRTY;
327	}
328
329	#ifdef CONFIG_JFFS2_FS_XATTR
330	static int jffs2_scan_xattr_node(struct jffs2_sb_info c, struct jffs2_eraseblock jeb,
331	struct jffs2_raw_xattr *rx, uint32_t ofs,
332	struct jffs2_summary *s)
333	{
334	struct jffs2_xattr_datum *xd;
335	uint32_t xid, version, totlen, crc;
336	int err;
337
338	crc = crc32(0, rx, sizeof(struct jffs2_raw_xattr) - 4);
339	if (crc != je32_to_cpu(rx->node_crc)) {
340	JFFS2_WARNING("node CRC failed at %#08x, read=%#08x, calc=%#08x\n",
341	ofs, je32_to_cpu(rx->node_crc), crc);
342	if ((err = jffs2_scan_dirty_space(c, jeb, je32_to_cpu(rx->totlen))))
343	return err;
344	return 0;
345	}
346
347	xid = je32_to_cpu(rx->xid);
348	version = je32_to_cpu(rx->version);
349
350	totlen = PAD(sizeof(struct jffs2_raw_xattr)
351	+ rx->name_len + 1 + je16_to_cpu(rx->value_len));
352	if (totlen != je32_to_cpu(rx->totlen)) {
353	JFFS2_WARNING("node length mismatch at %#08x, read=%u, calc=%u\n",
354	ofs, je32_to_cpu(rx->totlen), totlen);
355	if ((err = jffs2_scan_dirty_space(c, jeb, je32_to_cpu(rx->totlen))))
356	return err;
357	return 0;
358	}
359
360	xd = jffs2_setup_xattr_datum(c, xid, version);
361	if (IS_ERR(xd))
362	return PTR_ERR(xd);
363
364	if (xd->version > version) {
365	struct jffs2_raw_node_ref *raw
366	= jffs2_link_node_ref(c, jeb, ofs \| REF_PRISTINE, totlen, NULL);
367	raw->next_in_ino = xd->node->next_in_ino;
368	xd->node->next_in_ino = raw;
369	} else {
370	xd->version = version;
371	xd->xprefix = rx->xprefix;
372	xd->name_len = rx->name_len;
373	xd->value_len = je16_to_cpu(rx->value_len);
374	xd->data_crc = je32_to_cpu(rx->data_crc);
375
376	jffs2_link_node_ref(c, jeb, ofs \| REF_PRISTINE, totlen, (void *)xd);
377	}
378
379	if (jffs2_sum_active())
380	jffs2_sum_add_xattr_mem(s, rx, ofs - jeb->offset);
381	dbg_xattr("scanning xdatum at %#08x (xid=%u, version=%u)\n",
382	ofs, xd->xid, xd->version);
383	return 0;
384	}
385
386	static int jffs2_scan_xref_node(struct jffs2_sb_info c, struct jffs2_eraseblock jeb,
387	struct jffs2_raw_xref *rr, uint32_t ofs,
388	struct jffs2_summary *s)
389	{
390	struct jffs2_xattr_ref *ref;
391	uint32_t crc;
392	int err;
393
394	crc = crc32(0, rr, sizeof(*rr) - 4);
395	if (crc != je32_to_cpu(rr->node_crc)) {
396	JFFS2_WARNING("node CRC failed at %#08x, read=%#08x, calc=%#08x\n",
397	ofs, je32_to_cpu(rr->node_crc), crc);
398	if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(rr->totlen)))))
399	return err;
400	return 0;
401	}
402
403	if (PAD(sizeof(struct jffs2_raw_xref)) != je32_to_cpu(rr->totlen)) {
404	JFFS2_WARNING("node length mismatch at %#08x, read=%u, calc=%zd\n",
405	ofs, je32_to_cpu(rr->totlen),
406	PAD(sizeof(struct jffs2_raw_xref)));
407	if ((err = jffs2_scan_dirty_space(c, jeb, je32_to_cpu(rr->totlen))))
408	return err;
409	return 0;
410	}
411
412	ref = jffs2_alloc_xattr_ref();
413	if (!ref)
414	return -ENOMEM;
415
416	/* BEFORE jffs2_build_xattr_subsystem() called,
417	* and AFTER xattr_ref is marked as a dead xref,
418	* ref->xid is used to store 32bit xid, xd is not used
419	* ref->ino is used to store 32bit inode-number, ic is not used
420	* Thoes variables are declared as union, thus using those
421	* are exclusive. In a similar way, ref->next is temporarily
422	* used to chain all xattr_ref object. It's re-chained to
423	* jffs2_inode_cache in jffs2_build_xattr_subsystem() correctly.
424	*/
425	ref->ino = je32_to_cpu(rr->ino);
426	ref->xid = je32_to_cpu(rr->xid);
427	ref->xseqno = je32_to_cpu(rr->xseqno);
428	if (ref->xseqno > c->highest_xseqno)
429	c->highest_xseqno = (ref->xseqno & ~XREF_DELETE_MARKER);
430	ref->next = c->xref_temp;
431	c->xref_temp = ref;
432
433	jffs2_link_node_ref(c, jeb, ofs \| REF_PRISTINE, PAD(je32_to_cpu(rr->totlen)), (void *)ref);
434
435	if (jffs2_sum_active())
436	jffs2_sum_add_xref_mem(s, rr, ofs - jeb->offset);
437	dbg_xattr("scan xref at %#08x (xid=%u, ino=%u)\n",
438	ofs, ref->xid, ref->ino);
439	return 0;
440	}
441	#endif
442
443	/* Called with 'buf_size == 0' if buf is in fact a pointer _directly_ into
444	the flash, XIP-style */
445	static int jffs2_scan_eraseblock (struct jffs2_sb_info c, struct jffs2_eraseblock jeb,
446	unsigned char buf, uint32_t buf_size, struct jffs2_summary s) {
447	struct jffs2_unknown_node *node;
448	struct jffs2_unknown_node crcnode;
449	uint32_t ofs, prevofs, max_ofs;
450	uint32_t hdr_crc, buf_ofs, buf_len;
451	int err;
452	int noise = 0;
453
454
455	#ifdef CONFIG_JFFS2_FS_WRITEBUFFER
456	int cleanmarkerfound = 0;
457	#endif
458
459	ofs = jeb->offset;
460	prevofs = jeb->offset - 1;
461
462	jffs2_dbg(1, "%s(): Scanning block at 0x%x\n", __func__, ofs);
463
464	#ifdef CONFIG_JFFS2_FS_WRITEBUFFER
465	if (jffs2_cleanmarker_oob(c)) {
466	int ret;
467
468	if (mtd_block_isbad(c->mtd, jeb->offset))
469	return BLK_STATE_BADBLOCK;
470
471	ret = jffs2_check_nand_cleanmarker(c, jeb);
472	jffs2_dbg(2, "jffs_check_nand_cleanmarker returned %d\n", ret);
473
474	/* Even if it's not found, we still scan to see
475	if the block is empty. We use this information
476	to decide whether to erase it or not. */
477	switch (ret) {
478	case 0: cleanmarkerfound = 1; break;
479	case 1: break;
480	default: return ret;
481	}
482	}
483	#endif
484
485	if (jffs2_sum_active()) {
486	struct jffs2_sum_marker *sm;
487	void *sumptr = NULL;
488	uint32_t sumlen;
489
490	if (!buf_size) {
491	/* XIP case. Just look, point at the summary if it's there */
492	sm = (void )buf + c->sector_size - sizeof(sm);
493	if (je32_to_cpu(sm->magic) == JFFS2_SUM_MAGIC) {
494	sumptr = buf + je32_to_cpu(sm->offset);
495	sumlen = c->sector_size - je32_to_cpu(sm->offset);
496	}
497	} else {
498	/* If NAND flash, read a whole page of it. Else just the end */
499	if (c->wbuf_pagesize)
500	buf_len = c->wbuf_pagesize;
501	else
502	buf_len = sizeof(*sm);
503
504	/* Read as much as we want into the _end_ of the preallocated buffer */
505	err = jffs2_fill_scan_buf(c, buf + buf_size - buf_len,
506	jeb->offset + c->sector_size - buf_len,
507	buf_len);
508	if (err)
509	return err;
510
511	sm = (void )buf + buf_size - sizeof(sm);
512	if (je32_to_cpu(sm->magic) == JFFS2_SUM_MAGIC) {
513	sumlen = c->sector_size - je32_to_cpu(sm->offset);
514	sumptr = buf + buf_size - sumlen;
515
516	/* Now, make sure the summary itself is available */
517	if (sumlen > buf_size) {
518	/* Need to kmalloc for this. */
519	sumptr = kmalloc(sumlen, GFP_KERNEL);
520	if (!sumptr)
521	return -ENOMEM;
522	memcpy(sumptr + sumlen - buf_len, buf + buf_size - buf_len, buf_len);
523	}
524	if (buf_len < sumlen) {
525	/* Need to read more so that the entire summary node is present */
526	err = jffs2_fill_scan_buf(c, sumptr,
527	jeb->offset + c->sector_size - sumlen,
528	sumlen - buf_len);
529	if (err)
530	return err;
531	}
532	}
533
534	}
535
536	if (sumptr) {
537	err = jffs2_sum_scan_sumnode(c, jeb, sumptr, sumlen, &pseudo_random);
538
539	if (buf_size && sumlen > buf_size)
540	kfree(sumptr);
541	/* If it returns with a real error, bail.
542	If it returns positive, that's a block classification
543	(i.e. BLK_STATE_xxx) so return that too.
544	If it returns zero, fall through to full scan. */
545	if (err)
546	return err;
547	}
548	}
549
550	buf_ofs = jeb->offset;
551
552	if (!buf_size) {
553	/* This is the XIP case -- we're reading _directly_ from the flash chip */
554	buf_len = c->sector_size;
555	} else {
556	buf_len = EMPTY_SCAN_SIZE(c->sector_size);
557	err = jffs2_fill_scan_buf(c, buf, buf_ofs, buf_len);
558	if (err)
559	return err;
560	}
561
562	/* We temporarily use 'ofs' as a pointer into the buffer/jeb */
563	ofs = 0;
564	max_ofs = EMPTY_SCAN_SIZE(c->sector_size);
565	/* Scan only EMPTY_SCAN_SIZE of 0xFF before declaring it's empty */
566	while(ofs < max_ofs && (uint32_t )(&buf[ofs]) == 0xFFFFFFFF)
567	ofs += 4;
568
569	if (ofs == max_ofs) {
570	#ifdef CONFIG_JFFS2_FS_WRITEBUFFER
571	if (jffs2_cleanmarker_oob(c)) {
572	/* scan oob, take care of cleanmarker */
573	int ret = jffs2_check_oob_empty(c, jeb, cleanmarkerfound);
574	jffs2_dbg(2, "jffs2_check_oob_empty returned %d\n",
575	ret);
576	switch (ret) {
577	case 0: return cleanmarkerfound ? BLK_STATE_CLEANMARKER : BLK_STATE_ALLFF;
578	case 1: return BLK_STATE_ALLDIRTY;
579	default: return ret;
580	}
581	}
582	#endif
583	jffs2_dbg(1, "Block at 0x%08x is empty (erased)\n",
584	jeb->offset);
585	if (c->cleanmarker_size == 0)
586	return BLK_STATE_CLEANMARKER; /* don't bother with re-erase */
587	else
588	return BLK_STATE_ALLFF; /* OK to erase if all blocks are like this */
589	}
590	if (ofs) {
591	jffs2_dbg(1, "Free space at %08x ends at %08x\n", jeb->offset,
592	jeb->offset + ofs);
593	if ((err = jffs2_prealloc_raw_node_refs(c, jeb, 1)))
594	return err;
595	if ((err = jffs2_scan_dirty_space(c, jeb, ofs)))
596	return err;
597	}
598
599	/* Now ofs is a complete physical flash offset as it always was... */
600	ofs += jeb->offset;
601
602	noise = 10;
603
604	dbg_summary("no summary found in jeb 0x%08x. Apply original scan.\n",jeb->offset);
605
606	scan_more:
607	while(ofs < jeb->offset + c->sector_size) {
608
609	jffs2_dbg_acct_paranoia_check_nolock(c, jeb);
610
611	/* Make sure there are node refs available for use */
612	err = jffs2_prealloc_raw_node_refs(c, jeb, 2);
613	if (err)
614	return err;
615
616	cond_resched();
617
618	if (ofs & 3) {
619	pr_warn("Eep. ofs 0x%08x not word-aligned!\n", ofs);
620	ofs = PAD(ofs);
621	continue;
622	}
623	if (ofs == prevofs) {
624	pr_warn("ofs 0x%08x has already been seen. Skipping\n",
625	ofs);
626	if ((err = jffs2_scan_dirty_space(c, jeb, 4)))
627	return err;
628	ofs += 4;
629	continue;
630	}
631	prevofs = ofs;
632
633	if (jeb->offset + c->sector_size < ofs + sizeof(*node)) {
634	jffs2_dbg(1, "Fewer than %zd bytes left to end of block. (%x+%x<%x+%zx) Not reading\n",
635	sizeof(struct jffs2_unknown_node),
636	jeb->offset, c->sector_size, ofs,
637	sizeof(*node));
638	if ((err = jffs2_scan_dirty_space(c, jeb, (jeb->offset + c->sector_size)-ofs)))
639	return err;
640	break;
641	}
642
643	if (buf_ofs + buf_len < ofs + sizeof(*node)) {
644	buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs);
645	jffs2_dbg(1, "Fewer than %zd bytes (node header) left to end of buf. Reading 0x%x at 0x%08x\n",
646	sizeof(struct jffs2_unknown_node),
647	buf_len, ofs);
648	err = jffs2_fill_scan_buf(c, buf, ofs, buf_len);
649	if (err)
650	return err;
651	buf_ofs = ofs;
652	}
653
654	node = (struct jffs2_unknown_node *)&buf[ofs-buf_ofs];
655
656	if ((uint32_t )(&buf[ofs-buf_ofs]) == 0xffffffff) {
657	uint32_t inbuf_ofs;
658	uint32_t empty_start, scan_end;
659
660	empty_start = ofs;
661	ofs += 4;
662	scan_end = min_t(uint32_t, EMPTY_SCAN_SIZE(c->sector_size)/8, buf_len);
663
664	jffs2_dbg(1, "Found empty flash at 0x%08x\n", ofs);
665	more_empty:
666	inbuf_ofs = ofs - buf_ofs;
667	while (inbuf_ofs < scan_end) {
668	if (unlikely((uint32_t )(&buf[inbuf_ofs]) != 0xffffffff)) {
669	pr_warn("Empty flash at 0x%08x ends at 0x%08x\n",
670	empty_start, ofs);
671	if ((err = jffs2_scan_dirty_space(c, jeb, ofs-empty_start)))
672	return err;
673	goto scan_more;
674	}
675
676	inbuf_ofs+=4;
677	ofs += 4;
678	}
679	/* Ran off end. */
680	jffs2_dbg(1, "Empty flash to end of buffer at 0x%08x\n",
681	ofs);
682
683	/* If we're only checking the beginning of a block with a cleanmarker,
684	bail now */
685	if (buf_ofs == jeb->offset && jeb->used_size == PAD(c->cleanmarker_size) &&
686	c->cleanmarker_size && !jeb->dirty_size && !ref_next(jeb->first_node)) {
687	jffs2_dbg(1, "%d bytes at start of block seems clean... assuming all clean\n",
688	EMPTY_SCAN_SIZE(c->sector_size));
689	return BLK_STATE_CLEANMARKER;
690	}
691	if (!buf_size && (scan_end != buf_len)) {/* XIP/point case */
692	scan_end = buf_len;
693	goto more_empty;
694	}
695
696	/* See how much more there is to read in this eraseblock... */
697	buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs);
698	if (!buf_len) {
699	/* No more to read. Break out of main loop without marking
700	this range of empty space as dirty (because it's not) */
701	jffs2_dbg(1, "Empty flash at %08x runs to end of block. Treating as free_space\n",
702	empty_start);
703	break;
704	}
705	/* point never reaches here */
706	scan_end = buf_len;
707	jffs2_dbg(1, "Reading another 0x%x at 0x%08x\n",
708	buf_len, ofs);
709	err = jffs2_fill_scan_buf(c, buf, ofs, buf_len);
710	if (err)
711	return err;
712	buf_ofs = ofs;
713	goto more_empty;
714	}
715
716	if (ofs == jeb->offset && je16_to_cpu(node->magic) == KSAMTIB_CIGAM_2SFFJ) {
717	pr_warn("Magic bitmask is backwards at offset 0x%08x. Wrong endian filesystem?\n",
718	ofs);
719	if ((err = jffs2_scan_dirty_space(c, jeb, 4)))
720	return err;
721	ofs += 4;
722	continue;
723	}
724	if (je16_to_cpu(node->magic) == JFFS2_DIRTY_BITMASK) {
725	jffs2_dbg(1, "Dirty bitmask at 0x%08x\n", ofs);
726	if ((err = jffs2_scan_dirty_space(c, jeb, 4)))
727	return err;
728	ofs += 4;
729	continue;
730	}
731	if (je16_to_cpu(node->magic) == JFFS2_OLD_MAGIC_BITMASK) {
732	pr_warn("Old JFFS2 bitmask found at 0x%08x\n", ofs);
733	pr_warn("You cannot use older JFFS2 filesystems with newer kernels\n");
734	if ((err = jffs2_scan_dirty_space(c, jeb, 4)))
735	return err;
736	ofs += 4;
737	continue;
738	}
739	if (je16_to_cpu(node->magic) != JFFS2_MAGIC_BITMASK) {
740	/* OK. We're out of possibilities. Whinge and move on */
741	noisy_printk(&noise, "%s(): Magic bitmask 0x%04x not found at 0x%08x: 0x%04x instead\n",
742	__func__,
743	JFFS2_MAGIC_BITMASK, ofs,
744	je16_to_cpu(node->magic));
745	if ((err = jffs2_scan_dirty_space(c, jeb, 4)))
746	return err;
747	ofs += 4;
748	continue;
749	}
750	/* We seem to have a node of sorts. Check the CRC */
751	crcnode.magic = node->magic;
752	crcnode.nodetype = cpu_to_je16( je16_to_cpu(node->nodetype) \| JFFS2_NODE_ACCURATE);
753	crcnode.totlen = node->totlen;
754	hdr_crc = crc32(0, &crcnode, sizeof(crcnode)-4);
755
756	if (hdr_crc != je32_to_cpu(node->hdr_crc)) {
757	noisy_printk(&noise, "%s(): Node at 0x%08x {0x%04x, 0x%04x, 0x%08x) has invalid CRC 0x%08x (calculated 0x%08x)\n",
758	__func__,
759	ofs, je16_to_cpu(node->magic),
760	je16_to_cpu(node->nodetype),
761	je32_to_cpu(node->totlen),
762	je32_to_cpu(node->hdr_crc),
763	hdr_crc);
764	if ((err = jffs2_scan_dirty_space(c, jeb, 4)))
765	return err;
766	ofs += 4;
767	continue;
768	}
769
770	if (ofs + je32_to_cpu(node->totlen) > jeb->offset + c->sector_size) {
771	/* Eep. Node goes over the end of the erase block. */
772	pr_warn("Node at 0x%08x with length 0x%08x would run over the end of the erase block\n",
773	ofs, je32_to_cpu(node->totlen));
774	pr_warn("Perhaps the file system was created with the wrong erase size?\n");
775	if ((err = jffs2_scan_dirty_space(c, jeb, 4)))
776	return err;
777	ofs += 4;
778	continue;
779	}
780
781	if (!(je16_to_cpu(node->nodetype) & JFFS2_NODE_ACCURATE)) {
782	/* Wheee. This is an obsoleted node */
783	jffs2_dbg(2, "Node at 0x%08x is obsolete. Skipping\n",
784	ofs);
785	if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(node->totlen)))))
786	return err;
787	ofs += PAD(je32_to_cpu(node->totlen));
788	continue;
789	}
790
791	switch(je16_to_cpu(node->nodetype)) {
792	case JFFS2_NODETYPE_INODE:
793	if (buf_ofs + buf_len < ofs + sizeof(struct jffs2_raw_inode)) {
794	buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs);
795	jffs2_dbg(1, "Fewer than %zd bytes (inode node) left to end of buf. Reading 0x%x at 0x%08x\n",
796	sizeof(struct jffs2_raw_inode),
797	buf_len, ofs);
798	err = jffs2_fill_scan_buf(c, buf, ofs, buf_len);
799	if (err)
800	return err;
801	buf_ofs = ofs;
802	node = (void *)buf;
803	}
804	err = jffs2_scan_inode_node(c, jeb, (void *)node, ofs, s);
805	if (err) return err;
806	ofs += PAD(je32_to_cpu(node->totlen));
807	break;
808
809	case JFFS2_NODETYPE_DIRENT:
810	if (buf_ofs + buf_len < ofs + je32_to_cpu(node->totlen)) {
811	buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs);
812	jffs2_dbg(1, "Fewer than %d bytes (dirent node) left to end of buf. Reading 0x%x at 0x%08x\n",
813	je32_to_cpu(node->totlen), buf_len,
814	ofs);
815	err = jffs2_fill_scan_buf(c, buf, ofs, buf_len);
816	if (err)
817	return err;
818	buf_ofs = ofs;
819	node = (void *)buf;
820	}
821	err = jffs2_scan_dirent_node(c, jeb, (void *)node, ofs, s);
822	if (err) return err;
823	ofs += PAD(je32_to_cpu(node->totlen));
824	break;
825
826	#ifdef CONFIG_JFFS2_FS_XATTR
827	case JFFS2_NODETYPE_XATTR:
828	if (buf_ofs + buf_len < ofs + je32_to_cpu(node->totlen)) {
829	buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs);
830	jffs2_dbg(1, "Fewer than %d bytes (xattr node) left to end of buf. Reading 0x%x at 0x%08x\n",
831	je32_to_cpu(node->totlen), buf_len,
832	ofs);
833	err = jffs2_fill_scan_buf(c, buf, ofs, buf_len);
834	if (err)
835	return err;
836	buf_ofs = ofs;
837	node = (void *)buf;
838	}
839	err = jffs2_scan_xattr_node(c, jeb, (void *)node, ofs, s);
840	if (err)
841	return err;
842	ofs += PAD(je32_to_cpu(node->totlen));
843	break;
844	case JFFS2_NODETYPE_XREF:
845	if (buf_ofs + buf_len < ofs + je32_to_cpu(node->totlen)) {
846	buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs);
847	jffs2_dbg(1, "Fewer than %d bytes (xref node) left to end of buf. Reading 0x%x at 0x%08x\n",
848	je32_to_cpu(node->totlen), buf_len,
849	ofs);
850	err = jffs2_fill_scan_buf(c, buf, ofs, buf_len);
851	if (err)
852	return err;
853	buf_ofs = ofs;
854	node = (void *)buf;
855	}
856	err = jffs2_scan_xref_node(c, jeb, (void *)node, ofs, s);
857	if (err)
858	return err;
859	ofs += PAD(je32_to_cpu(node->totlen));
860	break;
861	#endif /* CONFIG_JFFS2_FS_XATTR */
862
863	case JFFS2_NODETYPE_CLEANMARKER:
864	jffs2_dbg(1, "CLEANMARKER node found at 0x%08x\n", ofs);
865	if (je32_to_cpu(node->totlen) != c->cleanmarker_size) {
866	pr_notice("CLEANMARKER node found at 0x%08x has totlen 0x%x != normal 0x%x\n",
867	ofs, je32_to_cpu(node->totlen),
868	c->cleanmarker_size);
869	if ((err = jffs2_scan_dirty_space(c, jeb, PAD(sizeof(struct jffs2_unknown_node)))))
870	return err;
871	ofs += PAD(sizeof(struct jffs2_unknown_node));
872	} else if (jeb->first_node) {
873	pr_notice("CLEANMARKER node found at 0x%08x, not first node in block (0x%08x)\n",
874	ofs, jeb->offset);
875	if ((err = jffs2_scan_dirty_space(c, jeb, PAD(sizeof(struct jffs2_unknown_node)))))
876	return err;
877	ofs += PAD(sizeof(struct jffs2_unknown_node));
878	} else {
879	jffs2_link_node_ref(c, jeb, ofs \| REF_NORMAL, c->cleanmarker_size, NULL);
880
881	ofs += PAD(c->cleanmarker_size);
882	}
883	break;
884
885	case JFFS2_NODETYPE_PADDING:
886	if (jffs2_sum_active())
887	jffs2_sum_add_padding_mem(s, je32_to_cpu(node->totlen));
888	if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(node->totlen)))))
889	return err;
890	ofs += PAD(je32_to_cpu(node->totlen));
891	break;
892
893	default:
894	switch (je16_to_cpu(node->nodetype) & JFFS2_COMPAT_MASK) {
895	case JFFS2_FEATURE_ROCOMPAT:
896	pr_notice("Read-only compatible feature node (0x%04x) found at offset 0x%08x\n",
897	je16_to_cpu(node->nodetype), ofs);
898	c->flags \|= JFFS2_SB_FLAG_RO;
899	if (!(jffs2_is_readonly(c)))
900	return -EROFS;
901	if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(node->totlen)))))
902	return err;
903	ofs += PAD(je32_to_cpu(node->totlen));
904	break;
905
906	case JFFS2_FEATURE_INCOMPAT:
907	pr_notice("Incompatible feature node (0x%04x) found at offset 0x%08x\n",
908	je16_to_cpu(node->nodetype), ofs);
909	return -EINVAL;
910
911	case JFFS2_FEATURE_RWCOMPAT_DELETE:
912	jffs2_dbg(1, "Unknown but compatible feature node (0x%04x) found at offset 0x%08x\n",
913	je16_to_cpu(node->nodetype), ofs);
914	if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(node->totlen)))))
915	return err;
916	ofs += PAD(je32_to_cpu(node->totlen));
917	break;
918
919	case JFFS2_FEATURE_RWCOMPAT_COPY: {
920	jffs2_dbg(1, "Unknown but compatible feature node (0x%04x) found at offset 0x%08x\n",
921	je16_to_cpu(node->nodetype), ofs);
922
923	jffs2_link_node_ref(c, jeb, ofs \| REF_PRISTINE, PAD(je32_to_cpu(node->totlen)), NULL);
924
925	/* We can't summarise nodes we don't grok */
926	jffs2_sum_disable_collecting(s);
927	ofs += PAD(je32_to_cpu(node->totlen));
928	break;
929	}
930	}
931	}
932	}
933
934	if (jffs2_sum_active()) {
935	if (PAD(s->sum_size + JFFS2_SUMMARY_FRAME_SIZE) > jeb->free_size) {
936	dbg_summary("There is not enough space for "
937	"summary information, disabling for this jeb!\n");
938	jffs2_sum_disable_collecting(s);
939	}
940	}
941
942	jffs2_dbg(1, "Block at 0x%08x: free 0x%08x, dirty 0x%08x, unchecked 0x%08x, used 0x%08x, wasted 0x%08x\n",
943	jeb->offset, jeb->free_size, jeb->dirty_size,
944	jeb->unchecked_size, jeb->used_size, jeb->wasted_size);
945
946	/* mark_node_obsolete can add to wasted !! */
947	if (jeb->wasted_size) {
948	jeb->dirty_size += jeb->wasted_size;
949	c->dirty_size += jeb->wasted_size;
950	c->wasted_size -= jeb->wasted_size;
951	jeb->wasted_size = 0;
952	}
953
954	return jffs2_scan_classify_jeb(c, jeb);
955	}
956
957	struct jffs2_inode_cache jffs2_scan_make_ino_cache(struct jffs2_sb_info c, uint32_t ino)
958	{
959	struct jffs2_inode_cache *ic;
960
961	ic = jffs2_get_ino_cache(c, ino);
962	if (ic)
963	return ic;
964
965	if (ino > c->highest_ino)
966	c->highest_ino = ino;
967
968	ic = jffs2_alloc_inode_cache();
969	if (!ic) {
970	pr_notice("%s(): allocation of inode cache failed\n", __func__);
971	return NULL;
972	}
973	memset(ic, 0, sizeof(*ic));
974
975	ic->ino = ino;
976	ic->nodes = (void *)ic;
977	jffs2_add_ino_cache(c, ic);
978	if (ino == 1)
979	ic->pino_nlink = 1;
980	return ic;
981	}
982
983	static int jffs2_scan_inode_node(struct jffs2_sb_info c, struct jffs2_eraseblock jeb,
984	struct jffs2_raw_inode ri, uint32_t ofs, struct jffs2_summary s)
985	{
986	struct jffs2_inode_cache *ic;
987	uint32_t crc, ino = je32_to_cpu(ri->ino);
988
989	jffs2_dbg(1, "%s(): Node at 0x%08x\n", __func__, ofs);
990
991	/* We do very little here now. Just check the ino# to which we should attribute
992	this node; we can do all the CRC checking etc. later. There's a tradeoff here --
993	we used to scan the flash once only, reading everything we want from it into
994	memory, then building all our in-core data structures and freeing the extra
995	information. Now we allow the first part of the mount to complete a lot quicker,
996	but we have to go _back_ to the flash in order to finish the CRC checking, etc.
997	Which means that the _full_ amount of time to get to proper write mode with GC
998	operational may actually be _longer_ than before. Sucks to be me. */
999
1000	/* Check the node CRC in any case. */
1001	crc = crc32(0, ri, sizeof(*ri)-8);
1002	if (crc != je32_to_cpu(ri->node_crc)) {
1003	pr_notice("%s(): CRC failed on node at 0x%08x: Read 0x%08x, calculated 0x%08x\n",
1004	__func__, ofs, je32_to_cpu(ri->node_crc), crc);
1005	/*
1006	* We believe totlen because the CRC on the node
1007	* _header_ was OK, just the node itself failed.
1008	*/
1009	return jffs2_scan_dirty_space(c, jeb,
1010	PAD(je32_to_cpu(ri->totlen)));
1011	}
1012
1013	ic = jffs2_get_ino_cache(c, ino);
1014	if (!ic) {
1015	ic = jffs2_scan_make_ino_cache(c, ino);
1016	if (!ic)
1017	return -ENOMEM;
1018	}
1019
1020	/* Wheee. It worked */
1021	jffs2_link_node_ref(c, jeb, ofs \| REF_UNCHECKED, PAD(je32_to_cpu(ri->totlen)), ic);
1022
1023	jffs2_dbg(1, "Node is ino #%u, version %d. Range 0x%x-0x%x\n",
1024	je32_to_cpu(ri->ino), je32_to_cpu(ri->version),
1025	je32_to_cpu(ri->offset),
1026	je32_to_cpu(ri->offset)+je32_to_cpu(ri->dsize));
1027
1028	pseudo_random += je32_to_cpu(ri->version);
1029
1030	if (jffs2_sum_active()) {
1031	jffs2_sum_add_inode_mem(s, ri, ofs - jeb->offset);
1032	}
1033
1034	return 0;
1035	}
1036
1037	static int jffs2_scan_dirent_node(struct jffs2_sb_info c, struct jffs2_eraseblock jeb,
1038	struct jffs2_raw_dirent rd, uint32_t ofs, struct jffs2_summary s)
1039	{
1040	struct jffs2_full_dirent *fd;
1041	struct jffs2_inode_cache *ic;
1042	uint32_t checkedlen;
1043	uint32_t crc;
1044	int err;
1045
1046	jffs2_dbg(1, "%s(): Node at 0x%08x\n", __func__, ofs);
1047
1048	/* We don't get here unless the node is still valid, so we don't have to
1049	mask in the ACCURATE bit any more. */
1050	crc = crc32(0, rd, sizeof(*rd)-8);
1051
1052	if (crc != je32_to_cpu(rd->node_crc)) {
1053	pr_notice("%s(): Node CRC failed on node at 0x%08x: Read 0x%08x, calculated 0x%08x\n",
1054	__func__, ofs, je32_to_cpu(rd->node_crc), crc);
1055	/* We believe totlen because the CRC on the node _header_ was OK, just the node itself failed. */
1056	if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(rd->totlen)))))
1057	return err;
1058	return 0;
1059	}
1060
1061	pseudo_random += je32_to_cpu(rd->version);
1062
1063	/* Should never happen. Did. (OLPC trac #4184)*/
1064	checkedlen = strnlen(rd->name, rd->nsize);
1065	if (checkedlen < rd->nsize) {
1066	pr_err("Dirent at %08x has zeroes in name. Truncating to %d chars\n",
1067	ofs, checkedlen);
1068	}
1069	fd = jffs2_alloc_full_dirent(checkedlen+1);
1070	if (!fd) {
1071	return -ENOMEM;
1072	}
1073	memcpy(&fd->name, rd->name, checkedlen);
1074	fd->name[checkedlen] = 0;
1075
1076	crc = crc32(0, fd->name, rd->nsize);
1077	if (crc != je32_to_cpu(rd->name_crc)) {
1078	pr_notice("%s(): Name CRC failed on node at 0x%08x: Read 0x%08x, calculated 0x%08x\n",
1079	__func__, ofs, je32_to_cpu(rd->name_crc), crc);
1080	jffs2_dbg(1, "Name for which CRC failed is (now) '%s', ino #%d\n",
1081	fd->name, je32_to_cpu(rd->ino));
1082	jffs2_free_full_dirent(fd);
1083	/* FIXME: Why do we believe totlen? */
1084	/* We believe totlen because the CRC on the node _header_ was OK, just the name failed. */
1085	if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(rd->totlen)))))
1086	return err;
1087	return 0;
1088	}
1089	ic = jffs2_scan_make_ino_cache(c, je32_to_cpu(rd->pino));
1090	if (!ic) {
1091	jffs2_free_full_dirent(fd);
1092	return -ENOMEM;
1093	}
1094
1095	fd->raw = jffs2_link_node_ref(c, jeb, ofs \| dirent_node_state(rd),
1096	PAD(je32_to_cpu(rd->totlen)), ic);
1097
1098	fd->next = NULL;
1099	fd->version = je32_to_cpu(rd->version);
1100	fd->ino = je32_to_cpu(rd->ino);
1101	fd->nhash = full_name_hash(fd->name, checkedlen);
1102	fd->type = rd->type;
1103	jffs2_add_fd_to_list(c, fd, &ic->scan_dents);
1104
1105	if (jffs2_sum_active()) {
1106	jffs2_sum_add_dirent_mem(s, rd, ofs - jeb->offset);
1107	}
1108
1109	return 0;
1110	}
1111
1112	static int count_list(struct list_head *l)
1113	{
1114	uint32_t count = 0;
1115	struct list_head *tmp;
1116
1117	list_for_each(tmp, l) {
1118	count++;
1119	}
1120	return count;
1121	}
1122
1123	/* Note: This breaks if list_empty(head). I don't care. You
1124	might, if you copy this code and use it elsewhere :) */
1125	static void rotate_list(struct list_head *head, uint32_t count)
1126	{
1127	struct list_head *n = head->next;
1128
1129	list_del(head);
1130	while(count--) {
1131	n = n->next;
1132	}
1133	list_add(head, n);
1134	}
1135
1136	void jffs2_rotate_lists(struct jffs2_sb_info *c)
1137	{
1138	uint32_t x;
1139	uint32_t rotateby;
1140
1141	x = count_list(&c->clean_list);
1142	if (x) {
1143	rotateby = pseudo_random % x;
1144	rotate_list((&c->clean_list), rotateby);
1145	}
1146
1147	x = count_list(&c->very_dirty_list);
1148	if (x) {
1149	rotateby = pseudo_random % x;
1150	rotate_list((&c->very_dirty_list), rotateby);
1151	}
1152
1153	x = count_list(&c->dirty_list);
1154	if (x) {
1155	rotateby = pseudo_random % x;
1156	rotate_list((&c->dirty_list), rotateby);
1157	}
1158
1159	x = count_list(&c->erasable_list);
1160	if (x) {
1161	rotateby = pseudo_random % x;
1162	rotate_list((&c->erasable_list), rotateby);
1163	}
1164
1165	if (c->nr_erasing_blocks) {
1166	rotateby = pseudo_random % c->nr_erasing_blocks;
1167	rotate_list((&c->erase_pending_list), rotateby);
1168	}
1169
1170	if (c->nr_free_blocks) {
1171	rotateby = pseudo_random % c->nr_free_blocks;
1172	rotate_list((&c->free_list), rotateby);
1173	}
1174	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: