Root/fs/jffs2/scan.c

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

Archive Download this file



interactive