source: rtems/cpukit/libfs/src/jffs2/src/scan.c @ 0ec9bbc

Last change on this file since 0ec9bbc was 0ec9bbc, checked in by Linus Torvalds <torvalds@…>, on Jun 10, 2016 at 2:51:30 PM

vfs: make the string hashes salt the hash

We always mixed in the parent pointer into the dentry name hash, but we
did it late at lookup time. It turns out that we can simplify that
lookup-time action by salting the hash with the parent pointer early
instead of late.

A few other users of our string hashes also wanted to mix in their own
pointers into the hash, and those are updated to use the same mechanism.

Hash users that don't have any particular initial salt can just use the
NULL pointer as a no-salt.

Cc: Vegard Nossum <vegard.nossum@…>
Cc: George Spelvin <linux@…>
Cc: Al Viro <viro@…>
Signed-off-by: Linus Torvalds <torvalds@…>

  • Property mode set to 100644
File size: 35.2 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, ...)                                   \
30do {                                                                    \
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
39static uint32_t pseudo_random;
40
41static 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 */
48static 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);
50static 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
53static 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
64static 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
71static 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
93int 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
290static 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
310int 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
330static 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
386static 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 */
445static 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                                /* sm->offset maybe wrong but MAGIC maybe right */
517                                if (sumlen > c->sector_size)
518                                        goto full_scan;
519
520                                /* Now, make sure the summary itself is available */
521                                if (sumlen > buf_size) {
522                                        /* Need to kmalloc for this. */
523                                        sumptr = kmalloc(sumlen, GFP_KERNEL);
524                                        if (!sumptr)
525                                                return -ENOMEM;
526                                        memcpy(sumptr + sumlen - buf_len, buf + buf_size - buf_len, buf_len);
527                                }
528                                if (buf_len < sumlen) {
529                                        /* Need to read more so that the entire summary node is present */
530                                        err = jffs2_fill_scan_buf(c, sumptr, 
531                                                                  jeb->offset + c->sector_size - sumlen,
532                                                                  sumlen - buf_len);                           
533                                        if (err)
534                                                return err;
535                                }
536                        }
537
538                }
539
540                if (sumptr) {
541                        err = jffs2_sum_scan_sumnode(c, jeb, sumptr, sumlen, &pseudo_random);
542
543                        if (buf_size && sumlen > buf_size)
544                                kfree(sumptr);
545                        /* If it returns with a real error, bail.
546                           If it returns positive, that's a block classification
547                           (i.e. BLK_STATE_xxx) so return that too.
548                           If it returns zero, fall through to full scan. */
549                        if (err)
550                                return err;
551                }
552        }
553
554full_scan:
555        buf_ofs = jeb->offset;
556
557        if (!buf_size) {
558                /* This is the XIP case -- we're reading _directly_ from the flash chip */
559                buf_len = c->sector_size;
560        } else {
561                buf_len = EMPTY_SCAN_SIZE(c->sector_size);
562                err = jffs2_fill_scan_buf(c, buf, buf_ofs, buf_len);
563                if (err)
564                        return err;
565        }
566
567        /* We temporarily use 'ofs' as a pointer into the buffer/jeb */
568        ofs = 0;
569        max_ofs = EMPTY_SCAN_SIZE(c->sector_size);
570        /* Scan only EMPTY_SCAN_SIZE of 0xFF before declaring it's empty */
571        while(ofs < max_ofs && *(uint32_t *)(&buf[ofs]) == 0xFFFFFFFF)
572                ofs += 4;
573
574        if (ofs == max_ofs) {
575#ifdef CONFIG_JFFS2_FS_WRITEBUFFER
576                if (jffs2_cleanmarker_oob(c)) {
577                        /* scan oob, take care of cleanmarker */
578                        int ret = jffs2_check_oob_empty(c, jeb, cleanmarkerfound);
579                        jffs2_dbg(2, "jffs2_check_oob_empty returned %d\n",
580                                  ret);
581                        switch (ret) {
582                        case 0:         return cleanmarkerfound ? BLK_STATE_CLEANMARKER : BLK_STATE_ALLFF;
583                        case 1:         return BLK_STATE_ALLDIRTY;
584                        default:        return ret;
585                        }
586                }
587#endif
588                jffs2_dbg(1, "Block at 0x%08x is empty (erased)\n",
589                          jeb->offset);
590                if (c->cleanmarker_size == 0)
591                        return BLK_STATE_CLEANMARKER;   /* don't bother with re-erase */
592                else
593                        return BLK_STATE_ALLFF; /* OK to erase if all blocks are like this */
594        }
595        if (ofs) {
596                jffs2_dbg(1, "Free space at %08x ends at %08x\n", jeb->offset,
597                          jeb->offset + ofs);
598                if ((err = jffs2_prealloc_raw_node_refs(c, jeb, 1)))
599                        return err;
600                if ((err = jffs2_scan_dirty_space(c, jeb, ofs)))
601                        return err;
602        }
603
604        /* Now ofs is a complete physical flash offset as it always was... */
605        ofs += jeb->offset;
606
607        noise = 10;
608
609        dbg_summary("no summary found in jeb 0x%08x. Apply original scan.\n",jeb->offset);
610
611scan_more:
612        while(ofs < jeb->offset + c->sector_size) {
613
614                jffs2_dbg_acct_paranoia_check_nolock(c, jeb);
615
616                /* Make sure there are node refs available for use */
617                err = jffs2_prealloc_raw_node_refs(c, jeb, 2);
618                if (err)
619                        return err;
620
621                cond_resched();
622
623                if (ofs & 3) {
624                        pr_warn("Eep. ofs 0x%08x not word-aligned!\n", ofs);
625                        ofs = PAD(ofs);
626                        continue;
627                }
628                if (ofs == prevofs) {
629                        pr_warn("ofs 0x%08x has already been seen. Skipping\n",
630                                ofs);
631                        if ((err = jffs2_scan_dirty_space(c, jeb, 4)))
632                                return err;
633                        ofs += 4;
634                        continue;
635                }
636                prevofs = ofs;
637
638                if (jeb->offset + c->sector_size < ofs + sizeof(*node)) {
639                        jffs2_dbg(1, "Fewer than %zd bytes left to end of block. (%x+%x<%x+%zx) Not reading\n",
640                                  sizeof(struct jffs2_unknown_node),
641                                  jeb->offset, c->sector_size, ofs,
642                                  sizeof(*node));
643                        if ((err = jffs2_scan_dirty_space(c, jeb, (jeb->offset + c->sector_size)-ofs)))
644                                return err;
645                        break;
646                }
647
648                if (buf_ofs + buf_len < ofs + sizeof(*node)) {
649                        buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs);
650                        jffs2_dbg(1, "Fewer than %zd bytes (node header) left to end of buf. Reading 0x%x at 0x%08x\n",
651                                  sizeof(struct jffs2_unknown_node),
652                                  buf_len, ofs);
653                        err = jffs2_fill_scan_buf(c, buf, ofs, buf_len);
654                        if (err)
655                                return err;
656                        buf_ofs = ofs;
657                }
658
659                node = (struct jffs2_unknown_node *)&buf[ofs-buf_ofs];
660
661                if (*(uint32_t *)(&buf[ofs-buf_ofs]) == 0xffffffff) {
662                        uint32_t inbuf_ofs;
663                        uint32_t empty_start, scan_end;
664
665                        empty_start = ofs;
666                        ofs += 4;
667                        scan_end = min_t(uint32_t, EMPTY_SCAN_SIZE(c->sector_size)/8, buf_len);
668
669                        jffs2_dbg(1, "Found empty flash at 0x%08x\n", ofs);
670                more_empty:
671                        inbuf_ofs = ofs - buf_ofs;
672                        while (inbuf_ofs < scan_end) {
673                                if (unlikely(*(uint32_t *)(&buf[inbuf_ofs]) != 0xffffffff)) {
674                                        pr_warn("Empty flash at 0x%08x ends at 0x%08x\n",
675                                                empty_start, ofs);
676                                        if ((err = jffs2_scan_dirty_space(c, jeb, ofs-empty_start)))
677                                                return err;
678                                        goto scan_more;
679                                }
680
681                                inbuf_ofs+=4;
682                                ofs += 4;
683                        }
684                        /* Ran off end. */
685                        jffs2_dbg(1, "Empty flash to end of buffer at 0x%08x\n",
686                                  ofs);
687
688                        /* If we're only checking the beginning of a block with a cleanmarker,
689                           bail now */
690                        if (buf_ofs == jeb->offset && jeb->used_size == PAD(c->cleanmarker_size) &&
691                            c->cleanmarker_size && !jeb->dirty_size && !ref_next(jeb->first_node)) {
692                                jffs2_dbg(1, "%d bytes at start of block seems clean... assuming all clean\n",
693                                          EMPTY_SCAN_SIZE(c->sector_size));
694                                return BLK_STATE_CLEANMARKER;
695                        }
696                        if (!buf_size && (scan_end != buf_len)) {/* XIP/point case */
697                                scan_end = buf_len;
698                                goto more_empty;
699                        }
700                       
701                        /* See how much more there is to read in this eraseblock... */
702                        buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs);
703                        if (!buf_len) {
704                                /* No more to read. Break out of main loop without marking
705                                   this range of empty space as dirty (because it's not) */
706                                jffs2_dbg(1, "Empty flash at %08x runs to end of block. Treating as free_space\n",
707                                          empty_start);
708                                break;
709                        }
710                        /* point never reaches here */
711                        scan_end = buf_len;
712                        jffs2_dbg(1, "Reading another 0x%x at 0x%08x\n",
713                                  buf_len, ofs);
714                        err = jffs2_fill_scan_buf(c, buf, ofs, buf_len);
715                        if (err)
716                                return err;
717                        buf_ofs = ofs;
718                        goto more_empty;
719                }
720
721                if (ofs == jeb->offset && je16_to_cpu(node->magic) == KSAMTIB_CIGAM_2SFFJ) {
722                        pr_warn("Magic bitmask is backwards at offset 0x%08x. Wrong endian filesystem?\n",
723                                ofs);
724                        if ((err = jffs2_scan_dirty_space(c, jeb, 4)))
725                                return err;
726                        ofs += 4;
727                        continue;
728                }
729                if (je16_to_cpu(node->magic) == JFFS2_DIRTY_BITMASK) {
730                        jffs2_dbg(1, "Dirty bitmask at 0x%08x\n", ofs);
731                        if ((err = jffs2_scan_dirty_space(c, jeb, 4)))
732                                return err;
733                        ofs += 4;
734                        continue;
735                }
736                if (je16_to_cpu(node->magic) == JFFS2_OLD_MAGIC_BITMASK) {
737                        pr_warn("Old JFFS2 bitmask found at 0x%08x\n", ofs);
738                        pr_warn("You cannot use older JFFS2 filesystems with newer kernels\n");
739                        if ((err = jffs2_scan_dirty_space(c, jeb, 4)))
740                                return err;
741                        ofs += 4;
742                        continue;
743                }
744                if (je16_to_cpu(node->magic) != JFFS2_MAGIC_BITMASK) {
745                        /* OK. We're out of possibilities. Whinge and move on */
746                        noisy_printk(&noise, "%s(): Magic bitmask 0x%04x not found at 0x%08x: 0x%04x instead\n",
747                                     __func__,
748                                     JFFS2_MAGIC_BITMASK, ofs,
749                                     je16_to_cpu(node->magic));
750                        if ((err = jffs2_scan_dirty_space(c, jeb, 4)))
751                                return err;
752                        ofs += 4;
753                        continue;
754                }
755                /* We seem to have a node of sorts. Check the CRC */
756                crcnode.magic = node->magic;
757                crcnode.nodetype = cpu_to_je16( je16_to_cpu(node->nodetype) | JFFS2_NODE_ACCURATE);
758                crcnode.totlen = node->totlen;
759                hdr_crc = crc32(0, &crcnode, sizeof(crcnode)-4);
760
761                if (hdr_crc != je32_to_cpu(node->hdr_crc)) {
762                        noisy_printk(&noise, "%s(): Node at 0x%08x {0x%04x, 0x%04x, 0x%08x) has invalid CRC 0x%08x (calculated 0x%08x)\n",
763                                     __func__,
764                                     ofs, je16_to_cpu(node->magic),
765                                     je16_to_cpu(node->nodetype),
766                                     je32_to_cpu(node->totlen),
767                                     je32_to_cpu(node->hdr_crc),
768                                     hdr_crc);
769                        if ((err = jffs2_scan_dirty_space(c, jeb, 4)))
770                                return err;
771                        ofs += 4;
772                        continue;
773                }
774
775                if (ofs + je32_to_cpu(node->totlen) > jeb->offset + c->sector_size) {
776                        /* Eep. Node goes over the end of the erase block. */
777                        pr_warn("Node at 0x%08x with length 0x%08x would run over the end of the erase block\n",
778                                ofs, je32_to_cpu(node->totlen));
779                        pr_warn("Perhaps the file system was created with the wrong erase size?\n");
780                        if ((err = jffs2_scan_dirty_space(c, jeb, 4)))
781                                return err;
782                        ofs += 4;
783                        continue;
784                }
785
786                if (!(je16_to_cpu(node->nodetype) & JFFS2_NODE_ACCURATE)) {
787                        /* Wheee. This is an obsoleted node */
788                        jffs2_dbg(2, "Node at 0x%08x is obsolete. Skipping\n",
789                                  ofs);
790                        if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(node->totlen)))))
791                                return err;
792                        ofs += PAD(je32_to_cpu(node->totlen));
793                        continue;
794                }
795
796                switch(je16_to_cpu(node->nodetype)) {
797                case JFFS2_NODETYPE_INODE:
798                        if (buf_ofs + buf_len < ofs + sizeof(struct jffs2_raw_inode)) {
799                                buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs);
800                                jffs2_dbg(1, "Fewer than %zd bytes (inode node) left to end of buf. Reading 0x%x at 0x%08x\n",
801                                          sizeof(struct jffs2_raw_inode),
802                                          buf_len, ofs);
803                                err = jffs2_fill_scan_buf(c, buf, ofs, buf_len);
804                                if (err)
805                                        return err;
806                                buf_ofs = ofs;
807                                node = (void *)buf;
808                        }
809                        err = jffs2_scan_inode_node(c, jeb, (void *)node, ofs, s);
810                        if (err) return err;
811                        ofs += PAD(je32_to_cpu(node->totlen));
812                        break;
813
814                case JFFS2_NODETYPE_DIRENT:
815                        if (buf_ofs + buf_len < ofs + je32_to_cpu(node->totlen)) {
816                                buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs);
817                                jffs2_dbg(1, "Fewer than %d bytes (dirent node) left to end of buf. Reading 0x%x at 0x%08x\n",
818                                          je32_to_cpu(node->totlen), buf_len,
819                                          ofs);
820                                err = jffs2_fill_scan_buf(c, buf, ofs, buf_len);
821                                if (err)
822                                        return err;
823                                buf_ofs = ofs;
824                                node = (void *)buf;
825                        }
826                        err = jffs2_scan_dirent_node(c, jeb, (void *)node, ofs, s);
827                        if (err) return err;
828                        ofs += PAD(je32_to_cpu(node->totlen));
829                        break;
830
831#ifdef CONFIG_JFFS2_FS_XATTR
832                case JFFS2_NODETYPE_XATTR:
833                        if (buf_ofs + buf_len < ofs + je32_to_cpu(node->totlen)) {
834                                buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs);
835                                jffs2_dbg(1, "Fewer than %d bytes (xattr node) left to end of buf. Reading 0x%x at 0x%08x\n",
836                                          je32_to_cpu(node->totlen), buf_len,
837                                          ofs);
838                                err = jffs2_fill_scan_buf(c, buf, ofs, buf_len);
839                                if (err)
840                                        return err;
841                                buf_ofs = ofs;
842                                node = (void *)buf;
843                        }
844                        err = jffs2_scan_xattr_node(c, jeb, (void *)node, ofs, s);
845                        if (err)
846                                return err;
847                        ofs += PAD(je32_to_cpu(node->totlen));
848                        break;
849                case JFFS2_NODETYPE_XREF:
850                        if (buf_ofs + buf_len < ofs + je32_to_cpu(node->totlen)) {
851                                buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs);
852                                jffs2_dbg(1, "Fewer than %d bytes (xref node) left to end of buf. Reading 0x%x at 0x%08x\n",
853                                          je32_to_cpu(node->totlen), buf_len,
854                                          ofs);
855                                err = jffs2_fill_scan_buf(c, buf, ofs, buf_len);
856                                if (err)
857                                        return err;
858                                buf_ofs = ofs;
859                                node = (void *)buf;
860                        }
861                        err = jffs2_scan_xref_node(c, jeb, (void *)node, ofs, s);
862                        if (err)
863                                return err;
864                        ofs += PAD(je32_to_cpu(node->totlen));
865                        break;
866#endif  /* CONFIG_JFFS2_FS_XATTR */
867
868                case JFFS2_NODETYPE_CLEANMARKER:
869                        jffs2_dbg(1, "CLEANMARKER node found at 0x%08x\n", ofs);
870                        if (je32_to_cpu(node->totlen) != c->cleanmarker_size) {
871                                pr_notice("CLEANMARKER node found at 0x%08x has totlen 0x%x != normal 0x%x\n",
872                                          ofs, je32_to_cpu(node->totlen),
873                                          c->cleanmarker_size);
874                                if ((err = jffs2_scan_dirty_space(c, jeb, PAD(sizeof(struct jffs2_unknown_node)))))
875                                        return err;
876                                ofs += PAD(sizeof(struct jffs2_unknown_node));
877                        } else if (jeb->first_node) {
878                                pr_notice("CLEANMARKER node found at 0x%08x, not first node in block (0x%08x)\n",
879                                          ofs, jeb->offset);
880                                if ((err = jffs2_scan_dirty_space(c, jeb, PAD(sizeof(struct jffs2_unknown_node)))))
881                                        return err;
882                                ofs += PAD(sizeof(struct jffs2_unknown_node));
883                        } else {
884                                jffs2_link_node_ref(c, jeb, ofs | REF_NORMAL, c->cleanmarker_size, NULL);
885
886                                ofs += PAD(c->cleanmarker_size);
887                        }
888                        break;
889
890                case JFFS2_NODETYPE_PADDING:
891                        if (jffs2_sum_active())
892                                jffs2_sum_add_padding_mem(s, je32_to_cpu(node->totlen));
893                        if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(node->totlen)))))
894                                return err;
895                        ofs += PAD(je32_to_cpu(node->totlen));
896                        break;
897
898                default:
899                        switch (je16_to_cpu(node->nodetype) & JFFS2_COMPAT_MASK) {
900                        case JFFS2_FEATURE_ROCOMPAT:
901                                pr_notice("Read-only compatible feature node (0x%04x) found at offset 0x%08x\n",
902                                          je16_to_cpu(node->nodetype), ofs);
903                                c->flags |= JFFS2_SB_FLAG_RO;
904                                if (!(jffs2_is_readonly(c)))
905                                        return -EROFS;
906                                if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(node->totlen)))))
907                                        return err;
908                                ofs += PAD(je32_to_cpu(node->totlen));
909                                break;
910
911                        case JFFS2_FEATURE_INCOMPAT:
912                                pr_notice("Incompatible feature node (0x%04x) found at offset 0x%08x\n",
913                                          je16_to_cpu(node->nodetype), ofs);
914                                return -EINVAL;
915
916                        case JFFS2_FEATURE_RWCOMPAT_DELETE:
917                                jffs2_dbg(1, "Unknown but compatible feature node (0x%04x) found at offset 0x%08x\n",
918                                          je16_to_cpu(node->nodetype), ofs);
919                                if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(node->totlen)))))
920                                        return err;
921                                ofs += PAD(je32_to_cpu(node->totlen));
922                                break;
923
924                        case JFFS2_FEATURE_RWCOMPAT_COPY: {
925                                jffs2_dbg(1, "Unknown but compatible feature node (0x%04x) found at offset 0x%08x\n",
926                                          je16_to_cpu(node->nodetype), ofs);
927
928                                jffs2_link_node_ref(c, jeb, ofs | REF_PRISTINE, PAD(je32_to_cpu(node->totlen)), NULL);
929
930                                /* We can't summarise nodes we don't grok */
931                                jffs2_sum_disable_collecting(s);
932                                ofs += PAD(je32_to_cpu(node->totlen));
933                                break;
934                                }
935                        }
936                }
937        }
938
939        if (jffs2_sum_active()) {
940                if (PAD(s->sum_size + JFFS2_SUMMARY_FRAME_SIZE) > jeb->free_size) {
941                        dbg_summary("There is not enough space for "
942                                "summary information, disabling for this jeb!\n");
943                        jffs2_sum_disable_collecting(s);
944                }
945        }
946
947        jffs2_dbg(1, "Block at 0x%08x: free 0x%08x, dirty 0x%08x, unchecked 0x%08x, used 0x%08x, wasted 0x%08x\n",
948                  jeb->offset, jeb->free_size, jeb->dirty_size,
949                  jeb->unchecked_size, jeb->used_size, jeb->wasted_size);
950       
951        /* mark_node_obsolete can add to wasted !! */
952        if (jeb->wasted_size) {
953                jeb->dirty_size += jeb->wasted_size;
954                c->dirty_size += jeb->wasted_size;
955                c->wasted_size -= jeb->wasted_size;
956                jeb->wasted_size = 0;
957        }
958
959        return jffs2_scan_classify_jeb(c, jeb);
960}
961
962struct jffs2_inode_cache *jffs2_scan_make_ino_cache(struct jffs2_sb_info *c, uint32_t ino)
963{
964        struct jffs2_inode_cache *ic;
965
966        ic = jffs2_get_ino_cache(c, ino);
967        if (ic)
968                return ic;
969
970        if (ino > c->highest_ino)
971                c->highest_ino = ino;
972
973        ic = jffs2_alloc_inode_cache();
974        if (!ic) {
975                pr_notice("%s(): allocation of inode cache failed\n", __func__);
976                return NULL;
977        }
978        memset(ic, 0, sizeof(*ic));
979
980        ic->ino = ino;
981        ic->nodes = (void *)ic;
982        jffs2_add_ino_cache(c, ic);
983        if (ino == 1)
984                ic->pino_nlink = 1;
985        return ic;
986}
987
988static int jffs2_scan_inode_node(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
989                                 struct jffs2_raw_inode *ri, uint32_t ofs, struct jffs2_summary *s)
990{
991        struct jffs2_inode_cache *ic;
992        uint32_t crc, ino = je32_to_cpu(ri->ino);
993
994        jffs2_dbg(1, "%s(): Node at 0x%08x\n", __func__, ofs);
995
996        /* We do very little here now. Just check the ino# to which we should attribute
997           this node; we can do all the CRC checking etc. later. There's a tradeoff here --
998           we used to scan the flash once only, reading everything we want from it into
999           memory, then building all our in-core data structures and freeing the extra
1000           information. Now we allow the first part of the mount to complete a lot quicker,
1001           but we have to go _back_ to the flash in order to finish the CRC checking, etc.
1002           Which means that the _full_ amount of time to get to proper write mode with GC
1003           operational may actually be _longer_ than before. Sucks to be me. */
1004
1005        /* Check the node CRC in any case. */
1006        crc = crc32(0, ri, sizeof(*ri)-8);
1007        if (crc != je32_to_cpu(ri->node_crc)) {
1008                pr_notice("%s(): CRC failed on node at 0x%08x: Read 0x%08x, calculated 0x%08x\n",
1009                          __func__, ofs, je32_to_cpu(ri->node_crc), crc);
1010                /*
1011                 * We believe totlen because the CRC on the node
1012                 * _header_ was OK, just the node itself failed.
1013                 */
1014                return jffs2_scan_dirty_space(c, jeb,
1015                                              PAD(je32_to_cpu(ri->totlen)));
1016        }
1017
1018        ic = jffs2_get_ino_cache(c, ino);
1019        if (!ic) {
1020                ic = jffs2_scan_make_ino_cache(c, ino);
1021                if (!ic)
1022                        return -ENOMEM;
1023        }
1024
1025        /* Wheee. It worked */
1026        jffs2_link_node_ref(c, jeb, ofs | REF_UNCHECKED, PAD(je32_to_cpu(ri->totlen)), ic);
1027
1028        jffs2_dbg(1, "Node is ino #%u, version %d. Range 0x%x-0x%x\n",
1029                  je32_to_cpu(ri->ino), je32_to_cpu(ri->version),
1030                  je32_to_cpu(ri->offset),
1031                  je32_to_cpu(ri->offset)+je32_to_cpu(ri->dsize));
1032
1033        pseudo_random += je32_to_cpu(ri->version);
1034
1035        if (jffs2_sum_active()) {
1036                jffs2_sum_add_inode_mem(s, ri, ofs - jeb->offset);
1037        }
1038
1039        return 0;
1040}
1041
1042static int jffs2_scan_dirent_node(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
1043                                  struct jffs2_raw_dirent *rd, uint32_t ofs, struct jffs2_summary *s)
1044{
1045        struct jffs2_full_dirent *fd;
1046        struct jffs2_inode_cache *ic;
1047        uint32_t checkedlen;
1048        uint32_t crc;
1049        int err;
1050
1051        jffs2_dbg(1, "%s(): Node at 0x%08x\n", __func__, ofs);
1052
1053        /* We don't get here unless the node is still valid, so we don't have to
1054           mask in the ACCURATE bit any more. */
1055        crc = crc32(0, rd, sizeof(*rd)-8);
1056
1057        if (crc != je32_to_cpu(rd->node_crc)) {
1058                pr_notice("%s(): Node CRC failed on node at 0x%08x: Read 0x%08x, calculated 0x%08x\n",
1059                          __func__, ofs, je32_to_cpu(rd->node_crc), crc);
1060                /* We believe totlen because the CRC on the node _header_ was OK, just the node itself failed. */
1061                if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(rd->totlen)))))
1062                        return err;
1063                return 0;
1064        }
1065
1066        pseudo_random += je32_to_cpu(rd->version);
1067
1068        /* Should never happen. Did. (OLPC trac #4184)*/
1069        checkedlen = strnlen(rd->name, rd->nsize);
1070        if (checkedlen < rd->nsize) {
1071                pr_err("Dirent at %08x has zeroes in name. Truncating to %d chars\n",
1072                       ofs, checkedlen);
1073        }
1074        fd = jffs2_alloc_full_dirent(checkedlen+1);
1075        if (!fd) {
1076                return -ENOMEM;
1077        }
1078        memcpy(&fd->name, rd->name, checkedlen);
1079        fd->name[checkedlen] = 0;
1080
1081        crc = crc32(0, fd->name, rd->nsize);
1082        if (crc != je32_to_cpu(rd->name_crc)) {
1083                pr_notice("%s(): Name CRC failed on node at 0x%08x: Read 0x%08x, calculated 0x%08x\n",
1084                          __func__, ofs, je32_to_cpu(rd->name_crc), crc);
1085                jffs2_dbg(1, "Name for which CRC failed is (now) '%s', ino #%d\n",
1086                          fd->name, je32_to_cpu(rd->ino));
1087                jffs2_free_full_dirent(fd);
1088                /* FIXME: Why do we believe totlen? */
1089                /* We believe totlen because the CRC on the node _header_ was OK, just the name failed. */
1090                if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(rd->totlen)))))
1091                        return err;
1092                return 0;
1093        }
1094        ic = jffs2_scan_make_ino_cache(c, je32_to_cpu(rd->pino));
1095        if (!ic) {
1096                jffs2_free_full_dirent(fd);
1097                return -ENOMEM;
1098        }
1099
1100        fd->raw = jffs2_link_node_ref(c, jeb, ofs | dirent_node_state(rd),
1101                                      PAD(je32_to_cpu(rd->totlen)), ic);
1102
1103        fd->next = NULL;
1104        fd->version = je32_to_cpu(rd->version);
1105        fd->ino = je32_to_cpu(rd->ino);
1106        fd->nhash = full_name_hash(NULL, fd->name, checkedlen);
1107        fd->type = rd->type;
1108        jffs2_add_fd_to_list(c, fd, &ic->scan_dents);
1109
1110        if (jffs2_sum_active()) {
1111                jffs2_sum_add_dirent_mem(s, rd, ofs - jeb->offset);
1112        }
1113
1114        return 0;
1115}
1116
1117static int count_list(struct list_head *l)
1118{
1119        uint32_t count = 0;
1120        struct list_head *tmp;
1121
1122        list_for_each(tmp, l) {
1123                count++;
1124        }
1125        return count;
1126}
1127
1128/* Note: This breaks if list_empty(head). I don't care. You
1129   might, if you copy this code and use it elsewhere :) */
1130static void rotate_list(struct list_head *head, uint32_t count)
1131{
1132        struct list_head *n = head->next;
1133
1134        list_del(head);
1135        while(count--) {
1136                n = n->next;
1137        }
1138        list_add(head, n);
1139}
1140
1141void jffs2_rotate_lists(struct jffs2_sb_info *c)
1142{
1143        uint32_t x;
1144        uint32_t rotateby;
1145
1146        x = count_list(&c->clean_list);
1147        if (x) {
1148                rotateby = pseudo_random % x;
1149                rotate_list((&c->clean_list), rotateby);
1150        }
1151
1152        x = count_list(&c->very_dirty_list);
1153        if (x) {
1154                rotateby = pseudo_random % x;
1155                rotate_list((&c->very_dirty_list), rotateby);
1156        }
1157
1158        x = count_list(&c->dirty_list);
1159        if (x) {
1160                rotateby = pseudo_random % x;
1161                rotate_list((&c->dirty_list), rotateby);
1162        }
1163
1164        x = count_list(&c->erasable_list);
1165        if (x) {
1166                rotateby = pseudo_random % x;
1167                rotate_list((&c->erasable_list), rotateby);
1168        }
1169
1170        if (c->nr_erasing_blocks) {
1171                rotateby = pseudo_random % c->nr_erasing_blocks;
1172                rotate_list((&c->erase_pending_list), rotateby);
1173        }
1174
1175        if (c->nr_free_blocks) {
1176                rotateby = pseudo_random % c->nr_free_blocks;
1177                rotate_list((&c->free_list), rotateby);
1178        }
1179}
Note: See TracBrowser for help on using the repository browser.