fs/jffs2/scan.c

   1 /*
   2  * JFFS2 -- Journalling Flash File System, Version 2.
   3  *
   4  * Copyright (C) 2001-2003 Red Hat, Inc.
   5  *
   6  * Created by David Woodhouse <dwmw2@redhat.com>
   7  *
   8  * For licensing information, see the file 'LICENCE' in this directory.
   9  *
  10  * $Id: scan.c,v 1.104 2003/10/11 14:52:48 dwmw2 Exp $
  11  *
  12  */
  13 #include <linux/kernel.h>
  14 #include <linux/sched.h>
  15 #include <linux/slab.h>
  16 #include <linux/mtd/mtd.h>
  17 #include <linux/pagemap.h>
  18 #include <linux/crc32.h>
  19 #include <linux/compiler.h>
  20 #include "nodelist.h"
  21
  22 #define EMPTY_SCAN_SIZE 1024
  23
  24 #define DIRTY_SPACE(x) do { typeof(x) _x = (x); \
  25                 c->free_size -= _x; c->dirty_size += _x; \
  26                 jeb->free_size -= _x ; jeb->dirty_size += _x; \
  27                 }while(0)
  28 #define USED_SPACE(x) do { typeof(x) _x = (x); \
  29                 c->free_size -= _x; c->used_size += _x; \
  30                 jeb->free_size -= _x ; jeb->used_size += _x; \
  31                 }while(0)
  32 #define UNCHECKED_SPACE(x) do { typeof(x) _x = (x); \
  33                 c->free_size -= _x; c->unchecked_size += _x; \
  34                 jeb->free_size -= _x ; jeb->unchecked_size += _x; \
  35                 }while(0)
  36
  37 #define noisy_printk(noise, args...) do { \
  38         if (*(noise)) { \
  39                 printk(KERN_NOTICE args); \
  40                  (*(noise))--; \
  41                  if (!(*(noise))) { \
  42                          printk(KERN_NOTICE "Further such events for this erase block will not be printed\n"); \
  43                  } \
  44         } \
  45 } while(0)
  46
  47 static uint32_t pseudo_random;
  48
  49 static int jffs2_scan_eraseblock (struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
  50                                   unsigned char *buf, uint32_t buf_size);
  51
  52 /* These helper functions _must_ increase ofs and also do the dirty/used space accounting.
  53  * Returning an error will abort the mount - bad checksums etc. should just mark the space
  54  * as dirty.
  55  */
  56 static int jffs2_scan_inode_node(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
  57                                  struct jffs2_raw_inode *ri, uint32_t ofs);
  58 static int jffs2_scan_dirent_node(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
  59                                  struct jffs2_raw_dirent *rd, uint32_t ofs);
  60
  61 #define BLK_STATE_ALLFF         0
  62 #define BLK_STATE_CLEAN         1
  63 #define BLK_STATE_PARTDIRTY     2
  64 #define BLK_STATE_CLEANMARKER   3
  65 #define BLK_STATE_ALLDIRTY      4
  66 #define BLK_STATE_BADBLOCK      5
  67
  68 static inline int min_free(struct jffs2_sb_info *c)
  69 {
  70         uint32_t min = 2 * sizeof(struct jffs2_raw_inode);
  71 #ifdef CONFIG_JFFS2_FS_NAND
  72         if (!jffs2_can_mark_obsolete(c) && min < c->wbuf_pagesize)
  73                 return c->wbuf_pagesize;
  74 #endif
  75         return min;
  76
  77 }
  78 int jffs2_scan_medium(struct jffs2_sb_info *c)
  79 {
  80         int i, ret;
  81         uint32_t empty_blocks = 0, bad_blocks = 0;
  82         unsigned char *flashbuf = NULL;
  83         uint32_t buf_size = 0;
  84 #ifndef __ECOS
  85         size_t pointlen;
  86
  87         if (c->mtd->point) {
  88                 ret = c->mtd->point (c->mtd, 0, c->mtd->size, &pointlen, &flashbuf);
  89                 if (!ret && pointlen < c->mtd->size) {
  90                         /* Don't muck about if it won't let us point to the whole flash */
  91                         D1(printk(KERN_DEBUG "MTD point returned len too short: 0x%zx\n", pointlen));
  92                         c->mtd->unpoint(c->mtd, flashbuf, 0, c->mtd->size);
  93                         flashbuf = NULL;
  94                 }
  95                 if (ret)
  96                         D1(printk(KERN_DEBUG "MTD point failed %d\n", ret));
  97         }
  98 #endif
  99         if (!flashbuf) {
 100                 /* For NAND it's quicker to read a whole eraseblock at a time,
 101                    apparently */
 102                 if (jffs2_cleanmarker_oob(c))
 103                         buf_size = c->sector_size;
 104                 else
 105                         buf_size = PAGE_SIZE;
 106
 107                 D1(printk(KERN_DEBUG "Allocating readbuf of %d bytes\n", buf_size));
 108                 flashbuf = kmalloc(buf_size, GFP_KERNEL);
 109                 if (!flashbuf)
 110                         return -ENOMEM;
 111         }
 112
 113         for (i=0; i<c->nr_blocks; i++) {
 114                 struct jffs2_eraseblock *jeb = &c->blocks[i];
 115
 116                 ret = jffs2_scan_eraseblock(c, jeb, buf_size?flashbuf:(flashbuf+jeb->offset), buf_size);
 117
 118                 if (ret < 0)
 119                         goto out;
 120
 121                 ACCT_PARANOIA_CHECK(jeb);
 122
 123                 /* Now decide which list to put it on */
 124                 switch(ret) {
 125                 case BLK_STATE_ALLFF:
 126                         /*
 127                          * Empty block.   Since we can't be sure it
 128                          * was entirely erased, we just queue it for erase
 129                          * again.  It will be marked as such when the erase
 130                          * is complete.  Meanwhile we still count it as empty
 131                          * for later checks.
 132                          */
 133                         empty_blocks++;
 134                         list_add(&jeb->list, &c->erase_pending_list);
 135                         c->nr_erasing_blocks++;
 136                         break;
 137
 138                 case BLK_STATE_CLEANMARKER:
 139                         /* Only a CLEANMARKER node is valid */
 140                         if (!jeb->dirty_size) {
 141                                 /* It's actually free */
 142                                 list_add(&jeb->list, &c->free_list);
 143                                 c->nr_free_blocks++;
 144                         } else {
 145                                 /* Dirt */
 146                                 D1(printk(KERN_DEBUG "Adding all-dirty block at 0x%08x to erase_pending_list\n", jeb->offset));
 147                                 list_add(&jeb->list, &c->erase_pending_list);
 148                                 c->nr_erasing_blocks++;
 149                         }
 150                         break;
 151
 152                 case BLK_STATE_CLEAN:
 153                         /* Full (or almost full) of clean data. Clean list */
 154                         list_add(&jeb->list, &c->clean_list);
 155                         break;
 156
 157                 case BLK_STATE_PARTDIRTY:
 158                         /* Some data, but not full. Dirty list. */
 159                         /* Except that we want to remember the block with most free space,
 160                            and stick it in the 'nextblock' position to start writing to it.
 161                            Later when we do snapshots, this must be the most recent block,
 162                            not the one with most free space.
 163                         */
 164                         if (jeb->free_size > min_free(c) &&
 165                             (!c->nextblock || c->nextblock->free_size < jeb->free_size)) {
 166                                 /* Better candidate for the next writes to go to */
 167                                 if (c->nextblock) {
 168                                         c->nextblock->dirty_size += c->nextblock->free_size + c->nextblock->wasted_size;
 169                                         c->dirty_size += c->nextblock->free_size + c->nextblock->wasted_size;
 170                                         c->free_size -= c->nextblock->free_size;
 171                                         c->wasted_size -= c->nextblock->wasted_size;
 172                                         c->nextblock->free_size = c->nextblock->wasted_size = 0;
 173                                         if (VERYDIRTY(c, c->nextblock->dirty_size)) {
 174                                                 list_add(&c->nextblock->list, &c->very_dirty_list);
 175                                         } else {
 176                                                 list_add(&c->nextblock->list, &c->dirty_list);
 177                                         }
 178                                 }
 179                                 c->nextblock = jeb;
 180                         } else {
 181                                 jeb->dirty_size += jeb->free_size + jeb->wasted_size;
 182                                 c->dirty_size += jeb->free_size + jeb->wasted_size;
 183                                 c->free_size -= jeb->free_size;
 184                                 c->wasted_size -= jeb->wasted_size;
 185                                 jeb->free_size = jeb->wasted_size = 0;
 186                                 if (VERYDIRTY(c, jeb->dirty_size)) {
 187                                         list_add(&jeb->list, &c->very_dirty_list);
 188                                 } else {
 189                                         list_add(&jeb->list, &c->dirty_list);
 190                                 }
 191                         }
 192                         break;
 193
 194                 case BLK_STATE_ALLDIRTY:
 195                         /* Nothing valid - not even a clean marker. Needs erasing. */
 196                         /* For now we just put it on the erasing list. We'll start the erases later */
 197                         D1(printk(KERN_NOTICE "JFFS2: Erase block at 0x%08x is not formatted. It will be erased\n", jeb->offset));
 198                         list_add(&jeb->list, &c->erase_pending_list);
 199                         c->nr_erasing_blocks++;
 200                         break;
 201
 202                 case BLK_STATE_BADBLOCK:
 203                         D1(printk(KERN_NOTICE "JFFS2: Block at 0x%08x is bad\n", jeb->offset));
 204                         list_add(&jeb->list, &c->bad_list);
 205                         c->bad_size += c->sector_size;
 206                         c->free_size -= c->sector_size;
 207                         bad_blocks++;
 208                         break;
 209                 default:
 210                         printk(KERN_WARNING "jffs2_scan_medium(): unknown block state\n");
 211                         BUG();
 212                 }
 213         }
 214
 215         /* Nextblock dirty is always seen as wasted, because we cannot recycle it now */
 216         if (c->nextblock && (c->nextblock->dirty_size)) {
 217                 c->nextblock->wasted_size += c->nextblock->dirty_size;
 218                 c->wasted_size += c->nextblock->dirty_size;
 219                 c->dirty_size -= c->nextblock->dirty_size;
 220                 c->nextblock->dirty_size = 0;
 221         }
 222 #ifdef CONFIG_JFFS2_FS_NAND
 223         if (!jffs2_can_mark_obsolete(c) && c->nextblock && (c->nextblock->free_size & (c->wbuf_pagesize-1))) {
 224                 /* If we're going to start writing into a block which already
 225                    contains data, and the end of the data isn't page-aligned,
 226                    skip a little and align it. */
 227
 228                 uint32_t skip = c->nextblock->free_size & (c->wbuf_pagesize-1);
 229
 230                 D1(printk(KERN_DEBUG "jffs2_scan_medium(): Skipping %d bytes in nextblock to ensure page alignment\n",
 231                           skip));
 232                 c->nextblock->wasted_size += skip;
 233                 c->wasted_size += skip;
 234
 235                 c->nextblock->free_size -= skip;
 236                 c->free_size -= skip;
 237         }
 238 #endif
 239         if (c->nr_erasing_blocks) {
 240                 if ( !c->used_size && ((empty_blocks+bad_blocks)!= c->nr_blocks || bad_blocks == c->nr_blocks) ) {
 241                         printk(KERN_NOTICE "Cowardly refusing to erase blocks on filesystem with no valid JFFS2 nodes\n");
 242                         printk(KERN_NOTICE "empty_blocks %d, bad_blocks %d, c->nr_blocks %d\n",empty_blocks,bad_blocks,c->nr_blocks);
 243                         ret = -EIO;
 244                         goto out;
 245                 }
 246                 jffs2_erase_pending_trigger(c);
 247         }
 248         ret = 0;
 249  out:
 250         if (buf_size)
 251                 kfree(flashbuf);
 252 #ifndef __ECOS
 253         else
 254                 c->mtd->unpoint(c->mtd, flashbuf, 0, c->mtd->size);
 255 #endif
 256         return ret;
 257 }
 258
 259 static int jffs2_fill_scan_buf (struct jffs2_sb_info *c, unsigned char *buf,
 260                                 uint32_t ofs, uint32_t len)
 261 {
 262         int ret;
 263         size_t retlen;
 264
 265         ret = jffs2_flash_read(c, ofs, len, &retlen, buf);
 266         if (ret) {
 267                 D1(printk(KERN_WARNING "mtd->read(0x%x bytes from 0x%x) returned %d\n", len, ofs, ret));
 268                 return ret;
 269         }
 270         if (retlen < len) {
 271                 D1(printk(KERN_WARNING "Read at 0x%x gave only 0x%zx bytes\n", ofs, retlen));
 272                 return -EIO;
 273         }
 274         D2(printk(KERN_DEBUG "Read 0x%x bytes from 0x%08x into buf\n", len, ofs));
 275         D2(printk(KERN_DEBUG "000: %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x\n",
 276                   buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6], buf[7], buf[8], buf[9], buf[10], buf[11], buf[12], buf[13], buf[14], buf[15]));
 277         return 0;
 278 }
 279
 280 static int jffs2_scan_eraseblock (struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
 281                                   unsigned char *buf, uint32_t buf_size) {
 282         struct jffs2_unknown_node *node;
 283         struct jffs2_unknown_node crcnode;
 284         uint32_t ofs, prevofs;
 285         uint32_t hdr_crc, buf_ofs, buf_len;
 286         int err;
 287         int noise = 0;
 288         int wasempty = 0;
 289         uint32_t empty_start = 0;
 290 #ifdef CONFIG_JFFS2_FS_NAND
 291         int cleanmarkerfound = 0;
 292 #endif
 293
 294         ofs = jeb->offset;
 295         prevofs = jeb->offset - 1;
 296
 297         D1(printk(KERN_DEBUG "jffs2_scan_eraseblock(): Scanning block at 0x%x\n", ofs));
 298
 299 #ifdef CONFIG_JFFS2_FS_NAND
 300         if (jffs2_cleanmarker_oob(c)) {
 301                 int ret = jffs2_check_nand_cleanmarker(c, jeb);
 302                 D2(printk(KERN_NOTICE "jffs_check_nand_cleanmarker returned %d\n",ret));
 303                 /* Even if it's not found, we still scan to see
 304                    if the block is empty. We use this information
 305                    to decide whether to erase it or not. */
 306                 switch (ret) {
 307                 case 0:         cleanmarkerfound = 1; break;
 308                 case 1:         break;
 309                 case 2:         return BLK_STATE_BADBLOCK;
 310                 case 3:         return BLK_STATE_ALLDIRTY; /* Block has failed to erase min. once */
 311                 default:        return ret;
 312                 }
 313         }
 314 #endif
 315         buf_ofs = jeb->offset;
 316
 317         if (!buf_size) {
 318                 buf_len = c->sector_size;
 319         } else {
 320                 buf_len = EMPTY_SCAN_SIZE;
 321                 err = jffs2_fill_scan_buf(c, buf, buf_ofs, buf_len);
 322                 if (err)
 323                         return err;
 324         }
 325
 326         /* We temporarily use 'ofs' as a pointer into the buffer/jeb */
 327         ofs = 0;
 328
 329         /* Scan only 4KiB of 0xFF before declaring it's empty */
 330         while(ofs < EMPTY_SCAN_SIZE && *(uint32_t *)(&buf[ofs]) == 0xFFFFFFFF)
 331                 ofs += 4;
 332
 333         if (ofs == EMPTY_SCAN_SIZE) {
 334 #ifdef CONFIG_JFFS2_FS_NAND
 335                 if (jffs2_cleanmarker_oob(c)) {
 336                         /* scan oob, take care of cleanmarker */
 337                         int ret = jffs2_check_oob_empty(c, jeb, cleanmarkerfound);
 338                         D2(printk(KERN_NOTICE "jffs2_check_oob_empty returned %d\n",ret));
 339                         switch (ret) {
 340                         case 0:         return cleanmarkerfound ? BLK_STATE_CLEANMARKER : BLK_STATE_ALLFF;
 341                         case 1:         return BLK_STATE_ALLDIRTY;
 342                         case 2:         return BLK_STATE_BADBLOCK; /* case 2/3 are paranoia checks */
 343                         case 3:         return BLK_STATE_ALLDIRTY; /* Block has failed to erase min. once */
 344                         default:        return ret;
 345                         }
 346                 }
 347 #endif
 348                 D1(printk(KERN_DEBUG "Block at 0x%08x is empty (erased)\n", jeb->offset));
 349                 return BLK_STATE_ALLFF; /* OK to erase if all blocks are like this */
 350         }
 351         if (ofs) {
 352                 D1(printk(KERN_DEBUG "Free space at %08x ends at %08x\n", jeb->offset,
 353                           jeb->offset + ofs));
 354                 DIRTY_SPACE(ofs);
 355         }
 356
 357         /* Now ofs is a complete physical flash offset as it always was... */
 358         ofs += jeb->offset;
 359
 360         noise = 10;
 361
 362         while(ofs < jeb->offset + c->sector_size) {
 363
 364                 D1(ACCT_PARANOIA_CHECK(jeb));
 365
 366                 cond_resched();
 367
 368                 if (ofs & 3) {
 369                         printk(KERN_WARNING "Eep. ofs 0x%08x not word-aligned!\n", ofs);
 370                         ofs = PAD(ofs);
 371                         continue;
 372                 }
 373                 if (ofs == prevofs) {
 374                         printk(KERN_WARNING "ofs 0x%08x has already been seen. Skipping\n", ofs);
 375                         DIRTY_SPACE(4);
 376                         ofs += 4;
 377                         continue;
 378                 }
 379                 prevofs = ofs;
 380
 381                 if (jeb->offset + c->sector_size < ofs + sizeof(*node)) {
 382                         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),
 383                                   jeb->offset, c->sector_size, ofs, sizeof(*node)));
 384                         DIRTY_SPACE((jeb->offset + c->sector_size)-ofs);
 385                         break;
 386                 }
 387
 388                 if (buf_ofs + buf_len < ofs + sizeof(*node)) {
 389                         buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs);
 390                         D1(printk(KERN_DEBUG "Fewer than %zd bytes (node header) left to end of buf. Reading 0x%x at 0x%08x\n",
 391                                   sizeof(struct jffs2_unknown_node), buf_len, ofs));
 392                         err = jffs2_fill_scan_buf(c, buf, ofs, buf_len);
 393                         if (err)
 394                                 return err;
 395                         buf_ofs = ofs;
 396                 }
 397
 398                 node = (struct jffs2_unknown_node *)&buf[ofs-buf_ofs];
 399
 400                 if (*(uint32_t *)(&buf[ofs-buf_ofs]) == 0xffffffff) {
 401                         uint32_t inbuf_ofs = ofs - buf_ofs + 4;
 402                         uint32_t scanend;
 403
 404                         empty_start = ofs;
 405                         ofs += 4;
 406
 407                         /* If scanning empty space after only a cleanmarker, don't
 408                            bother scanning the whole block */
 409                         if (unlikely(empty_start == jeb->offset + c->cleanmarker_size &&
 410                                      jeb->offset + EMPTY_SCAN_SIZE < buf_ofs + buf_len))
 411                                 scanend = jeb->offset + EMPTY_SCAN_SIZE - buf_ofs;
 412                         else
 413                                 scanend = buf_len;
 414
 415                         D1(printk(KERN_DEBUG "Found empty flash at 0x%08x\n", ofs));
 416                         while (inbuf_ofs < scanend) {
 417                                 if (*(uint32_t *)(&buf[inbuf_ofs]) != 0xffffffff)
 418                                         goto emptyends;
 419
 420                                 inbuf_ofs+=4;
 421                                 ofs += 4;
 422                         }
 423                         /* Ran off end. */
 424                         D1(printk(KERN_DEBUG "Empty flash ends normally at 0x%08x\n", ofs));
 425
 426                         if (buf_ofs == jeb->offset &&  jeb->used_size == PAD(c->cleanmarker_size) &&
 427                             c->cleanmarker_size && !jeb->first_node->next_in_ino && !jeb->dirty_size)
 428                                 return BLK_STATE_CLEANMARKER;
 429                         wasempty = 1;
 430                         continue;
 431                 } else if (wasempty) {
 432                 emptyends:
 433                         printk(KERN_WARNING "Empty flash at 0x%08x ends at 0x%08x\n", empty_start, ofs);
 434                         DIRTY_SPACE(ofs-empty_start);
 435                         wasempty = 0;
 436                         continue;
 437                 }
 438
 439                 if (ofs == jeb->offset && je16_to_cpu(node->magic) == KSAMTIB_CIGAM_2SFFJ) {
 440                         printk(KERN_WARNING "Magic bitmask is backwards at offset 0x%08x. Wrong endian filesystem?\n", ofs);
 441                         DIRTY_SPACE(4);
 442                         ofs += 4;
 443                         continue;
 444                 }
 445                 if (je16_to_cpu(node->magic) == JFFS2_DIRTY_BITMASK) {
 446                         D1(printk(KERN_DEBUG "Dirty bitmask at 0x%08x\n", ofs));
 447                         DIRTY_SPACE(4);
 448                         ofs += 4;
 449                         continue;
 450                 }
 451                 if (je16_to_cpu(node->magic) == JFFS2_OLD_MAGIC_BITMASK) {
 452                         printk(KERN_WARNING "Old JFFS2 bitmask found at 0x%08x\n", ofs);
 453                         printk(KERN_WARNING "You cannot use older JFFS2 filesystems with newer kernels\n");
 454                         DIRTY_SPACE(4);
 455                         ofs += 4;
 456                         continue;
 457                 }
 458                 if (je16_to_cpu(node->magic) != JFFS2_MAGIC_BITMASK) {
 459                         /* OK. We're out of possibilities. Whinge and move on */
 460                         noisy_printk(&noise, "jffs2_scan_eraseblock(): Magic bitmask 0x%04x not found at 0x%08x: 0x%04x instead\n",
 461                                      JFFS2_MAGIC_BITMASK, ofs,
 462                                      je16_to_cpu(node->magic));
 463                         DIRTY_SPACE(4);
 464                         ofs += 4;
 465                         continue;
 466                 }
 467                 /* We seem to have a node of sorts. Check the CRC */
 468                 crcnode.magic = node->magic;
 469                 crcnode.nodetype = cpu_to_je16( je16_to_cpu(node->nodetype) | JFFS2_NODE_ACCURATE);
 470                 crcnode.totlen = node->totlen;
 471                 hdr_crc = crc32(0, &crcnode, sizeof(crcnode)-4);
 472
 473                 if (hdr_crc != je32_to_cpu(node->hdr_crc)) {
 474                         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",
 475                                      ofs, je16_to_cpu(node->magic),
 476                                      je16_to_cpu(node->nodetype),
 477                                      je32_to_cpu(node->totlen),
 478                                      je32_to_cpu(node->hdr_crc),
 479                                      hdr_crc);
 480                         DIRTY_SPACE(4);
 481                         ofs += 4;
 482                         continue;
 483                 }
 484
 485                 if (ofs + je32_to_cpu(node->totlen) >
 486                     jeb->offset + c->sector_size) {
 487                         /* Eep. Node goes over the end of the erase block. */
 488                         printk(KERN_WARNING "Node at 0x%08x with length 0x%08x would run over the end of the erase block\n",
 489                                ofs, je32_to_cpu(node->totlen));
 490                         printk(KERN_WARNING "Perhaps the file system was created with the wrong erase size?\n");
 491                         DIRTY_SPACE(4);
 492                         ofs += 4;
 493                         continue;
 494                 }
 495
 496                 if (!(je16_to_cpu(node->nodetype) & JFFS2_NODE_ACCURATE)) {
 497                         /* Wheee. This is an obsoleted node */
 498                         D2(printk(KERN_DEBUG "Node at 0x%08x is obsolete. Skipping\n", ofs));
 499                         DIRTY_SPACE(PAD(je32_to_cpu(node->totlen)));
 500                         ofs += PAD(je32_to_cpu(node->totlen));
 501                         continue;
 502                 }
 503
 504                 switch(je16_to_cpu(node->nodetype)) {
 505                 case JFFS2_NODETYPE_INODE:
 506                         if (buf_ofs + buf_len < ofs + sizeof(struct jffs2_raw_inode)) {
 507                                 buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs);
 508                                 D1(printk(KERN_DEBUG "Fewer than %zd bytes (inode node) left to end of buf. Reading 0x%x at 0x%08x\n",
 509                                           sizeof(struct jffs2_raw_inode), buf_len, ofs));
 510                                 err = jffs2_fill_scan_buf(c, buf, ofs, buf_len);
 511                                 if (err)
 512                                         return err;
 513                                 buf_ofs = ofs;
 514                                 node = (void *)buf;
 515                         }
 516                         err = jffs2_scan_inode_node(c, jeb, (void *)node, ofs);
 517                         if (err) return err;
 518                         ofs += PAD(je32_to_cpu(node->totlen));
 519                         break;
 520
 521                 case JFFS2_NODETYPE_DIRENT:
 522                         if (buf_ofs + buf_len < ofs + je32_to_cpu(node->totlen)) {
 523                                 buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs);
 524                                 D1(printk(KERN_DEBUG "Fewer than %d bytes (dirent node) left to end of buf. Reading 0x%x at 0x%08x\n",
 525                                           je32_to_cpu(node->totlen), buf_len, ofs));
 526                                 err = jffs2_fill_scan_buf(c, buf, ofs, buf_len);
 527                                 if (err)
 528                                         return err;
 529                                 buf_ofs = ofs;
 530                                 node = (void *)buf;
 531                         }
 532                         err = jffs2_scan_dirent_node(c, jeb, (void *)node, ofs);
 533                         if (err) return err;
 534                         ofs += PAD(je32_to_cpu(node->totlen));
 535                         break;
 536
 537                 case JFFS2_NODETYPE_CLEANMARKER:
 538                         D1(printk(KERN_DEBUG "CLEANMARKER node found at 0x%08x\n", ofs));
 539                         if (je32_to_cpu(node->totlen) != c->cleanmarker_size) {
 540                                 printk(KERN_NOTICE "CLEANMARKER node found at 0x%08x has totlen 0x%x != normal 0x%x\n",
 541                                        ofs, je32_to_cpu(node->totlen), c->cleanmarker_size);
 542                                 DIRTY_SPACE(PAD(sizeof(struct jffs2_unknown_node)));
 543                                 ofs += PAD(sizeof(struct jffs2_unknown_node));
 544                         } else if (jeb->first_node) {
 545                                 printk(KERN_NOTICE "CLEANMARKER node found at 0x%08x, not first node in block (0x%08x)\n", ofs, jeb->offset);
 546                                 DIRTY_SPACE(PAD(sizeof(struct jffs2_unknown_node)));
 547                                 ofs += PAD(sizeof(struct jffs2_unknown_node));
 548                         } else {
 549                                 struct jffs2_raw_node_ref *marker_ref = jffs2_alloc_raw_node_ref();
 550                                 if (!marker_ref) {
 551                                         printk(KERN_NOTICE "Failed to allocate node ref for clean marker\n");
 552                                         return -ENOMEM;
 553                                 }
 554                                 marker_ref->next_in_ino = NULL;
 555                                 marker_ref->next_phys = NULL;
 556                                 marker_ref->flash_offset = ofs | REF_NORMAL;
 557                                 marker_ref->totlen = c->cleanmarker_size;
 558                                 jeb->first_node = jeb->last_node = marker_ref;
 559
 560                                 USED_SPACE(PAD(c->cleanmarker_size));
 561                                 ofs += PAD(c->cleanmarker_size);
 562                         }
 563                         break;
 564
 565                 case JFFS2_NODETYPE_PADDING:
 566                         DIRTY_SPACE(PAD(je32_to_cpu(node->totlen)));
 567                         ofs += PAD(je32_to_cpu(node->totlen));
 568                         break;
 569
 570                 default:
 571                         switch (je16_to_cpu(node->nodetype) & JFFS2_COMPAT_MASK) {
 572                         case JFFS2_FEATURE_ROCOMPAT:
 573                                 printk(KERN_NOTICE "Read-only compatible feature node (0x%04x) found at offset 0x%08x\n", je16_to_cpu(node->nodetype), ofs);
 574                                 c->flags |= JFFS2_SB_FLAG_RO;
 575                                 if (!(jffs2_is_readonly(c)))
 576                                         return -EROFS;
 577                                 DIRTY_SPACE(PAD(je32_to_cpu(node->totlen)));
 578                                 ofs += PAD(je32_to_cpu(node->totlen));
 579                                 break;
 580
 581                         case JFFS2_FEATURE_INCOMPAT:
 582                                 printk(KERN_NOTICE "Incompatible feature node (0x%04x) found at offset 0x%08x\n", je16_to_cpu(node->nodetype), ofs);
 583                                 return -EINVAL;
 584
 585                         case JFFS2_FEATURE_RWCOMPAT_DELETE:
 586                                 D1(printk(KERN_NOTICE "Unknown but compatible feature node (0x%04x) found at offset 0x%08x\n", je16_to_cpu(node->nodetype), ofs));
 587                                 DIRTY_SPACE(PAD(je32_to_cpu(node->totlen)));
 588                                 ofs += PAD(je32_to_cpu(node->totlen));
 589                                 break;
 590
 591                         case JFFS2_FEATURE_RWCOMPAT_COPY:
 592                                 D1(printk(KERN_NOTICE "Unknown but compatible feature node (0x%04x) found at offset 0x%08x\n", je16_to_cpu(node->nodetype), ofs));
 593                                 USED_SPACE(PAD(je32_to_cpu(node->totlen)));
 594                                 ofs += PAD(je32_to_cpu(node->totlen));
 595                                 break;
 596                         }
 597                 }
 598         }
 599
 600
 601         D1(printk(KERN_DEBUG "Block at 0x%08x: free 0x%08x, dirty 0x%08x, unchecked 0x%08x, used 0x%08x\n", jeb->offset,
 602                   jeb->free_size, jeb->dirty_size, jeb->unchecked_size, jeb->used_size));
 603
 604         /* mark_node_obsolete can add to wasted !! */
 605         if (jeb->wasted_size) {
 606                 jeb->dirty_size += jeb->wasted_size;
 607                 c->dirty_size += jeb->wasted_size;
 608                 c->wasted_size -= jeb->wasted_size;
 609                 jeb->wasted_size = 0;
 610         }
 611
 612         if ((jeb->used_size + jeb->unchecked_size) == PAD(c->cleanmarker_size) && !jeb->dirty_size
 613                 && (!jeb->first_node || jeb->first_node->next_in_ino) )
 614                 return BLK_STATE_CLEANMARKER;
 615
 616         /* move blocks with max 4 byte dirty space to cleanlist */
 617         else if (!ISDIRTY(c->sector_size - (jeb->used_size + jeb->unchecked_size))) {
 618                 c->dirty_size -= jeb->dirty_size;
 619                 c->wasted_size += jeb->dirty_size;
 620                 jeb->wasted_size += jeb->dirty_size;
 621                 jeb->dirty_size = 0;
 622                 return BLK_STATE_CLEAN;
 623         } else if (jeb->used_size || jeb->unchecked_size)
 624                 return BLK_STATE_PARTDIRTY;
 625         else
 626                 return BLK_STATE_ALLDIRTY;
 627 }
 628
 629 static struct jffs2_inode_cache *jffs2_scan_make_ino_cache(struct jffs2_sb_info *c, uint32_t ino)
 630 {
 631         struct jffs2_inode_cache *ic;
 632
 633         ic = jffs2_get_ino_cache(c, ino);
 634         if (ic)
 635                 return ic;
 636
 637         ic = jffs2_alloc_inode_cache();
 638         if (!ic) {
 639                 printk(KERN_NOTICE "jffs2_scan_make_inode_cache(): allocation of inode cache failed\n");
 640                 return NULL;
 641         }
 642         memset(ic, 0, sizeof(*ic));
 643
 644         ic->ino = ino;
 645         ic->nodes = (void *)ic;
 646         jffs2_add_ino_cache(c, ic);
 647         if (ino == 1)
 648                 ic->nlink=1;
 649         return ic;
 650 }
 651
 652 static int jffs2_scan_inode_node(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
 653                                  struct jffs2_raw_inode *ri, uint32_t ofs)
 654 {
 655         struct jffs2_raw_node_ref *raw;
 656         struct jffs2_inode_cache *ic;
 657         uint32_t ino = je32_to_cpu(ri->ino);
 658
 659         D1(printk(KERN_DEBUG "jffs2_scan_inode_node(): Node at 0x%08x\n", ofs));
 660
 661         /* We do very little here now. Just check the ino# to which we should attribute
 662            this node; we can do all the CRC checking etc. later. There's a tradeoff here --
 663            we used to scan the flash once only, reading everything we want from it into
 664            memory, then building all our in-core data structures and freeing the extra
 665            information. Now we allow the first part of the mount to complete a lot quicker,
 666            but we have to go _back_ to the flash in order to finish the CRC checking, etc.
 667            Which means that the _full_ amount of time to get to proper write mode with GC
 668            operational may actually be _longer_ than before. Sucks to be me. */
 669
 670         raw = jffs2_alloc_raw_node_ref();
 671         if (!raw) {
 672                 printk(KERN_NOTICE "jffs2_scan_inode_node(): allocation of node reference failed\n");
 673                 return -ENOMEM;
 674         }
 675
 676         ic = jffs2_get_ino_cache(c, ino);
 677         if (!ic) {
 678                 /* Inocache get failed. Either we read a bogus ino# or it's just genuinely the
 679                    first node we found for this inode. Do a CRC check to protect against the former
 680                    case */
 681                 uint32_t crc = crc32(0, ri, sizeof(*ri)-8);
 682
 683                 if (crc != je32_to_cpu(ri->node_crc)) {
 684                         printk(KERN_NOTICE "jffs2_scan_inode_node(): CRC failed on node at 0x%08x: Read 0x%08x, calculated 0x%08x\n",
 685                                ofs, je32_to_cpu(ri->node_crc), crc);
 686                         /* We believe totlen because the CRC on the node _header_ was OK, just the node itself failed. */
 687                         DIRTY_SPACE(PAD(je32_to_cpu(ri->totlen)));
 688                         jffs2_free_raw_node_ref(raw);
 689                         return 0;
 690                 }
 691                 ic = jffs2_scan_make_ino_cache(c, ino);
 692                 if (!ic) {
 693                         jffs2_free_raw_node_ref(raw);
 694                         return -ENOMEM;
 695                 }
 696         }
 697
 698         /* Wheee. It worked */
 699
 700         raw->flash_offset = ofs | REF_UNCHECKED;
 701         raw->totlen = PAD(je32_to_cpu(ri->totlen));
 702         raw->next_phys = NULL;
 703         raw->next_in_ino = ic->nodes;
 704
 705         ic->nodes = raw;
 706         if (!jeb->first_node)
 707                 jeb->first_node = raw;
 708         if (jeb->last_node)
 709                 jeb->last_node->next_phys = raw;
 710         jeb->last_node = raw;
 711
 712         D1(printk(KERN_DEBUG "Node is ino #%u, version %d. Range 0x%x-0x%x\n",
 713                   je32_to_cpu(ri->ino), je32_to_cpu(ri->version),
 714                   je32_to_cpu(ri->offset),
 715                   je32_to_cpu(ri->offset)+je32_to_cpu(ri->dsize)));
 716
 717         pseudo_random += je32_to_cpu(ri->version);
 718
 719         UNCHECKED_SPACE(PAD(je32_to_cpu(ri->totlen)));
 720         return 0;
 721 }
 722
 723 static int jffs2_scan_dirent_node(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
 724                                   struct jffs2_raw_dirent *rd, uint32_t ofs)
 725 {
 726         struct jffs2_raw_node_ref *raw;
 727         struct jffs2_full_dirent *fd;
 728         struct jffs2_inode_cache *ic;
 729         uint32_t crc;
 730
 731         D1(printk(KERN_DEBUG "jffs2_scan_dirent_node(): Node at 0x%08x\n", ofs));
 732
 733         /* We don't get here unless the node is still valid, so we don't have to
 734            mask in the ACCURATE bit any more. */
 735         crc = crc32(0, rd, sizeof(*rd)-8);
 736
 737         if (crc != je32_to_cpu(rd->node_crc)) {
 738                 printk(KERN_NOTICE "jffs2_scan_dirent_node(): Node CRC failed on node at 0x%08x: Read 0x%08x, calculated 0x%08x\n",
 739                        ofs, je32_to_cpu(rd->node_crc), crc);
 740                 /* We believe totlen because the CRC on the node _header_ was OK, just the node itself failed. */
 741                 DIRTY_SPACE(PAD(je32_to_cpu(rd->totlen)));
 742                 return 0;
 743         }
 744
 745         pseudo_random += je32_to_cpu(rd->version);
 746
 747         fd = jffs2_alloc_full_dirent(rd->nsize+1);
 748         if (!fd) {
 749                 return -ENOMEM;
 750         }
 751         memcpy(&fd->name, rd->name, rd->nsize);
 752         fd->name[rd->nsize] = 0;
 753
 754         crc = crc32(0, fd->name, rd->nsize);
 755         if (crc != je32_to_cpu(rd->name_crc)) {
 756                 printk(KERN_NOTICE "jffs2_scan_dirent_node(): Name CRC failed on node at 0x%08x: Read 0x%08x, calculated 0x%08x\n",
 757                        ofs, je32_to_cpu(rd->name_crc), crc);
 758                 D1(printk(KERN_NOTICE "Name for which CRC failed is (now) '%s', ino #%d\n", fd->name, je32_to_cpu(rd->ino)));
 759                 jffs2_free_full_dirent(fd);
 760                 /* FIXME: Why do we believe totlen? */
 761                 /* We believe totlen because the CRC on the node _header_ was OK, just the name failed. */
 762                 DIRTY_SPACE(PAD(je32_to_cpu(rd->totlen)));
 763                 return 0;
 764         }
 765         raw = jffs2_alloc_raw_node_ref();
 766         if (!raw) {
 767                 jffs2_free_full_dirent(fd);
 768                 printk(KERN_NOTICE "jffs2_scan_dirent_node(): allocation of node reference failed\n");
 769                 return -ENOMEM;
 770         }
 771         ic = jffs2_scan_make_ino_cache(c, je32_to_cpu(rd->pino));
 772         if (!ic) {
 773                 jffs2_free_full_dirent(fd);
 774                 jffs2_free_raw_node_ref(raw);
 775                 return -ENOMEM;
 776         }
 777
 778         raw->totlen = PAD(je32_to_cpu(rd->totlen));
 779         raw->flash_offset = ofs | REF_PRISTINE;
 780         raw->next_phys = NULL;
 781         raw->next_in_ino = ic->nodes;
 782         ic->nodes = raw;
 783         if (!jeb->first_node)
 784                 jeb->first_node = raw;
 785         if (jeb->last_node)
 786                 jeb->last_node->next_phys = raw;
 787         jeb->last_node = raw;
 788
 789         fd->raw = raw;
 790         fd->next = NULL;
 791         fd->version = je32_to_cpu(rd->version);
 792         fd->ino = je32_to_cpu(rd->ino);
 793         fd->nhash = full_name_hash(fd->name, rd->nsize);
 794         fd->type = rd->type;
 795         USED_SPACE(PAD(je32_to_cpu(rd->totlen)));
 796         jffs2_add_fd_to_list(c, fd, &ic->scan_dents);
 797
 798         return 0;
 799 }
 800
 801 static int count_list(struct list_head *l)
 802 {
 803         uint32_t count = 0;
 804         struct list_head *tmp;
 805
 806         list_for_each(tmp, l) {
 807                 count++;
 808         }
 809         return count;
 810 }
 811
 812 /* Note: This breaks if list_empty(head). I don't care. You
 813    might, if you copy this code and use it elsewhere :) */
 814 static void rotate_list(struct list_head *head, uint32_t count)
 815 {
 816         struct list_head *n = head->next;
 817
 818         list_del(head);
 819         while(count--) {
 820                 n = n->next;
 821         }
 822         list_add(head, n);
 823 }
 824
 825 void jffs2_rotate_lists(struct jffs2_sb_info *c)
 826 {
 827         uint32_t x;
 828         uint32_t rotateby;
 829
 830         x = count_list(&c->clean_list);
 831         if (x) {
 832                 rotateby = pseudo_random % x;
 833                 D1(printk(KERN_DEBUG "Rotating clean_list by %d\n", rotateby));
 834
 835                 rotate_list((&c->clean_list), rotateby);
 836
 837                 D1(printk(KERN_DEBUG "Erase block at front of clean_list is at %08x\n",
 838                           list_entry(c->clean_list.next, struct jffs2_eraseblock, list)->offset));
 839         } else {
 840                 D1(printk(KERN_DEBUG "Not rotating empty clean_list\n"));
 841         }
 842
 843         x = count_list(&c->very_dirty_list);
 844         if (x) {
 845                 rotateby = pseudo_random % x;
 846                 D1(printk(KERN_DEBUG "Rotating very_dirty_list by %d\n", rotateby));
 847
 848                 rotate_list((&c->very_dirty_list), rotateby);
 849
 850                 D1(printk(KERN_DEBUG "Erase block at front of very_dirty_list is at %08x\n",
 851                           list_entry(c->very_dirty_list.next, struct jffs2_eraseblock, list)->offset));
 852         } else {
 853                 D1(printk(KERN_DEBUG "Not rotating empty very_dirty_list\n"));
 854         }
 855
 856         x = count_list(&c->dirty_list);
 857         if (x) {
 858                 rotateby = pseudo_random % x;
 859                 D1(printk(KERN_DEBUG "Rotating dirty_list by %d\n", rotateby));
 860
 861                 rotate_list((&c->dirty_list), rotateby);
 862
 863                 D1(printk(KERN_DEBUG "Erase block at front of dirty_list is at %08x\n",
 864                           list_entry(c->dirty_list.next, struct jffs2_eraseblock, list)->offset));
 865         } else {
 866                 D1(printk(KERN_DEBUG "Not rotating empty dirty_list\n"));
 867         }
 868
 869         x = count_list(&c->erasable_list);
 870         if (x) {
 871                 rotateby = pseudo_random % x;
 872                 D1(printk(KERN_DEBUG "Rotating erasable_list by %d\n", rotateby));
 873
 874                 rotate_list((&c->erasable_list), rotateby);
 875
 876                 D1(printk(KERN_DEBUG "Erase block at front of erasable_list is at %08x\n",
 877                           list_entry(c->erasable_list.next, struct jffs2_eraseblock, list)->offset));
 878         } else {
 879                 D1(printk(KERN_DEBUG "Not rotating empty erasable_list\n"));
 880         }
 881
 882         if (c->nr_erasing_blocks) {
 883                 rotateby = pseudo_random % c->nr_erasing_blocks;
 884                 D1(printk(KERN_DEBUG "Rotating erase_pending_list by %d\n", rotateby));
 885
 886                 rotate_list((&c->erase_pending_list), rotateby);
 887
 888                 D1(printk(KERN_DEBUG "Erase block at front of erase_pending_list is at %08x\n",
 889                           list_entry(c->erase_pending_list.next, struct jffs2_eraseblock, list)->offset));
 890         } else {
 891                 D1(printk(KERN_DEBUG "Not rotating empty erase_pending_list\n"));
 892         }
 893
 894         if (c->nr_free_blocks) {
 895                 rotateby = pseudo_random % c->nr_free_blocks;
 896                 D1(printk(KERN_DEBUG "Rotating free_list by %d\n", rotateby));
 897
 898                 rotate_list((&c->free_list), rotateby);
 899
 900                 D1(printk(KERN_DEBUG "Erase block at front of free_list is at %08x\n",
 901                           list_entry(c->free_list.next, struct jffs2_eraseblock, list)->offset));
 902         } else {
 903                 D1(printk(KERN_DEBUG "Not rotating empty free_list\n"));
 904         }
 905 }