target/linux/generic-2.6/patches-2.6.28/511-yaffs-cvs-2009-01-23.patch

   1 --- a/fs/yaffs2/yaffs_tagscompat.h
   2 +++ b/fs/yaffs2/yaffs_tagscompat.h
   3 @@ -30,8 +30,9 @@ int yaffs_TagsCompatabilityReadChunkWith
   4  int yaffs_TagsCompatabilityMarkNANDBlockBad(struct yaffs_DeviceStruct *dev,
   5                                             int blockNo);
   6  int yaffs_TagsCompatabilityQueryNANDBlock(struct yaffs_DeviceStruct *dev,
   7 -                                         int blockNo, yaffs_BlockState *
   8 -                                         state, int *sequenceNumber);
   9 +                                         int blockNo,
  10 +                                         yaffs_BlockState *state,
  11 +                                         __u32 *sequenceNumber);
  12
  13  void yaffs_CalcTagsECC(yaffs_Tags * tags);
  14  int yaffs_CheckECCOnTags(yaffs_Tags * tags);
  15 --- a/fs/yaffs2/Kconfig
  16 +++ b/fs/yaffs2/Kconfig
  17 @@ -43,7 +43,8 @@ config YAFFS_9BYTE_TAGS
  18           format that you need to continue to support.  New data written
  19           also uses the older-style format.  Note: Use of this option
  20           generally requires that MTD's oob layout be adjusted to use the
  21 -         older-style format.  See notes on tags formats and MTD versions.
  22 +         older-style format.  See notes on tags formats and MTD versions
  23 +         in yaffs_mtdif1.c.
  24
  25           If unsure, say N.
  26
  27 @@ -109,26 +110,6 @@ config YAFFS_DISABLE_LAZY_LOAD
  28
  29           If unsure, say N.
  30
  31 -config YAFFS_CHECKPOINT_RESERVED_BLOCKS
  32 -       int "Reserved blocks for checkpointing"
  33 -       depends on YAFFS_YAFFS2
  34 -       default 10
  35 -       help
  36 -          Give the number of Blocks to reserve for checkpointing.
  37 -         Checkpointing saves the state at unmount so that mounting is
  38 -         much faster as a scan of all the flash to regenerate this state
  39 -         is not needed.  These Blocks are reserved per partition, so if
  40 -         you have very small partitions the default (10) may be a mess
  41 -         for you.  You can set this value to 0, but that does not mean
  42 -         checkpointing is disabled at all. There only won't be any
  43 -         specially reserved blocks for checkpointing, so if there is
  44 -         enough free space on the filesystem, it will be used for
  45 -         checkpointing.
  46 -
  47 -         If unsure, leave at default (10), but don't wonder if there are
  48 -         always 2MB used on your large page device partition (10 x 2k
  49 -         pagesize). When using small partitions or when being very small
  50 -         on space, you probably want to set this to zero.
  51
  52  config YAFFS_DISABLE_WIDE_TNODES
  53         bool "Turn off wide tnodes"
  54 --- a/fs/yaffs2/yaffs_mtdif.h
  55 +++ b/fs/yaffs2/yaffs_mtdif.h
  56 @@ -18,6 +18,11 @@
  57
  58  #include "yaffs_guts.h"
  59
  60 +#if (MTD_VERSION_CODE < MTD_VERSION(2,6,18))
  61 +extern struct nand_oobinfo yaffs_oobinfo;
  62 +extern struct nand_oobinfo yaffs_noeccinfo;
  63 +#endif
  64 +
  65  int nandmtd_WriteChunkToNAND(yaffs_Device * dev, int chunkInNAND,
  66                              const __u8 * data, const yaffs_Spare * spare);
  67  int nandmtd_ReadChunkFromNAND(yaffs_Device * dev, int chunkInNAND, __u8 * data,
  68 --- a/fs/yaffs2/devextras.h
  69 +++ b/fs/yaffs2/devextras.h
  70 @@ -1,5 +1,5 @@
  71  /*
  72 - * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
  73 + * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
  74   *
  75   * Copyright (C) 2002-2007 Aleph One Ltd.
  76   *   for Toby Churchill Ltd and Brightstar Engineering
  77 @@ -14,203 +14,145 @@
  78   */
  79
  80  /*
  81 - * This file is just holds extra declarations used during development.
  82 - * Most of these are from kernel includes placed here so we can use them in
  83 - * applications.
  84 + * This file is just holds extra declarations of macros that would normally
  85 + * be providesd in the Linux kernel. These macros have been written from
  86 + * scratch but are functionally equivalent to the Linux ones.
  87   *
  88   */
  89
  90  #ifndef __EXTRAS_H__
  91  #define __EXTRAS_H__
  92
  93 -#if defined WIN32
  94 -#define __inline__ __inline
  95 -#define new newHack
  96 -#endif
  97 -
  98 -#if !(defined __KERNEL__) || (defined WIN32)
  99
 100 -/* User space defines */
 101 +#if !(defined __KERNEL__)
 102
 103 +/* Definition of types */
 104  typedef unsigned char __u8;
 105  typedef unsigned short __u16;
 106  typedef unsigned __u32;
 107
 108 +#endif
 109 +
 110  /*
 111 - * Simple doubly linked list implementation.
 112 - *
 113 - * Some of the internal functions ("__xxx") are useful when
 114 - * manipulating whole lists rather than single entries, as
 115 - * sometimes we already know the next/prev entries and we can
 116 - * generate better code by using them directly rather than
 117 - * using the generic single-entry routines.
 118 + * This is a simple doubly linked list implementation that matches the
 119 + * way the Linux kernel doubly linked list implementation works.
 120   */
 121
 122 -#define prefetch(x) 1
 123 -
 124 -struct list_head {
 125 -       struct list_head *next, *prev;
 126 +struct ylist_head {
 127 +       struct ylist_head *next; /* next in chain */
 128 +       struct ylist_head *prev; /* previous in chain */
 129  };
 130
 131 -#define LIST_HEAD_INIT(name) { &(name), &(name) }
 132
 133 -#define LIST_HEAD(name) \
 134 -       struct list_head name = LIST_HEAD_INIT(name)
 135 +/* Initialise a static list */
 136 +#define YLIST_HEAD(name) \
 137 +struct ylist_head name = { &(name),&(name)}
 138
 139 -#define INIT_LIST_HEAD(ptr) do { \
 140 -       (ptr)->next = (ptr); (ptr)->prev = (ptr); \
 141 -} while (0)
 142
 143 -/*
 144 - * Insert a new entry between two known consecutive entries.
 145 - *
 146 - * This is only for internal list manipulation where we know
 147 - * the prev/next entries already!
 148 - */
 149 -static __inline__ void __list_add(struct list_head *new,
 150 -                                 struct list_head *prev,
 151 -                                 struct list_head *next)
 152 -{
 153 -       next->prev = new;
 154 -       new->next = next;
 155 -       new->prev = prev;
 156 -       prev->next = new;
 157 -}
 158
 159 -/**
 160 - * list_add - add a new entry
 161 - * @new: new entry to be added
 162 - * @head: list head to add it after
 163 - *
 164 - * Insert a new entry after the specified head.
 165 - * This is good for implementing stacks.
 166 - */
 167 -static __inline__ void list_add(struct list_head *new, struct list_head *head)
 168 -{
 169 -       __list_add(new, head, head->next);
 170 -}
 171 +/* Initialise a list head to an empty list */
 172 +#define YINIT_LIST_HEAD(p) \
 173 +do { \
 174 + (p)->next = (p);\
 175 + (p)->prev = (p); \
 176 +} while(0)
 177
 178 -/**
 179 - * list_add_tail - add a new entry
 180 - * @new: new entry to be added
 181 - * @head: list head to add it before
 182 - *
 183 - * Insert a new entry before the specified head.
 184 - * This is useful for implementing queues.
 185 - */
 186 -static __inline__ void list_add_tail(struct list_head *new,
 187 -                                    struct list_head *head)
 188 +
 189 +/* Add an element to a list */
 190 +static __inline__ void ylist_add(struct ylist_head *newEntry,
 191 +                                 struct ylist_head *list)
 192  {
 193 -       __list_add(new, head->prev, head);
 194 +        struct ylist_head *listNext = list->next;
 195 +
 196 +        list->next = newEntry;
 197 +        newEntry->prev = list;
 198 +       newEntry->next = listNext;
 199 +       listNext->prev = newEntry;
 200 +
 201  }
 202
 203 -/*
 204 - * Delete a list entry by making the prev/next entries
 205 - * point to each other.
 206 - *
 207 - * This is only for internal list manipulation where we know
 208 - * the prev/next entries already!
 209 - */
 210 -static __inline__ void __list_del(struct list_head *prev,
 211 -                                 struct list_head *next)
 212 +static __inline__ void ylist_add_tail(struct ylist_head *newEntry,
 213 +                                struct ylist_head *list)
 214  {
 215 -       next->prev = prev;
 216 -       prev->next = next;
 217 +       struct ylist_head *listPrev = list->prev;
 218 +
 219 +       list->prev = newEntry;
 220 +       newEntry->next = list;
 221 +       newEntry->prev = listPrev;
 222 +       listPrev->next = newEntry;
 223 +
 224  }
 225
 226 -/**
 227 - * list_del - deletes entry from list.
 228 - * @entry: the element to delete from the list.
 229 - * Note: list_empty on entry does not return true after this, the entry is
 230 - * in an undefined state.
 231 - */
 232 -static __inline__ void list_del(struct list_head *entry)
 233 +
 234 +/* Take an element out of its current list, with or without
 235 + * reinitialising the links.of the entry*/
 236 +static __inline__ void ylist_del(struct ylist_head *entry)
 237  {
 238 -       __list_del(entry->prev, entry->next);
 239 +        struct ylist_head *listNext = entry->next;
 240 +        struct ylist_head *listPrev = entry->prev;
 241 +
 242 +        listNext->prev = listPrev;
 243 +        listPrev->next = listNext;
 244 +
 245  }
 246
 247 -/**
 248 - * list_del_init - deletes entry from list and reinitialize it.
 249 - * @entry: the element to delete from the list.
 250 - */
 251 -static __inline__ void list_del_init(struct list_head *entry)
 252 +static __inline__ void ylist_del_init(struct ylist_head *entry)
 253  {
 254 -       __list_del(entry->prev, entry->next);
 255 -       INIT_LIST_HEAD(entry);
 256 +        ylist_del(entry);
 257 +        entry->next = entry->prev = entry;
 258  }
 259
 260 -/**
 261 - * list_empty - tests whether a list is empty
 262 - * @head: the list to test.
 263 - */
 264 -static __inline__ int list_empty(struct list_head *head)
 265 +
 266 +/* Test if the list is empty */
 267 +static __inline__ int ylist_empty(struct ylist_head *entry)
 268  {
 269 -       return head->next == head;
 270 +        return (entry->next == entry);
 271  }
 272
 273 -/**
 274 - * list_splice - join two lists
 275 - * @list: the new list to add.
 276 - * @head: the place to add it in the first list.
 277 +
 278 +/* ylist_entry takes a pointer to a list entry and offsets it to that
 279 + * we can find a pointer to the object it is embedded in.
 280   */
 281 -static __inline__ void list_splice(struct list_head *list,
 282 -                                  struct list_head *head)
 283 -{
 284 -       struct list_head *first = list->next;
 285 +
 286 +
 287 +#define ylist_entry(entry, type, member) \
 288 +        ((type *)((char *)(entry)-(unsigned long)(&((type *)NULL)->member)))
 289
 290 -       if (first != list) {
 291 -               struct list_head *last = list->prev;
 292 -               struct list_head *at = head->next;
 293 -
 294 -               first->prev = head;
 295 -               head->next = first;
 296 -
 297 -               last->next = at;
 298 -               at->prev = last;
 299 -       }
 300 -}
 301
 302 -/**
 303 - * list_entry - get the struct for this entry
 304 - * @ptr:       the &struct list_head pointer.
 305 - * @type:      the type of the struct this is embedded in.
 306 - * @member:    the name of the list_struct within the struct.
 307 +/* ylist_for_each and list_for_each_safe  iterate over lists.
 308 + * ylist_for_each_safe uses temporary storage to make the list delete safe
 309   */
 310 -#define list_entry(ptr, type, member) \
 311 -       ((type *)((char *)(ptr)-(unsigned long)(&((type *)0)->member)))
 312
 313 -/**
 314 - * list_for_each       -       iterate over a list
 315 - * @pos:       the &struct list_head to use as a loop counter.
 316 - * @head:      the head for your list.
 317 - */
 318 -#define list_for_each(pos, head) \
 319 -       for (pos = (head)->next, prefetch(pos->next); pos != (head); \
 320 -               pos = pos->next, prefetch(pos->next))
 321 -
 322 -/**
 323 - * list_for_each_safe  -       iterate over a list safe against removal
 324 - *                              of list entry
 325 - * @pos:       the &struct list_head to use as a loop counter.
 326 - * @n:         another &struct list_head to use as temporary storage
 327 - * @head:      the head for your list.
 328 - */
 329 -#define list_for_each_safe(pos, n, head) \
 330 -       for (pos = (head)->next, n = pos->next; pos != (head); \
 331 -               pos = n, n = pos->next)
 332 +#define ylist_for_each(itervar, list) \
 333 +        for (itervar = (list)->next; itervar != (list); itervar = itervar->next )
 334
 335 -/*
 336 - * File types
 337 - */
 338 -#define DT_UNKNOWN     0
 339 -#define DT_FIFO                1
 340 -#define DT_CHR         2
 341 +#define ylist_for_each_safe(itervar,saveVar, list) \
 342 +        for (itervar = (list)->next, saveVar = (list)->next->next; itervar != (list); \
 343 +         itervar = saveVar, saveVar = saveVar->next)
 344 +
 345 +
 346 +#if !(defined __KERNEL__)
 347 +
 348 +
 349 +#ifndef WIN32
 350 +#include <sys/stat.h>
 351 +#endif
 352 +
 353 +
 354 +#ifdef CONFIG_YAFFS_PROVIDE_DEFS
 355 +/* File types */
 356 +
 357 +
 358 +#define DT_UNKNOWN      0
 359 +#define DT_FIFO         1
 360 +#define DT_CHR          2
 361  #define DT_DIR         4
 362  #define DT_BLK         6
 363 -#define DT_REG         8
 364 -#define DT_LNK         10
 365 -#define DT_SOCK                12
 366 -#define DT_WHT         14
 367 +#define DT_REG          8
 368 +#define DT_LNK          10
 369 +#define DT_SOCK         12
 370 +#define DT_WHT          14
 371 +
 372
 373  #ifndef WIN32
 374  #include <sys/stat.h>
 375 @@ -220,17 +162,13 @@ static __inline__ void list_splice(struc
 376   * Attribute flags.  These should be or-ed together to figure out what
 377   * has been changed!
 378   */
 379 -#define ATTR_MODE      1
 380 -#define ATTR_UID       2
 381 +#define ATTR_MODE       1
 382 +#define ATTR_UID        2
 383  #define ATTR_GID       4
 384  #define ATTR_SIZE      8
 385  #define ATTR_ATIME     16
 386  #define ATTR_MTIME     32
 387  #define ATTR_CTIME     64
 388 -#define ATTR_ATIME_SET 128
 389 -#define ATTR_MTIME_SET 256
 390 -#define ATTR_FORCE     512     /* Not a change, but a change it */
 391 -#define ATTR_ATTR_FLAG 1024
 392
 393  struct iattr {
 394         unsigned int ia_valid;
 395 @@ -241,24 +179,21 @@ struct iattr {
 396         unsigned ia_atime;
 397         unsigned ia_mtime;
 398         unsigned ia_ctime;
 399 -       unsigned int ia_attr_flags;
 400 +        unsigned int ia_attr_flags;
 401  };
 402
 403 +#endif
 404 +
 405 +
 406  #define KERN_DEBUG
 407
 408  #else
 409
 410 -#ifndef WIN32
 411  #include <linux/types.h>
 412 -#include <linux/list.h>
 413  #include <linux/fs.h>
 414  #include <linux/stat.h>
 415 -#endif
 416
 417  #endif
 418
 419 -#if defined WIN32
 420 -#undef new
 421 -#endif
 422
 423  #endif
 424 --- a/fs/yaffs2/yaffs_packedtags2.c
 425 +++ b/fs/yaffs2/yaffs_packedtags2.c
 426 @@ -37,60 +37,70 @@
 427  #define EXTRA_OBJECT_TYPE_SHIFT (28)
 428  #define EXTRA_OBJECT_TYPE_MASK  ((0x0F) << EXTRA_OBJECT_TYPE_SHIFT)
 429
 430 -static void yaffs_DumpPackedTags2(const yaffs_PackedTags2 * pt)
 431 +
 432 +static void yaffs_DumpPackedTags2TagsPart(const yaffs_PackedTags2TagsPart * ptt)
 433  {
 434         T(YAFFS_TRACE_MTD,
 435           (TSTR("packed tags obj %d chunk %d byte %d seq %d" TENDSTR),
 436 -          pt->t.objectId, pt->t.chunkId, pt->t.byteCount,
 437 -          pt->t.sequenceNumber));
 438 +          ptt->objectId, ptt->chunkId, ptt->byteCount,
 439 +          ptt->sequenceNumber));
 440 +}
 441 +static void yaffs_DumpPackedTags2(const yaffs_PackedTags2 * pt)
 442 +{
 443 +       yaffs_DumpPackedTags2TagsPart(&pt->t);
 444  }
 445
 446  static void yaffs_DumpTags2(const yaffs_ExtendedTags * t)
 447  {
 448         T(YAFFS_TRACE_MTD,
 449           (TSTR
 450 -          ("ext.tags eccres %d blkbad %d chused %d obj %d chunk%d byte "
 451 -           "%d del %d ser %d seq %d"
 452 +          ("ext.tags eccres %d blkbad %d chused %d obj %d chunk%d byte %d del %d ser %d seq %d"
 453             TENDSTR), t->eccResult, t->blockBad, t->chunkUsed, t->objectId,
 454            t->chunkId, t->byteCount, t->chunkDeleted, t->serialNumber,
 455            t->sequenceNumber));
 456
 457  }
 458
 459 -void yaffs_PackTags2(yaffs_PackedTags2 * pt, const yaffs_ExtendedTags * t)
 460 +void yaffs_PackTags2TagsPart(yaffs_PackedTags2TagsPart * ptt, const yaffs_ExtendedTags * t)
 461  {
 462 -       pt->t.chunkId = t->chunkId;
 463 -       pt->t.sequenceNumber = t->sequenceNumber;
 464 -       pt->t.byteCount = t->byteCount;
 465 -       pt->t.objectId = t->objectId;
 466 +       ptt->chunkId = t->chunkId;
 467 +       ptt->sequenceNumber = t->sequenceNumber;
 468 +       ptt->byteCount = t->byteCount;
 469 +       ptt->objectId = t->objectId;
 470
 471         if (t->chunkId == 0 && t->extraHeaderInfoAvailable) {
 472                 /* Store the extra header info instead */
 473                 /* We save the parent object in the chunkId */
 474 -               pt->t.chunkId = EXTRA_HEADER_INFO_FLAG
 475 +               ptt->chunkId = EXTRA_HEADER_INFO_FLAG
 476                         | t->extraParentObjectId;
 477                 if (t->extraIsShrinkHeader) {
 478 -                       pt->t.chunkId |= EXTRA_SHRINK_FLAG;
 479 +                       ptt->chunkId |= EXTRA_SHRINK_FLAG;
 480                 }
 481                 if (t->extraShadows) {
 482 -                       pt->t.chunkId |= EXTRA_SHADOWS_FLAG;
 483 +                       ptt->chunkId |= EXTRA_SHADOWS_FLAG;
 484                 }
 485
 486 -               pt->t.objectId &= ~EXTRA_OBJECT_TYPE_MASK;
 487 -               pt->t.objectId |=
 488 +               ptt->objectId &= ~EXTRA_OBJECT_TYPE_MASK;
 489 +               ptt->objectId |=
 490                     (t->extraObjectType << EXTRA_OBJECT_TYPE_SHIFT);
 491
 492                 if (t->extraObjectType == YAFFS_OBJECT_TYPE_HARDLINK) {
 493 -                       pt->t.byteCount = t->extraEquivalentObjectId;
 494 +                       ptt->byteCount = t->extraEquivalentObjectId;
 495                 } else if (t->extraObjectType == YAFFS_OBJECT_TYPE_FILE) {
 496 -                       pt->t.byteCount = t->extraFileLength;
 497 +                       ptt->byteCount = t->extraFileLength;
 498                 } else {
 499 -                       pt->t.byteCount = 0;
 500 +                       ptt->byteCount = 0;
 501                 }
 502         }
 503
 504 -       yaffs_DumpPackedTags2(pt);
 505 +       yaffs_DumpPackedTags2TagsPart(ptt);
 506         yaffs_DumpTags2(t);
 507 +}
 508 +
 509 +
 510 +void yaffs_PackTags2(yaffs_PackedTags2 * pt, const yaffs_ExtendedTags * t)
 511 +{
 512 +       yaffs_PackTags2TagsPart(&pt->t,t);
 513
 514  #ifndef YAFFS_IGNORE_TAGS_ECC
 515         {
 516 @@ -101,20 +111,63 @@ void yaffs_PackTags2(yaffs_PackedTags2 *
 517  #endif
 518  }
 519
 520 -void yaffs_UnpackTags2(yaffs_ExtendedTags * t, yaffs_PackedTags2 * pt)
 521 +
 522 +void yaffs_UnpackTags2TagsPart(yaffs_ExtendedTags * t, yaffs_PackedTags2TagsPart * ptt)
 523  {
 524
 525         memset(t, 0, sizeof(yaffs_ExtendedTags));
 526
 527         yaffs_InitialiseTags(t);
 528
 529 +       if (ptt->sequenceNumber != 0xFFFFFFFF) {
 530 +               t->blockBad = 0;
 531 +               t->chunkUsed = 1;
 532 +               t->objectId = ptt->objectId;
 533 +               t->chunkId = ptt->chunkId;
 534 +               t->byteCount = ptt->byteCount;
 535 +               t->chunkDeleted = 0;
 536 +               t->serialNumber = 0;
 537 +               t->sequenceNumber = ptt->sequenceNumber;
 538 +
 539 +               /* Do extra header info stuff */
 540 +
 541 +               if (ptt->chunkId & EXTRA_HEADER_INFO_FLAG) {
 542 +                       t->chunkId = 0;
 543 +                       t->byteCount = 0;
 544 +
 545 +                       t->extraHeaderInfoAvailable = 1;
 546 +                       t->extraParentObjectId =
 547 +                           ptt->chunkId & (~(ALL_EXTRA_FLAGS));
 548 +                       t->extraIsShrinkHeader =
 549 +                           (ptt->chunkId & EXTRA_SHRINK_FLAG) ? 1 : 0;
 550 +                       t->extraShadows =
 551 +                           (ptt->chunkId & EXTRA_SHADOWS_FLAG) ? 1 : 0;
 552 +                       t->extraObjectType =
 553 +                           ptt->objectId >> EXTRA_OBJECT_TYPE_SHIFT;
 554 +                       t->objectId &= ~EXTRA_OBJECT_TYPE_MASK;
 555 +
 556 +                       if (t->extraObjectType == YAFFS_OBJECT_TYPE_HARDLINK) {
 557 +                               t->extraEquivalentObjectId = ptt->byteCount;
 558 +                       } else {
 559 +                               t->extraFileLength = ptt->byteCount;
 560 +                       }
 561 +               }
 562 +       }
 563 +
 564 +       yaffs_DumpPackedTags2TagsPart(ptt);
 565 +       yaffs_DumpTags2(t);
 566 +
 567 +}
 568 +
 569 +
 570 +void yaffs_UnpackTags2(yaffs_ExtendedTags * t, yaffs_PackedTags2 * pt)
 571 +{
 572 +
 573 +       yaffs_ECCResult eccResult = YAFFS_ECC_RESULT_NO_ERROR;
 574 +
 575         if (pt->t.sequenceNumber != 0xFFFFFFFF) {
 576                 /* Page is in use */
 577 -#ifdef YAFFS_IGNORE_TAGS_ECC
 578 -               {
 579 -                       t->eccResult = YAFFS_ECC_RESULT_NO_ERROR;
 580 -               }
 581 -#else
 582 +#ifndef YAFFS_IGNORE_TAGS_ECC
 583                 {
 584                         yaffs_ECCOther ecc;
 585                         int result;
 586 @@ -129,54 +182,27 @@ void yaffs_UnpackTags2(yaffs_ExtendedTag
 587                                                   &pt->ecc, &ecc);
 588                         switch(result){
 589                                 case 0:
 590 -                                       t->eccResult = YAFFS_ECC_RESULT_NO_ERROR;
 591 +                                       eccResult = YAFFS_ECC_RESULT_NO_ERROR;
 592                                         break;
 593                                 case 1:
 594 -                                       t->eccResult = YAFFS_ECC_RESULT_FIXED;
 595 +                                       eccResult = YAFFS_ECC_RESULT_FIXED;
 596                                         break;
 597                                 case -1:
 598 -                                       t->eccResult = YAFFS_ECC_RESULT_UNFIXED;
 599 +                                       eccResult = YAFFS_ECC_RESULT_UNFIXED;
 600                                         break;
 601                                 default:
 602 -                                       t->eccResult = YAFFS_ECC_RESULT_UNKNOWN;
 603 +                                       eccResult = YAFFS_ECC_RESULT_UNKNOWN;
 604                         }
 605                 }
 606  #endif
 607 -               t->blockBad = 0;
 608 -               t->chunkUsed = 1;
 609 -               t->objectId = pt->t.objectId;
 610 -               t->chunkId = pt->t.chunkId;
 611 -               t->byteCount = pt->t.byteCount;
 612 -               t->chunkDeleted = 0;
 613 -               t->serialNumber = 0;
 614 -               t->sequenceNumber = pt->t.sequenceNumber;
 615 -
 616 -               /* Do extra header info stuff */
 617 -
 618 -               if (pt->t.chunkId & EXTRA_HEADER_INFO_FLAG) {
 619 -                       t->chunkId = 0;
 620 -                       t->byteCount = 0;
 621 -
 622 -                       t->extraHeaderInfoAvailable = 1;
 623 -                       t->extraParentObjectId =
 624 -                           pt->t.chunkId & (~(ALL_EXTRA_FLAGS));
 625 -                       t->extraIsShrinkHeader =
 626 -                           (pt->t.chunkId & EXTRA_SHRINK_FLAG) ? 1 : 0;
 627 -                       t->extraShadows =
 628 -                           (pt->t.chunkId & EXTRA_SHADOWS_FLAG) ? 1 : 0;
 629 -                       t->extraObjectType =
 630 -                           pt->t.objectId >> EXTRA_OBJECT_TYPE_SHIFT;
 631 -                       t->objectId &= ~EXTRA_OBJECT_TYPE_MASK;
 632 -
 633 -                       if (t->extraObjectType == YAFFS_OBJECT_TYPE_HARDLINK) {
 634 -                               t->extraEquivalentObjectId = pt->t.byteCount;
 635 -                       } else {
 636 -                               t->extraFileLength = pt->t.byteCount;
 637 -                       }
 638 -               }
 639         }
 640
 641 +       yaffs_UnpackTags2TagsPart(t,&pt->t);
 642 +
 643 +       t->eccResult = eccResult;
 644 +
 645         yaffs_DumpPackedTags2(pt);
 646         yaffs_DumpTags2(t);
 647
 648  }
 649 +
 650 --- a/fs/yaffs2/yaffs_ecc.c
 651 +++ b/fs/yaffs2/yaffs_ecc.c
 652 @@ -29,7 +29,7 @@
 653   */
 654
 655  const char *yaffs_ecc_c_version =
 656 -    "$Id: yaffs_ecc.c,v 1.9 2007-02-14 01:09:06 wookey Exp $";
 657 +    "$Id: yaffs_ecc.c,v 1.10 2007-12-13 15:35:17 wookey Exp $";
 658
 659  #include "yportenv.h"
 660
 661 --- a/fs/yaffs2/yaffs_packedtags2.h
 662 +++ b/fs/yaffs2/yaffs_packedtags2.h
 663 @@ -33,6 +33,11 @@ typedef struct {
 664         yaffs_ECCOther ecc;
 665  } yaffs_PackedTags2;
 666
 667 +/* Full packed tags with ECC, used for oob tags */
 668  void yaffs_PackTags2(yaffs_PackedTags2 * pt, const yaffs_ExtendedTags * t);
 669  void yaffs_UnpackTags2(yaffs_ExtendedTags * t, yaffs_PackedTags2 * pt);
 670 +
 671 +/* Only the tags part (no ECC for use with inband tags */
 672 +void yaffs_PackTags2TagsPart(yaffs_PackedTags2TagsPart * pt, const yaffs_ExtendedTags * t);
 673 +void yaffs_UnpackTags2TagsPart(yaffs_ExtendedTags * t, yaffs_PackedTags2TagsPart * pt);
 674  #endif
 675 --- a/fs/yaffs2/yportenv.h
 676 +++ b/fs/yaffs2/yportenv.h
 677 @@ -17,6 +17,14 @@
 678  #ifndef __YPORTENV_H__
 679  #define __YPORTENV_H__
 680
 681 +/*
 682 + * Define the MTD version in terms of Linux Kernel versions
 683 + * This allows yaffs to be used independantly of the kernel
 684 + * as well as with it.
 685 + */
 686 +
 687 +#define MTD_VERSION(a,b,c) (((a) << 16) + ((b) << 8) + (c))
 688 +
 689  #if defined CONFIG_YAFFS_WINCE
 690
 691  #include "ywinceenv.h"
 692 @@ -26,7 +34,10 @@
 693  #include "moduleconfig.h"
 694
 695  /* Linux kernel */
 696 +
 697  #include <linux/version.h>
 698 +#define MTD_VERSION_CODE LINUX_VERSION_CODE
 699 +
 700  #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19))
 701  #include <linux/config.h>
 702  #endif
 703 @@ -40,6 +51,7 @@
 704  #define YCHAR char
 705  #define YUCHAR unsigned char
 706  #define _Y(x)     x
 707 +#define yaffs_strcat(a,b)    strcat(a,b)
 708  #define yaffs_strcpy(a,b)    strcpy(a,b)
 709  #define yaffs_strncpy(a,b,c) strncpy(a,b,c)
 710  #define yaffs_strncmp(a,b,c) strncmp(a,b,c)
 711 @@ -90,6 +102,8 @@
 712
 713  #elif defined CONFIG_YAFFS_DIRECT
 714
 715 +#define MTD_VERSION_CODE MTD_VERSION(2,6,22)
 716 +
 717  /* Direct interface */
 718  #include "ydirectenv.h"
 719
 720 @@ -111,6 +125,7 @@
 721  #define YCHAR char
 722  #define YUCHAR unsigned char
 723  #define _Y(x)     x
 724 +#define yaffs_strcat(a,b)    strcat(a,b)
 725  #define yaffs_strcpy(a,b)    strcpy(a,b)
 726  #define yaffs_strncpy(a,b,c) strncpy(a,b,c)
 727  #define yaffs_strlen(s)             strlen(s)
 728 @@ -180,8 +195,8 @@ extern unsigned int yaffs_wr_attempts;
 729
 730  #define T(mask,p) do{ if((mask) & (yaffs_traceMask | YAFFS_TRACE_ALWAYS)) TOUT(p);} while(0)
 731
 732 -#ifndef CONFIG_YAFFS_WINCE
 733 -#define YBUG() T(YAFFS_TRACE_BUG,(TSTR("==>> yaffs bug: " __FILE__ " %d" TENDSTR),__LINE__))
 734 +#ifndef YBUG
 735 +#define YBUG() do {T(YAFFS_TRACE_BUG,(TSTR("==>> yaffs bug: " __FILE__ " %d" TENDSTR),__LINE__));} while(0)
 736  #endif
 737
 738  #endif
 739 --- a/fs/yaffs2/Makefile
 740 +++ b/fs/yaffs2/Makefile
 741 @@ -5,7 +5,6 @@
 742  obj-$(CONFIG_YAFFS_FS) += yaffs.o
 743
 744  yaffs-y := yaffs_ecc.o yaffs_fs.o yaffs_guts.o yaffs_checkptrw.o
 745 -yaffs-y += yaffs_packedtags2.o yaffs_nand.o yaffs_qsort.o
 746 +yaffs-y += yaffs_packedtags1.o yaffs_packedtags2.o yaffs_nand.o yaffs_qsort.o
 747  yaffs-y += yaffs_tagscompat.o yaffs_tagsvalidity.o
 748 -yaffs-y += yaffs_mtdif1.o yaffs_packedtags1.o
 749 -yaffs-y += yaffs_mtdif.o yaffs_mtdif2.o
 750 +yaffs-y += yaffs_mtdif.o yaffs_mtdif1.o yaffs_mtdif2.o
 751 --- a/fs/yaffs2/yaffs_fs.c
 752 +++ b/fs/yaffs2/yaffs_fs.c
 753 @@ -32,7 +32,7 @@
 754   */
 755
 756  const char *yaffs_fs_c_version =
 757 -    "$Id: yaffs_fs.c,v 1.63 2007-09-19 20:35:40 imcd Exp $";
 758 +    "$Id: yaffs_fs.c,v 1.71 2009-01-22 00:45:54 charles Exp $";
 759  extern const char *yaffs_guts_c_version;
 760
 761  #include <linux/version.h>
 762 @@ -43,7 +43,6 @@ extern const char *yaffs_guts_c_version;
 763  #include <linux/module.h>
 764  #include <linux/slab.h>
 765  #include <linux/init.h>
 766 -#include <linux/list.h>
 767  #include <linux/fs.h>
 768  #include <linux/proc_fs.h>
 769  #include <linux/smp_lock.h>
 770 @@ -53,6 +52,8 @@ extern const char *yaffs_guts_c_version;
 771  #include <linux/string.h>
 772  #include <linux/ctype.h>
 773
 774 +#include "asm/div64.h"
 775 +
 776  #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
 777
 778  #include <linux/statfs.h>      /* Added NCB 15-8-2003 */
 779 @@ -76,6 +77,12 @@ extern const char *yaffs_guts_c_version;
 780
 781  #endif
 782
 783 +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,26))
 784 +#define YPROC_ROOT  &proc_root
 785 +#else
 786 +#define YPROC_ROOT  NULL
 787 +#endif
 788 +
 789  #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
 790  #define WRITE_SIZE_STR "writesize"
 791  #define WRITE_SIZE(mtd) (mtd)->writesize
 792 @@ -84,6 +91,13 @@ extern const char *yaffs_guts_c_version;
 793  #define WRITE_SIZE(mtd) (mtd)->oobblock
 794  #endif
 795
 796 +#if(LINUX_VERSION_CODE > KERNEL_VERSION(2,6,27))
 797 +#define YAFFS_USE_WRITE_BEGIN_END 1
 798 +#else
 799 +#define YAFFS_USE_WRITE_BEGIN_END 0
 800 +#endif
 801 +
 802 +
 803  #include <asm/uaccess.h>
 804
 805  #include "yportenv.h"
 806 @@ -96,14 +110,30 @@ extern const char *yaffs_guts_c_version;
 807
 808  unsigned int yaffs_traceMask = YAFFS_TRACE_BAD_BLOCKS;
 809  unsigned int yaffs_wr_attempts = YAFFS_WR_ATTEMPTS;
 810 +unsigned int yaffs_auto_checkpoint = 1;
 811
 812  /* Module Parameters */
 813  #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
 814  module_param(yaffs_traceMask,uint,0644);
 815  module_param(yaffs_wr_attempts,uint,0644);
 816 +module_param(yaffs_auto_checkpoint,uint,0644);
 817  #else
 818  MODULE_PARM(yaffs_traceMask,"i");
 819  MODULE_PARM(yaffs_wr_attempts,"i");
 820 +MODULE_PARM(yaffs_auto_checkpoint,"i");
 821 +#endif
 822 +
 823 +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,25))
 824 +/* use iget and read_inode */
 825 +#define Y_IGET(sb,inum) iget((sb),(inum))
 826 +static void yaffs_read_inode(struct inode *inode);
 827 +
 828 +#else
 829 +/* Call local equivalent */
 830 +#define YAFFS_USE_OWN_IGET
 831 +#define Y_IGET(sb,inum) yaffs_iget((sb),(inum))
 832 +
 833 +static struct inode * yaffs_iget(struct super_block *sb, unsigned long ino);
 834  #endif
 835
 836  /*#define T(x) printk x */
 837 @@ -127,6 +157,8 @@ static void yaffs_put_super(struct super
 838
 839  static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n,
 840                                 loff_t * pos);
 841 +static ssize_t yaffs_hold_space(struct file *f);
 842 +static void yaffs_release_space(struct file *f);
 843
 844  #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
 845  static int yaffs_file_flush(struct file *file, fl_owner_t id);
 846 @@ -181,9 +213,11 @@ static int yaffs_statfs(struct super_blo
 847  #else
 848  static int yaffs_statfs(struct super_block *sb, struct statfs *buf);
 849  #endif
 850 -static void yaffs_read_inode(struct inode *inode);
 851
 852 +#ifdef YAFFS_HAS_PUT_INODE
 853  static void yaffs_put_inode(struct inode *inode);
 854 +#endif
 855 +
 856  static void yaffs_delete_inode(struct inode *);
 857  static void yaffs_clear_inode(struct inode *);
 858
 859 @@ -193,10 +227,22 @@ static int yaffs_writepage(struct page *
 860  #else
 861  static int yaffs_writepage(struct page *page);
 862  #endif
 863 +
 864 +
 865 +#if (YAFFS_USE_WRITE_BEGIN_END != 0)
 866 +static int yaffs_write_begin(struct file *filp, struct address_space *mapping,
 867 +                             loff_t pos, unsigned len, unsigned flags,
 868 +                          struct page **pagep, void **fsdata);
 869 +static int yaffs_write_end(struct file *filp, struct address_space *mapping,
 870 +                          loff_t pos, unsigned len, unsigned copied,
 871 +                          struct page *pg, void *fsdadata);
 872 +#else
 873  static int yaffs_prepare_write(struct file *f, struct page *pg,
 874                                unsigned offset, unsigned to);
 875  static int yaffs_commit_write(struct file *f, struct page *pg, unsigned offset,
 876                               unsigned to);
 877 +
 878 +#endif
 879
 880  static int yaffs_readlink(struct dentry *dentry, char __user * buffer,
 881                           int buflen);
 882 @@ -209,8 +255,13 @@ static int yaffs_follow_link(struct dent
 883  static struct address_space_operations yaffs_file_address_operations = {
 884         .readpage = yaffs_readpage,
 885         .writepage = yaffs_writepage,
 886 +#if (YAFFS_USE_WRITE_BEGIN_END > 0)
 887 +       .write_begin = yaffs_write_begin,
 888 +       .write_end = yaffs_write_end,
 889 +#else
 890         .prepare_write = yaffs_prepare_write,
 891         .commit_write = yaffs_commit_write,
 892 +#endif
 893  };
 894
 895  #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,22))
 896 @@ -224,6 +275,7 @@ static struct file_operations yaffs_file
 897         .fsync = yaffs_sync_object,
 898         .splice_read = generic_file_splice_read,
 899         .splice_write = generic_file_splice_write,
 900 +       .llseek = generic_file_llseek,
 901  };
 902
 903  #elif (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,18))
 904 @@ -284,8 +336,13 @@ static struct file_operations yaffs_dir_
 905
 906  static struct super_operations yaffs_super_ops = {
 907         .statfs = yaffs_statfs,
 908 +
 909 +#ifndef YAFFS_USE_OWN_IGET
 910         .read_inode = yaffs_read_inode,
 911 +#endif
 912 +#ifdef YAFFS_HAS_PUT_INODE
 913         .put_inode = yaffs_put_inode,
 914 +#endif
 915         .put_super = yaffs_put_super,
 916         .delete_inode = yaffs_delete_inode,
 917         .clear_inode = yaffs_clear_inode,
 918 @@ -429,6 +486,9 @@ static struct dentry *yaffs_lookup(struc
 919
 920  }
 921
 922 +
 923 +#ifdef YAFFS_HAS_PUT_INODE
 924 +
 925  /* For now put inode is just for debugging
 926   * Put inode is called when the inode **structure** is put.
 927   */
 928 @@ -439,6 +499,7 @@ static void yaffs_put_inode(struct inode
 929            atomic_read(&inode->i_count)));
 930
 931  }
 932 +#endif
 933
 934  /* clear is called to tell the fs to release any per-inode data it holds */
 935  static void yaffs_clear_inode(struct inode *inode)
 936 @@ -667,6 +728,64 @@ static int yaffs_writepage(struct page *
 937         return (nWritten == nBytes) ? 0 : -ENOSPC;
 938  }
 939
 940 +
 941 +#if (YAFFS_USE_WRITE_BEGIN_END > 0)
 942 +static int yaffs_write_begin(struct file *filp, struct address_space *mapping,
 943 +                             loff_t pos, unsigned len, unsigned flags,
 944 +                          struct page **pagep, void **fsdata)
 945 +
 946 +{
 947 +       struct page *pg = NULL;
 948 +        pgoff_t index = pos >> PAGE_CACHE_SHIFT;
 949 +        uint32_t offset = pos & (PAGE_CACHE_SIZE - 1);
 950 +        uint32_t to = offset + len;
 951 +
 952 +        int ret = 0;
 953 +        int space_held = 0;
 954 +
 955 +       T(YAFFS_TRACE_OS, (KERN_DEBUG "start yaffs_write_begin\n"));
 956 +       /* Get a page */
 957 +       pg = __grab_cache_page(mapping,index);
 958 +       *pagep = pg;
 959 +       if(!pg){
 960 +               ret =  -ENOMEM;
 961 +               goto out;
 962 +       }
 963 +       /* Get fs space */
 964 +       space_held = yaffs_hold_space(filp);
 965 +
 966 +       if(!space_held){
 967 +               ret = -ENOSPC;
 968 +               goto out;
 969 +       }
 970 +
 971 +       /* Update page if required */
 972 +
 973 +       if (!Page_Uptodate(pg) && (offset || to < PAGE_CACHE_SIZE))
 974 +               ret = yaffs_readpage_nolock(filp, pg);
 975 +
 976 +       if(ret)
 977 +               goto out;
 978 +
 979 +       /* Happy path return */
 980 +       T(YAFFS_TRACE_OS, (KERN_DEBUG "end yaffs_write_begin - ok\n"));
 981 +
 982 +       return 0;
 983 +
 984 +out:
 985 +       T(YAFFS_TRACE_OS, (KERN_DEBUG "end yaffs_write_begin fail returning %d\n",ret));
 986 +       if(space_held){
 987 +               yaffs_release_space(filp);
 988 +       }
 989 +       if(pg) {
 990 +               unlock_page(pg);
 991 +               page_cache_release(pg);
 992 +       }
 993 +       return ret;
 994 +}
 995 +
 996 +#else
 997 +
 998  static int yaffs_prepare_write(struct file *f, struct page *pg,
 999                                unsigned offset, unsigned to)
1000  {
1001 @@ -674,22 +793,69 @@ static int yaffs_prepare_write(struct fi
1002         T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_prepair_write\n"));
1003         if (!Page_Uptodate(pg) && (offset || to < PAGE_CACHE_SIZE))
1004                 return yaffs_readpage_nolock(f, pg);
1005 -
1006         return 0;
1007
1008  }
1009 +#endif
1010 +
1011 +#if (YAFFS_USE_WRITE_BEGIN_END > 0)
1012 +static int yaffs_write_end(struct file *filp, struct address_space *mapping,
1013 +                          loff_t pos, unsigned len, unsigned copied,
1014 +                          struct page *pg, void *fsdadata)
1015 +{
1016 +       int ret = 0;
1017 +       void *addr, *kva;
1018 +        pgoff_t index = pos >> PAGE_CACHE_SHIFT;
1019 +        uint32_t offset_into_page = pos & (PAGE_CACHE_SIZE -1);
1020 +
1021 +
1022 +
1023 +       kva=kmap(pg);
1024 +       addr = kva + offset_into_page;
1025 +
1026 +       T(YAFFS_TRACE_OS,
1027 +         (KERN_DEBUG "yaffs_write_end addr %x pos %x nBytes %d\n", (unsigned) addr,
1028 +          (int)pos, copied));
1029 +
1030 +       ret = yaffs_file_write(filp, addr, copied, &pos);
1031 +
1032 +       if (ret != copied) {
1033 +               T(YAFFS_TRACE_OS,
1034 +                 (KERN_DEBUG
1035 +                  "yaffs_write_end not same size ret %d  copied %d\n",
1036 +                  ret, copied ));
1037 +               SetPageError(pg);
1038 +               ClearPageUptodate(pg);
1039 +       } else {
1040 +               SetPageUptodate(pg);
1041 +       }
1042 +
1043 +       kunmap(pg);
1044 +
1045 +       yaffs_release_space(filp);
1046 +       unlock_page(pg);
1047 +       page_cache_release(pg);
1048 +       return ret;
1049 +}
1050 +#else
1051
1052  static int yaffs_commit_write(struct file *f, struct page *pg, unsigned offset,
1053                               unsigned to)
1054  {
1055
1056 -       void *addr = page_address(pg) + offset;
1057 +       void *addr, *kva;
1058 +
1059         loff_t pos = (((loff_t) pg->index) << PAGE_CACHE_SHIFT) + offset;
1060         int nBytes = to - offset;
1061         int nWritten;
1062
1063         unsigned spos = pos;
1064 -       unsigned saddr = (unsigned)addr;
1065 +       unsigned saddr;
1066 +
1067 +       kva=kmap(pg);
1068 +       addr = kva + offset;
1069 +
1070 +       saddr = (unsigned) addr;
1071
1072         T(YAFFS_TRACE_OS,
1073           (KERN_DEBUG "yaffs_commit_write addr %x pos %x nBytes %d\n", saddr,
1074 @@ -708,6 +874,8 @@ static int yaffs_commit_write(struct fil
1075                 SetPageUptodate(pg);
1076         }
1077
1078 +       kunmap(pg);
1079 +
1080         T(YAFFS_TRACE_OS,
1081           (KERN_DEBUG "yaffs_commit_write returning %d\n",
1082            nWritten == nBytes ? 0 : nWritten));
1083 @@ -715,6 +883,8 @@ static int yaffs_commit_write(struct fil
1084         return nWritten == nBytes ? 0 : nWritten;
1085
1086  }
1087 +#endif
1088 +
1089
1090  static void yaffs_FillInodeFromObject(struct inode *inode, yaffs_Object * obj)
1091  {
1092 @@ -753,6 +923,8 @@ static void yaffs_FillInodeFromObject(st
1093                         break;
1094                 }
1095
1096 +               inode->i_flags |= S_NOATIME;
1097 +
1098                 inode->i_ino = obj->objectId;
1099                 inode->i_mode = obj->yst_mode;
1100                 inode->i_uid = obj->yst_uid;
1101 @@ -844,7 +1016,9 @@ struct inode *yaffs_get_inode(struct sup
1102         T(YAFFS_TRACE_OS,
1103           (KERN_DEBUG "yaffs_get_inode for object %d\n", obj->objectId));
1104
1105 -       inode = iget(sb, obj->objectId);
1106 +       inode = Y_IGET(sb, obj->objectId);
1107 +       if(IS_ERR(inode))
1108 +         return NULL;
1109
1110         /* NB Side effect: iget calls back to yaffs_read_inode(). */
1111         /* iget also increments the inode's i_count */
1112 @@ -910,13 +1084,55 @@ static ssize_t yaffs_file_write(struct f
1113         return nWritten == 0 ? -ENOSPC : nWritten;
1114  }
1115
1116 +/* Space holding and freeing is done to ensure we have space available for write_begin/end */
1117 +/* For now we just assume few parallel writes and check against a small number. */
1118 +/* Todo: need to do this with a counter to handle parallel reads better */
1119 +
1120 +static ssize_t yaffs_hold_space(struct file *f)
1121 +{
1122 +       yaffs_Object *obj;
1123 +       yaffs_Device *dev;
1124 +
1125 +       int nFreeChunks;
1126 +
1127 +
1128 +       obj = yaffs_DentryToObject(f->f_dentry);
1129 +
1130 +       dev = obj->myDev;
1131 +
1132 +       yaffs_GrossLock(dev);
1133 +
1134 +       nFreeChunks = yaffs_GetNumberOfFreeChunks(dev);
1135 +
1136 +       yaffs_GrossUnlock(dev);
1137 +
1138 +       return (nFreeChunks > 20) ? 1 : 0;
1139 +}
1140 +
1141 +static void yaffs_release_space(struct file *f)
1142 +{
1143 +       yaffs_Object *obj;
1144 +       yaffs_Device *dev;
1145 +
1146 +
1147 +       obj = yaffs_DentryToObject(f->f_dentry);
1148 +
1149 +       dev = obj->myDev;
1150 +
1151 +       yaffs_GrossLock(dev);
1152 +
1153 +
1154 +       yaffs_GrossUnlock(dev);
1155 +
1156 +}
1157 +
1158  static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir)
1159  {
1160         yaffs_Object *obj;
1161         yaffs_Device *dev;
1162         struct inode *inode = f->f_dentry->d_inode;
1163         unsigned long offset, curoffs;
1164 -       struct list_head *i;
1165 +       struct ylist_head *i;
1166         yaffs_Object *l;
1167
1168         char name[YAFFS_MAX_NAME_LENGTH + 1];
1169 @@ -965,10 +1181,10 @@ static int yaffs_readdir(struct file *f,
1170                 f->f_version = inode->i_version;
1171         }
1172
1173 -       list_for_each(i, &obj->variant.directoryVariant.children) {
1174 +       ylist_for_each(i, &obj->variant.directoryVariant.children) {
1175                 curoffs++;
1176                 if (curoffs >= offset) {
1177 -                       l = list_entry(i, yaffs_Object, siblings);
1178 +                       l = ylist_entry(i, yaffs_Object, siblings);
1179
1180                         yaffs_GetObjectName(l, name,
1181                                             YAFFS_MAX_NAME_LENGTH + 1);
1182 @@ -1269,7 +1485,7 @@ static int yaffs_rename(struct inode *ol
1183
1184         if (target &&
1185             target->variantType == YAFFS_OBJECT_TYPE_DIRECTORY &&
1186 -           !list_empty(&target->variant.directoryVariant.children)) {
1187 +           !ylist_empty(&target->variant.directoryVariant.children)) {
1188
1189                 T(YAFFS_TRACE_OS, (KERN_DEBUG "target is non-empty dir\n"));
1190
1191 @@ -1350,25 +1566,47 @@ static int yaffs_statfs(struct super_blo
1192         buf->f_type = YAFFS_MAGIC;
1193         buf->f_bsize = sb->s_blocksize;
1194         buf->f_namelen = 255;
1195 -       if (sb->s_blocksize > dev->nDataBytesPerChunk) {
1196 -
1197 +
1198 +       if(dev->nDataBytesPerChunk & (dev->nDataBytesPerChunk - 1)){
1199 +               /* Do this if chunk size is not a power of 2 */
1200 +
1201 +               uint64_t bytesInDev;
1202 +               uint64_t bytesFree;
1203 +
1204 +               bytesInDev = ((uint64_t)((dev->endBlock - dev->startBlock +1))) *
1205 +                            ((uint64_t)(dev->nChunksPerBlock * dev->nDataBytesPerChunk));
1206 +
1207 +               do_div(bytesInDev,sb->s_blocksize); /* bytesInDev becomes the number of blocks */
1208 +               buf->f_blocks = bytesInDev;
1209 +
1210 +               bytesFree  = ((uint64_t)(yaffs_GetNumberOfFreeChunks(dev))) *
1211 +                            ((uint64_t)(dev->nDataBytesPerChunk));
1212 +
1213 +               do_div(bytesFree,sb->s_blocksize);
1214 +
1215 +               buf->f_bfree = bytesFree;
1216 +
1217 +       } else if (sb->s_blocksize > dev->nDataBytesPerChunk) {
1218 +
1219                 buf->f_blocks =
1220 -                   (dev->endBlock - dev->startBlock +
1221 -                    1) * dev->nChunksPerBlock / (sb->s_blocksize /
1222 -                                                 dev->nDataBytesPerChunk);
1223 -               buf->f_bfree =
1224 -                   yaffs_GetNumberOfFreeChunks(dev) / (sb->s_blocksize /
1225 -                                                       dev->nDataBytesPerChunk);
1226 +                          (dev->endBlock - dev->startBlock + 1) *
1227 +                           dev->nChunksPerBlock /
1228 +                           (sb->s_blocksize / dev->nDataBytesPerChunk);
1229 +               buf->f_bfree =
1230 +                          yaffs_GetNumberOfFreeChunks(dev) /
1231 +                          (sb->s_blocksize / dev->nDataBytesPerChunk);
1232         } else {
1233 -
1234 -               buf->f_blocks =
1235 -                   (dev->endBlock - dev->startBlock +
1236 -                    1) * dev->nChunksPerBlock * (dev->nDataBytesPerChunk /
1237 -                                                 sb->s_blocksize);
1238 -               buf->f_bfree =
1239 -                   yaffs_GetNumberOfFreeChunks(dev) * (dev->nDataBytesPerChunk /
1240 -                                                       sb->s_blocksize);
1241 +              buf->f_blocks =
1242 +                          (dev->endBlock - dev->startBlock + 1) *
1243 +                          dev->nChunksPerBlock *
1244 +                          (dev->nDataBytesPerChunk / sb->s_blocksize);
1245 +
1246 +                      buf->f_bfree =
1247 +                          yaffs_GetNumberOfFreeChunks(dev) *
1248 +                          (dev->nDataBytesPerChunk / sb->s_blocksize);
1249         }
1250 +
1251 +
1252         buf->f_files = 0;
1253         buf->f_ffree = 0;
1254         buf->f_bavail = buf->f_bfree;
1255 @@ -1378,7 +1616,6 @@ static int yaffs_statfs(struct super_blo
1256  }
1257
1258
1259 -/**
1260  static int yaffs_do_sync_fs(struct super_block *sb)
1261  {
1262
1263 @@ -1388,8 +1625,10 @@ static int yaffs_do_sync_fs(struct super
1264         if(sb->s_dirt) {
1265                 yaffs_GrossLock(dev);
1266
1267 -               if(dev)
1268 +               if(dev){
1269 +                       yaffs_FlushEntireDeviceCache(dev);
1270                         yaffs_CheckpointSave(dev);
1271 +               }
1272
1273                 yaffs_GrossUnlock(dev);
1274
1275 @@ -1397,7 +1636,7 @@ static int yaffs_do_sync_fs(struct super
1276         }
1277         return 0;
1278  }
1279 -**/
1280 +
1281
1282  #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
1283  static void yaffs_write_super(struct super_block *sb)
1284 @@ -1407,8 +1646,10 @@ static int yaffs_write_super(struct supe
1285  {
1286
1287         T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_write_super\n"));
1288 +       if (yaffs_auto_checkpoint >= 2)
1289 +               yaffs_do_sync_fs(sb);
1290  #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,18))
1291 -       return 0; /* yaffs_do_sync_fs(sb);*/
1292 +       return 0;
1293  #endif
1294  }
1295
1296 @@ -1422,10 +1663,48 @@ static int yaffs_sync_fs(struct super_bl
1297
1298         T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_sync_fs\n"));
1299
1300 -       return 0; /* yaffs_do_sync_fs(sb);*/
1301 +       if (yaffs_auto_checkpoint >= 1)
1302 +               yaffs_do_sync_fs(sb);
1303 +
1304 +       return 0;
1305
1306  }
1307
1308 +#ifdef YAFFS_USE_OWN_IGET
1309 +
1310 +static struct inode * yaffs_iget(struct super_block *sb, unsigned long ino)
1311 +{
1312 +       struct inode *inode;
1313 +       yaffs_Object *obj;
1314 +       yaffs_Device *dev = yaffs_SuperToDevice(sb);
1315 +
1316 +       T(YAFFS_TRACE_OS,
1317 +         (KERN_DEBUG "yaffs_iget for %lu\n", ino));
1318 +
1319 +       inode = iget_locked(sb, ino);
1320 +       if (!inode)
1321 +               return ERR_PTR(-ENOMEM);
1322 +       if (!(inode->i_state & I_NEW))
1323 +               return inode;
1324 +
1325 +       /* NB This is called as a side effect of other functions, but
1326 +       * we had to release the lock to prevent deadlocks, so
1327 +       * need to lock again.
1328 +       */
1329 +
1330 +       yaffs_GrossLock(dev);
1331 +
1332 +       obj = yaffs_FindObjectByNumber(dev, inode->i_ino);
1333 +
1334 +       yaffs_FillInodeFromObject(inode, obj);
1335 +
1336 +       yaffs_GrossUnlock(dev);
1337 +
1338 +       unlock_new_inode(inode);
1339 +       return inode;
1340 +}
1341 +
1342 +#else
1343
1344  static void yaffs_read_inode(struct inode *inode)
1345  {
1346 @@ -1449,7 +1728,9 @@ static void yaffs_read_inode(struct inod
1347         yaffs_GrossUnlock(dev);
1348  }
1349
1350 -static LIST_HEAD(yaffs_dev_list);
1351 +#endif
1352 +
1353 +static YLIST_HEAD(yaffs_dev_list);
1354
1355  #if 0 // not used
1356  static int yaffs_remount_fs(struct super_block *sb, int *flags, char *data)
1357 @@ -1503,7 +1784,7 @@ static void yaffs_put_super(struct super
1358         yaffs_GrossUnlock(dev);
1359
1360         /* we assume this is protected by lock_kernel() in mount/umount */
1361 -       list_del(&dev->devList);
1362 +       ylist_del(&dev->devList);
1363
1364         if(dev->spareBuffer){
1365                 YFREE(dev->spareBuffer);
1366 @@ -1532,8 +1813,8 @@ static void yaffs_MarkSuperBlockDirty(vo
1367         struct super_block *sb = (struct super_block *)vsb;
1368
1369         T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_MarkSuperBlockDirty() sb = %p\n",sb));
1370 -//     if(sb)
1371 -//             sb->s_dirt = 1;
1372 +       if(sb)
1373 +               sb->s_dirt = 1;
1374  }
1375
1376  typedef struct {
1377 @@ -1602,6 +1883,7 @@ static struct super_block *yaffs_interna
1378
1379         sb->s_magic = YAFFS_MAGIC;
1380         sb->s_op = &yaffs_super_ops;
1381 +       sb->s_flags |= MS_NOATIME;
1382
1383         if (!sb)
1384                 printk(KERN_INFO "yaffs: sb is NULL\n");
1385 @@ -1678,22 +1960,15 @@ static struct super_block *yaffs_interna
1386  #ifdef CONFIG_YAFFS_AUTO_YAFFS2
1387
1388         if (yaffsVersion == 1 &&
1389 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
1390 -           mtd->writesize >= 2048) {
1391 -#else
1392 -           mtd->oobblock >= 2048) {
1393 -#endif
1394 +           WRITE_SIZE(mtd) >= 2048) {
1395             T(YAFFS_TRACE_ALWAYS,("yaffs: auto selecting yaffs2\n"));
1396             yaffsVersion = 2;
1397         }
1398
1399         /* Added NCB 26/5/2006 for completeness */
1400 -       if (yaffsVersion == 2 &&
1401 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
1402 -           mtd->writesize == 512) {
1403 -#else
1404 -           mtd->oobblock == 512) {
1405 -#endif
1406 +       if (yaffsVersion == 2 &&
1407 +           !options.inband_tags &&
1408 +           WRITE_SIZE(mtd) == 512){
1409             T(YAFFS_TRACE_ALWAYS,("yaffs: auto selecting yaffs1\n"));
1410             yaffsVersion = 1;
1411         }
1412 @@ -1719,12 +1994,9 @@ static struct super_block *yaffs_interna
1413                         return NULL;
1414                 }
1415
1416 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
1417 -               if (mtd->writesize < YAFFS_MIN_YAFFS2_CHUNK_SIZE ||
1418 -#else
1419 -               if (mtd->oobblock < YAFFS_MIN_YAFFS2_CHUNK_SIZE ||
1420 -#endif
1421 -                   mtd->oobsize < YAFFS_MIN_YAFFS2_SPARE_SIZE) {
1422 +               if ((WRITE_SIZE(mtd) < YAFFS_MIN_YAFFS2_CHUNK_SIZE ||
1423 +                   mtd->oobsize < YAFFS_MIN_YAFFS2_SPARE_SIZE) &&
1424 +                   !options.inband_tags) {
1425                         T(YAFFS_TRACE_ALWAYS,
1426                           ("yaffs: MTD device does not have the "
1427                            "right page sizes\n"));
1428 @@ -1784,9 +2056,10 @@ static struct super_block *yaffs_interna
1429         dev->startBlock = 0;
1430         dev->endBlock = nBlocks - 1;
1431         dev->nChunksPerBlock = YAFFS_CHUNKS_PER_BLOCK;
1432 -       dev->nDataBytesPerChunk = YAFFS_BYTES_PER_CHUNK;
1433 +       dev->totalBytesPerChunk = YAFFS_BYTES_PER_CHUNK;
1434         dev->nReservedBlocks = 5;
1435         dev->nShortOpCaches = (options.no_cache) ? 0 : 10;
1436 +       dev->inbandTags = options.inband_tags;
1437
1438         /* ... and the functions. */
1439         if (yaffsVersion == 2) {
1440 @@ -1799,15 +2072,14 @@ static struct super_block *yaffs_interna
1441                 dev->spareBuffer = YMALLOC(mtd->oobsize);
1442                 dev->isYaffs2 = 1;
1443  #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
1444 -               dev->nDataBytesPerChunk = mtd->writesize;
1445 +               dev->totalBytesPerChunk = mtd->writesize;
1446                 dev->nChunksPerBlock = mtd->erasesize / mtd->writesize;
1447  #else
1448 -               dev->nDataBytesPerChunk = mtd->oobblock;
1449 +               dev->totalBytesPerChunk = mtd->oobblock;
1450                 dev->nChunksPerBlock = mtd->erasesize / mtd->oobblock;
1451  #endif
1452                 nBlocks = mtd->size / mtd->erasesize;
1453
1454 -               dev->nCheckpointReservedBlocks = CONFIG_YAFFS_CHECKPOINT_RESERVED_BLOCKS;
1455                 dev->startBlock = 0;
1456                 dev->endBlock = nBlocks - 1;
1457         } else {
1458 @@ -1847,7 +2119,7 @@ static struct super_block *yaffs_interna
1459         dev->skipCheckpointWrite = options.skip_checkpoint_write;
1460
1461         /* we assume this is protected by lock_kernel() in mount/umount */
1462 -       list_add_tail(&dev->devList, &yaffs_dev_list);
1463 +       ylist_add_tail(&dev->devList, &yaffs_dev_list);
1464
1465         init_MUTEX(&dev->grossLock);
1466
1467 @@ -1884,6 +2156,9 @@ static struct super_block *yaffs_interna
1468                 return NULL;
1469         }
1470         sb->s_root = root;
1471 +       sb->s_dirt = !dev->isCheckpointed;
1472 +       T(YAFFS_TRACE_ALWAYS,
1473 +         ("yaffs_read_super: isCheckpointed %d\n", dev->isCheckpointed));
1474
1475         T(YAFFS_TRACE_OS, ("yaffs_read_super: done\n"));
1476         return sb;
1477 @@ -1990,12 +2265,12 @@ static char *yaffs_dump_dev(char *buf, y
1478  {
1479         buf += sprintf(buf, "startBlock......... %d\n", dev->startBlock);
1480         buf += sprintf(buf, "endBlock........... %d\n", dev->endBlock);
1481 +       buf += sprintf(buf, "totalBytesPerChunk. %d\n", dev->totalBytesPerChunk);
1482         buf += sprintf(buf, "nDataBytesPerChunk. %d\n", dev->nDataBytesPerChunk);
1483         buf += sprintf(buf, "chunkGroupBits..... %d\n", dev->chunkGroupBits);
1484         buf += sprintf(buf, "chunkGroupSize..... %d\n", dev->chunkGroupSize);
1485         buf += sprintf(buf, "nErasedBlocks...... %d\n", dev->nErasedBlocks);
1486         buf += sprintf(buf, "nReservedBlocks.... %d\n", dev->nReservedBlocks);
1487 -       buf += sprintf(buf, "nCheckptResBlocks.. %d\n", dev->nCheckpointReservedBlocks);
1488         buf += sprintf(buf, "blocksInCheckpoint. %d\n", dev->blocksInCheckpoint);
1489         buf += sprintf(buf, "nTnodesCreated..... %d\n", dev->nTnodesCreated);
1490         buf += sprintf(buf, "nFreeTnodes........ %d\n", dev->nFreeTnodes);
1491 @@ -2006,10 +2281,8 @@ static char *yaffs_dump_dev(char *buf, y
1492         buf += sprintf(buf, "nPageReads......... %d\n", dev->nPageReads);
1493         buf += sprintf(buf, "nBlockErasures..... %d\n", dev->nBlockErasures);
1494         buf += sprintf(buf, "nGCCopies.......... %d\n", dev->nGCCopies);
1495 -       buf +=
1496 -           sprintf(buf, "garbageCollections. %d\n", dev->garbageCollections);
1497 -       buf +=
1498 -           sprintf(buf, "passiveGCs......... %d\n",
1499 +       buf += sprintf(buf, "garbageCollections. %d\n", dev->garbageCollections);
1500 +       buf += sprintf(buf, "passiveGCs......... %d\n",
1501                     dev->passiveGarbageCollections);
1502         buf += sprintf(buf, "nRetriedWrites..... %d\n", dev->nRetriedWrites);
1503         buf += sprintf(buf, "nShortOpCaches..... %d\n", dev->nShortOpCaches);
1504 @@ -2025,6 +2298,7 @@ static char *yaffs_dump_dev(char *buf, y
1505             sprintf(buf, "nBackgroudDeletions %d\n", dev->nBackgroundDeletions);
1506         buf += sprintf(buf, "useNANDECC......... %d\n", dev->useNANDECC);
1507         buf += sprintf(buf, "isYaffs2........... %d\n", dev->isYaffs2);
1508 +       buf += sprintf(buf, "inbandTags......... %d\n", dev->inbandTags);
1509
1510         return buf;
1511  }
1512 @@ -2033,7 +2307,7 @@ static int yaffs_proc_read(char *page,
1513                            char **start,
1514                            off_t offset, int count, int *eof, void *data)
1515  {
1516 -       struct list_head *item;
1517 +       struct ylist_head *item;
1518         char *buf = page;
1519         int step = offset;
1520         int n = 0;
1521 @@ -2057,8 +2331,8 @@ static int yaffs_proc_read(char *page,
1522         lock_kernel();
1523
1524         /* Locate and print the Nth entry.  Order N-squared but N is small. */
1525 -       list_for_each(item, &yaffs_dev_list) {
1526 -               yaffs_Device *dev = list_entry(item, yaffs_Device, devList);
1527 +       ylist_for_each(item, &yaffs_dev_list) {
1528 +               yaffs_Device *dev = ylist_entry(item, yaffs_Device, devList);
1529                 if (n < step) {
1530                         n++;
1531                         continue;
1532 @@ -2231,7 +2505,7 @@ static int __init init_yaffs_fs(void)
1533         /* Install the proc_fs entry */
1534         my_proc_entry = create_proc_entry("yaffs",
1535                                                S_IRUGO | S_IFREG,
1536 -                                              &proc_root);
1537 +                                              YPROC_ROOT);
1538
1539         if (my_proc_entry) {
1540                 my_proc_entry->write_proc = yaffs_proc_write;
1541 @@ -2277,7 +2551,7 @@ static void __exit exit_yaffs_fs(void)
1542         T(YAFFS_TRACE_ALWAYS, ("yaffs " __DATE__ " " __TIME__
1543                                " removing. \n"));
1544
1545 -       remove_proc_entry("yaffs", &proc_root);
1546 +       remove_proc_entry("yaffs", YPROC_ROOT);
1547
1548         fsinst = fs_to_install;
1549
1550 --- /dev/null
1551 +++ b/fs/yaffs2/yaffs_getblockinfo.h
1552 @@ -0,0 +1,34 @@
1553 +/*
1554 + * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
1555 + *
1556 + * Copyright (C) 2002-2007 Aleph One Ltd.
1557 + *   for Toby Churchill Ltd and Brightstar Engineering
1558 + *
1559 + * Created by Charles Manning <charles@aleph1.co.uk>
1560 + *
1561 + * This program is free software; you can redistribute it and/or modify
1562 + * it under the terms of the GNU Lesser General Public License version 2.1 as
1563 + * published by the Free Software Foundation.
1564 + *
1565 + * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL.
1566 + */
1567 +
1568 +#ifndef __YAFFS_GETBLOCKINFO_H__
1569 +#define __YAFFS_GETBLOCKINFO_H__
1570 +
1571 +#include "yaffs_guts.h"
1572 +
1573 +/* Function to manipulate block info */
1574 +static Y_INLINE yaffs_BlockInfo *yaffs_GetBlockInfo(yaffs_Device * dev, int blk)
1575 +{
1576 +       if (blk < dev->internalStartBlock || blk > dev->internalEndBlock) {
1577 +               T(YAFFS_TRACE_ERROR,
1578 +                 (TSTR
1579 +                  ("**>> yaffs: getBlockInfo block %d is not valid" TENDSTR),
1580 +                  blk));
1581 +               YBUG();
1582 +       }
1583 +       return &dev->blockInfo[blk - dev->internalStartBlock];
1584 +}
1585 +
1586 +#endif
1587 --- a/fs/yaffs2/yaffs_nand.c
1588 +++ b/fs/yaffs2/yaffs_nand.c
1589 @@ -12,12 +12,13 @@
1590   */
1591
1592  const char *yaffs_nand_c_version =
1593 -    "$Id: yaffs_nand.c,v 1.7 2007-02-14 01:09:06 wookey Exp $";
1594 +    "$Id: yaffs_nand.c,v 1.9 2008-05-05 07:58:58 charles Exp $";
1595
1596  #include "yaffs_nand.h"
1597  #include "yaffs_tagscompat.h"
1598  #include "yaffs_tagsvalidity.h"
1599
1600 +#include "yaffs_getblockinfo.h"
1601
1602  int yaffs_ReadChunkWithTagsFromNAND(yaffs_Device * dev, int chunkInNAND,
1603                                            __u8 * buffer,
1604 @@ -98,7 +99,7 @@ int yaffs_MarkBlockBad(yaffs_Device * de
1605  int yaffs_QueryInitialBlockState(yaffs_Device * dev,
1606                                                  int blockNo,
1607                                                  yaffs_BlockState * state,
1608 -                                                unsigned *sequenceNumber)
1609 +                                                __u32 *sequenceNumber)
1610  {
1611         blockNo -= dev->blockOffset;
1612
1613 --- a/fs/yaffs2/yaffs_guts.c
1614 +++ b/fs/yaffs2/yaffs_guts.c
1615 @@ -11,14 +11,16 @@
1616   * published by the Free Software Foundation.
1617   */
1618
1619 +
1620  const char *yaffs_guts_c_version =
1621 -    "$Id: yaffs_guts.c,v 1.49 2007-05-15 20:07:40 charles Exp $";
1622 +    "$Id: yaffs_guts.c,v 1.76 2009-01-23 06:36:49 charles Exp $";
1623
1624  #include "yportenv.h"
1625
1626  #include "yaffsinterface.h"
1627  #include "yaffs_guts.h"
1628  #include "yaffs_tagsvalidity.h"
1629 +#include "yaffs_getblockinfo.h"
1630
1631  #include "yaffs_tagscompat.h"
1632  #ifndef  CONFIG_YAFFS_USE_OWN_SORT
1633 @@ -32,11 +34,6 @@ const char *yaffs_guts_c_version =
1634  #include "yaffs_packedtags2.h"
1635
1636
1637 -#ifdef CONFIG_YAFFS_WINCE
1638 -void yfsd_LockYAFFS(BOOL fsLockOnly);
1639 -void yfsd_UnlockYAFFS(BOOL fsLockOnly);
1640 -#endif
1641 -
1642  #define YAFFS_PASSIVE_GC_CHUNKS 2
1643
1644  #include "yaffs_ecc.h"
1645 @@ -78,9 +75,6 @@ static int yaffs_DoGenericObjectDeletion
1646
1647  static yaffs_BlockInfo *yaffs_GetBlockInfo(yaffs_Device * dev, int blockNo);
1648
1649 -static __u8 *yaffs_GetTempBuffer(yaffs_Device * dev, int lineNo);
1650 -static void yaffs_ReleaseTempBuffer(yaffs_Device * dev, __u8 * buffer,
1651 -                                   int lineNo);
1652
1653  static int yaffs_CheckChunkErased(struct yaffs_DeviceStruct *dev,
1654                                   int chunkInNAND);
1655 @@ -99,6 +93,7 @@ static void yaffs_VerifyFreeChunks(yaffs
1656
1657  static void yaffs_CheckObjectDetailsLoaded(yaffs_Object *in);
1658
1659 +static void yaffs_VerifyDirectory(yaffs_Object *directory);
1660  #ifdef YAFFS_PARANOID
1661  static int yaffs_CheckFileSanity(yaffs_Object * in);
1662  #else
1663 @@ -121,95 +116,109 @@ static yaffs_Tnode *yaffs_FindLevel0Tnod
1664
1665  /* Function to calculate chunk and offset */
1666
1667 -static void yaffs_AddrToChunk(yaffs_Device *dev, loff_t addr, __u32 *chunk, __u32 *offset)
1668 +static void yaffs_AddrToChunk(yaffs_Device *dev, loff_t addr, int *chunkOut, __u32 *offsetOut)
1669  {
1670 -       if(dev->chunkShift){
1671 -               /* Easy-peasy power of 2 case */
1672 -               *chunk  = (__u32)(addr >> dev->chunkShift);
1673 -               *offset = (__u32)(addr & dev->chunkMask);
1674 -       }
1675 -       else if(dev->crumbsPerChunk)
1676 +       int chunk;
1677 +       __u32 offset;
1678 +
1679 +       chunk  = (__u32)(addr >> dev->chunkShift);
1680 +
1681 +       if(dev->chunkDiv == 1)
1682         {
1683 -               /* Case where we're using "crumbs" */
1684 -               *offset = (__u32)(addr & dev->crumbMask);
1685 -               addr >>= dev->crumbShift;
1686 -               *chunk = ((__u32)addr)/dev->crumbsPerChunk;
1687 -               *offset += ((addr - (*chunk * dev->crumbsPerChunk)) << dev->crumbShift);
1688 +               /* easy power of 2 case */
1689 +               offset = (__u32)(addr & dev->chunkMask);
1690         }
1691         else
1692 -               YBUG();
1693 +       {
1694 +               /* Non power-of-2 case */
1695 +
1696 +               loff_t chunkBase;
1697 +
1698 +               chunk /= dev->chunkDiv;
1699 +
1700 +               chunkBase = ((loff_t)chunk) * dev->nDataBytesPerChunk;
1701 +               offset = (__u32)(addr - chunkBase);
1702 +       }
1703 +
1704 +       *chunkOut = chunk;
1705 +       *offsetOut = offset;
1706  }
1707
1708 -/* Function to return the number of shifts for a power of 2 greater than or equal
1709 +/* Function to return the number of shifts for a power of 2 greater than or equal
1710   * to the given number
1711   * Note we don't try to cater for all possible numbers and this does not have to
1712   * be hellishly efficient.
1713   */
1714 -
1715 +
1716  static __u32 ShiftsGE(__u32 x)
1717  {
1718         int extraBits;
1719         int nShifts;
1720 -
1721 +
1722         nShifts = extraBits = 0;
1723 -
1724 +
1725         while(x>1){
1726                 if(x & 1) extraBits++;
1727                 x>>=1;
1728                 nShifts++;
1729         }
1730
1731 -       if(extraBits)
1732 +       if(extraBits)
1733                 nShifts++;
1734 -
1735 +
1736         return nShifts;
1737  }
1738
1739  /* Function to return the number of shifts to get a 1 in bit 0
1740   */
1741 -
1742 -static __u32 ShiftDiv(__u32 x)
1743 +
1744 +static __u32 Shifts(__u32 x)
1745  {
1746         int nShifts;
1747 -
1748 +
1749         nShifts =  0;
1750 -
1751 +
1752         if(!x) return 0;
1753 -
1754 +
1755         while( !(x&1)){
1756                 x>>=1;
1757                 nShifts++;
1758         }
1759 -
1760 +
1761         return nShifts;
1762  }
1763
1764
1765
1766 -/*
1767 +/*
1768   * Temporary buffer manipulations.
1769   */
1770
1771 -static int yaffs_InitialiseTempBuffers(yaffs_Device *dev)
1772 +static int yaffs_InitialiseTempBuffers(yaffs_Device *dev)
1773  {
1774         int i;
1775         __u8 *buf = (__u8 *)1;
1776 -
1777 +
1778         memset(dev->tempBuffer,0,sizeof(dev->tempBuffer));
1779 -
1780 +
1781         for (i = 0; buf && i < YAFFS_N_TEMP_BUFFERS; i++) {
1782                 dev->tempBuffer[i].line = 0;    /* not in use */
1783                 dev->tempBuffer[i].buffer = buf =
1784 -                   YMALLOC_DMA(dev->nDataBytesPerChunk);
1785 +                   YMALLOC_DMA(dev->totalBytesPerChunk);
1786         }
1787 -
1788 +
1789         return buf ? YAFFS_OK : YAFFS_FAIL;
1790 -
1791 +
1792  }
1793
1794 -static __u8 *yaffs_GetTempBuffer(yaffs_Device * dev, int lineNo)
1795 +__u8 *yaffs_GetTempBuffer(yaffs_Device * dev, int lineNo)
1796  {
1797         int i, j;
1798 +
1799 +       dev->tempInUse++;
1800 +       if(dev->tempInUse > dev->maxTemp)
1801 +               dev->maxTemp = dev->tempInUse;
1802 +
1803         for (i = 0; i < YAFFS_N_TEMP_BUFFERS; i++) {
1804                 if (dev->tempBuffer[i].line == 0) {
1805                         dev->tempBuffer[i].line = lineNo;
1806 @@ -242,10 +251,13 @@ static __u8 *yaffs_GetTempBuffer(yaffs_D
1807
1808  }
1809
1810 -static void yaffs_ReleaseTempBuffer(yaffs_Device * dev, __u8 * buffer,
1811 +void yaffs_ReleaseTempBuffer(yaffs_Device * dev, __u8 * buffer,
1812                                     int lineNo)
1813  {
1814         int i;
1815 +
1816 +       dev->tempInUse--;
1817 +
1818         for (i = 0; i < YAFFS_N_TEMP_BUFFERS; i++) {
1819                 if (dev->tempBuffer[i].buffer == buffer) {
1820                         dev->tempBuffer[i].line = 0;
1821 @@ -337,7 +349,7 @@ static Y_INLINE void yaffs_ClearChunkBit
1822  static Y_INLINE void yaffs_SetChunkBit(yaffs_Device * dev, int blk, int chunk)
1823  {
1824         __u8 *blkBits = yaffs_BlockBits(dev, blk);
1825 -
1826 +
1827         yaffs_VerifyChunkBitId(dev,blk,chunk);
1828
1829         blkBits[chunk / 8] |= (1 << (chunk & 7));
1830 @@ -375,16 +387,16 @@ static int yaffs_CountChunkBits(yaffs_De
1831                                 n++;
1832                         x >>=1;
1833                 }
1834 -
1835 +
1836                 blkBits++;
1837         }
1838         return n;
1839  }
1840
1841 -/*
1842 +/*
1843   * Verification code
1844   */
1845 -
1846 +
1847  static int yaffs_SkipVerification(yaffs_Device *dev)
1848  {
1849         return !(yaffs_traceMask & (YAFFS_TRACE_VERIFY | YAFFS_TRACE_VERIFY_FULL));
1850 @@ -417,14 +429,14 @@ static void yaffs_VerifyBlock(yaffs_Devi
1851  {
1852         int actuallyUsed;
1853         int inUse;
1854 -
1855 +
1856         if(yaffs_SkipVerification(dev))
1857                 return;
1858 -
1859 +
1860         /* Report illegal runtime states */
1861 -       if(bi->blockState <0 || bi->blockState >= YAFFS_NUMBER_OF_BLOCK_STATES)
1862 +       if(bi->blockState >= YAFFS_NUMBER_OF_BLOCK_STATES)
1863                 T(YAFFS_TRACE_VERIFY,(TSTR("Block %d has undefined state %d"TENDSTR),n,bi->blockState));
1864 -
1865 +
1866         switch(bi->blockState){
1867          case YAFFS_BLOCK_STATE_UNKNOWN:
1868          case YAFFS_BLOCK_STATE_SCANNING:
1869 @@ -432,43 +444,44 @@ static void yaffs_VerifyBlock(yaffs_Devi
1870                 T(YAFFS_TRACE_VERIFY,(TSTR("Block %d has bad run-state %s"TENDSTR),
1871                 n,blockStateName[bi->blockState]));
1872         }
1873 -
1874 +
1875         /* Check pages in use and soft deletions are legal */
1876 -
1877 +
1878         actuallyUsed = bi->pagesInUse - bi->softDeletions;
1879 -
1880 +
1881         if(bi->pagesInUse < 0 || bi->pagesInUse > dev->nChunksPerBlock ||
1882            bi->softDeletions < 0 || bi->softDeletions > dev->nChunksPerBlock ||
1883            actuallyUsed < 0 || actuallyUsed > dev->nChunksPerBlock)
1884                 T(YAFFS_TRACE_VERIFY,(TSTR("Block %d has illegal values pagesInUsed %d softDeletions %d"TENDSTR),
1885                 n,bi->pagesInUse,bi->softDeletions));
1886 -
1887 -
1888 +
1889 +
1890         /* Check chunk bitmap legal */
1891         inUse = yaffs_CountChunkBits(dev,n);
1892         if(inUse != bi->pagesInUse)
1893                 T(YAFFS_TRACE_VERIFY,(TSTR("Block %d has inconsistent values pagesInUse %d counted chunk bits %d"TENDSTR),
1894                         n,bi->pagesInUse,inUse));
1895 -
1896 +
1897         /* Check that the sequence number is valid.
1898 -        * Ten million is legal, but is very unlikely
1899 +        * Ten million is legal, but is very unlikely
1900          */
1901 -       if(dev->isYaffs2 &&
1902 +       if(dev->isYaffs2 &&
1903            (bi->blockState == YAFFS_BLOCK_STATE_ALLOCATING || bi->blockState == YAFFS_BLOCK_STATE_FULL) &&
1904            (bi->sequenceNumber < YAFFS_LOWEST_SEQUENCE_NUMBER || bi->sequenceNumber > 10000000 ))
1905                 T(YAFFS_TRACE_VERIFY,(TSTR("Block %d has suspect sequence number of %d"TENDSTR),
1906                 n,bi->sequenceNumber));
1907 -
1908 +
1909  }
1910
1911  static void yaffs_VerifyCollectedBlock(yaffs_Device *dev,yaffs_BlockInfo *bi,int n)
1912  {
1913         yaffs_VerifyBlock(dev,bi,n);
1914 -
1915 +
1916         /* After collection the block should be in the erased state */
1917 -       /* TODO: This will need to change if we do partial gc */
1918 -
1919 -       if(bi->blockState != YAFFS_BLOCK_STATE_EMPTY){
1920 +       /* This will need to change if we do partial gc */
1921 +
1922 +       if(bi->blockState != YAFFS_BLOCK_STATE_COLLECTING &&
1923 +          bi->blockState != YAFFS_BLOCK_STATE_EMPTY){
1924                 T(YAFFS_TRACE_ERROR,(TSTR("Block %d is in state %d after gc, should be erased"TENDSTR),
1925                         n,bi->blockState));
1926         }
1927 @@ -479,28 +492,28 @@ static void yaffs_VerifyBlocks(yaffs_Dev
1928         int i;
1929         int nBlocksPerState[YAFFS_NUMBER_OF_BLOCK_STATES];
1930         int nIllegalBlockStates = 0;
1931 -
1932 +
1933
1934         if(yaffs_SkipVerification(dev))
1935                 return;
1936
1937         memset(nBlocksPerState,0,sizeof(nBlocksPerState));
1938
1939 -
1940 +
1941         for(i = dev->internalStartBlock; i <= dev->internalEndBlock; i++){
1942                 yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev,i);
1943                 yaffs_VerifyBlock(dev,bi,i);
1944
1945 -               if(bi->blockState >=0 && bi->blockState < YAFFS_NUMBER_OF_BLOCK_STATES)
1946 +               if(bi->blockState < YAFFS_NUMBER_OF_BLOCK_STATES)
1947                         nBlocksPerState[bi->blockState]++;
1948                 else
1949                         nIllegalBlockStates++;
1950 -
1951 +
1952         }
1953 -
1954 +
1955         T(YAFFS_TRACE_VERIFY,(TSTR(""TENDSTR)));
1956         T(YAFFS_TRACE_VERIFY,(TSTR("Block summary"TENDSTR)));
1957 -
1958 +
1959         T(YAFFS_TRACE_VERIFY,(TSTR("%d blocks have illegal states"TENDSTR),nIllegalBlockStates));
1960         if(nBlocksPerState[YAFFS_BLOCK_STATE_ALLOCATING] > 1)
1961                 T(YAFFS_TRACE_VERIFY,(TSTR("Too many allocating blocks"TENDSTR)));
1962 @@ -509,17 +522,17 @@ static void yaffs_VerifyBlocks(yaffs_Dev
1963                 T(YAFFS_TRACE_VERIFY,
1964                   (TSTR("%s %d blocks"TENDSTR),
1965                   blockStateName[i],nBlocksPerState[i]));
1966 -
1967 +
1968         if(dev->blocksInCheckpoint != nBlocksPerState[YAFFS_BLOCK_STATE_CHECKPOINT])
1969                 T(YAFFS_TRACE_VERIFY,
1970                  (TSTR("Checkpoint block count wrong dev %d count %d"TENDSTR),
1971                  dev->blocksInCheckpoint, nBlocksPerState[YAFFS_BLOCK_STATE_CHECKPOINT]));
1972 -
1973 +
1974         if(dev->nErasedBlocks != nBlocksPerState[YAFFS_BLOCK_STATE_EMPTY])
1975                 T(YAFFS_TRACE_VERIFY,
1976                  (TSTR("Erased block count wrong dev %d count %d"TENDSTR),
1977                  dev->nErasedBlocks, nBlocksPerState[YAFFS_BLOCK_STATE_EMPTY]));
1978 -
1979 +
1980         if(nBlocksPerState[YAFFS_BLOCK_STATE_COLLECTING] > 1)
1981                 T(YAFFS_TRACE_VERIFY,
1982                  (TSTR("Too many collecting blocks %d (max is 1)"TENDSTR),
1983 @@ -535,16 +548,16 @@ static void yaffs_VerifyBlocks(yaffs_Dev
1984   */
1985  static void yaffs_VerifyObjectHeader(yaffs_Object *obj, yaffs_ObjectHeader *oh, yaffs_ExtendedTags *tags, int parentCheck)
1986  {
1987 -       if(yaffs_SkipVerification(obj->myDev))
1988 +       if(obj && yaffs_SkipVerification(obj->myDev))
1989                 return;
1990 -
1991 +
1992         if(!(tags && obj && oh)){
1993                 T(YAFFS_TRACE_VERIFY,
1994                                 (TSTR("Verifying object header tags %x obj %x oh %x"TENDSTR),
1995                                 (__u32)tags,(__u32)obj,(__u32)oh));
1996                 return;
1997         }
1998 -
1999 +
2000         if(oh->type <= YAFFS_OBJECT_TYPE_UNKNOWN ||
2001            oh->type > YAFFS_OBJECT_TYPE_MAX)
2002                 T(YAFFS_TRACE_VERIFY,
2003 @@ -559,25 +572,25 @@ static void yaffs_VerifyObjectHeader(yaf
2004
2005         /*
2006          * Check that the object's parent ids match if parentCheck requested.
2007 -        *
2008 +        *
2009          * Tests do not apply to the root object.
2010          */
2011 -
2012 +
2013         if(parentCheck && tags->objectId > 1 && !obj->parent)
2014                 T(YAFFS_TRACE_VERIFY,
2015                  (TSTR("Obj %d header mismatch parentId %d obj->parent is NULL"TENDSTR),
2016                  tags->objectId, oh->parentObjectId));
2017 -
2018 -
2019 +
2020 +
2021         if(parentCheck && obj->parent &&
2022 -          oh->parentObjectId != obj->parent->objectId &&
2023 +          oh->parentObjectId != obj->parent->objectId &&
2024            (oh->parentObjectId != YAFFS_OBJECTID_UNLINKED ||
2025             obj->parent->objectId != YAFFS_OBJECTID_DELETED))
2026                 T(YAFFS_TRACE_VERIFY,
2027                  (TSTR("Obj %d header mismatch parentId %d parentObjectId %d"TENDSTR),
2028                  tags->objectId, oh->parentObjectId, obj->parent->objectId));
2029 -
2030 -
2031 +
2032 +
2033         if(tags->objectId > 1 && oh->name[0] == 0) /* Null name */
2034                 T(YAFFS_TRACE_VERIFY,
2035                 (TSTR("Obj %d header name is NULL"TENDSTR),
2036 @@ -597,7 +610,6 @@ static int yaffs_VerifyTnodeWorker(yaffs
2037         int i;
2038         yaffs_Device *dev = obj->myDev;
2039         int ok = 1;
2040 -       int nTnodeBytes = (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8;
2041
2042         if (tn) {
2043                 if (level > 0) {
2044 @@ -611,15 +623,14 @@ static int yaffs_VerifyTnodeWorker(yaffs
2045                                 }
2046                         }
2047                 } else if (level == 0) {
2048 -                       int i;
2049                         yaffs_ExtendedTags tags;
2050                         __u32 objectId = obj->objectId;
2051 -
2052 +
2053                         chunkOffset <<=  YAFFS_TNODES_LEVEL0_BITS;
2054 -
2055 +
2056                         for(i = 0; i < YAFFS_NTNODES_LEVEL0; i++){
2057                                 __u32 theChunk = yaffs_GetChunkGroupBase(dev,tn,i);
2058 -
2059 +
2060                                 if(theChunk > 0){
2061                                         /* T(~0,(TSTR("verifying (%d:%d) %d"TENDSTR),tags.objectId,tags.chunkId,theChunk)); */
2062                                         yaffs_ReadChunkWithTagsFromNAND(dev,theChunk,NULL, &tags);
2063 @@ -646,18 +657,20 @@ static void yaffs_VerifyFile(yaffs_Objec
2064         __u32 lastChunk;
2065         __u32 x;
2066         __u32 i;
2067 -       int ok;
2068         yaffs_Device *dev;
2069         yaffs_ExtendedTags tags;
2070         yaffs_Tnode *tn;
2071         __u32 objectId;
2072 -
2073 -       if(obj && yaffs_SkipVerification(obj->myDev))
2074 +
2075 +       if(!obj)
2076                 return;
2077
2078 +       if(yaffs_SkipVerification(obj->myDev))
2079 +               return;
2080 +
2081         dev = obj->myDev;
2082         objectId = obj->objectId;
2083 -
2084 +
2085         /* Check file size is consistent with tnode depth */
2086         lastChunk =  obj->variant.fileVariant.fileSize / dev->nDataBytesPerChunk + 1;
2087         x = lastChunk >> YAFFS_TNODES_LEVEL0_BITS;
2088 @@ -666,23 +679,23 @@ static void yaffs_VerifyFile(yaffs_Objec
2089                 x >>= YAFFS_TNODES_INTERNAL_BITS;
2090                 requiredTallness++;
2091         }
2092 -
2093 +
2094         actualTallness = obj->variant.fileVariant.topLevel;
2095 -
2096 +
2097         if(requiredTallness > actualTallness )
2098                 T(YAFFS_TRACE_VERIFY,
2099                 (TSTR("Obj %d had tnode tallness %d, needs to be %d"TENDSTR),
2100                  obj->objectId,actualTallness, requiredTallness));
2101 -
2102 -
2103 -       /* Check that the chunks in the tnode tree are all correct.
2104 +
2105 +
2106 +       /* Check that the chunks in the tnode tree are all correct.
2107          * We do this by scanning through the tnode tree and
2108          * checking the tags for every chunk match.
2109          */
2110
2111         if(yaffs_SkipNANDVerification(dev))
2112                 return;
2113 -
2114 +
2115         for(i = 1; i <= lastChunk; i++){
2116                 tn = yaffs_FindLevel0Tnode(dev, &obj->variant.fileVariant,i);
2117
2118 @@ -703,18 +716,12 @@ static void yaffs_VerifyFile(yaffs_Objec
2119
2120  }
2121
2122 -static void yaffs_VerifyDirectory(yaffs_Object *obj)
2123 -{
2124 -       if(obj && yaffs_SkipVerification(obj->myDev))
2125 -               return;
2126 -
2127 -}
2128
2129  static void yaffs_VerifyHardLink(yaffs_Object *obj)
2130  {
2131         if(obj && yaffs_SkipVerification(obj->myDev))
2132                 return;
2133 -
2134 +
2135         /* Verify sane equivalent object */
2136  }
2137
2138 @@ -722,7 +729,7 @@ static void yaffs_VerifySymlink(yaffs_Ob
2139  {
2140         if(obj && yaffs_SkipVerification(obj->myDev))
2141                 return;
2142 -
2143 +
2144         /* Verify symlink string */
2145  }
2146
2147 @@ -735,69 +742,77 @@ static void yaffs_VerifySpecial(yaffs_Ob
2148  static void yaffs_VerifyObject(yaffs_Object *obj)
2149  {
2150         yaffs_Device *dev;
2151 -
2152 +
2153         __u32 chunkMin;
2154         __u32 chunkMax;
2155 -
2156 +
2157         __u32 chunkIdOk;
2158 -       __u32 chunkIsLive;
2159 -
2160 +       __u32 chunkInRange;
2161 +       __u32 chunkShouldNotBeDeleted;
2162 +       __u32 chunkValid;
2163 +
2164         if(!obj)
2165                 return;
2166 -
2167 +
2168 +       if(obj->beingCreated)
2169 +               return;
2170 +
2171         dev = obj->myDev;
2172 -
2173 +
2174         if(yaffs_SkipVerification(dev))
2175                 return;
2176 -
2177 +
2178         /* Check sane object header chunk */
2179
2180         chunkMin = dev->internalStartBlock * dev->nChunksPerBlock;
2181         chunkMax = (dev->internalEndBlock+1) * dev->nChunksPerBlock - 1;
2182
2183 -       chunkIdOk = (obj->chunkId >= chunkMin && obj->chunkId <= chunkMax);
2184 -       chunkIsLive = chunkIdOk &&
2185 +       chunkInRange = (((unsigned)(obj->hdrChunk)) >= chunkMin && ((unsigned)(obj->hdrChunk)) <= chunkMax);
2186 +       chunkIdOk = chunkInRange || obj->hdrChunk == 0;
2187 +       chunkValid  =  chunkInRange &&
2188                         yaffs_CheckChunkBit(dev,
2189 -                                           obj->chunkId / dev->nChunksPerBlock,
2190 -                                           obj->chunkId % dev->nChunksPerBlock);
2191 +                                           obj->hdrChunk / dev->nChunksPerBlock,
2192 +                                           obj->hdrChunk % dev->nChunksPerBlock);
2193 +       chunkShouldNotBeDeleted = chunkInRange && !chunkValid;
2194 +
2195         if(!obj->fake &&
2196 -           (!chunkIdOk || !chunkIsLive)) {
2197 +           (!chunkIdOk || chunkShouldNotBeDeleted)) {
2198            T(YAFFS_TRACE_VERIFY,
2199            (TSTR("Obj %d has chunkId %d %s %s"TENDSTR),
2200 -          obj->objectId,obj->chunkId,
2201 +          obj->objectId,obj->hdrChunk,
2202            chunkIdOk ? "" : ",out of range",
2203 -          chunkIsLive || !chunkIdOk ? "" : ",marked as deleted"));
2204 +          chunkShouldNotBeDeleted ? ",marked as deleted" : ""));
2205         }
2206 -
2207 -       if(chunkIdOk && chunkIsLive &&!yaffs_SkipNANDVerification(dev)) {
2208 +
2209 +       if(chunkValid &&!yaffs_SkipNANDVerification(dev)) {
2210                 yaffs_ExtendedTags tags;
2211                 yaffs_ObjectHeader *oh;
2212                 __u8 *buffer = yaffs_GetTempBuffer(dev,__LINE__);
2213 -
2214 +
2215                 oh = (yaffs_ObjectHeader *)buffer;
2216
2217 -               yaffs_ReadChunkWithTagsFromNAND(dev, obj->chunkId,buffer, &tags);
2218 +               yaffs_ReadChunkWithTagsFromNAND(dev, obj->hdrChunk,buffer, &tags);
2219
2220                 yaffs_VerifyObjectHeader(obj,oh,&tags,1);
2221 -
2222 +
2223                 yaffs_ReleaseTempBuffer(dev,buffer,__LINE__);
2224         }
2225 -
2226 +
2227         /* Verify it has a parent */
2228         if(obj && !obj->fake &&
2229            (!obj->parent || obj->parent->myDev != dev)){
2230            T(YAFFS_TRACE_VERIFY,
2231            (TSTR("Obj %d has parent pointer %p which does not look like an object"TENDSTR),
2232 -          obj->objectId,obj->parent));
2233 +          obj->objectId,obj->parent));
2234         }
2235 -
2236 +
2237         /* Verify parent is a directory */
2238         if(obj->parent && obj->parent->variantType != YAFFS_OBJECT_TYPE_DIRECTORY){
2239            T(YAFFS_TRACE_VERIFY,
2240            (TSTR("Obj %d's parent is not a directory (type %d)"TENDSTR),
2241 -          obj->objectId,obj->parent->variantType));
2242 +          obj->objectId,obj->parent->variantType));
2243         }
2244 -
2245 +
2246         switch(obj->variantType){
2247         case YAFFS_OBJECT_TYPE_FILE:
2248                 yaffs_VerifyFile(obj);
2249 @@ -818,31 +833,31 @@ static void yaffs_VerifyObject(yaffs_Obj
2250         default:
2251                 T(YAFFS_TRACE_VERIFY,
2252                 (TSTR("Obj %d has illegaltype %d"TENDSTR),
2253 -               obj->objectId,obj->variantType));
2254 +               obj->objectId,obj->variantType));
2255                 break;
2256         }
2257 -
2258 -
2259 +
2260 +
2261  }
2262
2263  static void yaffs_VerifyObjects(yaffs_Device *dev)
2264  {
2265 -       yaffs_Object *obj;
2266 -       int i;
2267 -       struct list_head *lh;
2268 -
2269 -       if(yaffs_SkipVerification(dev))
2270 -               return;
2271 -
2272 -       /* Iterate through the objects in each hash entry */
2273 -
2274 -        for(i = 0; i <  YAFFS_NOBJECT_BUCKETS; i++){
2275 -               list_for_each(lh, &dev->objectBucket[i].list) {
2276 -                       if (lh) {
2277 -                               obj = list_entry(lh, yaffs_Object, hashLink);
2278 -                               yaffs_VerifyObject(obj);
2279 -                       }
2280 -               }
2281 +        yaffs_Object *obj;
2282 +        int i;
2283 +        struct ylist_head *lh;
2284 +
2285 +        if(yaffs_SkipVerification(dev))
2286 +                return;
2287 +
2288 +        /* Iterate through the objects in each hash entry */
2289 +
2290 +         for(i = 0; i <  YAFFS_NOBJECT_BUCKETS; i++){
2291 +                ylist_for_each(lh, &dev->objectBucket[i].list) {
2292 +                        if (lh) {
2293 +                                obj = ylist_entry(lh, yaffs_Object, hashLink);
2294 +                                yaffs_VerifyObject(obj);
2295 +                        }
2296 +                }
2297          }
2298
2299  }
2300 @@ -851,7 +866,7 @@ static void yaffs_VerifyObjects(yaffs_De
2301  /*
2302   *  Simple hash function. Needs to have a reasonable spread
2303   */
2304 -
2305 +
2306  static Y_INLINE int yaffs_HashFunction(int n)
2307  {
2308         n = abs(n);
2309 @@ -859,9 +874,10 @@ static Y_INLINE int yaffs_HashFunction(i
2310  }
2311
2312  /*
2313 - * Access functions to useful fake objects
2314 + * Access functions to useful fake objects.
2315 + * Note that root might have a presence in NAND if permissions are set.
2316   */
2317 -
2318 +
2319  yaffs_Object *yaffs_Root(yaffs_Device * dev)
2320  {
2321         return dev->rootDir;
2322 @@ -876,7 +892,7 @@ yaffs_Object *yaffs_LostNFound(yaffs_Dev
2323  /*
2324   *  Erased NAND checking functions
2325   */
2326 -
2327 +
2328  int yaffs_CheckFF(__u8 * buffer, int nBytes)
2329  {
2330         /* Horrible, slow implementation */
2331 @@ -898,10 +914,10 @@ static int yaffs_CheckChunkErased(struct
2332         int result;
2333
2334         result = yaffs_ReadChunkWithTagsFromNAND(dev, chunkInNAND, data, &tags);
2335 -
2336 +
2337         if(tags.eccResult > YAFFS_ECC_RESULT_NO_ERROR)
2338                 retval = YAFFS_FAIL;
2339 -
2340 +
2341
2342         if (!yaffs_CheckFF(data, dev->nDataBytesPerChunk) || tags.chunkUsed) {
2343                 T(YAFFS_TRACE_NANDACCESS,
2344 @@ -915,7 +931,6 @@ static int yaffs_CheckChunkErased(struct
2345
2346  }
2347
2348 -
2349  static int yaffs_WriteNewChunkWithTagsToNAND(struct yaffs_DeviceStruct *dev,
2350                                              const __u8 * data,
2351                                              yaffs_ExtendedTags * tags,
2352 @@ -992,7 +1007,11 @@ static int yaffs_WriteNewChunkWithTagsTo
2353                 /* Copy the data into the robustification buffer */
2354                 yaffs_HandleWriteChunkOk(dev, chunk, data, tags);
2355
2356 -       } while (writeOk != YAFFS_OK && attempts < yaffs_wr_attempts);
2357 +       } while (writeOk != YAFFS_OK &&
2358 +               (yaffs_wr_attempts <= 0 || attempts <= yaffs_wr_attempts));
2359 +
2360 +       if(!writeOk)
2361 +               chunk = -1;
2362
2363         if (attempts > 1) {
2364                 T(YAFFS_TRACE_ERROR,
2365 @@ -1008,13 +1027,13 @@ static int yaffs_WriteNewChunkWithTagsTo
2366  /*
2367   * Block retiring for handling a broken block.
2368   */
2369 -
2370 +
2371  static void yaffs_RetireBlock(yaffs_Device * dev, int blockInNAND)
2372  {
2373         yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, blockInNAND);
2374
2375         yaffs_InvalidateCheckpoint(dev);
2376 -
2377 +
2378         yaffs_MarkBlockBad(dev, blockInNAND);
2379
2380         bi->blockState = YAFFS_BLOCK_STATE_DEAD;
2381 @@ -1028,7 +1047,7 @@ static void yaffs_RetireBlock(yaffs_Devi
2382   * Functions for robustisizing TODO
2383   *
2384   */
2385 -
2386 +
2387  static void yaffs_HandleWriteChunkOk(yaffs_Device * dev, int chunkInNAND,
2388                                      const __u8 * data,
2389                                      const yaffs_ExtendedTags * tags)
2390 @@ -1046,13 +1065,13 @@ void yaffs_HandleChunkError(yaffs_Device
2391                 bi->gcPrioritise = 1;
2392                 dev->hasPendingPrioritisedGCs = 1;
2393                 bi->chunkErrorStrikes ++;
2394 -
2395 +
2396                 if(bi->chunkErrorStrikes > 3){
2397                         bi->needsRetiring = 1; /* Too many stikes, so retire this */
2398                         T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: Block struck out" TENDSTR)));
2399
2400                 }
2401 -
2402 +
2403         }
2404  }
2405
2406 @@ -1063,30 +1082,30 @@ static void yaffs_HandleWriteChunkError(
2407         yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, blockInNAND);
2408
2409         yaffs_HandleChunkError(dev,bi);
2410 -
2411 -
2412 +
2413 +
2414         if(erasedOk ) {
2415                 /* Was an actual write failure, so mark the block for retirement  */
2416                 bi->needsRetiring = 1;
2417                 T(YAFFS_TRACE_ERROR | YAFFS_TRACE_BAD_BLOCKS,
2418                   (TSTR("**>> Block %d needs retiring" TENDSTR), blockInNAND));
2419
2420 -
2421 +
2422         }
2423 -
2424 +
2425         /* Delete the chunk */
2426         yaffs_DeleteChunk(dev, chunkInNAND, 1, __LINE__);
2427  }
2428
2429
2430 -/*---------------- Name handling functions ------------*/
2431 +/*---------------- Name handling functions ------------*/
2432
2433  static __u16 yaffs_CalcNameSum(const YCHAR * name)
2434  {
2435         __u16 sum = 0;
2436         __u16 i = 1;
2437
2438 -       YUCHAR *bname = (YUCHAR *) name;
2439 +       const YUCHAR *bname = (const YUCHAR *) name;
2440         if (bname) {
2441                 while ((*bname) && (i < (YAFFS_MAX_NAME_LENGTH/2))) {
2442
2443 @@ -1099,12 +1118,14 @@ static __u16 yaffs_CalcNameSum(const YCH
2444                         bname++;
2445                 }
2446         }
2447 +
2448         return sum;
2449  }
2450
2451  static void yaffs_SetObjectName(yaffs_Object * obj, const YCHAR * name)
2452  {
2453  #ifdef CONFIG_YAFFS_SHORT_NAMES_IN_RAM
2454 +       memset(obj->shortName,0,sizeof (YCHAR) * (YAFFS_SHORT_NAME_LENGTH+1));
2455         if (name && yaffs_strlen(name) <= YAFFS_SHORT_NAME_LENGTH) {
2456                 yaffs_strcpy(obj->shortName, name);
2457         } else {
2458 @@ -1120,7 +1141,7 @@ static void yaffs_SetObjectName(yaffs_Ob
2459   * The list is hooked together using the first pointer
2460   * in the tnode.
2461   */
2462 -
2463 +
2464  /* yaffs_CreateTnodes creates a bunch more tnodes and
2465   * adds them to the tnode free list.
2466   * Don't use this function directly
2467 @@ -1138,11 +1159,15 @@ static int yaffs_CreateTnodes(yaffs_Devi
2468
2469         if (nTnodes < 1)
2470                 return YAFFS_OK;
2471 -
2472 +
2473         /* Calculate the tnode size in bytes for variable width tnode support.
2474          * Must be a multiple of 32-bits  */
2475         tnodeSize = (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8;
2476
2477 +       if(tnodeSize < sizeof(yaffs_Tnode))
2478 +               tnodeSize = sizeof(yaffs_Tnode);
2479 +
2480 +
2481         /* make these things */
2482
2483         newTnodes = YMALLOC(nTnodes * tnodeSize);
2484 @@ -1175,7 +1200,7 @@ static int yaffs_CreateTnodes(yaffs_Devi
2485                 next = (yaffs_Tnode *) &mem[(i+1) * tnodeSize];
2486                 curr->internal[0] = next;
2487         }
2488 -
2489 +
2490         curr = (yaffs_Tnode *) &mem[(nTnodes - 1) * tnodeSize];
2491         curr->internal[0] = dev->freeTnodes;
2492         dev->freeTnodes = (yaffs_Tnode *)mem;
2493 @@ -1190,7 +1215,7 @@ static int yaffs_CreateTnodes(yaffs_Devi
2494          * NB If we can't add this to the management list it isn't fatal
2495          * but it just means we can't free this bunch of tnodes later.
2496          */
2497 -
2498 +
2499         tnl = YMALLOC(sizeof(yaffs_TnodeList));
2500         if (!tnl) {
2501                 T(YAFFS_TRACE_ERROR,
2502 @@ -1233,17 +1258,23 @@ static yaffs_Tnode *yaffs_GetTnodeRaw(ya
2503                 dev->nFreeTnodes--;
2504         }
2505
2506 +       dev->nCheckpointBlocksRequired = 0; /* force recalculation*/
2507 +
2508         return tn;
2509  }
2510
2511  static yaffs_Tnode *yaffs_GetTnode(yaffs_Device * dev)
2512  {
2513         yaffs_Tnode *tn = yaffs_GetTnodeRaw(dev);
2514 +       int tnodeSize = (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8;
2515
2516 +       if(tnodeSize < sizeof(yaffs_Tnode))
2517 +               tnodeSize = sizeof(yaffs_Tnode);
2518 +
2519         if(tn)
2520 -               memset(tn, 0, (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8);
2521 +               memset(tn, 0, tnodeSize);
2522
2523 -       return tn;
2524 +       return tn;
2525  }
2526
2527  /* FreeTnode frees up a tnode and puts it back on the free list */
2528 @@ -1262,6 +1293,8 @@ static void yaffs_FreeTnode(yaffs_Device
2529                 dev->freeTnodes = tn;
2530                 dev->nFreeTnodes++;
2531         }
2532 +       dev->nCheckpointBlocksRequired = 0; /* force recalculation*/
2533 +
2534  }
2535
2536  static void yaffs_DeinitialiseTnodes(yaffs_Device * dev)
2537 @@ -1299,19 +1332,19 @@ void yaffs_PutLevel0Tnode(yaffs_Device *
2538    __u32 bitInWord;
2539    __u32 wordInMap;
2540    __u32 mask;
2541 -
2542 +
2543    pos &= YAFFS_TNODES_LEVEL0_MASK;
2544    val >>= dev->chunkGroupBits;
2545 -
2546 +
2547    bitInMap = pos * dev->tnodeWidth;
2548    wordInMap = bitInMap /32;
2549    bitInWord = bitInMap & (32 -1);
2550 -
2551 +
2552    mask = dev->tnodeMask << bitInWord;
2553 -
2554 +
2555    map[wordInMap] &= ~mask;
2556    map[wordInMap] |= (mask & (val << bitInWord));
2557 -
2558 +
2559    if(dev->tnodeWidth > (32-bitInWord)) {
2560      bitInWord = (32 - bitInWord);
2561      wordInMap++;;
2562 @@ -1328,24 +1361,24 @@ static __u32 yaffs_GetChunkGroupBase(yaf
2563    __u32 bitInWord;
2564    __u32 wordInMap;
2565    __u32 val;
2566 -
2567 +
2568    pos &= YAFFS_TNODES_LEVEL0_MASK;
2569 -
2570 +
2571    bitInMap = pos * dev->tnodeWidth;
2572    wordInMap = bitInMap /32;
2573    bitInWord = bitInMap & (32 -1);
2574 -
2575 +
2576    val = map[wordInMap] >> bitInWord;
2577 -
2578 +
2579    if(dev->tnodeWidth > (32-bitInWord)) {
2580      bitInWord = (32 - bitInWord);
2581      wordInMap++;;
2582      val |= (map[wordInMap] << bitInWord);
2583    }
2584 -
2585 +
2586    val &= dev->tnodeMask;
2587    val <<= dev->chunkGroupBits;
2588 -
2589 +
2590    return val;
2591  }
2592
2593 @@ -1394,7 +1427,7 @@ static yaffs_Tnode *yaffs_FindLevel0Tnod
2594         while (level > 0 && tn) {
2595                 tn = tn->
2596                     internal[(chunkId >>
2597 -                              ( YAFFS_TNODES_LEVEL0_BITS +
2598 +                              ( YAFFS_TNODES_LEVEL0_BITS +
2599                                  (level - 1) *
2600                                  YAFFS_TNODES_INTERNAL_BITS)
2601                               ) &
2602 @@ -1416,7 +1449,7 @@ static yaffs_Tnode *yaffs_FindLevel0Tnod
2603   *  If the tn argument is NULL, then a fresh tnode will be added otherwise the specified tn will
2604   *  be plugged into the ttree.
2605   */
2606 -
2607 +
2608  static yaffs_Tnode *yaffs_AddOrFindLevel0Tnode(yaffs_Device * dev,
2609                                                yaffs_FileStructure * fStruct,
2610                                                __u32 chunkId,
2611 @@ -1453,7 +1486,7 @@ static yaffs_Tnode *yaffs_AddOrFindLevel
2612         if (requiredTallness > fStruct->topLevel) {
2613                 /* Not tall enough,gotta make the tree taller */
2614                 for (i = fStruct->topLevel; i < requiredTallness; i++) {
2615 -
2616 +
2617                         tn = yaffs_GetTnode(dev);
2618
2619                         if (tn) {
2620 @@ -1472,7 +1505,7 @@ static yaffs_Tnode *yaffs_AddOrFindLevel
2621
2622         l = fStruct->topLevel;
2623         tn = fStruct->top;
2624 -
2625 +
2626         if(l > 0) {
2627                 while (l > 0 && tn) {
2628                         x = (chunkId >>
2629 @@ -1492,13 +1525,13 @@ static yaffs_Tnode *yaffs_AddOrFindLevel
2630                                         if(tn->internal[x])
2631                                                 yaffs_FreeTnode(dev,tn->internal[x]);
2632                                         tn->internal[x] = passedTn;
2633 -
2634 +
2635                                 } else if(!tn->internal[x]) {
2636                                         /* Don't have one, none passed in */
2637                                         tn->internal[x] = yaffs_GetTnode(dev);
2638                                 }
2639                         }
2640 -
2641 +
2642                         tn = tn->internal[x];
2643                         l--;
2644                 }
2645 @@ -1539,7 +1572,7 @@ static int yaffs_FindChunkInGroup(yaffs_
2646
2647  /* DeleteWorker scans backwards through the tnode tree and deletes all the
2648   * chunks and tnodes in the file
2649 - * Returns 1 if the tree was deleted.
2650 + * Returns 1 if the tree was deleted.
2651   * Returns 0 if it stopped early due to hitting the limit and the delete is incomplete.
2652   */
2653
2654 @@ -1653,7 +1686,7 @@ static void yaffs_SoftDeleteChunk(yaffs_
2655   * of the tnode.
2656   * Thus, essentially this is the same as DeleteWorker except that the chunks are soft deleted.
2657   */
2658 -
2659 +
2660  static int yaffs_SoftDeleteWorker(yaffs_Object * in, yaffs_Tnode * tn,
2661                                   __u32 level, int chunkOffset)
2662  {
2663 @@ -1694,7 +1727,7 @@ static int yaffs_SoftDeleteWorker(yaffs_
2664                                 theChunk = yaffs_GetChunkGroupBase(dev,tn,i);
2665                                 if (theChunk) {
2666                                         /* Note this does not find the real chunk, only the chunk group.
2667 -                                        * We make an assumption that a chunk group is not larger than
2668 +                                        * We make an assumption that a chunk group is not larger than
2669                                          * a block.
2670                                          */
2671                                         yaffs_SoftDeleteChunk(dev, theChunk);
2672 @@ -1796,7 +1829,7 @@ static int yaffs_PruneFileStructure(yaff
2673                 /* Now we have a tree with all the non-zero branches NULL but the height
2674                  * is the same as it was.
2675                  * Let's see if we can trim internal tnodes to shorten the tree.
2676 -                * We can do this if only the 0th element in the tnode is in use
2677 +                * We can do this if only the 0th element in the tnode is in use
2678                  * (ie all the non-zero are NULL)
2679                  */
2680
2681 @@ -1850,14 +1883,14 @@ static int yaffs_CreateFreeObjects(yaffs
2682                   (TSTR("yaffs: Could not allocate more objects" TENDSTR)));
2683                 return YAFFS_FAIL;
2684         }
2685 +
2686 +        /* Hook them into the free list */
2687 +        for (i = 0; i < nObjects - 1; i++) {
2688 +                newObjects[i].siblings.next =
2689 +                    (struct ylist_head *)(&newObjects[i + 1]);
2690 +        }
2691
2692 -       /* Hook them into the free list */
2693 -       for (i = 0; i < nObjects - 1; i++) {
2694 -               newObjects[i].siblings.next =
2695 -                   (struct list_head *)(&newObjects[i + 1]);
2696 -       }
2697 -
2698 -       newObjects[nObjects - 1].siblings.next = (void *)dev->freeObjects;
2699 +        newObjects[nObjects - 1].siblings.next = (void *)dev->freeObjects;
2700         dev->freeObjects = newObjects;
2701         dev->nFreeObjects += nObjects;
2702         dev->nObjectsCreated += nObjects;
2703 @@ -1877,6 +1910,9 @@ static yaffs_Object *yaffs_AllocateEmpty
2704  {
2705         yaffs_Object *tn = NULL;
2706
2707 +#ifdef VALGRIND_TEST
2708 +       tn = YMALLOC(sizeof(yaffs_Object));
2709 +#else
2710         /* If there are none left make more */
2711         if (!dev->freeObjects) {
2712                 yaffs_CreateFreeObjects(dev, YAFFS_ALLOCATION_NOBJECTS);
2713 @@ -1887,25 +1923,40 @@ static yaffs_Object *yaffs_AllocateEmpty
2714                 dev->freeObjects =
2715                     (yaffs_Object *) (dev->freeObjects->siblings.next);
2716                 dev->nFreeObjects--;
2717 -
2718 +       }
2719 +#endif
2720 +       if(tn){
2721                 /* Now sweeten it up... */
2722
2723                 memset(tn, 0, sizeof(yaffs_Object));
2724 +               tn->beingCreated = 1;
2725 +
2726                 tn->myDev = dev;
2727 -               tn->chunkId = -1;
2728 +               tn->hdrChunk = 0;
2729                 tn->variantType = YAFFS_OBJECT_TYPE_UNKNOWN;
2730 -               INIT_LIST_HEAD(&(tn->hardLinks));
2731 -               INIT_LIST_HEAD(&(tn->hashLink));
2732 -               INIT_LIST_HEAD(&tn->siblings);
2733 +               YINIT_LIST_HEAD(&(tn->hardLinks));
2734 +               YINIT_LIST_HEAD(&(tn->hashLink));
2735 +               YINIT_LIST_HEAD(&tn->siblings);
2736 +
2737 +
2738 +               /* Now make the directory sane */
2739 +               if(dev->rootDir){
2740 +                       tn->parent = dev->rootDir;
2741 +                       ylist_add(&(tn->siblings),&dev->rootDir->variant.directoryVariant.children);
2742 +               }
2743
2744 -               /* Add it to the lost and found directory.
2745 -                * NB Can't put root or lostNFound in lostNFound so
2746 +                /* Add it to the lost and found directory.
2747 +                 * NB Can't put root or lostNFound in lostNFound so
2748                  * check if lostNFound exists first
2749                  */
2750                 if (dev->lostNFoundDir) {
2751                         yaffs_AddObjectToDirectory(dev->lostNFoundDir, tn);
2752                 }
2753 +
2754 +               tn->beingCreated = 0;
2755         }
2756 +
2757 +       dev->nCheckpointBlocksRequired = 0; /* force recalculation*/
2758
2759         return tn;
2760  }
2761 @@ -1917,14 +1968,14 @@ static yaffs_Object *yaffs_CreateFakeDir
2762         yaffs_Object *obj =
2763             yaffs_CreateNewObject(dev, number, YAFFS_OBJECT_TYPE_DIRECTORY);
2764         if (obj) {
2765 -               obj->fake = 1;          /* it is fake so it has no NAND presence... */
2766 +               obj->fake = 1;          /* it is fake so it might have no NAND presence... */
2767                 obj->renameAllowed = 0; /* ... and we're not allowed to rename it... */
2768                 obj->unlinkAllowed = 0; /* ... or unlink it */
2769                 obj->deleted = 0;
2770                 obj->unlinked = 0;
2771                 obj->yst_mode = mode;
2772                 obj->myDev = dev;
2773 -               obj->chunkId = 0;       /* Not a valid chunk. */
2774 +               obj->hdrChunk = 0;      /* Not a valid chunk. */
2775         }
2776
2777         return obj;
2778 @@ -1934,14 +1985,14 @@ static yaffs_Object *yaffs_CreateFakeDir
2779  static void yaffs_UnhashObject(yaffs_Object * tn)
2780  {
2781         int bucket;
2782 -       yaffs_Device *dev = tn->myDev;
2783 +        yaffs_Device *dev = tn->myDev;
2784
2785 -       /* If it is still linked into the bucket list, free from the list */
2786 -       if (!list_empty(&tn->hashLink)) {
2787 -               list_del_init(&tn->hashLink);
2788 -               bucket = yaffs_HashFunction(tn->objectId);
2789 -               dev->objectBucket[bucket].count--;
2790 -       }
2791 +        /* If it is still linked into the bucket list, free from the list */
2792 +        if (!ylist_empty(&tn->hashLink)) {
2793 +                ylist_del_init(&tn->hashLink);
2794 +                bucket = yaffs_HashFunction(tn->objectId);
2795 +                dev->objectBucket[bucket].count--;
2796 +        }
2797
2798  }
2799
2800 @@ -1951,6 +2002,13 @@ static void yaffs_FreeObject(yaffs_Objec
2801
2802         yaffs_Device *dev = tn->myDev;
2803
2804 +
2805 +       if(tn->parent)
2806 +               YBUG();
2807 +       if(!ylist_empty(&tn->siblings))
2808 +               YBUG();
2809 +
2810 +
2811  #ifdef  __KERNEL__
2812         if (tn->myInode) {
2813                 /* We're still hooked up to a cached inode.
2814 @@ -1961,12 +2019,18 @@ static void yaffs_FreeObject(yaffs_Objec
2815         }
2816  #endif
2817
2818 -       yaffs_UnhashObject(tn);
2819 +        yaffs_UnhashObject(tn);
2820 +
2821 +#ifdef VALGRIND_TEST
2822 +       YFREE(tn);
2823 +#else
2824 +        /* Link into the free list. */
2825 +        tn->siblings.next = (struct ylist_head *)(dev->freeObjects);
2826 +        dev->freeObjects = tn;
2827 +        dev->nFreeObjects++;
2828 +#endif
2829 +       dev->nCheckpointBlocksRequired = 0; /* force recalculation*/
2830
2831 -       /* Link into the free list. */
2832 -       tn->siblings.next = (struct list_head *)(dev->freeObjects);
2833 -       dev->freeObjects = tn;
2834 -       dev->nFreeObjects++;
2835  }
2836
2837  #ifdef __KERNEL__
2838 @@ -2004,12 +2068,12 @@ static void yaffs_InitialiseObjects(yaff
2839
2840         dev->allocatedObjectList = NULL;
2841         dev->freeObjects = NULL;
2842 -       dev->nFreeObjects = 0;
2843 +        dev->nFreeObjects = 0;
2844
2845 -       for (i = 0; i < YAFFS_NOBJECT_BUCKETS; i++) {
2846 -               INIT_LIST_HEAD(&dev->objectBucket[i].list);
2847 -               dev->objectBucket[i].count = 0;
2848 -       }
2849 +        for (i = 0; i < YAFFS_NOBJECT_BUCKETS; i++) {
2850 +                YINIT_LIST_HEAD(&dev->objectBucket[i].list);
2851 +                dev->objectBucket[i].count = 0;
2852 +        }
2853
2854  }
2855
2856 @@ -2055,26 +2119,26 @@ static int yaffs_CreateNewObjectNumber(y
2857
2858         /* Now find an object value that has not already been taken
2859          * by scanning the list.
2860 -        */
2861 +         */
2862
2863 -       int found = 0;
2864 -       struct list_head *i;
2865 +        int found = 0;
2866 +        struct ylist_head *i;
2867
2868 -       __u32 n = (__u32) bucket;
2869 +        __u32 n = (__u32) bucket;
2870
2871         /* yaffs_CheckObjectHashSanity();  */
2872
2873         while (!found) {
2874 -               found = 1;
2875 -               n += YAFFS_NOBJECT_BUCKETS;
2876 -               if (1 || dev->objectBucket[bucket].count > 0) {
2877 -                       list_for_each(i, &dev->objectBucket[bucket].list) {
2878 -                               /* If there is already one in the list */
2879 -                               if (i
2880 -                                   && list_entry(i, yaffs_Object,
2881 -                                                 hashLink)->objectId == n) {
2882 -                                       found = 0;
2883 -                               }
2884 +                found = 1;
2885 +                n += YAFFS_NOBJECT_BUCKETS;
2886 +                if (1 || dev->objectBucket[bucket].count > 0) {
2887 +                        ylist_for_each(i, &dev->objectBucket[bucket].list) {
2888 +                                /* If there is already one in the list */
2889 +                                if (i
2890 +                                    && ylist_entry(i, yaffs_Object,
2891 +                                                  hashLink)->objectId == n) {
2892 +                                        found = 0;
2893 +                                }
2894                         }
2895                 }
2896         }
2897 @@ -2085,27 +2149,27 @@ static int yaffs_CreateNewObjectNumber(y
2898
2899  static void yaffs_HashObject(yaffs_Object * in)
2900  {
2901 -       int bucket = yaffs_HashFunction(in->objectId);
2902 -       yaffs_Device *dev = in->myDev;
2903 +        int bucket = yaffs_HashFunction(in->objectId);
2904 +        yaffs_Device *dev = in->myDev;
2905
2906 -       list_add(&in->hashLink, &dev->objectBucket[bucket].list);
2907 -       dev->objectBucket[bucket].count++;
2908 +        ylist_add(&in->hashLink, &dev->objectBucket[bucket].list);
2909 +        dev->objectBucket[bucket].count++;
2910
2911  }
2912
2913  yaffs_Object *yaffs_FindObjectByNumber(yaffs_Device * dev, __u32 number)
2914  {
2915 -       int bucket = yaffs_HashFunction(number);
2916 -       struct list_head *i;
2917 -       yaffs_Object *in;
2918 -
2919 -       list_for_each(i, &dev->objectBucket[bucket].list) {
2920 -               /* Look if it is in the list */
2921 -               if (i) {
2922 -                       in = list_entry(i, yaffs_Object, hashLink);
2923 -                       if (in->objectId == number) {
2924 +        int bucket = yaffs_HashFunction(number);
2925 +        struct ylist_head *i;
2926 +        yaffs_Object *in;
2927 +
2928 +        ylist_for_each(i, &dev->objectBucket[bucket].list) {
2929 +                /* Look if it is in the list */
2930 +                if (i) {
2931 +                        in = ylist_entry(i, yaffs_Object, hashLink);
2932 +                        if (in->objectId == number) {
2933  #ifdef __KERNEL__
2934 -                               /* Don't tell the VFS about this one if it is defered free */
2935 +                                /* Don't tell the VFS about this one if it is defered free */
2936                                 if (in->deferedFree)
2937                                         return NULL;
2938  #endif
2939 @@ -2123,7 +2187,7 @@ yaffs_Object *yaffs_CreateNewObject(yaff
2940  {
2941
2942         yaffs_Object *theObject;
2943 -       yaffs_Tnode *tn;
2944 +       yaffs_Tnode *tn = NULL;
2945
2946         if (number < 0) {
2947                 number = yaffs_CreateNewObjectNumber(dev);
2948 @@ -2132,7 +2196,7 @@ yaffs_Object *yaffs_CreateNewObject(yaff
2949         theObject = yaffs_AllocateEmptyObject(dev);
2950         if(!theObject)
2951                 return NULL;
2952 -
2953 +
2954         if(type == YAFFS_OBJECT_TYPE_FILE){
2955                 tn = yaffs_GetTnode(dev);
2956                 if(!tn){
2957 @@ -2140,8 +2204,8 @@ yaffs_Object *yaffs_CreateNewObject(yaff
2958                         return NULL;
2959                 }
2960         }
2961 -
2962 -
2963 +
2964 +
2965
2966         if (theObject) {
2967                 theObject->fake = 0;
2968 @@ -2162,19 +2226,25 @@ yaffs_Object *yaffs_CreateNewObject(yaff
2969                 theObject->yst_atime = theObject->yst_mtime =
2970                     theObject->yst_ctime = Y_CURRENT_TIME;
2971  #endif
2972 +
2973 +#if 0
2974 +               theObject->sum_prev = 12345;
2975 +               theObject->sum_trailer = 6789;
2976 +#endif
2977 +
2978                 switch (type) {
2979                 case YAFFS_OBJECT_TYPE_FILE:
2980                         theObject->variant.fileVariant.fileSize = 0;
2981                         theObject->variant.fileVariant.scannedFileSize = 0;
2982                         theObject->variant.fileVariant.shrinkSize = 0xFFFFFFFF; /* max __u32 */
2983                         theObject->variant.fileVariant.topLevel = 0;
2984 -                       theObject->variant.fileVariant.top = tn;
2985 -                       break;
2986 -               case YAFFS_OBJECT_TYPE_DIRECTORY:
2987 -                       INIT_LIST_HEAD(&theObject->variant.directoryVariant.
2988 -                                      children);
2989 -                       break;
2990 -               case YAFFS_OBJECT_TYPE_SYMLINK:
2991 +                        theObject->variant.fileVariant.top = tn;
2992 +                        break;
2993 +                case YAFFS_OBJECT_TYPE_DIRECTORY:
2994 +                        YINIT_LIST_HEAD(&theObject->variant.directoryVariant.
2995 +                                       children);
2996 +                        break;
2997 +                case YAFFS_OBJECT_TYPE_SYMLINK:
2998                 case YAFFS_OBJECT_TYPE_HARDLINK:
2999                 case YAFFS_OBJECT_TYPE_SPECIAL:
3000                         /* No action required */
3001 @@ -2205,7 +2275,7 @@ static yaffs_Object *yaffs_FindOrCreateO
3002         return theObject;
3003
3004  }
3005 -
3006 +
3007
3008  static YCHAR *yaffs_CloneString(const YCHAR * str)
3009  {
3010 @@ -2227,7 +2297,7 @@ static YCHAR *yaffs_CloneString(const YC
3011   * aliasString only has meaning for a sumlink.
3012   * rdev only has meaning for devices (a subset of special objects)
3013   */
3014 -
3015 +
3016  static yaffs_Object *yaffs_MknodObject(yaffs_ObjectType type,
3017                                        yaffs_Object * parent,
3018                                        const YCHAR * name,
3019 @@ -2238,7 +2308,7 @@ static yaffs_Object *yaffs_MknodObject(y
3020                                        const YCHAR * aliasString, __u32 rdev)
3021  {
3022         yaffs_Object *in;
3023 -       YCHAR *str;
3024 +       YCHAR *str = NULL;
3025
3026         yaffs_Device *dev = parent->myDev;
3027
3028 @@ -2249,6 +2319,9 @@ static yaffs_Object *yaffs_MknodObject(y
3029
3030         in = yaffs_CreateNewObject(dev, -1, type);
3031
3032 +       if(!in)
3033 +               return YAFFS_FAIL;
3034 +
3035         if(type == YAFFS_OBJECT_TYPE_SYMLINK){
3036                 str = yaffs_CloneString(aliasString);
3037                 if(!str){
3038 @@ -2256,11 +2329,11 @@ static yaffs_Object *yaffs_MknodObject(y
3039                         return NULL;
3040                 }
3041         }
3042 -
3043 -
3044 +
3045 +
3046
3047         if (in) {
3048 -               in->chunkId = -1;
3049 +               in->hdrChunk = 0;
3050                 in->valid = 1;
3051                 in->variantType = type;
3052
3053 @@ -2293,13 +2366,13 @@ static yaffs_Object *yaffs_MknodObject(y
3054                         break;
3055                 case YAFFS_OBJECT_TYPE_HARDLINK:
3056                         in->variant.hardLinkVariant.equivalentObject =
3057 -                           equivalentObject;
3058 -                       in->variant.hardLinkVariant.equivalentObjectId =
3059 -                           equivalentObject->objectId;
3060 -                       list_add(&in->hardLinks, &equivalentObject->hardLinks);
3061 -                       break;
3062 -               case YAFFS_OBJECT_TYPE_FILE:
3063 -               case YAFFS_OBJECT_TYPE_DIRECTORY:
3064 +                            equivalentObject;
3065 +                        in->variant.hardLinkVariant.equivalentObjectId =
3066 +                            equivalentObject->objectId;
3067 +                        ylist_add(&in->hardLinks, &equivalentObject->hardLinks);
3068 +                        break;
3069 +                case YAFFS_OBJECT_TYPE_FILE:
3070 +                case YAFFS_OBJECT_TYPE_DIRECTORY:
3071                 case YAFFS_OBJECT_TYPE_SPECIAL:
3072                 case YAFFS_OBJECT_TYPE_UNKNOWN:
3073                         /* do nothing */
3074 @@ -2378,11 +2451,11 @@ static int yaffs_ChangeObjectName(yaffs_
3075         if (newDir->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) {
3076                 T(YAFFS_TRACE_ALWAYS,
3077                   (TSTR
3078 -                  ("tragendy: yaffs_ChangeObjectName: newDir is not a directory"
3079 +                  ("tragedy: yaffs_ChangeObjectName: newDir is not a directory"
3080                     TENDSTR)));
3081                 YBUG();
3082         }
3083 -
3084 +
3085         /* TODO: Do we need this different handling for YAFFS2 and YAFFS1?? */
3086         if (obj->myDev->isYaffs2) {
3087                 unlinkOp = (newDir == obj->myDev->unlinkedDir);
3088 @@ -2395,9 +2468,9 @@ static int yaffs_ChangeObjectName(yaffs_
3089
3090         existingTarget = yaffs_FindObjectByName(newDir, newName);
3091
3092 -       /* If the object is a file going into the unlinked directory,
3093 +       /* If the object is a file going into the unlinked directory,
3094          *   then it is OK to just stuff it in since duplicate names are allowed.
3095 -        *   else only proceed if the new name does not exist and if we're putting
3096 +        *   else only proceed if the new name does not exist and if we're putting
3097          *   it into a directory.
3098          */
3099         if ((unlinkOp ||
3100 @@ -2425,9 +2498,15 @@ static int yaffs_ChangeObjectName(yaffs_
3101  int yaffs_RenameObject(yaffs_Object * oldDir, const YCHAR * oldName,
3102                        yaffs_Object * newDir, const YCHAR * newName)
3103  {
3104 -       yaffs_Object *obj;
3105 -       yaffs_Object *existingTarget;
3106 +       yaffs_Object *obj=NULL;
3107 +       yaffs_Object *existingTarget=NULL;
3108         int force = 0;
3109 +
3110 +
3111 +       if(!oldDir || oldDir->variantType != YAFFS_OBJECT_TYPE_DIRECTORY)
3112 +               YBUG();
3113 +       if(!newDir || newDir->variantType != YAFFS_OBJECT_TYPE_DIRECTORY)
3114 +               YBUG();
3115
3116  #ifdef CONFIG_YAFFS_CASE_INSENSITIVE
3117         /* Special case for case insemsitive systems (eg. WinCE).
3118 @@ -2439,29 +2518,24 @@ int yaffs_RenameObject(yaffs_Object * ol
3119         }
3120  #endif
3121
3122 -       obj = yaffs_FindObjectByName(oldDir, oldName);
3123 -       /* Check new name to long. */
3124 -       if (obj->variantType == YAFFS_OBJECT_TYPE_SYMLINK &&
3125 -           yaffs_strlen(newName) > YAFFS_MAX_ALIAS_LENGTH)
3126 -         /* ENAMETOOLONG */
3127 -         return YAFFS_FAIL;
3128 -       else if (obj->variantType != YAFFS_OBJECT_TYPE_SYMLINK &&
3129 -                yaffs_strlen(newName) > YAFFS_MAX_NAME_LENGTH)
3130 +       else if (yaffs_strlen(newName) > YAFFS_MAX_NAME_LENGTH)
3131           /* ENAMETOOLONG */
3132           return YAFFS_FAIL;
3133
3134 +       obj = yaffs_FindObjectByName(oldDir, oldName);
3135 +
3136         if (obj && obj->renameAllowed) {
3137
3138                 /* Now do the handling for an existing target, if there is one */
3139
3140 -               existingTarget = yaffs_FindObjectByName(newDir, newName);
3141 -               if (existingTarget &&
3142 -                   existingTarget->variantType == YAFFS_OBJECT_TYPE_DIRECTORY &&
3143 -                   !list_empty(&existingTarget->variant.directoryVariant.children)) {
3144 -                       /* There is a target that is a non-empty directory, so we fail */
3145 -                       return YAFFS_FAIL;      /* EEXIST or ENOTEMPTY */
3146 -               } else if (existingTarget && existingTarget != obj) {
3147 -                       /* Nuke the target first, using shadowing,
3148 +                existingTarget = yaffs_FindObjectByName(newDir, newName);
3149 +                if (existingTarget &&
3150 +                    existingTarget->variantType == YAFFS_OBJECT_TYPE_DIRECTORY &&
3151 +                    !ylist_empty(&existingTarget->variant.directoryVariant.children)) {
3152 +                        /* There is a target that is a non-empty directory, so we fail */
3153 +                        return YAFFS_FAIL;      /* EEXIST or ENOTEMPTY */
3154 +                } else if (existingTarget && existingTarget != obj) {
3155 +                       /* Nuke the target first, using shadowing,
3156                          * but only if it isn't the same object
3157                          */
3158                         yaffs_ChangeObjectName(obj, newDir, newName, force,
3159 @@ -2479,10 +2553,10 @@ int yaffs_RenameObject(yaffs_Object * ol
3160  static int yaffs_InitialiseBlocks(yaffs_Device * dev)
3161  {
3162         int nBlocks = dev->internalEndBlock - dev->internalStartBlock + 1;
3163 -
3164 +
3165         dev->blockInfo = NULL;
3166         dev->chunkBits = NULL;
3167 -
3168 +
3169         dev->allocationBlock = -1;      /* force it to get a new one */
3170
3171         /* If the first allocation strategy fails, thry the alternate one */
3172 @@ -2493,9 +2567,9 @@ static int yaffs_InitialiseBlocks(yaffs_
3173         }
3174         else
3175                 dev->blockInfoAlt = 0;
3176 -
3177 +
3178         if(dev->blockInfo){
3179 -
3180 +
3181                 /* Set up dynamic blockinfo stuff. */
3182                 dev->chunkBitmapStride = (dev->nChunksPerBlock + 7) / 8; /* round up bytes */
3183                 dev->chunkBits = YMALLOC(dev->chunkBitmapStride * nBlocks);
3184 @@ -2506,7 +2580,7 @@ static int yaffs_InitialiseBlocks(yaffs_
3185                 else
3186                         dev->chunkBitsAlt = 0;
3187         }
3188 -
3189 +
3190         if (dev->blockInfo && dev->chunkBits) {
3191                 memset(dev->blockInfo, 0, nBlocks * sizeof(yaffs_BlockInfo));
3192                 memset(dev->chunkBits, 0, dev->chunkBitmapStride * nBlocks);
3193 @@ -2527,7 +2601,7 @@ static void yaffs_DeinitialiseBlocks(yaf
3194         dev->blockInfoAlt = 0;
3195
3196         dev->blockInfo = NULL;
3197 -
3198 +
3199         if(dev->chunkBitsAlt && dev->chunkBits)
3200                 YFREE_ALT(dev->chunkBits);
3201         else if(dev->chunkBits)
3202 @@ -2591,14 +2665,14 @@ static int yaffs_FindBlockForGarbageColl
3203         int prioritised=0;
3204         yaffs_BlockInfo *bi;
3205         int pendingPrioritisedExist = 0;
3206 -
3207 +
3208         /* First let's see if we need to grab a prioritised block */
3209         if(dev->hasPendingPrioritisedGCs){
3210                 for(i = dev->internalStartBlock; i < dev->internalEndBlock && !prioritised; i++){
3211
3212                         bi = yaffs_GetBlockInfo(dev, i);
3213                         //yaffs_VerifyBlock(dev,bi,i);
3214 -
3215 +
3216                         if(bi->gcPrioritise) {
3217                                 pendingPrioritisedExist = 1;
3218                                 if(bi->blockState == YAFFS_BLOCK_STATE_FULL &&
3219 @@ -2610,7 +2684,7 @@ static int yaffs_FindBlockForGarbageColl
3220                                 }
3221                         }
3222                 }
3223 -
3224 +
3225                 if(!pendingPrioritisedExist) /* None found, so we can clear this */
3226                         dev->hasPendingPrioritisedGCs = 0;
3227         }
3228 @@ -2662,7 +2736,7 @@ static int yaffs_FindBlockForGarbageColl
3229                         dirtiest = b;
3230                         pagesInUse = 0;
3231                 }
3232 -               else
3233 +               else
3234  #endif
3235
3236                 if (bi->blockState == YAFFS_BLOCK_STATE_FULL &&
3237 @@ -2699,11 +2773,11 @@ static void yaffs_BlockBecameDirty(yaffs
3238         /* If the block is still healthy erase it and mark as clean.
3239          * If the block has had a data failure, then retire it.
3240          */
3241 -
3242 +
3243         T(YAFFS_TRACE_GC | YAFFS_TRACE_ERASE,
3244                 (TSTR("yaffs_BlockBecameDirty block %d state %d %s"TENDSTR),
3245                 blockNo, bi->blockState, (bi->needsRetiring) ? "needs retiring" : ""));
3246 -
3247 +
3248         bi->blockState = YAFFS_BLOCK_STATE_DIRTY;
3249
3250         if (!bi->needsRetiring) {
3251 @@ -2716,7 +2790,7 @@ static void yaffs_BlockBecameDirty(yaffs
3252                 }
3253         }
3254
3255 -       if (erasedOk &&
3256 +       if (erasedOk &&
3257             ((yaffs_traceMask & YAFFS_TRACE_ERASE) || !yaffs_SkipVerification(dev))) {
3258                 int i;
3259                 for (i = 0; i < dev->nChunksPerBlock; i++) {
3260 @@ -2763,11 +2837,11 @@ static int yaffs_FindBlockForAllocation(
3261                  * Can't get space to gc
3262                  */
3263                 T(YAFFS_TRACE_ERROR,
3264 -                 (TSTR("yaffs tragedy: no more eraased blocks" TENDSTR)));
3265 +                 (TSTR("yaffs tragedy: no more erased blocks" TENDSTR)));
3266
3267                 return -1;
3268         }
3269 -
3270 +
3271         /* Find an empty block. */
3272
3273         for (i = dev->internalStartBlock; i <= dev->internalEndBlock; i++) {
3274 @@ -2794,13 +2868,48 @@ static int yaffs_FindBlockForAllocation(
3275
3276         T(YAFFS_TRACE_ALWAYS,
3277           (TSTR
3278 -          ("yaffs tragedy: no more eraased blocks, but there should have been %d"
3279 +          ("yaffs tragedy: no more erased blocks, but there should have been %d"
3280             TENDSTR), dev->nErasedBlocks));
3281
3282         return -1;
3283  }
3284
3285
3286 +
3287 +static int yaffs_CalcCheckpointBlocksRequired(yaffs_Device *dev)
3288 +{
3289 +       if(!dev->nCheckpointBlocksRequired &&
3290 +          dev->isYaffs2){
3291 +               /* Not a valid value so recalculate */
3292 +               int nBytes = 0;
3293 +               int nBlocks;
3294 +               int devBlocks = (dev->endBlock - dev->startBlock + 1);
3295 +               int tnodeSize;
3296 +
3297 +               tnodeSize = (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8;
3298 +
3299 +               if(tnodeSize < sizeof(yaffs_Tnode))
3300 +                       tnodeSize = sizeof(yaffs_Tnode);
3301 +
3302 +               nBytes += sizeof(yaffs_CheckpointValidity);
3303 +               nBytes += sizeof(yaffs_CheckpointDevice);
3304 +               nBytes += devBlocks * sizeof(yaffs_BlockInfo);
3305 +               nBytes += devBlocks * dev->chunkBitmapStride;
3306 +               nBytes += (sizeof(yaffs_CheckpointObject) + sizeof(__u32)) * (dev->nObjectsCreated - dev->nFreeObjects);
3307 +               nBytes += (tnodeSize + sizeof(__u32)) * (dev->nTnodesCreated - dev->nFreeTnodes);
3308 +               nBytes += sizeof(yaffs_CheckpointValidity);
3309 +               nBytes += sizeof(__u32); /* checksum*/
3310 +
3311 +               /* Round up and add 2 blocks to allow for some bad blocks, so add 3 */
3312 +
3313 +               nBlocks = (nBytes/(dev->nDataBytesPerChunk * dev->nChunksPerBlock)) + 3;
3314 +
3315 +               dev->nCheckpointBlocksRequired = nBlocks;
3316 +       }
3317 +
3318 +       return dev->nCheckpointBlocksRequired;
3319 +}
3320 +
3321  // Check if there's space to allocate...
3322  // Thinks.... do we need top make this ths same as yaffs_GetFreeChunks()?
3323  static int yaffs_CheckSpaceForAllocation(yaffs_Device * dev)
3324 @@ -2808,13 +2917,18 @@ static int yaffs_CheckSpaceForAllocation
3325         int reservedChunks;
3326         int reservedBlocks = dev->nReservedBlocks;
3327         int checkpointBlocks;
3328 -
3329 -       checkpointBlocks =  dev->nCheckpointReservedBlocks - dev->blocksInCheckpoint;
3330 -       if(checkpointBlocks < 0)
3331 -               checkpointBlocks = 0;
3332 -
3333 +
3334 +       if(dev->isYaffs2){
3335 +               checkpointBlocks =  yaffs_CalcCheckpointBlocksRequired(dev) -
3336 +                                   dev->blocksInCheckpoint;
3337 +               if(checkpointBlocks < 0)
3338 +                       checkpointBlocks = 0;
3339 +       } else {
3340 +               checkpointBlocks =0;
3341 +       }
3342 +
3343         reservedChunks = ((reservedBlocks + checkpointBlocks) * dev->nChunksPerBlock);
3344 -
3345 +
3346         return (dev->nFreeChunks > reservedChunks);
3347  }
3348
3349 @@ -2861,10 +2975,10 @@ static int yaffs_AllocateChunk(yaffs_Dev
3350
3351                 if(blockUsedPtr)
3352                         *blockUsedPtr = bi;
3353 -
3354 +
3355                 return retVal;
3356         }
3357 -
3358 +
3359         T(YAFFS_TRACE_ERROR,
3360           (TSTR("!!!!!!!!! Allocator out !!!!!!!!!!!!!!!!!" TENDSTR)));
3361
3362 @@ -2885,17 +2999,17 @@ static int yaffs_GetErasedChunks(yaffs_D
3363
3364  }
3365
3366 -static int yaffs_GarbageCollectBlock(yaffs_Device * dev, int block)
3367 +static int yaffs_GarbageCollectBlock(yaffs_Device * dev, int block, int wholeBlock)
3368  {
3369         int oldChunk;
3370         int newChunk;
3371 -       int chunkInBlock;
3372         int markNAND;
3373         int retVal = YAFFS_OK;
3374         int cleanups = 0;
3375         int i;
3376         int isCheckpointBlock;
3377         int matchingChunk;
3378 +       int maxCopies;
3379
3380         int chunksBefore = yaffs_GetErasedChunks(dev);
3381         int chunksAfter;
3382 @@ -2907,12 +3021,15 @@ static int yaffs_GarbageCollectBlock(yaf
3383         yaffs_Object *object;
3384
3385         isCheckpointBlock = (bi->blockState == YAFFS_BLOCK_STATE_CHECKPOINT);
3386 -
3387 +
3388         bi->blockState = YAFFS_BLOCK_STATE_COLLECTING;
3389
3390         T(YAFFS_TRACE_TRACING,
3391 -         (TSTR("Collecting block %d, in use %d, shrink %d, " TENDSTR), block,
3392 -          bi->pagesInUse, bi->hasShrinkHeader));
3393 +         (TSTR("Collecting block %d, in use %d, shrink %d, wholeBlock %d" TENDSTR),
3394 +         block,
3395 +         bi->pagesInUse,
3396 +         bi->hasShrinkHeader,
3397 +         wholeBlock));
3398
3399         /*yaffs_VerifyFreeChunks(dev); */
3400
3401 @@ -2935,16 +3052,23 @@ static int yaffs_GarbageCollectBlock(yaf
3402         } else {
3403
3404                 __u8 *buffer = yaffs_GetTempBuffer(dev, __LINE__);
3405 -
3406 +
3407                 yaffs_VerifyBlock(dev,bi,block);
3408
3409 -               for (chunkInBlock = 0, oldChunk = block * dev->nChunksPerBlock;
3410 -                    chunkInBlock < dev->nChunksPerBlock
3411 -                    && yaffs_StillSomeChunkBits(dev, block);
3412 -                    chunkInBlock++, oldChunk++) {
3413 -                       if (yaffs_CheckChunkBit(dev, block, chunkInBlock)) {
3414 +               maxCopies = (wholeBlock) ? dev->nChunksPerBlock : 10;
3415 +               oldChunk = block * dev->nChunksPerBlock + dev->gcChunk;
3416 +
3417 +               for ( /* init already done */;
3418 +                    retVal == YAFFS_OK &&
3419 +                    dev->gcChunk < dev->nChunksPerBlock &&
3420 +                    (bi->blockState == YAFFS_BLOCK_STATE_COLLECTING)&&
3421 +                    maxCopies > 0;
3422 +                    dev->gcChunk++, oldChunk++) {
3423 +                       if (yaffs_CheckChunkBit(dev, block, dev->gcChunk)) {
3424
3425                                 /* This page is in use and might need to be copied off */
3426 +
3427 +                               maxCopies--;
3428
3429                                 markNAND = 1;
3430
3431 @@ -2959,23 +3083,23 @@ static int yaffs_GarbageCollectBlock(yaf
3432
3433                                 T(YAFFS_TRACE_GC_DETAIL,
3434                                   (TSTR
3435 -                                  ("Collecting page %d, %d %d %d " TENDSTR),
3436 -                                  chunkInBlock, tags.objectId, tags.chunkId,
3437 +                                  ("Collecting chunk in block %d, %d %d %d " TENDSTR),
3438 +                                  dev->gcChunk, tags.objectId, tags.chunkId,
3439                                    tags.byteCount));
3440 -
3441 +
3442                                 if(object && !yaffs_SkipVerification(dev)){
3443                                         if(tags.chunkId == 0)
3444 -                                               matchingChunk = object->chunkId;
3445 +                                               matchingChunk = object->hdrChunk;
3446                                         else if(object->softDeleted)
3447                                                 matchingChunk = oldChunk; /* Defeat the test */
3448                                         else
3449                                                 matchingChunk = yaffs_FindChunkInFile(object,tags.chunkId,NULL);
3450 -
3451 +
3452                                         if(oldChunk != matchingChunk)
3453                                                 T(YAFFS_TRACE_ERROR,
3454                                                   (TSTR("gc: page in gc mismatch: %d %d %d %d"TENDSTR),
3455                                                   oldChunk,matchingChunk,tags.objectId, tags.chunkId));
3456 -
3457 +
3458                                 }
3459
3460                                 if (!object) {
3461 @@ -2986,11 +3110,13 @@ static int yaffs_GarbageCollectBlock(yaf
3462                                             tags.objectId, tags.chunkId, tags.byteCount));
3463                                 }
3464
3465 -                               if (object && object->deleted
3466 -                                   && tags.chunkId != 0) {
3467 -                                       /* Data chunk in a deleted file, throw it away
3468 +                               if (object &&
3469 +                                   object->deleted &&
3470 +                                   object->softDeleted &&
3471 +                                   tags.chunkId != 0) {
3472 +                                       /* Data chunk in a soft deleted file, throw it away
3473                                          * It's a soft deleted data chunk,
3474 -                                        * No need to copy this, just forget about it and
3475 +                                        * No need to copy this, just forget about it and
3476                                          * fix up the object.
3477                                          */
3478
3479 @@ -3009,7 +3135,7 @@ static int yaffs_GarbageCollectBlock(yaf
3480                                         /* Deleted object header with no data chunks.
3481                                          * Can be discarded and the file deleted.
3482                                          */
3483 -                                       object->chunkId = 0;
3484 +                                       object->hdrChunk = 0;
3485                                         yaffs_FreeTnode(object->myDev,
3486                                                         object->variant.
3487                                                         fileVariant.top);
3488 @@ -3037,10 +3163,9 @@ static int yaffs_GarbageCollectBlock(yaf
3489                                                 yaffs_ObjectHeader *oh;
3490                                                 oh = (yaffs_ObjectHeader *)buffer;
3491                                                 oh->isShrink = 0;
3492 -                                               oh->shadowsObject = -1;
3493                                                 tags.extraShadows = 0;
3494                                                 tags.extraIsShrinkHeader = 0;
3495 -
3496 +
3497                                                 yaffs_VerifyObjectHeader(object,oh,&tags,1);
3498                                         }
3499
3500 @@ -3055,7 +3180,7 @@ static int yaffs_GarbageCollectBlock(yaf
3501
3502                                                 if (tags.chunkId == 0) {
3503                                                         /* It's a header */
3504 -                                                       object->chunkId =  newChunk;
3505 +                                                       object->hdrChunk =  newChunk;
3506                                                         object->serial =   tags.serialNumber;
3507                                                 } else {
3508                                                         /* It's a data chunk */
3509 @@ -3067,12 +3192,14 @@ static int yaffs_GarbageCollectBlock(yaf
3510                                         }
3511                                 }
3512
3513 -                               yaffs_DeleteChunk(dev, oldChunk, markNAND, __LINE__);
3514 +                               if(retVal == YAFFS_OK)
3515 +                                       yaffs_DeleteChunk(dev, oldChunk, markNAND, __LINE__);
3516
3517                         }
3518                 }
3519
3520                 yaffs_ReleaseTempBuffer(dev, buffer, __LINE__);
3521 +
3522
3523
3524                 /* Do any required cleanups */
3525 @@ -3099,7 +3226,7 @@ static int yaffs_GarbageCollectBlock(yaf
3526         }
3527
3528         yaffs_VerifyCollectedBlock(dev,bi,block);
3529 -
3530 +
3531         if (chunksBefore >= (chunksAfter = yaffs_GetErasedChunks(dev))) {
3532                 T(YAFFS_TRACE_GC,
3533                   (TSTR
3534 @@ -3107,9 +3234,15 @@ static int yaffs_GarbageCollectBlock(yaf
3535                     TENDSTR), chunksBefore, chunksAfter));
3536         }
3537
3538 +       /* If the gc completed then clear the current gcBlock so that we find another. */
3539 +       if(bi->blockState != YAFFS_BLOCK_STATE_COLLECTING){
3540 +               dev->gcBlock = -1;
3541 +               dev->gcChunk = 0;
3542 +       }
3543 +
3544         dev->isDoingGC = 0;
3545
3546 -       return YAFFS_OK;
3547 +       return retVal;
3548  }
3549
3550  /* New garbage collector
3551 @@ -3127,22 +3260,22 @@ static int yaffs_CheckGarbageCollection(
3552         int aggressive;
3553         int gcOk = YAFFS_OK;
3554         int maxTries = 0;
3555 -
3556 +
3557         int checkpointBlockAdjust;
3558
3559         if (dev->isDoingGC) {
3560                 /* Bail out so we don't get recursive gc */
3561                 return YAFFS_OK;
3562         }
3563 -
3564 +
3565         /* This loop should pass the first time.
3566          * We'll only see looping here if the erase of the collected block fails.
3567          */
3568
3569         do {
3570                 maxTries++;
3571 -
3572 -               checkpointBlockAdjust = (dev->nCheckpointReservedBlocks - dev->blocksInCheckpoint);
3573 +
3574 +               checkpointBlockAdjust = yaffs_CalcCheckpointBlocksRequired(dev) - dev->blocksInCheckpoint;
3575                 if(checkpointBlockAdjust < 0)
3576                         checkpointBlockAdjust = 0;
3577
3578 @@ -3154,7 +3287,12 @@ static int yaffs_CheckGarbageCollection(
3579                         aggressive = 0;
3580                 }
3581
3582 -               block = yaffs_FindBlockForGarbageCollection(dev, aggressive);
3583 +               if(dev->gcBlock <= 0){
3584 +                       dev->gcBlock = yaffs_FindBlockForGarbageCollection(dev, aggressive);
3585 +                       dev->gcChunk = 0;
3586 +               }
3587 +
3588 +               block = dev->gcBlock;
3589
3590                 if (block > 0) {
3591                         dev->garbageCollections++;
3592 @@ -3167,7 +3305,7 @@ static int yaffs_CheckGarbageCollection(
3593                            ("yaffs: GC erasedBlocks %d aggressive %d" TENDSTR),
3594                            dev->nErasedBlocks, aggressive));
3595
3596 -                       gcOk = yaffs_GarbageCollectBlock(dev, block);
3597 +                       gcOk = yaffs_GarbageCollectBlock(dev,block,aggressive);
3598                 }
3599
3600                 if (dev->nErasedBlocks < (dev->nReservedBlocks) && block > 0) {
3601 @@ -3176,8 +3314,9 @@ static int yaffs_CheckGarbageCollection(
3602                            ("yaffs: GC !!!no reclaim!!! erasedBlocks %d after try %d block %d"
3603                             TENDSTR), dev->nErasedBlocks, maxTries, block));
3604                 }
3605 -       } while ((dev->nErasedBlocks < dev->nReservedBlocks) && (block > 0)
3606 -                && (maxTries < 2));
3607 +       } while ((dev->nErasedBlocks < dev->nReservedBlocks) &&
3608 +                (block > 0) &&
3609 +                (maxTries < 2));
3610
3611         return aggressive ? gcOk : YAFFS_OK;
3612  }
3613 @@ -3326,11 +3465,11 @@ static int yaffs_CheckFileSanity(yaffs_O
3614  static int yaffs_PutChunkIntoFile(yaffs_Object * in, int chunkInInode,
3615                                   int chunkInNAND, int inScan)
3616  {
3617 -       /* NB inScan is zero unless scanning.
3618 -        * For forward scanning, inScan is > 0;
3619 +       /* NB inScan is zero unless scanning.
3620 +        * For forward scanning, inScan is > 0;
3621          * for backward scanning inScan is < 0
3622          */
3623 -
3624 +
3625         yaffs_Tnode *tn;
3626         yaffs_Device *dev = in->myDev;
3627         int existingChunk;
3628 @@ -3354,7 +3493,7 @@ static int yaffs_PutChunkIntoFile(yaffs_
3629                 return YAFFS_OK;
3630         }
3631
3632 -       tn = yaffs_AddOrFindLevel0Tnode(dev,
3633 +       tn = yaffs_AddOrFindLevel0Tnode(dev,
3634                                         &in->variant.fileVariant,
3635                                         chunkInInode,
3636                                         NULL);
3637 @@ -3366,7 +3505,7 @@ static int yaffs_PutChunkIntoFile(yaffs_
3638
3639         if (inScan != 0) {
3640                 /* If we're scanning then we need to test for duplicates
3641 -                * NB This does not need to be efficient since it should only ever
3642 +                * NB This does not need to be efficient since it should only ever
3643                  * happen when the power fails during a write, then only one
3644                  * chunk should ever be affected.
3645                  *
3646 @@ -3374,7 +3513,7 @@ static int yaffs_PutChunkIntoFile(yaffs_
3647                  * Update: For backward scanning we don't need to re-read tags so this is quite cheap.
3648                  */
3649
3650 -               if (existingChunk != 0) {
3651 +               if (existingChunk > 0) {
3652                         /* NB Right now existing chunk will not be real chunkId if the device >= 32MB
3653                          *    thus we have to do a FindChunkInFile to get the real chunk id.
3654                          *
3655 @@ -3407,18 +3546,20 @@ static int yaffs_PutChunkIntoFile(yaffs_
3656
3657                         }
3658
3659 -                       /* NB The deleted flags should be false, otherwise the chunks will
3660 +                       /* NB The deleted flags should be false, otherwise the chunks will
3661                          * not be loaded during a scan
3662                          */
3663
3664 -                       newSerial = newTags.serialNumber;
3665 -                       existingSerial = existingTags.serialNumber;
3666 +                       if(inScan > 0) {
3667 +                               newSerial = newTags.serialNumber;
3668 +                               existingSerial = existingTags.serialNumber;
3669 +                       }
3670
3671                         if ((inScan > 0) &&
3672                             (in->myDev->isYaffs2 ||
3673                              existingChunk <= 0 ||
3674                              ((existingSerial + 1) & 3) == newSerial)) {
3675 -                               /* Forward scanning.
3676 +                               /* Forward scanning.
3677                                  * Use new
3678                                  * Delete the old one and drop through to update the tnode
3679                                  */
3680 @@ -3459,7 +3600,7 @@ static int yaffs_ReadChunkDataFromObject
3681                   (TSTR("Chunk %d not found zero instead" TENDSTR),
3682                    chunkInNAND));
3683                 /* get sane (zero) data if you read a hole */
3684 -               memset(buffer, 0, in->myDev->nDataBytesPerChunk);
3685 +               memset(buffer, 0, in->myDev->nDataBytesPerChunk);
3686                 return 0;
3687         }
3688
3689 @@ -3474,7 +3615,7 @@ void yaffs_DeleteChunk(yaffs_Device * de
3690
3691         if (chunkId <= 0)
3692                 return;
3693 -
3694 +
3695
3696         dev->nDeletions++;
3697         block = chunkId / dev->nChunksPerBlock;
3698 @@ -3560,6 +3701,14 @@ static int yaffs_WriteChunkDataToObject(
3699         newTags.serialNumber =
3700             (prevChunkId >= 0) ? prevTags.serialNumber + 1 : 1;
3701         newTags.byteCount = nBytes;
3702 +
3703 +       if(nBytes < 1 || nBytes > dev->totalBytesPerChunk){
3704 +         T(YAFFS_TRACE_ERROR,
3705 +         (TSTR("Writing %d bytes to chunk!!!!!!!!!" TENDSTR), nBytes));
3706 +         while(1){}
3707 +        }
3708 +
3709 +
3710
3711         newChunkId =
3712             yaffs_WriteNewChunkWithTagsToNAND(dev, buffer, &newTags,
3713 @@ -3601,11 +3750,14 @@ int yaffs_UpdateObjectHeader(yaffs_Objec
3714         __u8 *buffer = NULL;
3715         YCHAR oldName[YAFFS_MAX_NAME_LENGTH + 1];
3716
3717 -       yaffs_ObjectHeader *oh = NULL;
3718 +        yaffs_ObjectHeader *oh = NULL;
3719 +
3720 +        yaffs_strcpy(oldName,_Y("silly old name"));
3721
3722 -       yaffs_strcpy(oldName,"silly old name");
3723
3724 -       if (!in->fake || force) {
3725 +       if (!in->fake ||
3726 +           in == dev->rootDir || /* The rootDir should also be saved */
3727 +           force) {
3728
3729                 yaffs_CheckGarbageCollection(dev);
3730                 yaffs_CheckObjectDetailsLoaded(in);
3731 @@ -3613,14 +3765,14 @@ int yaffs_UpdateObjectHeader(yaffs_Objec
3732                 buffer = yaffs_GetTempBuffer(in->myDev, __LINE__);
3733                 oh = (yaffs_ObjectHeader *) buffer;
3734
3735 -               prevChunkId = in->chunkId;
3736 +               prevChunkId = in->hdrChunk;
3737
3738 -               if (prevChunkId >= 0) {
3739 +               if (prevChunkId > 0) {
3740                         result = yaffs_ReadChunkWithTagsFromNAND(dev, prevChunkId,
3741                                                         buffer, &oldTags);
3742 -
3743 +
3744                         yaffs_VerifyObjectHeader(in,oh,&oldTags,0);
3745 -
3746 +
3747                         memcpy(oldName, oh->name, sizeof(oh->name));
3748                 }
3749
3750 @@ -3628,7 +3780,7 @@ int yaffs_UpdateObjectHeader(yaffs_Objec
3751
3752                 oh->type = in->variantType;
3753                 oh->yst_mode = in->yst_mode;
3754 -               oh->shadowsObject = shadows;
3755 +               oh->shadowsObject = oh->inbandShadowsObject = shadows;
3756
3757  #ifdef CONFIG_YAFFS_WINCE
3758                 oh->win_atime[0] = in->win_atime[0];
3759 @@ -3717,7 +3869,7 @@ int yaffs_UpdateObjectHeader(yaffs_Objec
3760
3761                 if (newChunkId >= 0) {
3762
3763 -                       in->chunkId = newChunkId;
3764 +                       in->hdrChunk = newChunkId;
3765
3766                         if (prevChunkId >= 0) {
3767                                 yaffs_DeleteChunk(dev, prevChunkId, 1,
3768 @@ -3748,11 +3900,11 @@ int yaffs_UpdateObjectHeader(yaffs_Objec
3769
3770  /*------------------------ Short Operations Cache ----------------------------------------
3771   *   In many situations where there is no high level buffering (eg WinCE) a lot of
3772 - *   reads might be short sequential reads, and a lot of writes may be short
3773 + *   reads might be short sequential reads, and a lot of writes may be short
3774   *   sequential writes. eg. scanning/writing a jpeg file.
3775 - *   In these cases, a short read/write cache can provide a huge perfomance benefit
3776 + *   In these cases, a short read/write cache can provide a huge perfomance benefit
3777   *   with dumb-as-a-rock code.
3778 - *   In Linux, the page cache provides read buffering aand the short op cache provides write
3779 + *   In Linux, the page cache provides read buffering aand the short op cache provides write
3780   *   buffering.
3781   *
3782   *   There are a limited number (~10) of cache chunks per device so that we don't
3783 @@ -3765,14 +3917,14 @@ static int yaffs_ObjectHasCachedWriteDat
3784         int i;
3785         yaffs_ChunkCache *cache;
3786         int nCaches = obj->myDev->nShortOpCaches;
3787 -
3788 +
3789         for(i = 0; i < nCaches; i++){
3790                 cache = &dev->srCache[i];
3791                 if (cache->object == obj &&
3792                     cache->dirty)
3793                         return 1;
3794         }
3795 -
3796 +
3797         return 0;
3798  }
3799
3800 @@ -3838,7 +3990,7 @@ void yaffs_FlushEntireDeviceCache(yaffs_
3801         yaffs_Object *obj;
3802         int nCaches = dev->nShortOpCaches;
3803         int i;
3804 -
3805 +
3806         /* Find a dirty object in the cache and flush it...
3807          * until there are no further dirty objects.
3808          */
3809 @@ -3848,53 +4000,33 @@ void yaffs_FlushEntireDeviceCache(yaffs_
3810                         if (dev->srCache[i].object &&
3811                             dev->srCache[i].dirty)
3812                                 obj = dev->srCache[i].object;
3813 -
3814 +
3815                 }
3816                 if(obj)
3817                         yaffs_FlushFilesChunkCache(obj);
3818 -
3819 +
3820         } while(obj);
3821 -
3822 +
3823  }
3824
3825
3826  /* Grab us a cache chunk for use.
3827 - * First look for an empty one.
3828 + * First look for an empty one.
3829   * Then look for the least recently used non-dirty one.
3830   * Then look for the least recently used dirty one...., flush and look again.
3831   */
3832  static yaffs_ChunkCache *yaffs_GrabChunkCacheWorker(yaffs_Device * dev)
3833  {
3834         int i;
3835 -       int usage;
3836 -       int theOne;
3837
3838         if (dev->nShortOpCaches > 0) {
3839                 for (i = 0; i < dev->nShortOpCaches; i++) {
3840 -                       if (!dev->srCache[i].object)
3841 +                       if (!dev->srCache[i].object)
3842                                 return &dev->srCache[i];
3843                 }
3844 -
3845 -               return NULL;
3846 -
3847 -               theOne = -1;
3848 -               usage = 0;      /* just to stop the compiler grizzling */
3849 -
3850 -               for (i = 0; i < dev->nShortOpCaches; i++) {
3851 -                       if (!dev->srCache[i].dirty &&
3852 -                           ((dev->srCache[i].lastUse < usage && theOne >= 0) ||
3853 -                            theOne < 0)) {
3854 -                               usage = dev->srCache[i].lastUse;
3855 -                               theOne = i;
3856 -                       }
3857 -               }
3858 -
3859 -
3860 -               return theOne >= 0 ? &dev->srCache[theOne] : NULL;
3861 -       } else {
3862 -               return NULL;
3863         }
3864
3865 +       return NULL;
3866  }
3867
3868  static yaffs_ChunkCache *yaffs_GrabChunkCache(yaffs_Device * dev)
3869 @@ -4032,14 +4164,14 @@ static void yaffs_InvalidateWholeChunkCa
3870  static int yaffs_WriteCheckpointValidityMarker(yaffs_Device *dev,int head)
3871  {
3872         yaffs_CheckpointValidity cp;
3873 -
3874 +
3875         memset(&cp,0,sizeof(cp));
3876 -
3877 +
3878         cp.structType = sizeof(cp);
3879         cp.magic = YAFFS_MAGIC;
3880         cp.version = YAFFS_CHECKPOINT_VERSION;
3881         cp.head = (head) ? 1 : 0;
3882 -
3883 +
3884         return (yaffs_CheckpointWrite(dev,&cp,sizeof(cp)) == sizeof(cp))?
3885                 1 : 0;
3886  }
3887 @@ -4048,9 +4180,9 @@ static int yaffs_ReadCheckpointValidityM
3888  {
3889         yaffs_CheckpointValidity cp;
3890         int ok;
3891 -
3892 +
3893         ok = (yaffs_CheckpointRead(dev,&cp,sizeof(cp)) == sizeof(cp));
3894 -
3895 +
3896         if(ok)
3897                 ok = (cp.structType == sizeof(cp)) &&
3898                      (cp.magic == YAFFS_MAGIC) &&
3899 @@ -4059,20 +4191,20 @@ static int yaffs_ReadCheckpointValidityM
3900         return ok ? 1 : 0;
3901  }
3902
3903 -static void yaffs_DeviceToCheckpointDevice(yaffs_CheckpointDevice *cp,
3904 +static void yaffs_DeviceToCheckpointDevice(yaffs_CheckpointDevice *cp,
3905                                            yaffs_Device *dev)
3906  {
3907         cp->nErasedBlocks = dev->nErasedBlocks;
3908         cp->allocationBlock = dev->allocationBlock;
3909         cp->allocationPage = dev->allocationPage;
3910         cp->nFreeChunks = dev->nFreeChunks;
3911 -
3912 +
3913         cp->nDeletedFiles = dev->nDeletedFiles;
3914         cp->nUnlinkedFiles = dev->nUnlinkedFiles;
3915         cp->nBackgroundDeletions = dev->nBackgroundDeletions;
3916         cp->sequenceNumber = dev->sequenceNumber;
3917         cp->oldestDirtySequence = dev->oldestDirtySequence;
3918 -
3919 +
3920  }
3921
3922  static void yaffs_CheckpointDeviceToDevice(yaffs_Device *dev,
3923 @@ -4082,7 +4214,7 @@ static void yaffs_CheckpointDeviceToDevi
3924         dev->allocationBlock = cp->allocationBlock;
3925         dev->allocationPage = cp->allocationPage;
3926         dev->nFreeChunks = cp->nFreeChunks;
3927 -
3928 +
3929         dev->nDeletedFiles = cp->nDeletedFiles;
3930         dev->nUnlinkedFiles = cp->nUnlinkedFiles;
3931         dev->nBackgroundDeletions = cp->nBackgroundDeletions;
3932 @@ -4098,20 +4230,20 @@ static int yaffs_WriteCheckpointDevice(y
3933         __u32 nBlocks = (dev->internalEndBlock - dev->internalStartBlock + 1);
3934
3935         int ok;
3936 -
3937 +
3938         /* Write device runtime values*/
3939         yaffs_DeviceToCheckpointDevice(&cp,dev);
3940         cp.structType = sizeof(cp);
3941 -
3942 +
3943         ok = (yaffs_CheckpointWrite(dev,&cp,sizeof(cp)) == sizeof(cp));
3944 -
3945 +
3946         /* Write block info */
3947         if(ok) {
3948                 nBytes = nBlocks * sizeof(yaffs_BlockInfo);
3949                 ok = (yaffs_CheckpointWrite(dev,dev->blockInfo,nBytes) == nBytes);
3950         }
3951 -
3952 -       /* Write chunk bits */
3953 +
3954 +       /* Write chunk bits */
3955         if(ok) {
3956                 nBytes = nBlocks * dev->chunkBitmapStride;
3957                 ok = (yaffs_CheckpointWrite(dev,dev->chunkBits,nBytes) == nBytes);
3958 @@ -4126,28 +4258,28 @@ static int yaffs_ReadCheckpointDevice(ya
3959         __u32 nBytes;
3960         __u32 nBlocks = (dev->internalEndBlock - dev->internalStartBlock + 1);
3961
3962 -       int ok;
3963 -
3964 +       int ok;
3965 +
3966         ok = (yaffs_CheckpointRead(dev,&cp,sizeof(cp)) == sizeof(cp));
3967         if(!ok)
3968                 return 0;
3969 -
3970 +
3971         if(cp.structType != sizeof(cp))
3972                 return 0;
3973 -
3974 -
3975 +
3976 +
3977         yaffs_CheckpointDeviceToDevice(dev,&cp);
3978 -
3979 +
3980         nBytes = nBlocks * sizeof(yaffs_BlockInfo);
3981 -
3982 +
3983         ok = (yaffs_CheckpointRead(dev,dev->blockInfo,nBytes) == nBytes);
3984 -
3985 +
3986         if(!ok)
3987                 return 0;
3988         nBytes = nBlocks * dev->chunkBitmapStride;
3989 -
3990 +
3991         ok = (yaffs_CheckpointRead(dev,dev->chunkBits,nBytes) == nBytes);
3992 -
3993 +
3994         return ok ? 1 : 0;
3995  }
3996
3997 @@ -4157,7 +4289,7 @@ static void yaffs_ObjectToCheckpointObje
3998
3999         cp->objectId = obj->objectId;
4000         cp->parentId = (obj->parent) ? obj->parent->objectId : 0;
4001 -       cp->chunkId = obj->chunkId;
4002 +       cp->hdrChunk = obj->hdrChunk;
4003         cp->variantType = obj->variantType;
4004         cp->deleted = obj->deleted;
4005         cp->softDeleted = obj->softDeleted;
4006 @@ -4167,7 +4299,7 @@ static void yaffs_ObjectToCheckpointObje
4007         cp->unlinkAllowed = obj->unlinkAllowed;
4008         cp->serial = obj->serial;
4009         cp->nDataChunks = obj->nDataChunks;
4010 -
4011 +
4012         if(obj->variantType == YAFFS_OBJECT_TYPE_FILE)
4013                 cp->fileSizeOrEquivalentObjectId = obj->variant.fileVariant.fileSize;
4014         else if(obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK)
4015 @@ -4178,9 +4310,9 @@ static void yaffs_CheckpointObjectToObje
4016  {
4017
4018         yaffs_Object *parent;
4019 -
4020 +
4021         obj->objectId = cp->objectId;
4022 -
4023 +
4024         if(cp->parentId)
4025                 parent = yaffs_FindOrCreateObjectByNumber(
4026                                         obj->myDev,
4027 @@ -4188,11 +4320,11 @@ static void yaffs_CheckpointObjectToObje
4028                                         YAFFS_OBJECT_TYPE_DIRECTORY);
4029         else
4030                 parent = NULL;
4031 -
4032 +
4033         if(parent)
4034                 yaffs_AddObjectToDirectory(parent, obj);
4035
4036 -       obj->chunkId = cp->chunkId;
4037 +       obj->hdrChunk = cp->hdrChunk;
4038         obj->variantType = cp->variantType;
4039         obj->deleted = cp->deleted;
4040         obj->softDeleted = cp->softDeleted;
4041 @@ -4202,13 +4334,13 @@ static void yaffs_CheckpointObjectToObje
4042         obj->unlinkAllowed = cp->unlinkAllowed;
4043         obj->serial = cp->serial;
4044         obj->nDataChunks = cp->nDataChunks;
4045 -
4046 +
4047         if(obj->variantType == YAFFS_OBJECT_TYPE_FILE)
4048                 obj->variant.fileVariant.fileSize = cp->fileSizeOrEquivalentObjectId;
4049         else if(obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK)
4050                 obj->variant.hardLinkVariant.equivalentObjectId = cp->fileSizeOrEquivalentObjectId;
4051
4052 -       if(obj->objectId >= YAFFS_NOBJECT_BUCKETS)
4053 +       if(obj->hdrChunk > 0)
4054                 obj->lazyLoaded = 1;
4055  }
4056
4057 @@ -4220,7 +4352,11 @@ static int yaffs_CheckpointTnodeWorker(y
4058         int i;
4059         yaffs_Device *dev = in->myDev;
4060         int ok = 1;
4061 -       int nTnodeBytes = (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8;
4062 +       int tnodeSize = (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8;
4063 +
4064 +       if(tnodeSize < sizeof(yaffs_Tnode))
4065 +               tnodeSize = sizeof(yaffs_Tnode);
4066 +
4067
4068         if (tn) {
4069                 if (level > 0) {
4070 @@ -4235,10 +4371,9 @@ static int yaffs_CheckpointTnodeWorker(y
4071                         }
4072                 } else if (level == 0) {
4073                         __u32 baseOffset = chunkOffset <<  YAFFS_TNODES_LEVEL0_BITS;
4074 -                       /* printf("write tnode at %d\n",baseOffset); */
4075                         ok = (yaffs_CheckpointWrite(dev,&baseOffset,sizeof(baseOffset)) == sizeof(baseOffset));
4076                         if(ok)
4077 -                               ok = (yaffs_CheckpointWrite(dev,tn,nTnodeBytes) == nTnodeBytes);
4078 +                               ok = (yaffs_CheckpointWrite(dev,tn,tnodeSize) == tnodeSize);
4079                 }
4080         }
4081
4082 @@ -4250,17 +4385,17 @@ static int yaffs_WriteCheckpointTnodes(y
4083  {
4084         __u32 endMarker = ~0;
4085         int ok = 1;
4086 -
4087 +
4088         if(obj->variantType == YAFFS_OBJECT_TYPE_FILE){
4089                 ok = yaffs_CheckpointTnodeWorker(obj,
4090                                             obj->variant.fileVariant.top,
4091                                             obj->variant.fileVariant.topLevel,
4092                                             0);
4093                 if(ok)
4094 -                       ok = (yaffs_CheckpointWrite(obj->myDev,&endMarker,sizeof(endMarker)) ==
4095 +                       ok = (yaffs_CheckpointWrite(obj->myDev,&endMarker,sizeof(endMarker)) ==
4096                                 sizeof(endMarker));
4097         }
4098 -
4099 +
4100         return ok ? 1 : 0;
4101  }
4102
4103 @@ -4272,70 +4407,72 @@ static int yaffs_ReadCheckpointTnodes(ya
4104         yaffs_FileStructure *fileStructPtr = &obj->variant.fileVariant;
4105         yaffs_Tnode *tn;
4106         int nread = 0;
4107 +       int tnodeSize = (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8;
4108
4109 -       ok = (yaffs_CheckpointRead(dev,&baseChunk,sizeof(baseChunk)) == sizeof(baseChunk));
4110 +       if(tnodeSize < sizeof(yaffs_Tnode))
4111 +               tnodeSize = sizeof(yaffs_Tnode);
4112
4113 +       ok = (yaffs_CheckpointRead(dev,&baseChunk,sizeof(baseChunk)) == sizeof(baseChunk));
4114 +
4115         while(ok && (~baseChunk)){
4116                 nread++;
4117                 /* Read level 0 tnode */
4118 -
4119 -
4120 -               /* printf("read  tnode at %d\n",baseChunk); */
4121 +
4122 +
4123                 tn = yaffs_GetTnodeRaw(dev);
4124                 if(tn)
4125 -                       ok = (yaffs_CheckpointRead(dev,tn,(dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8) ==
4126 -                             (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8);
4127 +                       ok = (yaffs_CheckpointRead(dev,tn,tnodeSize) == tnodeSize);
4128                 else
4129                         ok = 0;
4130 -
4131 +
4132                 if(tn && ok){
4133                         ok = yaffs_AddOrFindLevel0Tnode(dev,
4134                                                         fileStructPtr,
4135                                                         baseChunk,
4136                                                         tn) ? 1 : 0;
4137 -
4138 +
4139                 }
4140 -
4141 +
4142                 if(ok)
4143                         ok = (yaffs_CheckpointRead(dev,&baseChunk,sizeof(baseChunk)) == sizeof(baseChunk));
4144 -
4145 +
4146         }
4147
4148         T(YAFFS_TRACE_CHECKPOINT,(
4149                 TSTR("Checkpoint read tnodes %d records, last %d. ok %d" TENDSTR),
4150                 nread,baseChunk,ok));
4151
4152 -       return ok ? 1 : 0;
4153 +       return ok ? 1 : 0;
4154  }
4155 -
4156 +
4157
4158  static int yaffs_WriteCheckpointObjects(yaffs_Device *dev)
4159  {
4160         yaffs_Object *obj;
4161 -       yaffs_CheckpointObject cp;
4162 -       int i;
4163 -       int ok = 1;
4164 -       struct list_head *lh;
4165 +        yaffs_CheckpointObject cp;
4166 +        int i;
4167 +        int ok = 1;
4168 +        struct ylist_head *lh;
4169
4170 -
4171 -       /* Iterate through the objects in each hash entry,
4172 +
4173 +        /* Iterate through the objects in each hash entry,
4174          * dumping them to the checkpointing stream.
4175 -        */
4176 -
4177 -        for(i = 0; ok &&  i <  YAFFS_NOBJECT_BUCKETS; i++){
4178 -               list_for_each(lh, &dev->objectBucket[i].list) {
4179 -                       if (lh) {
4180 -                               obj = list_entry(lh, yaffs_Object, hashLink);
4181 -                               if (!obj->deferedFree) {
4182 -                                       yaffs_ObjectToCheckpointObject(&cp,obj);
4183 -                                       cp.structType = sizeof(cp);
4184 +         */
4185 +
4186 +         for(i = 0; ok &&  i <  YAFFS_NOBJECT_BUCKETS; i++){
4187 +                ylist_for_each(lh, &dev->objectBucket[i].list) {
4188 +                        if (lh) {
4189 +                                obj = ylist_entry(lh, yaffs_Object, hashLink);
4190 +                                if (!obj->deferedFree) {
4191 +                                        yaffs_ObjectToCheckpointObject(&cp,obj);
4192 +                                        cp.structType = sizeof(cp);
4193
4194                                         T(YAFFS_TRACE_CHECKPOINT,(
4195                                                 TSTR("Checkpoint write object %d parent %d type %d chunk %d obj addr %x" TENDSTR),
4196 -                                               cp.objectId,cp.parentId,cp.variantType,cp.chunkId,(unsigned) obj));
4197 +                                               cp.objectId,cp.parentId,cp.variantType,cp.hdrChunk,(unsigned) obj));
4198
4199                                         ok = (yaffs_CheckpointWrite(dev,&cp,sizeof(cp)) == sizeof(cp));
4200 -
4201 +
4202                                         if(ok && obj->variantType == YAFFS_OBJECT_TYPE_FILE){
4203                                                 ok = yaffs_WriteCheckpointTnodes(obj);
4204                                         }
4205 @@ -4343,14 +4480,14 @@ static int yaffs_WriteCheckpointObjects(
4206                         }
4207                 }
4208          }
4209 -
4210 +
4211          /* Dump end of list */
4212         memset(&cp,0xFF,sizeof(yaffs_CheckpointObject));
4213         cp.structType = sizeof(cp);
4214 -
4215 +
4216         if(ok)
4217                 ok = (yaffs_CheckpointWrite(dev,&cp,sizeof(cp)) == sizeof(cp));
4218 -
4219 +
4220         return ok ? 1 : 0;
4221  }
4222
4223 @@ -4361,7 +4498,7 @@ static int yaffs_ReadCheckpointObjects(y
4224         int ok = 1;
4225         int done = 0;
4226         yaffs_Object *hardList = NULL;
4227 -
4228 +
4229         while(ok && !done) {
4230                 ok = (yaffs_CheckpointRead(dev,&cp,sizeof(cp)) == sizeof(cp));
4231                 if(cp.structType != sizeof(cp)) {
4232 @@ -4369,9 +4506,9 @@ static int yaffs_ReadCheckpointObjects(y
4233                                 cp.structType,sizeof(cp),ok));
4234                         ok = 0;
4235                 }
4236 -
4237 +
4238                 T(YAFFS_TRACE_CHECKPOINT,(TSTR("Checkpoint read object %d parent %d type %d chunk %d " TENDSTR),
4239 -                       cp.objectId,cp.parentId,cp.variantType,cp.chunkId));
4240 +                       cp.objectId,cp.parentId,cp.variantType,cp.hdrChunk));
4241
4242                 if(ok && cp.objectId == ~0)
4243                         done = 1;
4244 @@ -4380,21 +4517,21 @@ static int yaffs_ReadCheckpointObjects(y
4245                         if(obj) {
4246                                 yaffs_CheckpointObjectToObject(obj,&cp);
4247                                 if(obj->variantType == YAFFS_OBJECT_TYPE_FILE) {
4248 -                                       ok = yaffs_ReadCheckpointTnodes(obj);
4249 -                               } else if(obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK) {
4250 -                                       obj->hardLinks.next =
4251 -                                                   (struct list_head *)
4252 -                                                   hardList;
4253 -                                       hardList = obj;
4254 -                               }
4255 -
4256 +                                        ok = yaffs_ReadCheckpointTnodes(obj);
4257 +                                } else if(obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK) {
4258 +                                        obj->hardLinks.next =
4259 +                                                    (struct ylist_head *)
4260 +                                                    hardList;
4261 +                                        hardList = obj;
4262 +                                }
4263 +
4264                         }
4265                 }
4266         }
4267 -
4268 +
4269         if(ok)
4270                 yaffs_HardlinkFixup(dev,hardList);
4271 -
4272 +
4273         return ok ? 1 : 0;
4274  }
4275
4276 @@ -4402,14 +4539,14 @@ static int yaffs_WriteCheckpointSum(yaff
4277  {
4278         __u32 checkpointSum;
4279         int ok;
4280 -
4281 +
4282         yaffs_GetCheckpointSum(dev,&checkpointSum);
4283 -
4284 +
4285         ok = (yaffs_CheckpointWrite(dev,&checkpointSum,sizeof(checkpointSum)) == sizeof(checkpointSum));
4286 -
4287 +
4288         if(!ok)
4289                 return 0;
4290 -
4291 +
4292         return 1;
4293  }
4294
4295 @@ -4418,17 +4555,17 @@ static int yaffs_ReadCheckpointSum(yaffs
4296         __u32 checkpointSum0;
4297         __u32 checkpointSum1;
4298         int ok;
4299 -
4300 +
4301         yaffs_GetCheckpointSum(dev,&checkpointSum0);
4302 -
4303 +
4304         ok = (yaffs_CheckpointRead(dev,&checkpointSum1,sizeof(checkpointSum1)) == sizeof(checkpointSum1));
4305 -
4306 +
4307         if(!ok)
4308                 return 0;
4309 -
4310 +
4311         if(checkpointSum0 != checkpointSum1)
4312                 return 0;
4313 -
4314 +
4315         return 1;
4316  }
4317
4318 @@ -4437,15 +4574,15 @@ static int yaffs_WriteCheckpointData(yaf
4319  {
4320
4321         int ok = 1;
4322 -
4323 +
4324         if(dev->skipCheckpointWrite || !dev->isYaffs2){
4325                 T(YAFFS_TRACE_CHECKPOINT,(TSTR("skipping checkpoint write" TENDSTR)));
4326                 ok = 0;
4327         }
4328 -
4329 +
4330         if(ok)
4331                 ok = yaffs_CheckpointOpen(dev,1);
4332 -
4333 +
4334         if(ok){
4335                 T(YAFFS_TRACE_CHECKPOINT,(TSTR("write checkpoint validity" TENDSTR)));
4336                 ok = yaffs_WriteCheckpointValidityMarker(dev,1);
4337 @@ -4462,18 +4599,18 @@ static int yaffs_WriteCheckpointData(yaf
4338                 T(YAFFS_TRACE_CHECKPOINT,(TSTR("write checkpoint validity" TENDSTR)));
4339                 ok = yaffs_WriteCheckpointValidityMarker(dev,0);
4340         }
4341 -
4342 +
4343         if(ok){
4344                 ok = yaffs_WriteCheckpointSum(dev);
4345         }
4346 -
4347 -
4348 +
4349 +
4350         if(!yaffs_CheckpointClose(dev))
4351                  ok = 0;
4352 -
4353 +
4354         if(ok)
4355                 dev->isCheckpointed = 1;
4356 -        else
4357 +        else
4358                 dev->isCheckpointed = 0;
4359
4360         return dev->isCheckpointed;
4361 @@ -4482,17 +4619,17 @@ static int yaffs_WriteCheckpointData(yaf
4362  static int yaffs_ReadCheckpointData(yaffs_Device *dev)
4363  {
4364         int ok = 1;
4365 -
4366 +
4367         if(dev->skipCheckpointRead || !dev->isYaffs2){
4368                 T(YAFFS_TRACE_CHECKPOINT,(TSTR("skipping checkpoint read" TENDSTR)));
4369                 ok = 0;
4370         }
4371 -
4372 +
4373         if(ok)
4374                 ok = yaffs_CheckpointOpen(dev,0); /* open for read */
4375 -
4376 +
4377         if(ok){
4378 -               T(YAFFS_TRACE_CHECKPOINT,(TSTR("read checkpoint validity" TENDSTR)));
4379 +               T(YAFFS_TRACE_CHECKPOINT,(TSTR("read checkpoint validity" TENDSTR)));
4380                 ok = yaffs_ReadCheckpointValidityMarker(dev,1);
4381         }
4382         if(ok){
4383 @@ -4500,14 +4637,14 @@ static int yaffs_ReadCheckpointData(yaff
4384                 ok = yaffs_ReadCheckpointDevice(dev);
4385         }
4386         if(ok){
4387 -               T(YAFFS_TRACE_CHECKPOINT,(TSTR("read checkpoint objects" TENDSTR)));
4388 +               T(YAFFS_TRACE_CHECKPOINT,(TSTR("read checkpoint objects" TENDSTR)));
4389                 ok = yaffs_ReadCheckpointObjects(dev);
4390         }
4391         if(ok){
4392                 T(YAFFS_TRACE_CHECKPOINT,(TSTR("read checkpoint validity" TENDSTR)));
4393                 ok = yaffs_ReadCheckpointValidityMarker(dev,0);
4394         }
4395 -
4396 +
4397         if(ok){
4398                 ok = yaffs_ReadCheckpointSum(dev);
4399                 T(YAFFS_TRACE_CHECKPOINT,(TSTR("read checkpoint checksum %d" TENDSTR),ok));
4400 @@ -4518,7 +4655,7 @@ static int yaffs_ReadCheckpointData(yaff
4401
4402         if(ok)
4403                 dev->isCheckpointed = 1;
4404 -        else
4405 +        else
4406                 dev->isCheckpointed = 0;
4407
4408         return ok ? 1 : 0;
4409 @@ -4527,7 +4664,7 @@ static int yaffs_ReadCheckpointData(yaff
4410
4411  static void yaffs_InvalidateCheckpoint(yaffs_Device *dev)
4412  {
4413 -       if(dev->isCheckpointed ||
4414 +       if(dev->isCheckpointed ||
4415            dev->blocksInCheckpoint > 0){
4416                 dev->isCheckpointed = 0;
4417                 yaffs_CheckpointInvalidateStream(dev);
4418 @@ -4550,7 +4687,7 @@ int yaffs_CheckpointSave(yaffs_Device *d
4419                 yaffs_InvalidateCheckpoint(dev);
4420                 yaffs_WriteCheckpointData(dev);
4421         }
4422 -
4423 +
4424         T(YAFFS_TRACE_ALWAYS,(TSTR("save exit: isCheckpointed %d"TENDSTR),dev->isCheckpointed));
4425
4426         return dev->isCheckpointed;
4427 @@ -4560,7 +4697,7 @@ int yaffs_CheckpointRestore(yaffs_Device
4428  {
4429         int retval;
4430         T(YAFFS_TRACE_CHECKPOINT,(TSTR("restore entry: isCheckpointed %d"TENDSTR),dev->isCheckpointed));
4431 -
4432 +
4433         retval = yaffs_ReadCheckpointData(dev);
4434
4435         if(dev->isCheckpointed){
4436 @@ -4570,7 +4707,7 @@ int yaffs_CheckpointRestore(yaffs_Device
4437         }
4438
4439         T(YAFFS_TRACE_CHECKPOINT,(TSTR("restore exit: isCheckpointed %d"TENDSTR),dev->isCheckpointed));
4440 -
4441 +
4442         return retval;
4443  }
4444
4445 @@ -4589,7 +4726,7 @@ int yaffs_ReadDataFromFile(yaffs_Object
4446  {
4447
4448         int chunk;
4449 -       int start;
4450 +       __u32 start;
4451         int nToCopy;
4452         int n = nBytes;
4453         int nDone = 0;
4454 @@ -4606,7 +4743,7 @@ int yaffs_ReadDataFromFile(yaffs_Object
4455                 chunk++;
4456
4457                 /* OK now check for the curveball where the start and end are in
4458 -                * the same chunk.
4459 +                * the same chunk.
4460                  */
4461                 if ((start + n) < dev->nDataBytesPerChunk) {
4462                         nToCopy = n;
4463 @@ -4617,10 +4754,10 @@ int yaffs_ReadDataFromFile(yaffs_Object
4464                 cache = yaffs_FindChunkCache(in, chunk);
4465
4466                 /* If the chunk is already in the cache or it is less than a whole chunk
4467 -                * then use the cache (if there is caching)
4468 +                * or we're using inband tags then use the cache (if there is caching)
4469                  * else bypass the cache.
4470                  */
4471 -               if (cache || nToCopy != dev->nDataBytesPerChunk) {
4472 +               if (cache || nToCopy != dev->nDataBytesPerChunk || dev->inbandTags) {
4473                         if (dev->nShortOpCaches > 0) {
4474
4475                                 /* If we can't find the data in the cache, then load it up. */
4476 @@ -4641,14 +4778,9 @@ int yaffs_ReadDataFromFile(yaffs_Object
4477
4478                                 cache->locked = 1;
4479
4480 -#ifdef CONFIG_YAFFS_WINCE
4481 -                               yfsd_UnlockYAFFS(TRUE);
4482 -#endif
4483 +
4484                                 memcpy(buffer, &cache->data[start], nToCopy);
4485
4486 -#ifdef CONFIG_YAFFS_WINCE
4487 -                               yfsd_LockYAFFS(TRUE);
4488 -#endif
4489                                 cache->locked = 0;
4490                         } else {
4491                                 /* Read into the local buffer then copy..*/
4492 @@ -4657,41 +4789,19 @@ int yaffs_ReadDataFromFile(yaffs_Object
4493                                     yaffs_GetTempBuffer(dev, __LINE__);
4494                                 yaffs_ReadChunkDataFromObject(in, chunk,
4495                                                               localBuffer);
4496 -#ifdef CONFIG_YAFFS_WINCE
4497 -                               yfsd_UnlockYAFFS(TRUE);
4498 -#endif
4499 +
4500                                 memcpy(buffer, &localBuffer[start], nToCopy);
4501
4502 -#ifdef CONFIG_YAFFS_WINCE
4503 -                               yfsd_LockYAFFS(TRUE);
4504 -#endif
4505 +
4506                                 yaffs_ReleaseTempBuffer(dev, localBuffer,
4507                                                         __LINE__);
4508                         }
4509
4510                 } else {
4511 -#ifdef CONFIG_YAFFS_WINCE
4512 -                       __u8 *localBuffer = yaffs_GetTempBuffer(dev, __LINE__);
4513 -
4514 -                       /* Under WinCE can't do direct transfer. Need to use a local buffer.
4515 -                        * This is because we otherwise screw up WinCE's memory mapper
4516 -                        */
4517 -                       yaffs_ReadChunkDataFromObject(in, chunk, localBuffer);
4518 -
4519 -#ifdef CONFIG_YAFFS_WINCE
4520 -                       yfsd_UnlockYAFFS(TRUE);
4521 -#endif
4522 -                       memcpy(buffer, localBuffer, dev->nDataBytesPerChunk);
4523
4524 -#ifdef CONFIG_YAFFS_WINCE
4525 -                       yfsd_LockYAFFS(TRUE);
4526 -                       yaffs_ReleaseTempBuffer(dev, localBuffer, __LINE__);
4527 -#endif
4528 -
4529 -#else
4530                         /* A full chunk. Read directly into the supplied buffer. */
4531                         yaffs_ReadChunkDataFromObject(in, chunk, buffer);
4532 -#endif
4533 +
4534                 }
4535
4536                 n -= nToCopy;
4537 @@ -4709,14 +4819,15 @@ int yaffs_WriteDataToFile(yaffs_Object *
4538  {
4539
4540         int chunk;
4541 -       int start;
4542 +       __u32 start;
4543         int nToCopy;
4544 -       int n = nBytes;
4545 -       int nDone = 0;
4546 -       int nToWriteBack;
4547 -       int startOfWrite = offset;
4548 -       int chunkWritten = 0;
4549 -       int nBytesRead;
4550 +        int n = nBytes;
4551 +        int nDone = 0;
4552 +        int nToWriteBack;
4553 +        int startOfWrite = offset;
4554 +        int chunkWritten = 0;
4555 +        __u32 nBytesRead;
4556 +        __u32 chunkStart;
4557
4558         yaffs_Device *dev;
4559
4560 @@ -4726,6 +4837,12 @@ int yaffs_WriteDataToFile(yaffs_Object *
4561                 //chunk = offset / dev->nDataBytesPerChunk + 1;
4562                 //start = offset % dev->nDataBytesPerChunk;
4563                 yaffs_AddrToChunk(dev,offset,&chunk,&start);
4564 +
4565 +               if(chunk * dev->nDataBytesPerChunk + start != offset ||
4566 +                  start >= dev->nDataBytesPerChunk){
4567 +                  T(YAFFS_TRACE_ERROR,(TSTR("AddrToChunk of offset %d gives chunk %d start %d"TENDSTR),
4568 +                                       (int)offset, chunk,start));
4569 +               }
4570                 chunk++;
4571
4572                 /* OK now check for the curveball where the start and end are in
4573 @@ -4740,9 +4857,12 @@ int yaffs_WriteDataToFile(yaffs_Object *
4574                          * we need to write back as much as was there before.
4575                          */
4576
4577 -                       nBytesRead =
4578 -                           in->variant.fileVariant.fileSize -
4579 -                           ((chunk - 1) * dev->nDataBytesPerChunk);
4580 +                       chunkStart = ((chunk - 1) * dev->nDataBytesPerChunk);
4581 +
4582 +                       if(chunkStart > in->variant.fileVariant.fileSize)
4583 +                               nBytesRead = 0; /* Past end of file */
4584 +                       else
4585 +                               nBytesRead = in->variant.fileVariant.fileSize - chunkStart;
4586
4587                         if (nBytesRead > dev->nDataBytesPerChunk) {
4588                                 nBytesRead = dev->nDataBytesPerChunk;
4589 @@ -4751,19 +4871,24 @@ int yaffs_WriteDataToFile(yaffs_Object *
4590                         nToWriteBack =
4591                             (nBytesRead >
4592                              (start + n)) ? nBytesRead : (start + n);
4593 +
4594 +                       if(nToWriteBack < 0 || nToWriteBack > dev->nDataBytesPerChunk)
4595 +                               YBUG();
4596
4597                 } else {
4598                         nToCopy = dev->nDataBytesPerChunk - start;
4599                         nToWriteBack = dev->nDataBytesPerChunk;
4600                 }
4601
4602 -               if (nToCopy != dev->nDataBytesPerChunk) {
4603 -                       /* An incomplete start or end chunk (or maybe both start and end chunk) */
4604 +               if (nToCopy != dev->nDataBytesPerChunk || dev->inbandTags) {
4605 +                       /* An incomplete start or end chunk (or maybe both start and end chunk),
4606 +                        * or we're using inband tags, so we want to use the cache buffers.
4607 +                        */
4608                         if (dev->nShortOpCaches > 0) {
4609                                 yaffs_ChunkCache *cache;
4610                                 /* If we can't find the data in the cache, then load the cache */
4611                                 cache = yaffs_FindChunkCache(in, chunk);
4612 -
4613 +
4614                                 if (!cache
4615                                     && yaffs_CheckSpaceForAllocation(in->
4616                                                                      myDev)) {
4617 @@ -4776,28 +4901,24 @@ int yaffs_WriteDataToFile(yaffs_Object *
4618                                                                       cache->
4619                                                                       data);
4620                                 }
4621 -                               else if(cache &&
4622 +                               else if(cache &&
4623                                         !cache->dirty &&
4624                                         !yaffs_CheckSpaceForAllocation(in->myDev)){
4625                                         /* Drop the cache if it was a read cache item and
4626                                          * no space check has been made for it.
4627 -                                        */
4628 +                                        */
4629                                          cache = NULL;
4630                                 }
4631
4632                                 if (cache) {
4633                                         yaffs_UseChunkCache(dev, cache, 1);
4634                                         cache->locked = 1;
4635 -#ifdef CONFIG_YAFFS_WINCE
4636 -                                       yfsd_UnlockYAFFS(TRUE);
4637 -#endif
4638 +
4639
4640                                         memcpy(&cache->data[start], buffer,
4641                                                nToCopy);
4642
4643 -#ifdef CONFIG_YAFFS_WINCE
4644 -                                       yfsd_LockYAFFS(TRUE);
4645 -#endif
4646 +
4647                                         cache->locked = 0;
4648                                         cache->nBytes = nToWriteBack;
4649
4650 @@ -4825,15 +4946,10 @@ int yaffs_WriteDataToFile(yaffs_Object *
4651                                 yaffs_ReadChunkDataFromObject(in, chunk,
4652                                                               localBuffer);
4653
4654 -#ifdef CONFIG_YAFFS_WINCE
4655 -                               yfsd_UnlockYAFFS(TRUE);
4656 -#endif
4657 +
4658
4659                                 memcpy(&localBuffer[start], buffer, nToCopy);
4660
4661 -#ifdef CONFIG_YAFFS_WINCE
4662 -                               yfsd_LockYAFFS(TRUE);
4663 -#endif
4664                                 chunkWritten =
4665                                     yaffs_WriteChunkDataToObject(in, chunk,
4666                                                                  localBuffer,
4667 @@ -4846,31 +4962,15 @@ int yaffs_WriteDataToFile(yaffs_Object *
4668                         }
4669
4670                 } else {
4671 -
4672 -#ifdef CONFIG_YAFFS_WINCE
4673 -                       /* Under WinCE can't do direct transfer. Need to use a local buffer.
4674 -                        * This is because we otherwise screw up WinCE's memory mapper
4675 -                        */
4676 -                       __u8 *localBuffer = yaffs_GetTempBuffer(dev, __LINE__);
4677 -#ifdef CONFIG_YAFFS_WINCE
4678 -                       yfsd_UnlockYAFFS(TRUE);
4679 -#endif
4680 -                       memcpy(localBuffer, buffer, dev->nDataBytesPerChunk);
4681 -#ifdef CONFIG_YAFFS_WINCE
4682 -                       yfsd_LockYAFFS(TRUE);
4683 -#endif
4684 -                       chunkWritten =
4685 -                           yaffs_WriteChunkDataToObject(in, chunk, localBuffer,
4686 -                                                        dev->nDataBytesPerChunk,
4687 -                                                        0);
4688 -                       yaffs_ReleaseTempBuffer(dev, localBuffer, __LINE__);
4689 -#else
4690                         /* A full chunk. Write directly from the supplied buffer. */
4691 +
4692 +
4693 +
4694                         chunkWritten =
4695                             yaffs_WriteChunkDataToObject(in, chunk, buffer,
4696                                                          dev->nDataBytesPerChunk,
4697                                                          0);
4698 -#endif
4699 +
4700                         /* Since we've overwritten the cached data, we better invalidate it. */
4701                         yaffs_InvalidateChunkCache(in, chunk);
4702                 }
4703 @@ -4943,9 +5043,9 @@ int yaffs_ResizeFile(yaffs_Object * in,
4704  {
4705
4706         int oldFileSize = in->variant.fileVariant.fileSize;
4707 -       int newSizeOfPartialChunk;
4708 +       __u32 newSizeOfPartialChunk;
4709         int newFullChunks;
4710 -
4711 +
4712         yaffs_Device *dev = in->myDev;
4713
4714         yaffs_AddrToChunk(dev, newSize, &newFullChunks, &newSizeOfPartialChunk);
4715 @@ -4953,23 +5053,23 @@ int yaffs_ResizeFile(yaffs_Object * in,
4716         yaffs_FlushFilesChunkCache(in);
4717         yaffs_InvalidateWholeChunkCache(in);
4718
4719 -       yaffs_CheckGarbageCollection(dev);
4720 +        yaffs_CheckGarbageCollection(dev);
4721
4722 -       if (in->variantType != YAFFS_OBJECT_TYPE_FILE) {
4723 -               return yaffs_GetFileSize(in);
4724 -       }
4725 +        if (in->variantType != YAFFS_OBJECT_TYPE_FILE) {
4726 +                return YAFFS_FAIL;
4727 +        }
4728
4729 -       if (newSize == oldFileSize) {
4730 -               return oldFileSize;
4731 -       }
4732 +        if (newSize == oldFileSize) {
4733 +                return YAFFS_OK;
4734 +        }
4735
4736 -       if (newSize < oldFileSize) {
4737 +        if (newSize < oldFileSize) {
4738
4739                 yaffs_PruneResizedChunks(in, newSize);
4740
4741                 if (newSizeOfPartialChunk != 0) {
4742                         int lastChunk = 1 + newFullChunks;
4743 -
4744 +
4745                         __u8 *localBuffer = yaffs_GetTempBuffer(dev, __LINE__);
4746
4747                         /* Got to read and rewrite the last chunk with its new size and zero pad */
4748 @@ -4993,19 +5093,20 @@ int yaffs_ResizeFile(yaffs_Object * in,
4749                 in->variant.fileVariant.fileSize = newSize;
4750         }
4751
4752 -
4753 -
4754 +
4755 +
4756         /* Write a new object header.
4757          * show we've shrunk the file, if need be
4758          * Do this only if the file is not in the deleted directories.
4759          */
4760 -       if (in->parent->objectId != YAFFS_OBJECTID_UNLINKED &&
4761 +       if (in->parent &&
4762 +           in->parent->objectId != YAFFS_OBJECTID_UNLINKED &&
4763             in->parent->objectId != YAFFS_OBJECTID_DELETED) {
4764                 yaffs_UpdateObjectHeader(in, NULL, 0,
4765                                          (newSize < oldFileSize) ? 1 : 0, 0);
4766         }
4767
4768 -       return newSize;
4769 +       return YAFFS_OK;
4770  }
4771
4772  loff_t yaffs_GetFileSize(yaffs_Object * obj)
4773 @@ -5058,13 +5159,13 @@ static int yaffs_DoGenericObjectDeletion
4774
4775         if (in->myDev->isYaffs2 && (in->parent != in->myDev->deletedDir)) {
4776                 /* Move to the unlinked directory so we have a record that it was deleted. */
4777 -               yaffs_ChangeObjectName(in, in->myDev->deletedDir,"deleted", 0, 0);
4778 +               yaffs_ChangeObjectName(in, in->myDev->deletedDir,_Y("deleted"), 0, 0);
4779
4780         }
4781
4782         yaffs_RemoveObjectFromDirectory(in);
4783 -       yaffs_DeleteChunk(in->myDev, in->chunkId, 1, __LINE__);
4784 -       in->chunkId = -1;
4785 +       yaffs_DeleteChunk(in->myDev, in->hdrChunk, 1, __LINE__);
4786 +       in->hdrChunk = 0;
4787
4788         yaffs_FreeObject(in);
4789         return YAFFS_OK;
4790 @@ -5075,62 +5176,66 @@ static int yaffs_DoGenericObjectDeletion
4791   * and the inode associated with the file.
4792   * It does not delete the links associated with the file.
4793   */
4794 +
4795  static int yaffs_UnlinkFile(yaffs_Object * in)
4796  {
4797
4798         int retVal;
4799         int immediateDeletion = 0;
4800
4801 -       if (1) {
4802  #ifdef __KERNEL__
4803 -               if (!in->myInode) {
4804 -                       immediateDeletion = 1;
4805 -
4806 -               }
4807 +       if (!in->myInode) {
4808 +               immediateDeletion = 1;
4809 +       }
4810  #else
4811 -               if (in->inUse <= 0) {
4812 -                       immediateDeletion = 1;
4813 -
4814 -               }
4815 +       if (in->inUse <= 0) {
4816 +               immediateDeletion = 1;
4817 +       }
4818  #endif
4819 -               if (immediateDeletion) {
4820 -                       retVal =
4821 -                           yaffs_ChangeObjectName(in, in->myDev->deletedDir,
4822 -                                                  "deleted", 0, 0);
4823 -                       T(YAFFS_TRACE_TRACING,
4824 -                         (TSTR("yaffs: immediate deletion of file %d" TENDSTR),
4825 -                          in->objectId));
4826 -                       in->deleted = 1;
4827 -                       in->myDev->nDeletedFiles++;
4828 -                       if (0 && in->myDev->isYaffs2) {
4829 -                               yaffs_ResizeFile(in, 0);
4830 -                       }
4831 -                       yaffs_SoftDeleteFile(in);
4832 -               } else {
4833 -                       retVal =
4834 -                           yaffs_ChangeObjectName(in, in->myDev->unlinkedDir,
4835 -                                                  "unlinked", 0, 0);
4836 -               }
4837
4838 +       if (immediateDeletion) {
4839 +               retVal =
4840 +                   yaffs_ChangeObjectName(in, in->myDev->deletedDir,
4841 +                                          _Y("deleted"), 0, 0);
4842 +               T(YAFFS_TRACE_TRACING,
4843 +                 (TSTR("yaffs: immediate deletion of file %d" TENDSTR),
4844 +                  in->objectId));
4845 +               in->deleted = 1;
4846 +               in->myDev->nDeletedFiles++;
4847 +               if (1 || in->myDev->isYaffs2) {
4848 +                       yaffs_ResizeFile(in, 0);
4849 +               }
4850 +               yaffs_SoftDeleteFile(in);
4851 +       } else {
4852 +               retVal =
4853 +                   yaffs_ChangeObjectName(in, in->myDev->unlinkedDir,
4854 +                                          _Y("unlinked"), 0, 0);
4855         }
4856 +
4857 +
4858         return retVal;
4859  }
4860
4861  int yaffs_DeleteFile(yaffs_Object * in)
4862  {
4863         int retVal = YAFFS_OK;
4864 +       int deleted = in->deleted;
4865 +
4866 +       yaffs_ResizeFile(in,0);
4867
4868         if (in->nDataChunks > 0) {
4869 -               /* Use soft deletion if there is data in the file */
4870 +               /* Use soft deletion if there is data in the file.
4871 +                * That won't be the case if it has been resized to zero.
4872 +                */
4873                 if (!in->unlinked) {
4874                         retVal = yaffs_UnlinkFile(in);
4875                 }
4876                 if (retVal == YAFFS_OK && in->unlinked && !in->deleted) {
4877 -                       in->deleted = 1;
4878 +                       in->deleted = deleted = 1;
4879                         in->myDev->nDeletedFiles++;
4880                         yaffs_SoftDeleteFile(in);
4881                 }
4882 -               return in->deleted ? YAFFS_OK : YAFFS_FAIL;
4883 +               return deleted ? YAFFS_OK : YAFFS_FAIL;
4884         } else {
4885                 /* The file has no data chunks so we toss it immediately */
4886                 yaffs_FreeTnode(in->myDev, in->variant.fileVariant.top);
4887 @@ -5143,10 +5248,10 @@ int yaffs_DeleteFile(yaffs_Object * in)
4888
4889  static int yaffs_DeleteDirectory(yaffs_Object * in)
4890  {
4891 -       /* First check that the directory is empty. */
4892 -       if (list_empty(&in->variant.directoryVariant.children)) {
4893 -               return yaffs_DoGenericObjectDeletion(in);
4894 -       }
4895 +        /* First check that the directory is empty. */
4896 +        if (ylist_empty(&in->variant.directoryVariant.children)) {
4897 +                return yaffs_DoGenericObjectDeletion(in);
4898 +        }
4899
4900         return YAFFS_FAIL;
4901
4902 @@ -5161,11 +5266,11 @@ static int yaffs_DeleteSymLink(yaffs_Obj
4903
4904  static int yaffs_DeleteHardLink(yaffs_Object * in)
4905  {
4906 -       /* remove this hardlink from the list assocaited with the equivalent
4907 -        * object
4908 -        */
4909 -       list_del(&in->hardLinks);
4910 -       return yaffs_DoGenericObjectDeletion(in);
4911 +        /* remove this hardlink from the list assocaited with the equivalent
4912 +         * object
4913 +         */
4914 +        ylist_del_init(&in->hardLinks);
4915 +        return yaffs_DoGenericObjectDeletion(in);
4916  }
4917
4918  static void yaffs_DestroyObject(yaffs_Object * obj)
4919 @@ -5194,12 +5299,12 @@ static void yaffs_DestroyObject(yaffs_Ob
4920  static int yaffs_UnlinkWorker(yaffs_Object * obj)
4921  {
4922
4923 -       if (obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK) {
4924 -               return yaffs_DeleteHardLink(obj);
4925 -       } else if (!list_empty(&obj->hardLinks)) {
4926 -               /* Curve ball: We're unlinking an object that has a hardlink.
4927 -                *
4928 -                * This problem arises because we are not strictly following
4929 +        if (obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK) {
4930 +                return yaffs_DeleteHardLink(obj);
4931 +        } else if (!ylist_empty(&obj->hardLinks)) {
4932 +                /* Curve ball: We're unlinking an object that has a hardlink.
4933 +                 *
4934 +                 * This problem arises because we are not strictly following
4935                  * The Linux link/inode model.
4936                  *
4937                  * We can't really delete the object.
4938 @@ -5212,15 +5317,15 @@ static int yaffs_UnlinkWorker(yaffs_Obje
4939                  */
4940
4941                 yaffs_Object *hl;
4942 -               int retVal;
4943 -               YCHAR name[YAFFS_MAX_NAME_LENGTH + 1];
4944 +                int retVal;
4945 +                YCHAR name[YAFFS_MAX_NAME_LENGTH + 1];
4946
4947 -               hl = list_entry(obj->hardLinks.next, yaffs_Object, hardLinks);
4948 +                hl = ylist_entry(obj->hardLinks.next, yaffs_Object, hardLinks);
4949
4950 -               list_del_init(&hl->hardLinks);
4951 -               list_del_init(&hl->siblings);
4952 +                ylist_del_init(&hl->hardLinks);
4953 +                ylist_del_init(&hl->siblings);
4954
4955 -               yaffs_GetObjectName(hl, name, YAFFS_MAX_NAME_LENGTH + 1);
4956 +                yaffs_GetObjectName(hl, name, YAFFS_MAX_NAME_LENGTH + 1);
4957
4958                 retVal = yaffs_ChangeObjectName(obj, hl->parent, name, 0, 0);
4959
4960 @@ -5313,7 +5418,7 @@ static void yaffs_HardlinkFixup(yaffs_De
4961  {
4962         yaffs_Object *hl;
4963         yaffs_Object *in;
4964 -
4965 +
4966         while (hardList) {
4967                 hl = hardList;
4968                 hardList = (yaffs_Object *) (hardList->hardLinks.next);
4969 @@ -5322,18 +5427,18 @@ static void yaffs_HardlinkFixup(yaffs_De
4970                                               hl->variant.hardLinkVariant.
4971                                               equivalentObjectId);
4972
4973 -               if (in) {
4974 -                       /* Add the hardlink pointers */
4975 -                       hl->variant.hardLinkVariant.equivalentObject = in;
4976 -                       list_add(&hl->hardLinks, &in->hardLinks);
4977 -               } else {
4978 -                       /* Todo Need to report/handle this better.
4979 -                        * Got a problem... hardlink to a non-existant object
4980 -                        */
4981 -                       hl->variant.hardLinkVariant.equivalentObject = NULL;
4982 -                       INIT_LIST_HEAD(&hl->hardLinks);
4983 +                if (in) {
4984 +                        /* Add the hardlink pointers */
4985 +                        hl->variant.hardLinkVariant.equivalentObject = in;
4986 +                        ylist_add(&hl->hardLinks, &in->hardLinks);
4987 +                } else {
4988 +                        /* Todo Need to report/handle this better.
4989 +                         * Got a problem... hardlink to a non-existant object
4990 +                         */
4991 +                        hl->variant.hardLinkVariant.equivalentObject = NULL;
4992 +                        YINIT_LIST_HEAD(&hl->hardLinks);
4993
4994 -               }
4995 +                }
4996
4997         }
4998
4999 @@ -5355,6 +5460,42 @@ static int ybicmp(const void *a, const v
5000
5001  }
5002
5003 +
5004 +struct yaffs_ShadowFixerStruct {
5005 +       int objectId;
5006 +       int shadowedId;
5007 +       struct yaffs_ShadowFixerStruct *next;
5008 +};
5009 +
5010 +
5011 +static void yaffs_StripDeletedObjects(yaffs_Device *dev)
5012 +{
5013 +       /*
5014 +       *  Sort out state of unlinked and deleted objects after scanning.
5015 +       */
5016 +       struct ylist_head *i;
5017 +       struct ylist_head *n;
5018 +       yaffs_Object *l;
5019 +
5020 +       /* Soft delete all the unlinked files */
5021 +       ylist_for_each_safe(i, n,
5022 +               &dev->unlinkedDir->variant.directoryVariant.children) {
5023 +               if (i) {
5024 +                       l = ylist_entry(i, yaffs_Object, siblings);
5025 +                       yaffs_DestroyObject(l);
5026 +               }
5027 +       }
5028 +
5029 +       ylist_for_each_safe(i, n,
5030 +               &dev->deletedDir->variant.directoryVariant.children) {
5031 +               if (i) {
5032 +                       l = ylist_entry(i, yaffs_Object, siblings);
5033 +                       yaffs_DestroyObject(l);
5034 +               }
5035 +       }
5036 +
5037 +}
5038 +
5039  static int yaffs_Scan(yaffs_Device * dev)
5040  {
5041         yaffs_ExtendedTags tags;
5042 @@ -5362,7 +5503,6 @@ static int yaffs_Scan(yaffs_Device * dev
5043         int blockIterator;
5044         int startIterator;
5045         int endIterator;
5046 -       int nBlocksToScan = 0;
5047         int result;
5048
5049         int chunk;
5050 @@ -5371,27 +5511,20 @@ static int yaffs_Scan(yaffs_Device * dev
5051         yaffs_BlockState state;
5052         yaffs_Object *hardList = NULL;
5053         yaffs_BlockInfo *bi;
5054 -       int sequenceNumber;
5055 +       __u32 sequenceNumber;
5056         yaffs_ObjectHeader *oh;
5057         yaffs_Object *in;
5058         yaffs_Object *parent;
5059 -       int nBlocks = dev->internalEndBlock - dev->internalStartBlock + 1;
5060 -
5061 +
5062         int alloc_failed = 0;
5063 -
5064 +
5065 +       struct yaffs_ShadowFixerStruct *shadowFixerList = NULL;
5066 +
5067
5068         __u8 *chunkData;
5069
5070 -       yaffs_BlockIndex *blockIndex = NULL;
5071 -
5072 -       if (dev->isYaffs2) {
5073 -               T(YAFFS_TRACE_SCAN,
5074 -                 (TSTR("yaffs_Scan is not for YAFFS2!" TENDSTR)));
5075 -               return YAFFS_FAIL;
5076 -       }
5077 -
5078 -       //TODO  Throw all the yaffs2 stuuf out of yaffs_Scan since it is only for yaffs1 format.
5079 -
5080 +
5081 +
5082         T(YAFFS_TRACE_SCAN,
5083           (TSTR("yaffs_Scan starts  intstartblk %d intendblk %d..." TENDSTR),
5084            dev->internalStartBlock, dev->internalEndBlock));
5085 @@ -5400,12 +5533,6 @@ static int yaffs_Scan(yaffs_Device * dev
5086
5087         dev->sequenceNumber = YAFFS_LOWEST_SEQUENCE_NUMBER;
5088
5089 -       if (dev->isYaffs2) {
5090 -               blockIndex = YMALLOC(nBlocks * sizeof(yaffs_BlockIndex));
5091 -               if(!blockIndex)
5092 -                       return YAFFS_FAIL;
5093 -       }
5094 -
5095         /* Scan all the blocks to determine their state */
5096         for (blk = dev->internalStartBlock; blk <= dev->internalEndBlock; blk++) {
5097                 bi = yaffs_GetBlockInfo(dev, blk);
5098 @@ -5430,70 +5557,21 @@ static int yaffs_Scan(yaffs_Device * dev
5099                           (TSTR("Block empty " TENDSTR)));
5100                         dev->nErasedBlocks++;
5101                         dev->nFreeChunks += dev->nChunksPerBlock;
5102 -               } else if (state == YAFFS_BLOCK_STATE_NEEDS_SCANNING) {
5103 -
5104 -                       /* Determine the highest sequence number */
5105 -                       if (dev->isYaffs2 &&
5106 -                           sequenceNumber >= YAFFS_LOWEST_SEQUENCE_NUMBER &&
5107 -                           sequenceNumber < YAFFS_HIGHEST_SEQUENCE_NUMBER) {
5108 -
5109 -                               blockIndex[nBlocksToScan].seq = sequenceNumber;
5110 -                               blockIndex[nBlocksToScan].block = blk;
5111 -
5112 -                               nBlocksToScan++;
5113 -
5114 -                               if (sequenceNumber >= dev->sequenceNumber) {
5115 -                                       dev->sequenceNumber = sequenceNumber;
5116 -                               }
5117 -                       } else if (dev->isYaffs2) {
5118 -                               /* TODO: Nasty sequence number! */
5119 -                               T(YAFFS_TRACE_SCAN,
5120 -                                 (TSTR
5121 -                                  ("Block scanning block %d has bad sequence number %d"
5122 -                                   TENDSTR), blk, sequenceNumber));
5123 -
5124 -                       }
5125 -               }
5126 +               }
5127         }
5128
5129 -       /* Sort the blocks
5130 -        * Dungy old bubble sort for now...
5131 -        */
5132 -       if (dev->isYaffs2) {
5133 -               yaffs_BlockIndex temp;
5134 -               int i;
5135 -               int j;
5136 -
5137 -               for (i = 0; i < nBlocksToScan; i++)
5138 -                       for (j = i + 1; j < nBlocksToScan; j++)
5139 -                               if (blockIndex[i].seq > blockIndex[j].seq) {
5140 -                                       temp = blockIndex[j];
5141 -                                       blockIndex[j] = blockIndex[i];
5142 -                                       blockIndex[i] = temp;
5143 -                               }
5144 -       }
5145 -
5146 -       /* Now scan the blocks looking at the data. */
5147 -       if (dev->isYaffs2) {
5148 -               startIterator = 0;
5149 -               endIterator = nBlocksToScan - 1;
5150 -               T(YAFFS_TRACE_SCAN_DEBUG,
5151 -                 (TSTR("%d blocks to be scanned" TENDSTR), nBlocksToScan));
5152 -       } else {
5153 -               startIterator = dev->internalStartBlock;
5154 -               endIterator = dev->internalEndBlock;
5155 -       }
5156 +       startIterator = dev->internalStartBlock;
5157 +       endIterator = dev->internalEndBlock;
5158
5159         /* For each block.... */
5160         for (blockIterator = startIterator; !alloc_failed && blockIterator <= endIterator;
5161              blockIterator++) {
5162 +
5163 +               YYIELD();
5164
5165 -               if (dev->isYaffs2) {
5166 -                       /* get the block to scan in the correct order */
5167 -                       blk = blockIndex[blockIterator].block;
5168 -               } else {
5169 -                       blk = blockIterator;
5170 -               }
5171 +               YYIELD();
5172 +
5173 +               blk = blockIterator;
5174
5175                 bi = yaffs_GetBlockInfo(dev, blk);
5176                 state = bi->blockState;
5177 @@ -5511,7 +5589,7 @@ static int yaffs_Scan(yaffs_Device * dev
5178
5179                         /* Let's have a good look at this chunk... */
5180
5181 -                       if (!dev->isYaffs2 && tags.chunkDeleted) {
5182 +                       if (tags.eccResult == YAFFS_ECC_RESULT_UNFIXED || tags.chunkDeleted) {
5183                                 /* YAFFS1 only...
5184                                  * A deleted chunk
5185                                  */
5186 @@ -5520,7 +5598,7 @@ static int yaffs_Scan(yaffs_Device * dev
5187                                 /*T((" %d %d deleted\n",blk,c)); */
5188                         } else if (!tags.chunkUsed) {
5189                                 /* An unassigned chunk in the block
5190 -                                * This means that either the block is empty or
5191 +                                * This means that either the block is empty or
5192                                  * this is the one being allocated from
5193                                  */
5194
5195 @@ -5537,21 +5615,9 @@ static int yaffs_Scan(yaffs_Device * dev
5196                                         state = YAFFS_BLOCK_STATE_ALLOCATING;
5197                                         dev->allocationBlock = blk;
5198                                         dev->allocationPage = c;
5199 -                                       dev->allocationBlockFinder = blk;
5200 +                                       dev->allocationBlockFinder = blk;
5201                                         /* Set it to here to encourage the allocator to go forth from here. */
5202 -
5203 -                                       /* Yaffs2 sanity check:
5204 -                                        * This should be the one with the highest sequence number
5205 -                                        */
5206 -                                       if (dev->isYaffs2
5207 -                                           && (dev->sequenceNumber !=
5208 -                                               bi->sequenceNumber)) {
5209 -                                               T(YAFFS_TRACE_ALWAYS,
5210 -                                                 (TSTR
5211 -                                                  ("yaffs: Allocation block %d was not highest sequence id:"
5212 -                                                   " block seq = %d, dev seq = %d"
5213 -                                                   TENDSTR), blk,bi->sequenceNumber,dev->sequenceNumber));
5214 -                                       }
5215 +
5216                                 }
5217
5218                                 dev->nFreeChunks += (dev->nChunksPerBlock - c);
5219 @@ -5569,7 +5635,7 @@ static int yaffs_Scan(yaffs_Device * dev
5220                                 /* PutChunkIntoFile checks for a clash (two data chunks with
5221                                  * the same chunkId).
5222                                  */
5223 -
5224 +
5225                                 if(!in)
5226                                         alloc_failed = 1;
5227
5228 @@ -5577,11 +5643,11 @@ static int yaffs_Scan(yaffs_Device * dev
5229                                         if(!yaffs_PutChunkIntoFile(in, tags.chunkId, chunk,1))
5230                                                 alloc_failed = 1;
5231                                 }
5232 -
5233 +
5234                                 endpos =
5235                                     (tags.chunkId - 1) * dev->nDataBytesPerChunk +
5236                                     tags.byteCount;
5237 -                               if (in &&
5238 +                               if (in &&
5239                                     in->variantType == YAFFS_OBJECT_TYPE_FILE
5240                                     && in->variant.fileVariant.scannedFileSize <
5241                                     endpos) {
5242 @@ -5613,7 +5679,7 @@ static int yaffs_Scan(yaffs_Device * dev
5243                                                               tags.objectId);
5244                                 if (in && in->variantType != oh->type) {
5245                                         /* This should not happen, but somehow
5246 -                                        * Wev'e ended up with an objectId that has been reused but not yet
5247 +                                        * Wev'e ended up with an objectId that has been reused but not yet
5248                                          * deleted, and worse still it has changed type. Delete the old object.
5249                                          */
5250
5251 @@ -5629,12 +5695,18 @@ static int yaffs_Scan(yaffs_Device * dev
5252
5253                                 if(!in)
5254                                         alloc_failed = 1;
5255 -
5256 +
5257                                 if (in && oh->shadowsObject > 0) {
5258 -                                       yaffs_HandleShadowedObject(dev,
5259 -                                                                  oh->
5260 -                                                                  shadowsObject,
5261 -                                                                  0);
5262 +
5263 +                                       struct yaffs_ShadowFixerStruct *fixer;
5264 +                                       fixer = YMALLOC(sizeof(struct yaffs_ShadowFixerStruct));
5265 +                                       if(fixer){
5266 +                                               fixer-> next = shadowFixerList;
5267 +                                               shadowFixerList = fixer;
5268 +                                               fixer->objectId = tags.objectId;
5269 +                                               fixer->shadowedId = oh->shadowsObject;
5270 +                                       }
5271 +
5272                                 }
5273
5274                                 if (in && in->valid) {
5275 @@ -5643,12 +5715,10 @@ static int yaffs_Scan(yaffs_Device * dev
5276                                         unsigned existingSerial = in->serial;
5277                                         unsigned newSerial = tags.serialNumber;
5278
5279 -                                       if (dev->isYaffs2 ||
5280 -                                           ((existingSerial + 1) & 3) ==
5281 -                                           newSerial) {
5282 +                                       if (((existingSerial + 1) & 3) == newSerial) {
5283                                                 /* Use new one - destroy the exisiting one */
5284                                                 yaffs_DeleteChunk(dev,
5285 -                                                                 in->chunkId,
5286 +                                                                 in->hdrChunk,
5287                                                                   1, __LINE__);
5288                                                 in->valid = 0;
5289                                         } else {
5290 @@ -5681,7 +5751,8 @@ static int yaffs_Scan(yaffs_Device * dev
5291                                         in->yst_ctime = oh->yst_ctime;
5292                                         in->yst_rdev = oh->yst_rdev;
5293  #endif
5294 -                                       in->chunkId = chunk;
5295 +                                       in->hdrChunk = chunk;
5296 +                                       in->serial = tags.serialNumber;
5297
5298                                 } else if (in && !in->valid) {
5299                                         /* we need to load this info */
5300 @@ -5705,7 +5776,8 @@ static int yaffs_Scan(yaffs_Device * dev
5301                                         in->yst_ctime = oh->yst_ctime;
5302                                         in->yst_rdev = oh->yst_rdev;
5303  #endif
5304 -                                       in->chunkId = chunk;
5305 +                                       in->hdrChunk = chunk;
5306 +                                       in->serial = tags.serialNumber;
5307
5308                                         yaffs_SetObjectName(in, oh->name);
5309                                         in->dirty = 0;
5310 @@ -5720,13 +5792,13 @@ static int yaffs_Scan(yaffs_Device * dev
5311                                              YAFFS_OBJECT_TYPE_DIRECTORY);
5312                                         if (parent->variantType ==
5313                                             YAFFS_OBJECT_TYPE_UNKNOWN) {
5314 -                                               /* Set up as a directory */
5315 -                                               parent->variantType =
5316 -                                                   YAFFS_OBJECT_TYPE_DIRECTORY;
5317 -                                               INIT_LIST_HEAD(&parent->variant.
5318 -                                                              directoryVariant.
5319 -                                                              children);
5320 -                                       } else if (parent->variantType !=
5321 +                                                /* Set up as a directory */
5322 +                                                parent->variantType =
5323 +                                                    YAFFS_OBJECT_TYPE_DIRECTORY;
5324 +                                                YINIT_LIST_HEAD(&parent->variant.
5325 +                                                               directoryVariant.
5326 +                                                               children);
5327 +                                        } else if (parent->variantType !=
5328                                                    YAFFS_OBJECT_TYPE_DIRECTORY)
5329                                         {
5330                                                 /* Hoosterman, another problem....
5331 @@ -5735,8 +5807,7 @@ static int yaffs_Scan(yaffs_Device * dev
5332
5333                                                 T(YAFFS_TRACE_ERROR,
5334                                                   (TSTR
5335 -                                                  ("yaffs tragedy: attempting to use non-directory as"
5336 -                                                   " a directory in scan. Put in lost+found."
5337 +                                                  ("yaffs tragedy: attempting to use non-directory as a directory in scan. Put in lost+found."
5338                                                     TENDSTR)));
5339                                                 parent = dev->lostNFoundDir;
5340                                         }
5341 @@ -5752,23 +5823,14 @@ static int yaffs_Scan(yaffs_Device * dev
5342                                          * Since we might scan a hardlink before its equivalent object is scanned
5343                                          * we put them all in a list.
5344                                          * After scanning is complete, we should have all the objects, so we run through this
5345 -                                        * list and fix up all the chains.
5346 +                                        * list and fix up all the chains.
5347                                          */
5348
5349                                         switch (in->variantType) {
5350 -                                       case YAFFS_OBJECT_TYPE_UNKNOWN:
5351 +                                       case YAFFS_OBJECT_TYPE_UNKNOWN:
5352                                                 /* Todo got a problem */
5353                                                 break;
5354                                         case YAFFS_OBJECT_TYPE_FILE:
5355 -                                               if (dev->isYaffs2
5356 -                                                   && oh->isShrink) {
5357 -                                                       /* Prune back the shrunken chunks */
5358 -                                                       yaffs_PruneResizedChunks
5359 -                                                           (in, oh->fileSize);
5360 -                                                       /* Mark the block as having a shrinkHeader */
5361 -                                                       bi->hasShrinkHeader = 1;
5362 -                                               }
5363 -
5364                                                 if (dev->useHeaderFileSize)
5365
5366                                                         in->variant.fileVariant.
5367 @@ -5778,20 +5840,20 @@ static int yaffs_Scan(yaffs_Device * dev
5368                                                 break;
5369                                         case YAFFS_OBJECT_TYPE_HARDLINK:
5370                                                 in->variant.hardLinkVariant.
5371 -                                                   equivalentObjectId =
5372 -                                                   oh->equivalentObjectId;
5373 -                                               in->hardLinks.next =
5374 -                                                   (struct list_head *)
5375 -                                                   hardList;
5376 -                                               hardList = in;
5377 -                                               break;
5378 +                                                    equivalentObjectId =
5379 +                                                    oh->equivalentObjectId;
5380 +                                                in->hardLinks.next =
5381 +                                                    (struct ylist_head *)
5382 +                                                    hardList;
5383 +                                                hardList = in;
5384 +                                                break;
5385                                         case YAFFS_OBJECT_TYPE_DIRECTORY:
5386                                                 /* Do nothing */
5387                                                 break;
5388                                         case YAFFS_OBJECT_TYPE_SPECIAL:
5389                                                 /* Do nothing */
5390                                                 break;
5391 -                                       case YAFFS_OBJECT_TYPE_SYMLINK:
5392 +                                       case YAFFS_OBJECT_TYPE_SYMLINK:
5393                                                 in->variant.symLinkVariant.alias =
5394                                                     yaffs_CloneString(oh->alias);
5395                                                 if(!in->variant.symLinkVariant.alias)
5396 @@ -5799,10 +5861,12 @@ static int yaffs_Scan(yaffs_Device * dev
5397                                                 break;
5398                                         }
5399
5400 -                                       if (parent == dev->deletedDir) {
5401 +/*
5402 +                                       if (parent == dev->deletedDir) {
5403                                                 yaffs_DestroyObject(in);
5404                                                 bi->hasShrinkHeader = 1;
5405                                         }
5406 +*/
5407                                 }
5408                         }
5409                 }
5410 @@ -5823,35 +5887,36 @@ static int yaffs_Scan(yaffs_Device * dev
5411
5412         }
5413
5414 -       if (blockIndex) {
5415 -               YFREE(blockIndex);
5416 -       }
5417 -
5418 -
5419 +
5420         /* Ok, we've done all the scanning.
5421          * Fix up the hard link chains.
5422 -        * We should now have scanned all the objects, now it's time to add these
5423 +        * We should now have scanned all the objects, now it's time to add these
5424          * hardlinks.
5425          */
5426
5427         yaffs_HardlinkFixup(dev,hardList);
5428 -
5429 -       /* Handle the unlinked files. Since they were left in an unlinked state we should
5430 -        * just delete them.
5431 -        */
5432 +
5433 +       /* Fix up any shadowed objects */
5434         {
5435 -               struct list_head *i;
5436 -               struct list_head *n;
5437 -
5438 -               yaffs_Object *l;
5439 -               /* Soft delete all the unlinked files */
5440 -               list_for_each_safe(i, n,
5441 -                                  &dev->unlinkedDir->variant.directoryVariant.
5442 -                                  children) {
5443 -                       if (i) {
5444 -                               l = list_entry(i, yaffs_Object, siblings);
5445 -                               yaffs_DestroyObject(l);
5446 +               struct yaffs_ShadowFixerStruct *fixer;
5447 +               yaffs_Object *obj;
5448 +
5449 +               while(shadowFixerList){
5450 +                       fixer = shadowFixerList;
5451 +                       shadowFixerList = fixer->next;
5452 +                       /* Complete the rename transaction by deleting the shadowed object
5453 +                        * then setting the object header to unshadowed.
5454 +                        */
5455 +                       obj = yaffs_FindObjectByNumber(dev,fixer->shadowedId);
5456 +                       if(obj)
5457 +                               yaffs_DestroyObject(obj);
5458 +
5459 +                       obj = yaffs_FindObjectByNumber(dev,fixer->objectId);
5460 +                       if(obj){
5461 +                               yaffs_UpdateObjectHeader(obj,NULL,1,0,0);
5462                         }
5463 +
5464 +                       YFREE(fixer);
5465                 }
5466         }
5467
5468 @@ -5860,9 +5925,9 @@ static int yaffs_Scan(yaffs_Device * dev
5469         if(alloc_failed){
5470                 return YAFFS_FAIL;
5471         }
5472 -
5473 +
5474         T(YAFFS_TRACE_SCAN, (TSTR("yaffs_Scan ends" TENDSTR)));
5475 -
5476 +
5477
5478         return YAFFS_OK;
5479  }
5480 @@ -5871,25 +5936,27 @@ static void yaffs_CheckObjectDetailsLoad
5481  {
5482         __u8 *chunkData;
5483         yaffs_ObjectHeader *oh;
5484 -       yaffs_Device *dev = in->myDev;
5485 +       yaffs_Device *dev;
5486         yaffs_ExtendedTags tags;
5487         int result;
5488         int alloc_failed = 0;
5489
5490         if(!in)
5491                 return;
5492 -
5493 +
5494 +       dev = in->myDev;
5495 +
5496  #if 0
5497         T(YAFFS_TRACE_SCAN,(TSTR("details for object %d %s loaded" TENDSTR),
5498                 in->objectId,
5499                 in->lazyLoaded ? "not yet" : "already"));
5500  #endif
5501
5502 -       if(in->lazyLoaded){
5503 +       if(in->lazyLoaded && in->hdrChunk > 0){
5504                 in->lazyLoaded = 0;
5505                 chunkData = yaffs_GetTempBuffer(dev, __LINE__);
5506
5507 -               result = yaffs_ReadChunkWithTagsFromNAND(dev,in->chunkId,chunkData,&tags);
5508 +               result = yaffs_ReadChunkWithTagsFromNAND(dev,in->hdrChunk,chunkData,&tags);
5509                 oh = (yaffs_ObjectHeader *) chunkData;
5510
5511                 in->yst_mode = oh->yst_mode;
5512 @@ -5907,17 +5974,17 @@ static void yaffs_CheckObjectDetailsLoad
5513                 in->yst_mtime = oh->yst_mtime;
5514                 in->yst_ctime = oh->yst_ctime;
5515                 in->yst_rdev = oh->yst_rdev;
5516 -
5517 +
5518  #endif
5519                 yaffs_SetObjectName(in, oh->name);
5520 -
5521 +
5522                 if(in->variantType == YAFFS_OBJECT_TYPE_SYMLINK){
5523                          in->variant.symLinkVariant.alias =
5524                                                     yaffs_CloneString(oh->alias);
5525                         if(!in->variant.symLinkVariant.alias)
5526                                 alloc_failed = 1; /* Not returned to caller */
5527                 }
5528 -
5529 +
5530                 yaffs_ReleaseTempBuffer(dev,chunkData, __LINE__);
5531         }
5532  }
5533 @@ -5938,20 +6005,20 @@ static int yaffs_ScanBackwards(yaffs_Dev
5534         yaffs_BlockState state;
5535         yaffs_Object *hardList = NULL;
5536         yaffs_BlockInfo *bi;
5537 -       int sequenceNumber;
5538 +       __u32 sequenceNumber;
5539         yaffs_ObjectHeader *oh;
5540         yaffs_Object *in;
5541         yaffs_Object *parent;
5542         int nBlocks = dev->internalEndBlock - dev->internalStartBlock + 1;
5543         int itsUnlinked;
5544         __u8 *chunkData;
5545 -
5546 +
5547         int fileSize;
5548         int isShrink;
5549         int foundChunksInBlock;
5550         int equivalentObjectId;
5551         int alloc_failed = 0;
5552 -
5553 +
5554
5555         yaffs_BlockIndex *blockIndex = NULL;
5556         int altBlockIndex = 0;
5557 @@ -5971,20 +6038,20 @@ static int yaffs_ScanBackwards(yaffs_Dev
5558         dev->sequenceNumber = YAFFS_LOWEST_SEQUENCE_NUMBER;
5559
5560         blockIndex = YMALLOC(nBlocks * sizeof(yaffs_BlockIndex));
5561 -
5562 +
5563         if(!blockIndex) {
5564                 blockIndex = YMALLOC_ALT(nBlocks * sizeof(yaffs_BlockIndex));
5565                 altBlockIndex = 1;
5566         }
5567 -
5568 +
5569         if(!blockIndex) {
5570                 T(YAFFS_TRACE_SCAN,
5571                   (TSTR("yaffs_Scan() could not allocate block index!" TENDSTR)));
5572                 return YAFFS_FAIL;
5573         }
5574 -
5575 +
5576         dev->blocksInCheckpoint = 0;
5577 -
5578 +
5579         chunkData = yaffs_GetTempBuffer(dev, __LINE__);
5580
5581         /* Scan all the blocks to determine their state */
5582 @@ -6001,15 +6068,15 @@ static int yaffs_ScanBackwards(yaffs_Dev
5583
5584                 if(bi->sequenceNumber == YAFFS_SEQUENCE_CHECKPOINT_DATA)
5585                         bi->blockState = state = YAFFS_BLOCK_STATE_CHECKPOINT;
5586 -
5587 +
5588                 T(YAFFS_TRACE_SCAN_DEBUG,
5589                   (TSTR("Block scanning block %d state %d seq %d" TENDSTR), blk,
5590                    state, sequenceNumber));
5591
5592 -
5593 +
5594                 if(state == YAFFS_BLOCK_STATE_CHECKPOINT){
5595                         dev->blocksInCheckpoint++;
5596 -
5597 +
5598                 } else if (state == YAFFS_BLOCK_STATE_DEAD) {
5599                         T(YAFFS_TRACE_BAD_BLOCKS,
5600                           (TSTR("block %d is bad" TENDSTR), blk));
5601 @@ -6021,8 +6088,7 @@ static int yaffs_ScanBackwards(yaffs_Dev
5602                 } else if (state == YAFFS_BLOCK_STATE_NEEDS_SCANNING) {
5603
5604                         /* Determine the highest sequence number */
5605 -                       if (dev->isYaffs2 &&
5606 -                           sequenceNumber >= YAFFS_LOWEST_SEQUENCE_NUMBER &&
5607 +                       if (sequenceNumber >= YAFFS_LOWEST_SEQUENCE_NUMBER &&
5608                             sequenceNumber < YAFFS_HIGHEST_SEQUENCE_NUMBER) {
5609
5610                                 blockIndex[nBlocksToScan].seq = sequenceNumber;
5611 @@ -6033,7 +6099,7 @@ static int yaffs_ScanBackwards(yaffs_Dev
5612                                 if (sequenceNumber >= dev->sequenceNumber) {
5613                                         dev->sequenceNumber = sequenceNumber;
5614                                 }
5615 -                       } else if (dev->isYaffs2) {
5616 +                       } else {
5617                                 /* TODO: Nasty sequence number! */
5618                                 T(YAFFS_TRACE_SCAN,
5619                                   (TSTR
5620 @@ -6053,12 +6119,14 @@ static int yaffs_ScanBackwards(yaffs_Dev
5621
5622         /* Sort the blocks */
5623  #ifndef CONFIG_YAFFS_USE_OWN_SORT
5624 -       yaffs_qsort(blockIndex, nBlocksToScan,
5625 -               sizeof(yaffs_BlockIndex), ybicmp);
5626 +       {
5627 +               /* Use qsort now. */
5628 +               yaffs_qsort(blockIndex, nBlocksToScan, sizeof(yaffs_BlockIndex), ybicmp);
5629 +       }
5630  #else
5631         {
5632                 /* Dungy old bubble sort... */
5633 -
5634 +
5635                 yaffs_BlockIndex temp;
5636                 int i;
5637                 int j;
5638 @@ -6094,22 +6162,22 @@ static int yaffs_ScanBackwards(yaffs_Dev
5639                 blk = blockIndex[blockIterator].block;
5640
5641                 bi = yaffs_GetBlockInfo(dev, blk);
5642 -
5643 -
5644 +
5645 +
5646                 state = bi->blockState;
5647
5648                 deleted = 0;
5649
5650                 /* For each chunk in each block that needs scanning.... */
5651                 foundChunksInBlock = 0;
5652 -               for (c = dev->nChunksPerBlock - 1;
5653 +               for (c = dev->nChunksPerBlock - 1;
5654                      !alloc_failed && c >= 0 &&
5655                      (state == YAFFS_BLOCK_STATE_NEEDS_SCANNING ||
5656                       state == YAFFS_BLOCK_STATE_ALLOCATING); c--) {
5657 -                       /* Scan backwards...
5658 +                       /* Scan backwards...
5659                          * Read the tags and decide what to do
5660                          */
5661 -
5662 +
5663                         chunk = blk * dev->nChunksPerBlock + c;
5664
5665                         result = yaffs_ReadChunkWithTagsFromNAND(dev, chunk, NULL,
5666 @@ -6123,14 +6191,14 @@ static int yaffs_ScanBackwards(yaffs_Dev
5667                                  * it is a chunk that was skipped due to failing the erased
5668                                  * check. Just skip it so that it can be deleted.
5669                                  * But, more typically, We get here when this is an unallocated
5670 -                                * chunk and his means that either the block is empty or
5671 +                                * chunk and his means that either the block is empty or
5672                                  * this is the one being allocated from
5673                                  */
5674
5675                                 if(foundChunksInBlock)
5676                                 {
5677                                         /* This is a chunk that was skipped due to failing the erased check */
5678 -
5679 +
5680                                 } else if (c == 0) {
5681                                         /* We're looking at the first chunk in the block so the block is unused */
5682                                         state = YAFFS_BLOCK_STATE_EMPTY;
5683 @@ -6140,7 +6208,7 @@ static int yaffs_ScanBackwards(yaffs_Dev
5684                                             state == YAFFS_BLOCK_STATE_ALLOCATING) {
5685                                                 if(dev->sequenceNumber == bi->sequenceNumber) {
5686                                                         /* this is the block being allocated from */
5687 -
5688 +
5689                                                         T(YAFFS_TRACE_SCAN,
5690                                                           (TSTR
5691                                                            (" Allocating from %d %d"
5692 @@ -6149,34 +6217,41 @@ static int yaffs_ScanBackwards(yaffs_Dev
5693                                                         state = YAFFS_BLOCK_STATE_ALLOCATING;
5694                                                         dev->allocationBlock = blk;
5695                                                         dev->allocationPage = c;
5696 -                                                       dev->allocationBlockFinder = blk;
5697 +                                                       dev->allocationBlockFinder = blk;
5698                                                 }
5699                                                 else {
5700                                                         /* This is a partially written block that is not
5701                                                          * the current allocation block. This block must have
5702                                                          * had a write failure, so set up for retirement.
5703                                                          */
5704 -
5705 -                                                        bi->needsRetiring = 1;
5706 +
5707 +                                                        /* bi->needsRetiring = 1; ??? TODO */
5708                                                          bi->gcPrioritise = 1;
5709 -
5710 +
5711                                                          T(YAFFS_TRACE_ALWAYS,
5712 -                                                        (TSTR("Partially written block %d being set for retirement" TENDSTR),
5713 +                                                        (TSTR("Partially written block %d detected" TENDSTR),
5714                                                          blk));
5715                                                 }
5716
5717                                         }
5718 -
5719 +
5720                                 }
5721
5722                                 dev->nFreeChunks++;
5723 +
5724 +                       } else if (tags.eccResult == YAFFS_ECC_RESULT_UNFIXED){
5725 +                               T(YAFFS_TRACE_SCAN,
5726 +                                 (TSTR(" Unfixed ECC in chunk(%d:%d), chunk ignored"TENDSTR),
5727 +                                 blk, c));
5728
5729 -                       } else if (tags.chunkId > 0) {
5730 +                                 dev->nFreeChunks++;
5731 +
5732 +                       }else if (tags.chunkId > 0) {
5733                                 /* chunkId > 0 so it is a data chunk... */
5734                                 unsigned int endpos;
5735                                 __u32 chunkBase =
5736                                     (tags.chunkId - 1) * dev->nDataBytesPerChunk;
5737 -
5738 +
5739                                 foundChunksInBlock = 1;
5740
5741
5742 @@ -6191,7 +6266,7 @@ static int yaffs_ScanBackwards(yaffs_Dev
5743                                         /* Out of memory */
5744                                         alloc_failed = 1;
5745                                 }
5746 -
5747 +
5748                                 if (in &&
5749                                     in->variantType == YAFFS_OBJECT_TYPE_FILE
5750                                     && chunkBase <
5751 @@ -6202,14 +6277,14 @@ static int yaffs_ScanBackwards(yaffs_Dev
5752                                                 alloc_failed = 1;
5753                                         }
5754
5755 -                                       /* File size is calculated by looking at the data chunks if we have not
5756 +                                       /* File size is calculated by looking at the data chunks if we have not
5757                                          * seen an object header yet. Stop this practice once we find an object header.
5758                                          */
5759                                         endpos =
5760                                             (tags.chunkId -
5761                                              1) * dev->nDataBytesPerChunk +
5762                                             tags.byteCount;
5763 -
5764 +
5765                                         if (!in->valid &&       /* have not got an object header yet */
5766                                             in->variant.fileVariant.
5767                                             scannedFileSize < endpos) {
5768 @@ -6255,7 +6330,7 @@ static int yaffs_ScanBackwards(yaffs_Dev
5769                                     ) {
5770
5771                                         /* If we don't have  valid info then we need to read the chunk
5772 -                                        * TODO In future we can probably defer reading the chunk and
5773 +                                        * TODO In future we can probably defer reading the chunk and
5774                                          * living with invalid data until needed.
5775                                          */
5776
5777 @@ -6265,6 +6340,12 @@ static int yaffs_ScanBackwards(yaffs_Dev
5778                                                                         NULL);
5779
5780                                         oh = (yaffs_ObjectHeader *) chunkData;
5781 +
5782 +                                       if(dev->inbandTags){
5783 +                                               /* Fix up the header if they got corrupted by inband tags */
5784 +                                               oh->shadowsObject = oh->inbandShadowsObject;
5785 +                                               oh->isShrink = oh->inbandIsShrink;
5786 +                                       }
5787
5788                                         if (!in)
5789                                                 in = yaffs_FindOrCreateObjectByNumber(dev, tags.objectId, oh->type);
5790 @@ -6275,20 +6356,19 @@ static int yaffs_ScanBackwards(yaffs_Dev
5791                                         /* TODO Hoosterman we have a problem! */
5792                                         T(YAFFS_TRACE_ERROR,
5793                                           (TSTR
5794 -                                          ("yaffs tragedy: Could not make object for object  %d  "
5795 -                                           "at chunk %d during scan"
5796 +                                          ("yaffs tragedy: Could not make object for object  %d at chunk %d during scan"
5797                                             TENDSTR), tags.objectId, chunk));
5798
5799                                 }
5800
5801                                 if (in->valid) {
5802                                         /* We have already filled this one.
5803 -                                        * We have a duplicate that will be discarded, but
5804 +                                        * We have a duplicate that will be discarded, but
5805                                          * we first have to suck out resize info if it is a file.
5806                                          */
5807
5808 -                                       if ((in->variantType == YAFFS_OBJECT_TYPE_FILE) &&
5809 -                                            ((oh &&
5810 +                                       if ((in->variantType == YAFFS_OBJECT_TYPE_FILE) &&
5811 +                                            ((oh &&
5812                                                oh-> type == YAFFS_OBJECT_TYPE_FILE)||
5813                                               (tags.extraHeaderInfoAvailable  &&
5814                                                tags.extraObjectType == YAFFS_OBJECT_TYPE_FILE))
5815 @@ -6300,7 +6380,9 @@ static int yaffs_ScanBackwards(yaffs_Dev
5816                                                     (oh) ? oh->
5817                                                     parentObjectId : tags.
5818                                                     extraParentObjectId;
5819 -                                               unsigned isShrink =
5820 +
5821 +
5822 +                                               isShrink =
5823                                                     (oh) ? oh->isShrink : tags.
5824                                                     extraIsShrinkHeader;
5825
5826 @@ -6339,7 +6421,7 @@ static int yaffs_ScanBackwards(yaffs_Dev
5827                                      YAFFS_OBJECTID_LOSTNFOUND)) {
5828                                         /* We only load some info, don't fiddle with directory structure */
5829                                         in->valid = 1;
5830 -
5831 +
5832                                         if(oh) {
5833                                                 in->variantType = oh->type;
5834
5835 @@ -6358,20 +6440,20 @@ static int yaffs_ScanBackwards(yaffs_Dev
5836                                                 in->yst_mtime = oh->yst_mtime;
5837                                                 in->yst_ctime = oh->yst_ctime;
5838                                                 in->yst_rdev = oh->yst_rdev;
5839 -
5840 +
5841  #endif
5842                                         } else {
5843                                                 in->variantType = tags.extraObjectType;
5844                                                 in->lazyLoaded = 1;
5845                                         }
5846
5847 -                                       in->chunkId = chunk;
5848 +                                       in->hdrChunk = chunk;
5849
5850                                 } else if (!in->valid) {
5851                                         /* we need to load this info */
5852
5853                                         in->valid = 1;
5854 -                                       in->chunkId = chunk;
5855 +                                       in->hdrChunk = chunk;
5856
5857                                         if(oh) {
5858                                                 in->variantType = oh->type;
5859 @@ -6393,12 +6475,12 @@ static int yaffs_ScanBackwards(yaffs_Dev
5860                                                 in->yst_rdev = oh->yst_rdev;
5861  #endif
5862
5863 -                                               if (oh->shadowsObject > 0)
5864 +                                               if (oh->shadowsObject > 0)
5865                                                         yaffs_HandleShadowedObject(dev,
5866                                                                            oh->
5867                                                                            shadowsObject,
5868                                                                            1);
5869 -
5870 +
5871
5872                                                 yaffs_SetObjectName(in, oh->name);
5873                                                 parent =
5874 @@ -6431,13 +6513,13 @@ static int yaffs_ScanBackwards(yaffs_Dev
5875
5876                                         if (parent->variantType ==
5877                                             YAFFS_OBJECT_TYPE_UNKNOWN) {
5878 -                                               /* Set up as a directory */
5879 -                                               parent->variantType =
5880 -                                                   YAFFS_OBJECT_TYPE_DIRECTORY;
5881 -                                               INIT_LIST_HEAD(&parent->variant.
5882 -                                                              directoryVariant.
5883 -                                                              children);
5884 -                                       } else if (parent->variantType !=
5885 +                                                /* Set up as a directory */
5886 +                                                parent->variantType =
5887 +                                                    YAFFS_OBJECT_TYPE_DIRECTORY;
5888 +                                                YINIT_LIST_HEAD(&parent->variant.
5889 +                                                               directoryVariant.
5890 +                                                               children);
5891 +                                        } else if (parent->variantType !=
5892                                                    YAFFS_OBJECT_TYPE_DIRECTORY)
5893                                         {
5894                                                 /* Hoosterman, another problem....
5895 @@ -6446,8 +6528,7 @@ static int yaffs_ScanBackwards(yaffs_Dev
5896
5897                                                 T(YAFFS_TRACE_ERROR,
5898                                                   (TSTR
5899 -                                                  ("yaffs tragedy: attempting to use non-directory as"
5900 -                                                   " a directory in scan. Put in lost+found."
5901 +                                                  ("yaffs tragedy: attempting to use non-directory as a directory in scan. Put in lost+found."
5902                                                     TENDSTR)));
5903                                                 parent = dev->lostNFoundDir;
5904                                         }
5905 @@ -6466,11 +6547,11 @@ static int yaffs_ScanBackwards(yaffs_Dev
5906                                          * Since we might scan a hardlink before its equivalent object is scanned
5907                                          * we put them all in a list.
5908                                          * After scanning is complete, we should have all the objects, so we run
5909 -                                        * through this list and fix up all the chains.
5910 +                                        * through this list and fix up all the chains.
5911                                          */
5912
5913                                         switch (in->variantType) {
5914 -                                       case YAFFS_OBJECT_TYPE_UNKNOWN:
5915 +                                       case YAFFS_OBJECT_TYPE_UNKNOWN:
5916                                                 /* Todo got a problem */
5917                                                 break;
5918                                         case YAFFS_OBJECT_TYPE_FILE:
5919 @@ -6479,7 +6560,7 @@ static int yaffs_ScanBackwards(yaffs_Dev
5920                                                     scannedFileSize < fileSize) {
5921                                                         /* This covers the case where the file size is greater
5922                                                          * than where the data is
5923 -                                                        * This will happen if the file is resized to be larger
5924 +                                                        * This will happen if the file is resized to be larger
5925                                                          * than its current data extents.
5926                                                          */
5927                                                         in->variant.fileVariant.fileSize = fileSize;
5928 @@ -6495,13 +6576,13 @@ static int yaffs_ScanBackwards(yaffs_Dev
5929                                                 break;
5930                                         case YAFFS_OBJECT_TYPE_HARDLINK:
5931                                                 if(!itsUnlinked) {
5932 -                                                 in->variant.hardLinkVariant.equivalentObjectId =
5933 -                                                   equivalentObjectId;
5934 -                                                 in->hardLinks.next =
5935 -                                                   (struct list_head *) hardList;
5936 -                                                 hardList = in;
5937 -                                               }
5938 -                                               break;
5939 +                                                  in->variant.hardLinkVariant.equivalentObjectId =
5940 +                                                    equivalentObjectId;
5941 +                                                  in->hardLinks.next =
5942 +                                                    (struct ylist_head *) hardList;
5943 +                                                  hardList = in;
5944 +                                                }
5945 +                                                break;
5946                                         case YAFFS_OBJECT_TYPE_DIRECTORY:
5947                                                 /* Do nothing */
5948                                                 break;
5949 @@ -6520,7 +6601,7 @@ static int yaffs_ScanBackwards(yaffs_Dev
5950                                         }
5951
5952                                 }
5953 -
5954 +
5955                         }
5956
5957                 } /* End of scanning for each chunk */
5958 @@ -6541,72 +6622,128 @@ static int yaffs_ScanBackwards(yaffs_Dev
5959
5960         }
5961
5962 -       if (altBlockIndex)
5963 +       if (altBlockIndex)
5964                 YFREE_ALT(blockIndex);
5965         else
5966                 YFREE(blockIndex);
5967 -
5968 +
5969         /* Ok, we've done all the scanning.
5970          * Fix up the hard link chains.
5971 -        * We should now have scanned all the objects, now it's time to add these
5972 +        * We should now have scanned all the objects, now it's time to add these
5973          * hardlinks.
5974          */
5975         yaffs_HardlinkFixup(dev,hardList);
5976 +
5977
5978 +       yaffs_ReleaseTempBuffer(dev, chunkData, __LINE__);
5979 +
5980 +       if(alloc_failed){
5981 +               return YAFFS_FAIL;
5982 +       }
5983
5984 -       /*
5985 -       *  Sort out state of unlinked and deleted objects.
5986 -       */
5987 -       {
5988 -               struct list_head *i;
5989 -               struct list_head *n;
5990 +       T(YAFFS_TRACE_SCAN, (TSTR("yaffs_ScanBackwards ends" TENDSTR)));
5991
5992 -               yaffs_Object *l;
5993 +       return YAFFS_OK;
5994 +}
5995
5996 -               /* Soft delete all the unlinked files */
5997 -               list_for_each_safe(i, n,
5998 -                                  &dev->unlinkedDir->variant.directoryVariant.
5999 -                                  children) {
6000 -                       if (i) {
6001 -                               l = list_entry(i, yaffs_Object, siblings);
6002 -                               yaffs_DestroyObject(l);
6003 -                       }
6004 -               }
6005 +/*------------------------------  Directory Functions ----------------------------- */
6006
6007 -               /* Soft delete all the deletedDir files */
6008 -               list_for_each_safe(i, n,
6009 -                                  &dev->deletedDir->variant.directoryVariant.
6010 -                                  children) {
6011 -                       if (i) {
6012 -                               l = list_entry(i, yaffs_Object, siblings);
6013 -                               yaffs_DestroyObject(l);
6014 +static void yaffs_VerifyObjectInDirectory(yaffs_Object *obj)
6015 +{
6016 +        struct ylist_head *lh;
6017 +        yaffs_Object *listObj;
6018 +
6019 +        int count = 0;
6020
6021 -                       }
6022 -               }
6023 +       if(!obj){
6024 +               T(YAFFS_TRACE_ALWAYS, (TSTR("No object to verify" TENDSTR)));
6025 +               YBUG();
6026         }
6027
6028 -       yaffs_ReleaseTempBuffer(dev, chunkData, __LINE__);
6029 +        if(yaffs_SkipVerification(obj->myDev))
6030 +                return;
6031
6032 -       if(alloc_failed){
6033 -               return YAFFS_FAIL;
6034 +       if(!obj->parent){
6035 +               T(YAFFS_TRACE_ALWAYS, (TSTR("Object does not have parent" TENDSTR)));
6036 +               YBUG();
6037 +       }
6038 +
6039 +       if(obj->parent->variantType != YAFFS_OBJECT_TYPE_DIRECTORY){
6040 +               T(YAFFS_TRACE_ALWAYS, (TSTR("Parent is not directory" TENDSTR)));
6041 +               YBUG();
6042 +       }
6043 +
6044 +        /* Iterate through the objects in each hash entry */
6045 +
6046 +        ylist_for_each(lh, &obj->parent->variant.directoryVariant.children) {
6047 +               if (lh) {
6048 +                        listObj = ylist_entry(lh, yaffs_Object, siblings);
6049 +                       yaffs_VerifyObject(listObj);
6050 +                       if(obj == listObj)
6051 +                               count ++;
6052 +                }
6053 +        }
6054 +
6055 +        if(count != 1){
6056 +               T(YAFFS_TRACE_ALWAYS, (TSTR("Object in directory %d times" TENDSTR),count));
6057 +               YBUG();
6058         }
6059
6060 -       T(YAFFS_TRACE_SCAN, (TSTR("yaffs_ScanBackwards ends" TENDSTR)));
6061 +}
6062
6063 -       return YAFFS_OK;
6064 +static void yaffs_VerifyDirectory(yaffs_Object *directory)
6065 +{
6066 +
6067 +        struct ylist_head *lh;
6068 +        yaffs_Object *listObj;
6069 +
6070 +       if(!directory)
6071 +               YBUG();
6072 +
6073 +        if(yaffs_SkipFullVerification(directory->myDev))
6074 +                return;
6075 +
6076 +
6077 +       if(directory->variantType != YAFFS_OBJECT_TYPE_DIRECTORY){
6078 +               T(YAFFS_TRACE_ALWAYS, (TSTR("Directory has wrong type: %d" TENDSTR),directory->variantType));
6079 +               YBUG();
6080 +       }
6081 +
6082 +        /* Iterate through the objects in each hash entry */
6083 +
6084 +        ylist_for_each(lh, &directory->variant.directoryVariant.children) {
6085 +               if (lh) {
6086 +                        listObj = ylist_entry(lh, yaffs_Object, siblings);
6087 +                       if(listObj->parent != directory){
6088 +                               T(YAFFS_TRACE_ALWAYS, (TSTR("Object in directory list has wrong parent %p" TENDSTR),listObj->parent));
6089 +                               YBUG();
6090 +                       }
6091 +                       yaffs_VerifyObjectInDirectory(listObj);
6092 +                }
6093 +        }
6094 +
6095  }
6096
6097 -/*------------------------------  Directory Functions ----------------------------- */
6098
6099  static void yaffs_RemoveObjectFromDirectory(yaffs_Object * obj)
6100  {
6101         yaffs_Device *dev = obj->myDev;
6102 +       yaffs_Object *parent;
6103 +
6104 +        yaffs_VerifyObjectInDirectory(obj);
6105 +       parent = obj->parent;
6106 +
6107 +       yaffs_VerifyDirectory(parent);
6108 +
6109 +        if(dev && dev->removeObjectCallback)
6110 +                dev->removeObjectCallback(obj);
6111 +
6112 +
6113 +        ylist_del_init(&obj->siblings);
6114 +        obj->parent = NULL;
6115
6116 -       if(dev && dev->removeObjectCallback)
6117 -               dev->removeObjectCallback(obj);
6118 +       yaffs_VerifyDirectory(parent);
6119
6120 -       list_del_init(&obj->siblings);
6121 -       obj->parent = NULL;
6122  }
6123
6124
6125 @@ -6629,35 +6766,46 @@ static void yaffs_AddObjectToDirectory(y
6126                 YBUG();
6127         }
6128
6129 -       if (obj->siblings.prev == NULL) {
6130 -               /* Not initialised */
6131 -               INIT_LIST_HEAD(&obj->siblings);
6132 -
6133 -       } else if (!list_empty(&obj->siblings)) {
6134 -               /* If it is holed up somewhere else, un hook it */
6135 -               yaffs_RemoveObjectFromDirectory(obj);
6136 -       }
6137 -       /* Now add it */
6138 -       list_add(&obj->siblings, &directory->variant.directoryVariant.children);
6139 -       obj->parent = directory;
6140 +        if (obj->siblings.prev == NULL) {
6141 +                /* Not initialised */
6142 +                YBUG();
6143 +
6144 +        } else if (ylist_empty(&obj->siblings)) {
6145 +               YBUG();
6146 +        }
6147 +
6148
6149 -       if (directory == obj->myDev->unlinkedDir
6150 +       yaffs_VerifyDirectory(directory);
6151 +
6152 +       yaffs_RemoveObjectFromDirectory(obj);
6153 +
6154 +
6155 +        /* Now add it */
6156 +        ylist_add(&obj->siblings, &directory->variant.directoryVariant.children);
6157 +        obj->parent = directory;
6158 +
6159 +        if (directory == obj->myDev->unlinkedDir
6160             || directory == obj->myDev->deletedDir) {
6161                 obj->unlinked = 1;
6162                 obj->myDev->nUnlinkedFiles++;
6163                 obj->renameAllowed = 0;
6164         }
6165 +
6166 +       yaffs_VerifyDirectory(directory);
6167 +        yaffs_VerifyObjectInDirectory(obj);
6168 +
6169 +
6170  }
6171
6172  yaffs_Object *yaffs_FindObjectByName(yaffs_Object * directory,
6173                                      const YCHAR * name)
6174  {
6175 -       int sum;
6176 +        int sum;
6177
6178 -       struct list_head *i;
6179 -       YCHAR buffer[YAFFS_MAX_NAME_LENGTH + 1];
6180 +        struct ylist_head *i;
6181 +        YCHAR buffer[YAFFS_MAX_NAME_LENGTH + 1];
6182
6183 -       yaffs_Object *l;
6184 +        yaffs_Object *l;
6185
6186         if (!name) {
6187                 return NULL;
6188 @@ -6677,22 +6825,24 @@ yaffs_Object *yaffs_FindObjectByName(yaf
6189                 YBUG();
6190         }
6191
6192 -       sum = yaffs_CalcNameSum(name);
6193 +        sum = yaffs_CalcNameSum(name);
6194
6195 -       list_for_each(i, &directory->variant.directoryVariant.children) {
6196 -               if (i) {
6197 -                       l = list_entry(i, yaffs_Object, siblings);
6198 -
6199 -                       yaffs_CheckObjectDetailsLoaded(l);
6200 +        ylist_for_each(i, &directory->variant.directoryVariant.children) {
6201 +                if (i) {
6202 +                        l = ylist_entry(i, yaffs_Object, siblings);
6203 +
6204 +                        if(l->parent != directory)
6205 +                               YBUG();
6206 +
6207 +                        yaffs_CheckObjectDetailsLoaded(l);
6208
6209                         /* Special case for lost-n-found */
6210                         if (l->objectId == YAFFS_OBJECTID_LOSTNFOUND) {
6211                                 if (yaffs_strcmp(name, YAFFS_LOSTNFOUND_NAME) == 0) {
6212                                         return l;
6213                                 }
6214 -                       } else if (yaffs_SumCompare(l->sum, sum) || l->chunkId <= 0)
6215 -                       {
6216 -                               /* LostnFound cunk called Objxxx
6217 +                       } else if (yaffs_SumCompare(l->sum, sum) || l->hdrChunk <= 0){
6218 +                               /* LostnFound chunk called Objxxx
6219                                  * Do a real check
6220                                  */
6221                                 yaffs_GetObjectName(l, buffer,
6222 @@ -6711,12 +6861,12 @@ yaffs_Object *yaffs_FindObjectByName(yaf
6223
6224  #if 0
6225  int yaffs_ApplyToDirectoryChildren(yaffs_Object * theDir,
6226 -                                  int (*fn) (yaffs_Object *))
6227 +                                   int (*fn) (yaffs_Object *))
6228  {
6229 -       struct list_head *i;
6230 -       yaffs_Object *l;
6231 +        struct ylist_head *i;
6232 +        yaffs_Object *l;
6233
6234 -       if (!theDir) {
6235 +        if (!theDir) {
6236                 T(YAFFS_TRACE_ALWAYS,
6237                   (TSTR
6238                    ("tragedy: yaffs_FindObjectByName: null pointer directory"
6239 @@ -6727,15 +6877,15 @@ int yaffs_ApplyToDirectoryChildren(yaffs
6240                 T(YAFFS_TRACE_ALWAYS,
6241                   (TSTR
6242                    ("tragedy: yaffs_FindObjectByName: non-directory" TENDSTR)));
6243 -               YBUG();
6244 -       }
6245 +                YBUG();
6246 +        }
6247
6248 -       list_for_each(i, &theDir->variant.directoryVariant.children) {
6249 -               if (i) {
6250 -                       l = list_entry(i, yaffs_Object, siblings);
6251 -                       if (l && !fn(l)) {
6252 -                               return YAFFS_FAIL;
6253 -                       }
6254 +        ylist_for_each(i, &theDir->variant.directoryVariant.children) {
6255 +                if (i) {
6256 +                        l = ylist_entry(i, yaffs_Object, siblings);
6257 +                        if (l && !fn(l)) {
6258 +                                return YAFFS_FAIL;
6259 +                        }
6260                 }
6261         }
6262
6263 @@ -6762,16 +6912,25 @@ yaffs_Object *yaffs_GetEquivalentObject(
6264  int yaffs_GetObjectName(yaffs_Object * obj, YCHAR * name, int buffSize)
6265  {
6266         memset(name, 0, buffSize * sizeof(YCHAR));
6267 -
6268 +
6269         yaffs_CheckObjectDetailsLoaded(obj);
6270
6271         if (obj->objectId == YAFFS_OBJECTID_LOSTNFOUND) {
6272                 yaffs_strncpy(name, YAFFS_LOSTNFOUND_NAME, buffSize - 1);
6273 -       } else if (obj->chunkId <= 0) {
6274 +       } else if (obj->hdrChunk <= 0) {
6275                 YCHAR locName[20];
6276 +               YCHAR numString[20];
6277 +               YCHAR *x = &numString[19];
6278 +               unsigned v = obj->objectId;
6279 +               numString[19] = 0;
6280 +               while(v>0){
6281 +                       x--;
6282 +                       *x = '0' + (v % 10);
6283 +                       v /= 10;
6284 +               }
6285                 /* make up a name */
6286 -               yaffs_sprintf(locName, _Y("%s%d"), YAFFS_LOSTNFOUND_PREFIX,
6287 -                             obj->objectId);
6288 +               yaffs_strcpy(locName, YAFFS_LOSTNFOUND_PREFIX);
6289 +               yaffs_strcat(locName,x);
6290                 yaffs_strncpy(name, locName, buffSize - 1);
6291
6292         }
6293 @@ -6788,9 +6947,9 @@ int yaffs_GetObjectName(yaffs_Object * o
6294
6295                 memset(buffer, 0, obj->myDev->nDataBytesPerChunk);
6296
6297 -               if (obj->chunkId >= 0) {
6298 +               if (obj->hdrChunk > 0) {
6299                         result = yaffs_ReadChunkWithTagsFromNAND(obj->myDev,
6300 -                                                       obj->chunkId, buffer,
6301 +                                                       obj->hdrChunk, buffer,
6302                                                         NULL);
6303                 }
6304                 yaffs_strncpy(name, oh->name, buffSize - 1);
6305 @@ -6820,16 +6979,16 @@ int yaffs_GetObjectFileLength(yaffs_Obje
6306
6307  int yaffs_GetObjectLinkCount(yaffs_Object * obj)
6308  {
6309 -       int count = 0;
6310 -       struct list_head *i;
6311 +        int count = 0;
6312 +        struct ylist_head *i;
6313
6314 -       if (!obj->unlinked) {
6315 -               count++;        /* the object itself */
6316 -       }
6317 -       list_for_each(i, &obj->hardLinks) {
6318 -               count++;        /* add the hard links; */
6319 -       }
6320 -       return count;
6321 +        if (!obj->unlinked) {
6322 +                count++;        /* the object itself */
6323 +        }
6324 +        ylist_for_each(i, &obj->hardLinks) {
6325 +                count++;        /* add the hard links; */
6326 +        }
6327 +        return count;
6328
6329  }
6330
6331 @@ -6951,7 +7110,7 @@ int yaffs_DumpObject(yaffs_Object * obj)
6332            ("Object %d, inode %d \"%s\"\n dirty %d valid %d serial %d sum %d"
6333             " chunk %d type %d size %d\n"
6334             TENDSTR), obj->objectId, yaffs_GetObjectInode(obj), name,
6335 -          obj->dirty, obj->valid, obj->serial, obj->sum, obj->chunkId,
6336 +          obj->dirty, obj->valid, obj->serial, obj->sum, obj->hdrChunk,
6337            yaffs_GetObjectType(obj), yaffs_GetObjectFileLength(obj)));
6338
6339         return YAFFS_OK;
6340 @@ -6994,13 +7153,13 @@ static int yaffs_CheckDevFunctions(const
6341  static int yaffs_CreateInitialDirectories(yaffs_Device *dev)
6342  {
6343         /* Initialise the unlinked, deleted, root and lost and found directories */
6344 -
6345 +
6346         dev->lostNFoundDir = dev->rootDir =  NULL;
6347         dev->unlinkedDir = dev->deletedDir = NULL;
6348
6349         dev->unlinkedDir =
6350             yaffs_CreateFakeDirectory(dev, YAFFS_OBJECTID_UNLINKED, S_IFDIR);
6351 -
6352 +
6353         dev->deletedDir =
6354             yaffs_CreateFakeDirectory(dev, YAFFS_OBJECTID_DELETED, S_IFDIR);
6355
6356 @@ -7010,12 +7169,12 @@ static int yaffs_CreateInitialDirectorie
6357         dev->lostNFoundDir =
6358             yaffs_CreateFakeDirectory(dev, YAFFS_OBJECTID_LOSTNFOUND,
6359                                       YAFFS_LOSTNFOUND_MODE | S_IFDIR);
6360 -
6361 +
6362         if(dev->lostNFoundDir && dev->rootDir && dev->unlinkedDir && dev->deletedDir){
6363                 yaffs_AddObjectToDirectory(dev->rootDir, dev->lostNFoundDir);
6364                 return YAFFS_OK;
6365         }
6366 -
6367 +
6368         return YAFFS_FAIL;
6369  }
6370
6371 @@ -7039,6 +7198,8 @@ int yaffs_GutsInitialise(yaffs_Device *
6372         dev->blockOffset = 0;
6373         dev->chunkOffset = 0;
6374         dev->nFreeChunks = 0;
6375 +
6376 +       dev->gcBlock = -1;
6377
6378         if (dev->startBlock == 0) {
6379                 dev->internalStartBlock = dev->startBlock + 1;
6380 @@ -7049,18 +7210,19 @@ int yaffs_GutsInitialise(yaffs_Device *
6381
6382         /* Check geometry parameters. */
6383
6384 -       if ((dev->isYaffs2 && dev->nDataBytesPerChunk < 1024) ||
6385 -           (!dev->isYaffs2 && dev->nDataBytesPerChunk != 512) ||
6386 -            dev->nChunksPerBlock < 2 ||
6387 -            dev->nReservedBlocks < 2 ||
6388 -            dev->internalStartBlock <= 0 ||
6389 -            dev->internalEndBlock <= 0 ||
6390 +       if ((!dev->inbandTags && dev->isYaffs2 && dev->totalBytesPerChunk < 1024) ||
6391 +           (!dev->isYaffs2 && dev->totalBytesPerChunk < 512) ||
6392 +           (dev->inbandTags && !dev->isYaffs2 ) ||
6393 +            dev->nChunksPerBlock < 2 ||
6394 +            dev->nReservedBlocks < 2 ||
6395 +            dev->internalStartBlock <= 0 ||
6396 +            dev->internalEndBlock <= 0 ||
6397              dev->internalEndBlock <= (dev->internalStartBlock + dev->nReservedBlocks + 2)      // otherwise it is too small
6398             ) {
6399                 T(YAFFS_TRACE_ALWAYS,
6400                   (TSTR
6401 -                  ("yaffs: NAND geometry problems: chunk size %d, type is yaffs%s "
6402 -                   TENDSTR), dev->nDataBytesPerChunk, dev->isYaffs2 ? "2" : ""));
6403 +                  ("yaffs: NAND geometry problems: chunk size %d, type is yaffs%s, inbandTags %d "
6404 +                   TENDSTR), dev->totalBytesPerChunk, dev->isYaffs2 ? "2" : "", dev->inbandTags));
6405                 return YAFFS_FAIL;
6406         }
6407
6408 @@ -7069,6 +7231,12 @@ int yaffs_GutsInitialise(yaffs_Device *
6409                   (TSTR("yaffs: InitialiseNAND failed" TENDSTR)));
6410                 return YAFFS_FAIL;
6411         }
6412 +
6413 +       /* Sort out space for inband tags, if required */
6414 +       if(dev->inbandTags)
6415 +               dev->nDataBytesPerChunk = dev->totalBytesPerChunk - sizeof(yaffs_PackedTags2TagsPart);
6416 +       else
6417 +               dev->nDataBytesPerChunk = dev->totalBytesPerChunk;
6418
6419         /* Got the right mix of functions? */
6420         if (!yaffs_CheckDevFunctions(dev)) {
6421 @@ -7097,41 +7265,28 @@ int yaffs_GutsInitialise(yaffs_Device *
6422
6423         dev->isMounted = 1;
6424
6425 -
6426 -
6427         /* OK now calculate a few things for the device */
6428 -
6429 +
6430         /*
6431 -        *  Calculate all the chunk size manipulation numbers:
6432 +        *  Calculate all the chunk size manipulation numbers:
6433          */
6434 -        /* Start off assuming it is a power of 2 */
6435 -        dev->chunkShift = ShiftDiv(dev->nDataBytesPerChunk);
6436 -        dev->chunkMask = (1<<dev->chunkShift) - 1;
6437 -
6438 -        if(dev->nDataBytesPerChunk == (dev->chunkMask + 1)){
6439 -               /* Yes it is a power of 2, disable crumbs */
6440 -               dev->crumbMask = 0;
6441 -               dev->crumbShift = 0;
6442 -               dev->crumbsPerChunk = 0;
6443 -        } else {
6444 -               /* Not a power of 2, use crumbs instead */
6445 -               dev->crumbShift = ShiftDiv(sizeof(yaffs_PackedTags2TagsPart));
6446 -               dev->crumbMask = (1<<dev->crumbShift)-1;
6447 -               dev->crumbsPerChunk = dev->nDataBytesPerChunk/(1 << dev->crumbShift);
6448 -               dev->chunkShift = 0;
6449 -               dev->chunkMask = 0;
6450 -       }
6451 -
6452 -
6453 +       x = dev->nDataBytesPerChunk;
6454 +       /* We always use dev->chunkShift and dev->chunkDiv */
6455 +       dev->chunkShift = Shifts(x);
6456 +       x >>= dev->chunkShift;
6457 +       dev->chunkDiv = x;
6458 +       /* We only use chunk mask if chunkDiv is 1 */
6459 +       dev->chunkMask = (1<<dev->chunkShift) - 1;
6460 +
6461         /*
6462          * Calculate chunkGroupBits.
6463          * We need to find the next power of 2 > than internalEndBlock
6464          */
6465
6466         x = dev->nChunksPerBlock * (dev->internalEndBlock + 1);
6467 -
6468 +
6469         bits = ShiftsGE(x);
6470 -
6471 +
6472         /* Set up tnode width if wide tnodes are enabled. */
6473         if(!dev->wideTnodesDisabled){
6474                 /* bits must be even so that we end up with 32-bit words */
6475 @@ -7144,20 +7299,20 @@ int yaffs_GutsInitialise(yaffs_Device *
6476         }
6477         else
6478                 dev->tnodeWidth = 16;
6479 -
6480 +
6481         dev->tnodeMask = (1<<dev->tnodeWidth)-1;
6482 -
6483 +
6484         /* Level0 Tnodes are 16 bits or wider (if wide tnodes are enabled),
6485          * so if the bitwidth of the
6486          * chunk range we're using is greater than 16 we need
6487          * to figure out chunk shift and chunkGroupSize
6488          */
6489 -
6490 +
6491         if (bits <= dev->tnodeWidth)
6492                 dev->chunkGroupBits = 0;
6493         else
6494                 dev->chunkGroupBits = bits - dev->tnodeWidth;
6495 -
6496 +
6497
6498         dev->chunkGroupSize = 1 << dev->chunkGroupBits;
6499
6500 @@ -7195,40 +7350,42 @@ int yaffs_GutsInitialise(yaffs_Device *
6501         /* Initialise temporary buffers and caches. */
6502         if(!yaffs_InitialiseTempBuffers(dev))
6503                 init_failed = 1;
6504 -
6505 +
6506         dev->srCache = NULL;
6507         dev->gcCleanupList = NULL;
6508 -
6509 -
6510 +
6511 +
6512         if (!init_failed &&
6513             dev->nShortOpCaches > 0) {
6514                 int i;
6515 -               __u8 *buf;
6516 +               void *buf;
6517                 int srCacheBytes = dev->nShortOpCaches * sizeof(yaffs_ChunkCache);
6518
6519                 if (dev->nShortOpCaches > YAFFS_MAX_SHORT_OP_CACHES) {
6520                         dev->nShortOpCaches = YAFFS_MAX_SHORT_OP_CACHES;
6521                 }
6522
6523 -               buf = dev->srCache =  YMALLOC(srCacheBytes);
6524 -
6525 +               dev->srCache =  YMALLOC(srCacheBytes);
6526 +
6527 +               buf = (__u8 *) dev->srCache;
6528 +
6529                 if(dev->srCache)
6530                         memset(dev->srCache,0,srCacheBytes);
6531 -
6532 +
6533                 for (i = 0; i < dev->nShortOpCaches && buf; i++) {
6534                         dev->srCache[i].object = NULL;
6535                         dev->srCache[i].lastUse = 0;
6536                         dev->srCache[i].dirty = 0;
6537 -                       dev->srCache[i].data = buf = YMALLOC_DMA(dev->nDataBytesPerChunk);
6538 +                       dev->srCache[i].data = buf = YMALLOC_DMA(dev->totalBytesPerChunk);
6539                 }
6540                 if(!buf)
6541                         init_failed = 1;
6542 -
6543 +
6544                 dev->srLastUse = 0;
6545         }
6546
6547         dev->cacheHits = 0;
6548 -
6549 +
6550         if(!init_failed){
6551                 dev->gcCleanupList = YMALLOC(dev->nChunksPerBlock * sizeof(__u32));
6552                 if(!dev->gcCleanupList)
6553 @@ -7240,7 +7397,7 @@ int yaffs_GutsInitialise(yaffs_Device *
6554         }
6555         if(!init_failed && !yaffs_InitialiseBlocks(dev))
6556                 init_failed = 1;
6557 -
6558 +
6559         yaffs_InitialiseTnodes(dev);
6560         yaffs_InitialiseObjects(dev);
6561
6562 @@ -7252,18 +7409,19 @@ int yaffs_GutsInitialise(yaffs_Device *
6563                 /* Now scan the flash. */
6564                 if (dev->isYaffs2) {
6565                         if(yaffs_CheckpointRestore(dev)) {
6566 +                               yaffs_CheckObjectDetailsLoaded(dev->rootDir);
6567                                 T(YAFFS_TRACE_ALWAYS,
6568                                   (TSTR("yaffs: restored from checkpoint" TENDSTR)));
6569                         } else {
6570
6571 -                               /* Clean up the mess caused by an aborted checkpoint load
6572 -                                * and scan backwards.
6573 +                               /* Clean up the mess caused by an aborted checkpoint load
6574 +                                * and scan backwards.
6575                                  */
6576                                 yaffs_DeinitialiseBlocks(dev);
6577                                 yaffs_DeinitialiseTnodes(dev);
6578                                 yaffs_DeinitialiseObjects(dev);
6579 -
6580 -
6581 +
6582 +
6583                                 dev->nErasedBlocks = 0;
6584                                 dev->nFreeChunks = 0;
6585                                 dev->allocationBlock = -1;
6586 @@ -7275,7 +7433,7 @@ int yaffs_GutsInitialise(yaffs_Device *
6587
6588                                 if(!init_failed && !yaffs_InitialiseBlocks(dev))
6589                                         init_failed = 1;
6590 -
6591 +
6592                                 yaffs_InitialiseTnodes(dev);
6593                                 yaffs_InitialiseObjects(dev);
6594
6595 @@ -7288,8 +7446,10 @@ int yaffs_GutsInitialise(yaffs_Device *
6596                 }else
6597                         if(!yaffs_Scan(dev))
6598                                 init_failed = 1;
6599 -       }
6600
6601 +               yaffs_StripDeletedObjects(dev);
6602 +       }
6603 +
6604         if(init_failed){
6605                 /* Clean up the mess */
6606                 T(YAFFS_TRACE_TRACING,
6607 @@ -7310,7 +7470,7 @@ int yaffs_GutsInitialise(yaffs_Device *
6608
6609         yaffs_VerifyFreeChunks(dev);
6610         yaffs_VerifyBlocks(dev);
6611 -
6612 +
6613
6614         T(YAFFS_TRACE_TRACING,
6615           (TSTR("yaffs: yaffs_GutsInitialise() done.\n" TENDSTR)));
6616 @@ -7345,7 +7505,11 @@ void yaffs_Deinitialise(yaffs_Device * d
6617                         YFREE(dev->tempBuffer[i].buffer);
6618                 }
6619
6620 +
6621                 dev->isMounted = 0;
6622 +
6623 +               if(dev->deinitialiseNAND)
6624 +                       dev->deinitialiseNAND(dev);
6625         }
6626
6627  }
6628 @@ -7394,7 +7558,7 @@ int yaffs_GetNumberOfFreeChunks(yaffs_De
6629  #endif
6630
6631         nFree += dev->nDeletedFiles;
6632 -
6633 +
6634         /* Now count the number of dirty chunks in the cache and subtract those */
6635
6636         {
6637 @@ -7408,12 +7572,12 @@ int yaffs_GetNumberOfFreeChunks(yaffs_De
6638         nFree -= nDirtyCacheChunks;
6639
6640         nFree -= ((dev->nReservedBlocks + 1) * dev->nChunksPerBlock);
6641 -
6642 +
6643         /* Now we figure out how much to reserve for the checkpoint and report that... */
6644 -       blocksForCheckpoint = dev->nCheckpointReservedBlocks - dev->blocksInCheckpoint;
6645 +       blocksForCheckpoint = yaffs_CalcCheckpointBlocksRequired(dev) - dev->blocksInCheckpoint;
6646         if(blocksForCheckpoint < 0)
6647                 blocksForCheckpoint = 0;
6648 -
6649 +
6650         nFree -= (blocksForCheckpoint * dev->nChunksPerBlock);
6651
6652         if (nFree < 0)
6653 @@ -7429,10 +7593,10 @@ static void yaffs_VerifyFreeChunks(yaffs
6654  {
6655         int counted;
6656         int difference;
6657 -
6658 +
6659         if(yaffs_SkipVerification(dev))
6660                 return;
6661 -
6662 +
6663         counted = yaffs_CountFreeChunks(dev);
6664
6665         difference = dev->nFreeChunks - counted;
6666 @@ -7448,22 +7612,25 @@ static void yaffs_VerifyFreeChunks(yaffs
6667  /*---------------------------------------- YAFFS test code ----------------------*/
6668
6669  #define yaffs_CheckStruct(structure,syze, name) \
6670 +       do { \
6671             if(sizeof(structure) != syze) \
6672                { \
6673                  T(YAFFS_TRACE_ALWAYS,(TSTR("%s should be %d but is %d\n" TENDSTR),\
6674                  name,syze,sizeof(structure))); \
6675                  return YAFFS_FAIL; \
6676 -               }
6677 +               } \
6678 +       } while(0)
6679
6680  static int yaffs_CheckStructures(void)
6681  {
6682 -/*      yaffs_CheckStruct(yaffs_Tags,8,"yaffs_Tags") */
6683 -/*      yaffs_CheckStruct(yaffs_TagsUnion,8,"yaffs_TagsUnion") */
6684 -/*      yaffs_CheckStruct(yaffs_Spare,16,"yaffs_Spare") */
6685 +/*      yaffs_CheckStruct(yaffs_Tags,8,"yaffs_Tags"); */
6686 +/*      yaffs_CheckStruct(yaffs_TagsUnion,8,"yaffs_TagsUnion"); */
6687 +/*      yaffs_CheckStruct(yaffs_Spare,16,"yaffs_Spare"); */
6688  #ifndef CONFIG_YAFFS_TNODE_LIST_DEBUG
6689 -       yaffs_CheckStruct(yaffs_Tnode, 2 * YAFFS_NTNODES_LEVEL0, "yaffs_Tnode")
6690 +        yaffs_CheckStruct(yaffs_Tnode, 2 * YAFFS_NTNODES_LEVEL0, "yaffs_Tnode");
6691 +#endif
6692 +#ifndef CONFIG_YAFFS_WINCE
6693 +               yaffs_CheckStruct(yaffs_ObjectHeader, 512, "yaffs_ObjectHeader");
6694  #endif
6695 -           yaffs_CheckStruct(yaffs_ObjectHeader, 512, "yaffs_ObjectHeader")
6696 -
6697             return YAFFS_OK;
6698  }
6699 --- a/fs/yaffs2/yaffs_mtdif1.c
6700 +++ b/fs/yaffs2/yaffs_mtdif1.c
6701 @@ -34,9 +34,9 @@
6702  #include "linux/mtd/mtd.h"
6703
6704  /* Don't compile this module if we don't have MTD's mtd_oob_ops interface */
6705 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
6706 +#if (MTD_VERSION_CODE > MTD_VERSION(2,6,17))
6707
6708 -const char *yaffs_mtdif1_c_version = "$Id: yaffs_mtdif1.c,v 1.3 2007/05/15 20:16:11 ian Exp $";
6709 +const char *yaffs_mtdif1_c_version = "$Id: yaffs_mtdif1.c,v 1.8 2008-07-23 03:35:12 charles Exp $";
6710
6711  #ifndef CONFIG_YAFFS_9BYTE_TAGS
6712  # define YTAG1_SIZE 8
6713 @@ -189,7 +189,7 @@ int nandmtd1_ReadChunkWithTagsFromNAND(y
6714         ops.datbuf = data;
6715         ops.oobbuf = (__u8 *)&pt1;
6716
6717 -#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20))
6718 +#if (MTD_VERSION_CODE < MTD_VERSION(2,6,20))
6719         /* In MTD 2.6.18 to 2.6.19 nand_base.c:nand_do_read_oob() has a bug;
6720          * help it out with ops.len = ops.ooblen when ops.datbuf == NULL.
6721          */
6722 @@ -288,7 +288,7 @@ int nandmtd1_MarkNANDBlockBad(struct yaf
6723         int blocksize = dev->nChunksPerBlock * dev->nDataBytesPerChunk;
6724         int retval;
6725
6726 -       yaffs_trace(YAFFS_TRACE_BAD_BLOCKS, "marking block %d bad", blockNo);
6727 +       yaffs_trace(YAFFS_TRACE_BAD_BLOCKS, "marking block %d bad\n", blockNo);
6728
6729         retval = mtd->block_markbad(mtd, (loff_t)blocksize * blockNo);
6730         return (retval) ? YAFFS_FAIL : YAFFS_OK;
6731 @@ -323,10 +323,11 @@ static int nandmtd1_TestPrerequists(stru
6732   * Always returns YAFFS_OK.
6733   */
6734  int nandmtd1_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockNo,
6735 -       yaffs_BlockState * pState, int *pSequenceNumber)
6736 +       yaffs_BlockState * pState, __u32 *pSequenceNumber)
6737  {
6738         struct mtd_info * mtd = dev->genericDevice;
6739         int chunkNo = blockNo * dev->nChunksPerBlock;
6740 +       loff_t addr = (loff_t)chunkNo * dev->nDataBytesPerChunk;
6741         yaffs_ExtendedTags etags;
6742         int state = YAFFS_BLOCK_STATE_DEAD;
6743         int seqnum = 0;
6744 @@ -340,11 +341,16 @@ int nandmtd1_QueryNANDBlock(struct yaffs
6745         }
6746
6747         retval = nandmtd1_ReadChunkWithTagsFromNAND(dev, chunkNo, NULL, &etags);
6748 +       etags.blockBad = (mtd->block_isbad)(mtd, addr);
6749         if (etags.blockBad) {
6750                 yaffs_trace(YAFFS_TRACE_BAD_BLOCKS,
6751 -                       "block %d is marked bad", blockNo);
6752 +                       "block %d is marked bad\n", blockNo);
6753                 state = YAFFS_BLOCK_STATE_DEAD;
6754         }
6755 +       else if (etags.eccResult != YAFFS_ECC_RESULT_NO_ERROR) {
6756 +               /* bad tags, need to look more closely */
6757 +               state = YAFFS_BLOCK_STATE_NEEDS_SCANNING;
6758 +       }
6759         else if (etags.chunkUsed) {
6760                 state = YAFFS_BLOCK_STATE_NEEDS_SCANNING;
6761                 seqnum = etags.sequenceNumber;
6762 @@ -360,4 +366,4 @@ int nandmtd1_QueryNANDBlock(struct yaffs
6763         return YAFFS_OK;
6764  }
6765
6766 -#endif /*KERNEL_VERSION*/
6767 +#endif /*MTD_VERSION*/
6768 --- a/fs/yaffs2/yaffs_mtdif2.c
6769 +++ b/fs/yaffs2/yaffs_mtdif2.c
6770 @@ -14,7 +14,7 @@
6771  /* mtd interface for YAFFS2 */
6772
6773  const char *yaffs_mtdif2_c_version =
6774 -    "$Id: yaffs_mtdif2.c,v 1.17 2007-02-14 01:09:06 wookey Exp $";
6775 +    "$Id: yaffs_mtdif2.c,v 1.22 2008-11-02 22:47:13 charles Exp $";
6776
6777  #include "yportenv.h"
6778
6779 @@ -27,19 +27,23 @@ const char *yaffs_mtdif2_c_version =
6780
6781  #include "yaffs_packedtags2.h"
6782
6783 +/* NB For use with inband tags....
6784 + * We assume that the data buffer is of size totalBytersPerChunk so that we can also
6785 + * use it to load the tags.
6786 + */
6787  int nandmtd2_WriteChunkWithTagsToNAND(yaffs_Device * dev, int chunkInNAND,
6788                                       const __u8 * data,
6789                                       const yaffs_ExtendedTags * tags)
6790  {
6791         struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice);
6792 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
6793 +#if (MTD_VERSION_CODE > MTD_VERSION(2,6,17))
6794         struct mtd_oob_ops ops;
6795  #else
6796         size_t dummy;
6797  #endif
6798         int retval = 0;
6799
6800 -       loff_t addr = ((loff_t) chunkInNAND) * dev->nDataBytesPerChunk;
6801 +       loff_t addr;
6802
6803         yaffs_PackedTags2 pt;
6804
6805 @@ -47,47 +51,42 @@ int nandmtd2_WriteChunkWithTagsToNAND(ya
6806           (TSTR
6807            ("nandmtd2_WriteChunkWithTagsToNAND chunk %d data %p tags %p"
6808             TENDSTR), chunkInNAND, data, tags));
6809 +
6810
6811 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
6812 -       if (tags)
6813 -               yaffs_PackTags2(&pt, tags);
6814 +       addr  = ((loff_t) chunkInNAND) * dev->totalBytesPerChunk;
6815 +
6816 +       /* For yaffs2 writing there must be both data and tags.
6817 +        * If we're using inband tags, then the tags are stuffed into
6818 +        * the end of the data buffer.
6819 +        */
6820 +       if(!data || !tags)
6821 +               BUG();
6822 +       else if(dev->inbandTags){
6823 +               yaffs_PackedTags2TagsPart *pt2tp;
6824 +               pt2tp = (yaffs_PackedTags2TagsPart *)(data + dev->nDataBytesPerChunk);
6825 +               yaffs_PackTags2TagsPart(pt2tp,tags);
6826 +       }
6827         else
6828 -               BUG(); /* both tags and data should always be present */
6829 -
6830 -       if (data) {
6831 -               ops.mode = MTD_OOB_AUTO;
6832 -               ops.ooblen = sizeof(pt);
6833 -               ops.len = dev->nDataBytesPerChunk;
6834 -               ops.ooboffs = 0;
6835 -               ops.datbuf = (__u8 *)data;
6836 -               ops.oobbuf = (void *)&pt;
6837 -               retval = mtd->write_oob(mtd, addr, &ops);
6838 -       } else
6839 -               BUG(); /* both tags and data should always be present */
6840 -#else
6841 -       if (tags) {
6842                 yaffs_PackTags2(&pt, tags);
6843 -       }
6844 +
6845 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
6846 +       ops.mode = MTD_OOB_AUTO;
6847 +       ops.ooblen = (dev->inbandTags) ? 0 : sizeof(pt);
6848 +       ops.len = dev->totalBytesPerChunk;
6849 +       ops.ooboffs = 0;
6850 +       ops.datbuf = (__u8 *)data;
6851 +       ops.oobbuf = (dev->inbandTags) ? NULL : (void *)&pt;
6852 +       retval = mtd->write_oob(mtd, addr, &ops);
6853
6854 -       if (data && tags) {
6855 -               if (dev->useNANDECC)
6856 -                       retval =
6857 -                           mtd->write_ecc(mtd, addr, dev->nDataBytesPerChunk,
6858 -                                          &dummy, data, (__u8 *) & pt, NULL);
6859 -               else
6860 -                       retval =
6861 -                           mtd->write_ecc(mtd, addr, dev->nDataBytesPerChunk,
6862 -                                          &dummy, data, (__u8 *) & pt, NULL);
6863 +#else
6864 +       if (!dev->inbandTags) {
6865 +               retval =
6866 +                   mtd->write_ecc(mtd, addr, dev->nDataBytesPerChunk,
6867 +                                  &dummy, data, (__u8 *) & pt, NULL);
6868         } else {
6869 -               if (data)
6870 -                       retval =
6871 -                           mtd->write(mtd, addr, dev->nDataBytesPerChunk, &dummy,
6872 -                                      data);
6873 -               if (tags)
6874 -                       retval =
6875 -                           mtd->write_oob(mtd, addr, mtd->oobsize, &dummy,
6876 -                                          (__u8 *) & pt);
6877 -
6878 +               retval =
6879 +                   mtd->write(mtd, addr, dev->totalBytesPerChunk, &dummy,
6880 +                              data);
6881         }
6882  #endif
6883
6884 @@ -101,13 +100,14 @@ int nandmtd2_ReadChunkWithTagsFromNAND(y
6885                                        __u8 * data, yaffs_ExtendedTags * tags)
6886  {
6887         struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice);
6888 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
6889 +#if (MTD_VERSION_CODE > MTD_VERSION(2,6,17))
6890         struct mtd_oob_ops ops;
6891  #endif
6892         size_t dummy;
6893         int retval = 0;
6894 +       int localData = 0;
6895
6896 -       loff_t addr = ((loff_t) chunkInNAND) * dev->nDataBytesPerChunk;
6897 +       loff_t addr = ((loff_t) chunkInNAND) * dev->totalBytesPerChunk;
6898
6899         yaffs_PackedTags2 pt;
6900
6901 @@ -115,10 +115,21 @@ int nandmtd2_ReadChunkWithTagsFromNAND(y
6902           (TSTR
6903            ("nandmtd2_ReadChunkWithTagsFromNAND chunk %d data %p tags %p"
6904             TENDSTR), chunkInNAND, data, tags));
6905 +
6906 +       if(dev->inbandTags){
6907 +
6908 +               if(!data) {
6909 +                       localData = 1;
6910 +                       data = yaffs_GetTempBuffer(dev,__LINE__);
6911 +               }
6912 +
6913 +
6914 +       }
6915 +
6916
6917  #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
6918 -       if (data && !tags)
6919 -               retval = mtd->read(mtd, addr, dev->nDataBytesPerChunk,
6920 +       if (dev->inbandTags || (data && !tags))
6921 +               retval = mtd->read(mtd, addr, dev->totalBytesPerChunk,
6922                                 &dummy, data);
6923         else if (tags) {
6924                 ops.mode = MTD_OOB_AUTO;
6925 @@ -130,38 +141,43 @@ int nandmtd2_ReadChunkWithTagsFromNAND(y
6926                 retval = mtd->read_oob(mtd, addr, &ops);
6927         }
6928  #else
6929 -       if (data && tags) {
6930 -               if (dev->useNANDECC) {
6931 -                       retval =
6932 -                           mtd->read_ecc(mtd, addr, dev->nDataBytesPerChunk,
6933 -                                         &dummy, data, dev->spareBuffer,
6934 -                                         NULL);
6935 -               } else {
6936 -                       retval =
6937 -                           mtd->read_ecc(mtd, addr, dev->nDataBytesPerChunk,
6938 +       if (!dev->inbandTags && data && tags) {
6939 +
6940 +               retval = mtd->read_ecc(mtd, addr, dev->nDataBytesPerChunk,
6941                                           &dummy, data, dev->spareBuffer,
6942                                           NULL);
6943 -               }
6944         } else {
6945                 if (data)
6946                         retval =
6947                             mtd->read(mtd, addr, dev->nDataBytesPerChunk, &dummy,
6948                                       data);
6949 -               if (tags)
6950 +               if (!dev->inbandTags && tags)
6951                         retval =
6952                             mtd->read_oob(mtd, addr, mtd->oobsize, &dummy,
6953                                           dev->spareBuffer);
6954         }
6955  #endif
6956
6957 -       memcpy(&pt, dev->spareBuffer, sizeof(pt));
6958
6959 -       if (tags)
6960 -               yaffs_UnpackTags2(tags, &pt);
6961 +       if(dev->inbandTags){
6962 +               if(tags){
6963 +                       yaffs_PackedTags2TagsPart * pt2tp;
6964 +                       pt2tp = (yaffs_PackedTags2TagsPart *)&data[dev->nDataBytesPerChunk];
6965 +                       yaffs_UnpackTags2TagsPart(tags,pt2tp);
6966 +               }
6967 +       }
6968 +       else {
6969 +               if (tags){
6970 +                       memcpy(&pt, dev->spareBuffer, sizeof(pt));
6971 +                       yaffs_UnpackTags2(tags, &pt);
6972 +               }
6973 +       }
6974
6975 +       if(localData)
6976 +               yaffs_ReleaseTempBuffer(dev,data,__LINE__);
6977 +
6978         if(tags && retval == -EBADMSG && tags->eccResult == YAFFS_ECC_RESULT_NO_ERROR)
6979 -               tags->eccResult = YAFFS_ECC_RESULT_UNFIXED;
6980 -
6981 +               tags->eccResult = YAFFS_ECC_RESULT_UNFIXED;
6982         if (retval == 0)
6983                 return YAFFS_OK;
6984         else
6985 @@ -178,7 +194,7 @@ int nandmtd2_MarkNANDBlockBad(struct yaf
6986         retval =
6987             mtd->block_markbad(mtd,
6988                                blockNo * dev->nChunksPerBlock *
6989 -                              dev->nDataBytesPerChunk);
6990 +                              dev->totalBytesPerChunk);
6991
6992         if (retval == 0)
6993                 return YAFFS_OK;
6994 @@ -188,7 +204,7 @@ int nandmtd2_MarkNANDBlockBad(struct yaf
6995  }
6996
6997  int nandmtd2_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockNo,
6998 -                           yaffs_BlockState * state, int *sequenceNumber)
6999 +                           yaffs_BlockState * state, __u32 *sequenceNumber)
7000  {
7001         struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice);
7002         int retval;
7003 @@ -198,7 +214,7 @@ int nandmtd2_QueryNANDBlock(struct yaffs
7004         retval =
7005             mtd->block_isbad(mtd,
7006                              blockNo * dev->nChunksPerBlock *
7007 -                            dev->nDataBytesPerChunk);
7008 +                            dev->totalBytesPerChunk);
7009
7010         if (retval) {
7011                 T(YAFFS_TRACE_MTD, (TSTR("block is bad" TENDSTR)));
7012 --- a/fs/yaffs2/yaffs_guts.h
7013 +++ b/fs/yaffs2/yaffs_guts.h
7014 @@ -1,5 +1,5 @@
7015  /*
7016 - * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
7017 + * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
7018   *
7019   * Copyright (C) 2002-2007 Aleph One Ltd.
7020   *   for Toby Churchill Ltd and Brightstar Engineering
7021 @@ -22,11 +22,11 @@
7022  #define YAFFS_OK       1
7023  #define YAFFS_FAIL  0
7024
7025 -/* Give us a  Y=0x59,
7026 - * Give us an A=0x41,
7027 - * Give us an FF=0xFF
7028 +/* Give us a  Y=0x59,
7029 + * Give us an A=0x41,
7030 + * Give us an FF=0xFF
7031   * Give us an S=0x53
7032 - * And what have we got...
7033 + * And what have we got...
7034   */
7035  #define YAFFS_MAGIC                    0x5941FF53
7036
7037 @@ -90,7 +90,7 @@
7038
7039  #define YAFFS_MAX_SHORT_OP_CACHES      20
7040
7041 -#define YAFFS_N_TEMP_BUFFERS           4
7042 +#define YAFFS_N_TEMP_BUFFERS           6
7043
7044  /* We limit the number attempts at sucessfully saving a chunk of data.
7045   * Small-page devices have 32 pages per block; large-page devices have 64.
7046 @@ -102,7 +102,7 @@
7047   * The range is limited slightly to help distinguish bad numbers from good.
7048   * This also allows us to perhaps in the future use special numbers for
7049   * special purposes.
7050 - * EFFFFF00 allows the allocation of 8 blocks per second (~1Mbytes) for 15 years,
7051 + * EFFFFF00 allows the allocation of 8 blocks per second (~1Mbytes) for 15 years,
7052   * and is a larger number than the lifetime of a 2GB device.
7053   */
7054  #define YAFFS_LOWEST_SEQUENCE_NUMBER   0x00001000
7055 @@ -132,12 +132,12 @@ typedef struct {
7056
7057  #ifndef CONFIG_YAFFS_NO_YAFFS1
7058  typedef struct {
7059 -       unsigned chunkId:20;
7060 -       unsigned serialNumber:2;
7061 -       unsigned byteCount:10;
7062 -       unsigned objectId:18;
7063 -       unsigned ecc:12;
7064 -       unsigned unusedStuff:2;
7065 +        unsigned chunkId:20;
7066 +        unsigned serialNumber:2;
7067 +        unsigned byteCountLSB:10;
7068 +        unsigned objectId:18;
7069 +        unsigned ecc:12;
7070 +        unsigned byteCountMSB:2;
7071
7072  } yaffs_Tags;
7073
7074 @@ -178,7 +178,7 @@ typedef struct {
7075
7076         /* The following stuff only has meaning when we read */
7077         yaffs_ECCResult eccResult;
7078 -       unsigned blockBad;
7079 +       unsigned blockBad;
7080
7081         /* YAFFS 1 stuff */
7082         unsigned chunkDeleted;  /* The chunk is marked deleted */
7083 @@ -244,29 +244,29 @@ typedef enum {
7084         /* This block is empty */
7085
7086         YAFFS_BLOCK_STATE_ALLOCATING,
7087 -       /* This block is partially allocated.
7088 +       /* This block is partially allocated.
7089          * At least one page holds valid data.
7090          * This is the one currently being used for page
7091          * allocation. Should never be more than one of these
7092          */
7093
7094 -       YAFFS_BLOCK_STATE_FULL,
7095 +       YAFFS_BLOCK_STATE_FULL,
7096         /* All the pages in this block have been allocated.
7097          */
7098
7099         YAFFS_BLOCK_STATE_DIRTY,
7100 -       /* All pages have been allocated and deleted.
7101 +       /* All pages have been allocated and deleted.
7102          * Erase me, reuse me.
7103          */
7104
7105 -       YAFFS_BLOCK_STATE_CHECKPOINT,
7106 +       YAFFS_BLOCK_STATE_CHECKPOINT,
7107         /* This block is assigned to holding checkpoint data.
7108          */
7109
7110 -       YAFFS_BLOCK_STATE_COLLECTING,
7111 +       YAFFS_BLOCK_STATE_COLLECTING,
7112         /* This block is being garbage collected */
7113
7114 -       YAFFS_BLOCK_STATE_DEAD
7115 +       YAFFS_BLOCK_STATE_DEAD
7116         /* This block has failed and is not in use */
7117  } yaffs_BlockState;
7118
7119 @@ -277,11 +277,11 @@ typedef struct {
7120
7121         int softDeletions:10;   /* number of soft deleted pages */
7122         int pagesInUse:10;      /* number of pages in use */
7123 -       yaffs_BlockState blockState:4;  /* One of the above block states */
7124 +       unsigned blockState:4;  /* One of the above block states. NB use unsigned because enum is sometimes an int */
7125         __u32 needsRetiring:1;  /* Data has failed on this block, need to get valid data off */
7126                                 /* and retire the block. */
7127         __u32 skipErasedCheck: 1; /* If this is set we can skip the erased check on this block */
7128 -       __u32 gcPrioritise: 1;  /* An ECC check or blank check has failed on this block.
7129 +       __u32 gcPrioritise: 1;  /* An ECC check or blank check has failed on this block.
7130                                    It should be prioritised for GC */
7131          __u32 chunkErrorStrikes:3; /* How many times we've had ecc etc failures on this block and tried to reuse it */
7132
7133 @@ -300,11 +300,11 @@ typedef struct {
7134
7135         /* Apply to everything  */
7136         int parentObjectId;
7137 -       __u16 sum__NoLongerUsed;        /* checksum of name. No longer used */
7138 -       YCHAR name[YAFFS_MAX_NAME_LENGTH + 1];
7139 +        __u16 sum__NoLongerUsed;        /* checksum of name. No longer used */
7140 +        YCHAR name[YAFFS_MAX_NAME_LENGTH + 1];
7141
7142 -       /* Thes following apply to directories, files, symlinks - not hard links */
7143 -       __u32 yst_mode;         /* protection */
7144 +        /* The following apply to directories, files, symlinks - not hard links */
7145 +        __u32 yst_mode;         /* protection */
7146
7147  #ifdef CONFIG_YAFFS_WINCE
7148         __u32 notForWinCE[5];
7149 @@ -331,11 +331,14 @@ typedef struct {
7150         __u32 win_ctime[2];
7151         __u32 win_atime[2];
7152         __u32 win_mtime[2];
7153 -       __u32 roomToGrow[4];
7154  #else
7155 -       __u32 roomToGrow[10];
7156 +       __u32 roomToGrow[6];
7157 +
7158  #endif
7159 +       __u32 inbandShadowsObject;
7160 +       __u32 inbandIsShrink;
7161
7162 +       __u32 reservedSpace[2];
7163         int shadowsObject;      /* This object header shadows the specified object if > 0 */
7164
7165         /* isShrink applies to object headers written when we shrink the file (ie resize) */
7166 @@ -381,7 +384,7 @@ typedef struct {
7167  } yaffs_FileStructure;
7168
7169  typedef struct {
7170 -       struct list_head children;      /* list of child links */
7171 +        struct ylist_head children;     /* list of child links */
7172  } yaffs_DirectoryStructure;
7173
7174  typedef struct {
7175 @@ -408,7 +411,7 @@ struct yaffs_ObjectStruct {
7176         __u8 renameAllowed:1;   /* Some objects are not allowed to be renamed. */
7177         __u8 unlinkAllowed:1;
7178         __u8 dirty:1;           /* the object needs to be written to flash */
7179 -       __u8 valid:1;           /* When the file system is being loaded up, this
7180 +       __u8 valid:1;           /* When the file system is being loaded up, this
7181                                  * object might be created before the data
7182                                  * is available (ie. file data records appear before the header).
7183                                  */
7184 @@ -417,33 +420,36 @@ struct yaffs_ObjectStruct {
7185         __u8 deferedFree:1;     /* For Linux kernel. Object is removed from NAND, but is
7186                                  * still in the inode cache. Free of object is defered.
7187                                  * until the inode is released.
7188 -                                */
7189 +                                 */
7190 +        __u8 beingCreated:1;   /* This object is still being created so skip some checks. */
7191
7192 -       __u8 serial;            /* serial number of chunk in NAND. Cached here */
7193 -       __u16 sum;              /* sum of the name to speed searching */
7194 +        __u8 serial;            /* serial number of chunk in NAND. Cached here */
7195 +/*        __u16 sum_prev; */
7196 +        __u16 sum;              /* sum of the name to speed searching */
7197 +/*        __u16 sum_trailer; */
7198
7199 -       struct yaffs_DeviceStruct *myDev;       /* The device I'm on */
7200 +        struct yaffs_DeviceStruct *myDev;       /* The device I'm on */
7201
7202 -       struct list_head hashLink;      /* list of objects in this hash bucket */
7203 +        struct ylist_head hashLink;     /* list of objects in this hash bucket */
7204
7205 -       struct list_head hardLinks;     /* all the equivalent hard linked objects */
7206 +        struct ylist_head hardLinks;    /* all the equivalent hard linked objects */
7207
7208 -       /* directory structure stuff */
7209 -       /* also used for linking up the free list */
7210 -       struct yaffs_ObjectStruct *parent;
7211 -       struct list_head siblings;
7212 +        /* directory structure stuff */
7213 +        /* also used for linking up the free list */
7214 +        struct yaffs_ObjectStruct *parent;
7215 +        struct ylist_head siblings;
7216
7217         /* Where's my object header in NAND? */
7218 -       int chunkId;
7219 +       int hdrChunk;
7220
7221         int nDataChunks;        /* Number of data chunks attached to the file. */
7222
7223         __u32 objectId;         /* the object id value */
7224
7225 -       __u32 yst_mode;
7226 +        __u32 yst_mode;
7227
7228  #ifdef CONFIG_YAFFS_SHORT_NAMES_IN_RAM
7229 -       YCHAR shortName[YAFFS_SHORT_NAME_LENGTH + 1];
7230 +        YCHAR shortName[YAFFS_SHORT_NAME_LENGTH + 1];
7231  #endif
7232
7233  #ifndef __KERNEL__
7234 @@ -485,31 +491,30 @@ struct yaffs_ObjectList_struct {
7235  typedef struct yaffs_ObjectList_struct yaffs_ObjectList;
7236
7237  typedef struct {
7238 -       struct list_head list;
7239 -       int count;
7240 +        struct ylist_head list;
7241 +        int count;
7242  } yaffs_ObjectBucket;
7243
7244
7245 -/* yaffs_CheckpointObject holds the definition of an object as dumped
7246 +/* yaffs_CheckpointObject holds the definition of an object as dumped
7247   * by checkpointing.
7248   */
7249
7250  typedef struct {
7251          int structType;
7252 -       __u32 objectId;
7253 +       __u32 objectId;
7254         __u32 parentId;
7255 -       int chunkId;
7256 -
7257 +       int hdrChunk;
7258         yaffs_ObjectType variantType:3;
7259 -       __u8 deleted:1;
7260 -       __u8 softDeleted:1;
7261 -       __u8 unlinked:1;
7262 -       __u8 fake:1;
7263 +       __u8 deleted:1;
7264 +       __u8 softDeleted:1;
7265 +       __u8 unlinked:1;
7266 +       __u8 fake:1;
7267         __u8 renameAllowed:1;
7268         __u8 unlinkAllowed:1;
7269 -       __u8 serial;
7270 -
7271 -       int nDataChunks;
7272 +       __u8 serial;
7273 +
7274 +       int nDataChunks;
7275         __u32 fileSizeOrEquivalentObjectId;
7276
7277  }yaffs_CheckpointObject;
7278 @@ -528,25 +533,25 @@ typedef struct {
7279  /*----------------- Device ---------------------------------*/
7280
7281  struct yaffs_DeviceStruct {
7282 -       struct list_head devList;
7283 -       const char *name;
7284 +        struct ylist_head devList;
7285 +        const char *name;
7286
7287 -       /* Entry parameters set up way early. Yaffs sets up the rest.*/
7288 -       int nDataBytesPerChunk; /* Should be a power of 2 >= 512 */
7289 -       int nChunksPerBlock;    /* does not need to be a power of 2 */
7290 -       int nBytesPerSpare;     /* spare area size */
7291 -       int startBlock;         /* Start block we're allowed to use */
7292 -       int endBlock;           /* End block we're allowed to use */
7293 -       int nReservedBlocks;    /* We want this tuneable so that we can reduce */
7294 +        /* Entry parameters set up way early. Yaffs sets up the rest.*/
7295 +        int nDataBytesPerChunk; /* Should be a power of 2 >= 512 */
7296 +        int nChunksPerBlock;    /* does not need to be a power of 2 */
7297 +        int spareBytesPerChunk;/* spare area size */
7298 +        int startBlock;         /* Start block we're allowed to use */
7299 +        int endBlock;           /* End block we're allowed to use */
7300 +        int nReservedBlocks;    /* We want this tuneable so that we can reduce */
7301                                 /* reserved blocks on NOR and RAM. */
7302 -
7303 -
7304 +
7305 +
7306         /* Stuff used by the shared space checkpointing mechanism */
7307         /* If this value is zero, then this mechanism is disabled */
7308 +
7309 +//     int nCheckpointReservedBlocks; /* Blocks to reserve for checkpoint data */
7310
7311 -       int nCheckpointReservedBlocks; /* Blocks to reserve for checkpoint data */
7312 -
7313 -
7314 +
7315
7316
7317         int nShortOpCaches;     /* If <= 0, then short op caching is disabled, else
7318 @@ -561,7 +566,7 @@ struct yaffs_DeviceStruct {
7319                                  * On an mtd this holds the mtd pointer.
7320                                  */
7321          void *superBlock;
7322 -
7323 +
7324         /* NAND access functions (Must be set before calling YAFFS)*/
7325
7326         int (*writeChunkToNAND) (struct yaffs_DeviceStruct * dev,
7327 @@ -570,12 +575,13 @@ struct yaffs_DeviceStruct {
7328         int (*readChunkFromNAND) (struct yaffs_DeviceStruct * dev,
7329                                   int chunkInNAND, __u8 * data,
7330                                   yaffs_Spare * spare);
7331 -       int (*eraseBlockInNAND) (struct yaffs_DeviceStruct * dev,
7332 -                                int blockInNAND);
7333 -       int (*initialiseNAND) (struct yaffs_DeviceStruct * dev);
7334 +        int (*eraseBlockInNAND) (struct yaffs_DeviceStruct * dev,
7335 +                                 int blockInNAND);
7336 +        int (*initialiseNAND) (struct yaffs_DeviceStruct * dev);
7337 +        int (*deinitialiseNAND) (struct yaffs_DeviceStruct * dev);
7338
7339  #ifdef CONFIG_YAFFS_YAFFS2
7340 -       int (*writeChunkWithTagsToNAND) (struct yaffs_DeviceStruct * dev,
7341 +        int (*writeChunkWithTagsToNAND) (struct yaffs_DeviceStruct * dev,
7342                                          int chunkInNAND, const __u8 * data,
7343                                          const yaffs_ExtendedTags * tags);
7344         int (*readChunkWithTagsFromNAND) (struct yaffs_DeviceStruct * dev,
7345 @@ -583,25 +589,27 @@ struct yaffs_DeviceStruct {
7346                                           yaffs_ExtendedTags * tags);
7347         int (*markNANDBlockBad) (struct yaffs_DeviceStruct * dev, int blockNo);
7348         int (*queryNANDBlock) (struct yaffs_DeviceStruct * dev, int blockNo,
7349 -                              yaffs_BlockState * state, int *sequenceNumber);
7350 +                              yaffs_BlockState * state, __u32 *sequenceNumber);
7351  #endif
7352
7353         int isYaffs2;
7354 -
7355 -       /* The removeObjectCallback function must be supplied by OS flavours that
7356 +
7357 +       /* The removeObjectCallback function must be supplied by OS flavours that
7358          * need it. The Linux kernel does not use this, but yaffs direct does use
7359          * it to implement the faster readdir
7360          */
7361         void (*removeObjectCallback)(struct yaffs_ObjectStruct *obj);
7362 -
7363 +
7364         /* Callback to mark the superblock dirsty */
7365         void (*markSuperBlockDirty)(void * superblock);
7366 -
7367 +
7368         int wideTnodesDisabled; /* Set to disable wide tnodes */
7369 -
7370 +
7371 +       YCHAR *pathDividers;    /* String of legal path dividers */
7372 +
7373
7374         /* End of stuff that must be set before initialisation. */
7375 -
7376 +
7377         /* Checkpoint control. Can be set before or after initialisation */
7378         __u8 skipCheckpointRead;
7379         __u8 skipCheckpointWrite;
7380 @@ -610,34 +618,32 @@ struct yaffs_DeviceStruct {
7381
7382         __u16 chunkGroupBits;   /* 0 for devices <= 32MB. else log2(nchunks) - 16 */
7383         __u16 chunkGroupSize;   /* == 2^^chunkGroupBits */
7384 -
7385 +
7386         /* Stuff to support wide tnodes */
7387         __u32 tnodeWidth;
7388         __u32 tnodeMask;
7389 -
7390 -       /* Stuff to support various file offses to chunk/offset translations */
7391 -       /* "Crumbs" for nDataBytesPerChunk not being a power of 2 */
7392 -       __u32 crumbMask;
7393 -       __u32 crumbShift;
7394 -       __u32 crumbsPerChunk;
7395 -
7396 -       /* Straight shifting for nDataBytesPerChunk being a power of 2 */
7397 -       __u32 chunkShift;
7398 -       __u32 chunkMask;
7399 -
7400 +
7401 +       /* Stuff for figuring out file offset to chunk conversions */
7402 +       __u32 chunkShift; /* Shift value */
7403 +       __u32 chunkDiv;   /* Divisor after shifting: 1 for power-of-2 sizes */
7404 +       __u32 chunkMask;  /* Mask to use for power-of-2 case */
7405 +
7406 +       /* Stuff to handle inband tags */
7407 +       int inbandTags;
7408 +       __u32 totalBytesPerChunk;
7409
7410  #ifdef __KERNEL__
7411
7412         struct semaphore sem;   /* Semaphore for waiting on erasure.*/
7413         struct semaphore grossLock;     /* Gross locking semaphore */
7414 -       __u8 *spareBuffer;      /* For mtdif2 use. Don't know the size of the buffer
7415 +       __u8 *spareBuffer;      /* For mtdif2 use. Don't know the size of the buffer
7416                                  * at compile time so we have to allocate it.
7417                                  */
7418         void (*putSuperFunc) (struct super_block * sb);
7419  #endif
7420
7421         int isMounted;
7422 -
7423 +
7424         int isCheckpointed;
7425
7426
7427 @@ -646,7 +652,7 @@ struct yaffs_DeviceStruct {
7428         int internalEndBlock;
7429         int blockOffset;
7430         int chunkOffset;
7431 -
7432 +
7433
7434         /* Runtime checkpointing stuff */
7435         int checkpointPageSequence;   /* running sequence number of checkpoint pages */
7436 @@ -662,13 +668,15 @@ struct yaffs_DeviceStruct {
7437         int checkpointMaxBlocks;
7438         __u32 checkpointSum;
7439         __u32 checkpointXor;
7440 -
7441 +
7442 +       int nCheckpointBlocksRequired; /* Number of blocks needed to store current checkpoint set */
7443 +
7444         /* Block Info */
7445         yaffs_BlockInfo *blockInfo;
7446         __u8 *chunkBits;        /* bitmap of chunks in use */
7447         unsigned blockInfoAlt:1;        /* was allocated using alternative strategy */
7448         unsigned chunkBitsAlt:1;        /* was allocated using alternative strategy */
7449 -       int chunkBitmapStride;  /* Number of bytes of chunkBits per block.
7450 +       int chunkBitmapStride;  /* Number of bytes of chunkBits per block.
7451                                  * Must be consistent with nChunksPerBlock.
7452                                  */
7453
7454 @@ -684,10 +692,14 @@ struct yaffs_DeviceStruct {
7455         yaffs_TnodeList *allocatedTnodeList;
7456
7457         int isDoingGC;
7458 +       int gcBlock;
7459 +       int gcChunk;
7460
7461         int nObjectsCreated;
7462         yaffs_Object *freeObjects;
7463         int nFreeObjects;
7464 +
7465 +       int nHardLinks;
7466
7467         yaffs_ObjectList *allocatedObjectList;
7468
7469 @@ -716,7 +728,7 @@ struct yaffs_DeviceStruct {
7470         int tagsEccUnfixed;
7471         int nDeletions;
7472         int nUnmarkedDeletions;
7473 -
7474 +
7475         int hasPendingPrioritisedGCs; /* We think this device might have pending prioritised gcs */
7476
7477         /* Special directories */
7478 @@ -727,7 +739,7 @@ struct yaffs_DeviceStruct {
7479          *      __u8            bufferedData[YAFFS_CHUNKS_PER_BLOCK][YAFFS_BYTES_PER_CHUNK];
7480          *      yaffs_Spare bufferedSpare[YAFFS_CHUNKS_PER_BLOCK];
7481          */
7482 -
7483 +
7484         int bufferedBlock;      /* Which block is buffered here? */
7485         int doingBufferedBlockRewrite;
7486
7487 @@ -744,9 +756,11 @@ struct yaffs_DeviceStruct {
7488         int nUnlinkedFiles;             /* Count of unlinked files. */
7489         int nBackgroundDeletions;       /* Count of background deletions. */
7490
7491 -
7492 +
7493 +       /* Temporary buffer management */
7494         yaffs_TempBuffer tempBuffer[YAFFS_N_TEMP_BUFFERS];
7495         int maxTemp;
7496 +       int tempInUse;
7497         int unmanagedTempAllocations;
7498         int unmanagedTempDeallocations;
7499
7500 @@ -758,17 +772,17 @@ struct yaffs_DeviceStruct {
7501
7502  typedef struct yaffs_DeviceStruct yaffs_Device;
7503
7504 -/* The static layout of bllock usage etc is stored in the super block header */
7505 +/* The static layout of block usage etc is stored in the super block header */
7506  typedef struct {
7507          int StructType;
7508 -       int version;
7509 +        int version;
7510         int checkpointStartBlock;
7511         int checkpointEndBlock;
7512         int startBlock;
7513         int endBlock;
7514         int rfu[100];
7515  } yaffs_SuperBlockHeader;
7516 -
7517 +
7518  /* The CheckpointDevice structure holds the device information that changes at runtime and
7519   * must be preserved over unmount/mount cycles.
7520   */
7521 @@ -797,18 +811,6 @@ typedef struct {
7522      __u32 head;
7523  } yaffs_CheckpointValidity;
7524
7525 -/* Function to manipulate block info */
7526 -static Y_INLINE yaffs_BlockInfo *yaffs_GetBlockInfo(yaffs_Device * dev, int blk)
7527 -{
7528 -       if (blk < dev->internalStartBlock || blk > dev->internalEndBlock) {
7529 -               T(YAFFS_TRACE_ERROR,
7530 -                 (TSTR
7531 -                  ("**>> yaffs: getBlockInfo block %d is not valid" TENDSTR),
7532 -                  blk));
7533 -               YBUG();
7534 -       }
7535 -       return &dev->blockInfo[blk - dev->internalStartBlock];
7536 -}
7537
7538  /*----------------------- YAFFS Functions -----------------------*/
7539
7540 @@ -834,13 +836,13 @@ int yaffs_GetAttributes(yaffs_Object * o
7541
7542  /* File operations */
7543  int yaffs_ReadDataFromFile(yaffs_Object * obj, __u8 * buffer, loff_t offset,
7544 -                          int nBytes);
7545 +                           int nBytes);
7546  int yaffs_WriteDataToFile(yaffs_Object * obj, const __u8 * buffer, loff_t offset,
7547 -                         int nBytes, int writeThrough);
7548 +                          int nBytes, int writeThrough);
7549  int yaffs_ResizeFile(yaffs_Object * obj, loff_t newSize);
7550
7551  yaffs_Object *yaffs_MknodFile(yaffs_Object * parent, const YCHAR * name,
7552 -                             __u32 mode, __u32 uid, __u32 gid);
7553 +                              __u32 mode, __u32 uid, __u32 gid);
7554  int yaffs_FlushFile(yaffs_Object * obj, int updateTime);
7555
7556  /* Flushing and checkpointing */
7557 @@ -899,4 +901,7 @@ void yaffs_DeleteChunk(yaffs_Device * de
7558  int yaffs_CheckFF(__u8 * buffer, int nBytes);
7559  void yaffs_HandleChunkError(yaffs_Device *dev, yaffs_BlockInfo *bi);
7560
7561 +__u8 *yaffs_GetTempBuffer(yaffs_Device * dev, int lineNo);
7562 +void yaffs_ReleaseTempBuffer(yaffs_Device * dev, __u8 * buffer, int lineNo);
7563 +
7564  #endif
7565 --- a/fs/yaffs2/moduleconfig.h
7566 +++ b/fs/yaffs2/moduleconfig.h
7567 @@ -54,11 +54,11 @@ that you need to continue to support.  N
7568  older-style format.
7569  Note: Use of this option generally requires that MTD's oob layout be
7570  adjusted to use the older-style format.  See notes on tags formats and
7571 -MTD versions.
7572 +MTD versions in yaffs_mtdif1.c.
7573  */
7574  /* Default: Not selected */
7575  /* Meaning: Use older-style on-NAND data format with pageStatus byte */
7576 -#define CONFIG_YAFFS_9BYTE_TAGS
7577 +//#define CONFIG_YAFFS_9BYTE_TAGS
7578
7579  #endif /* YAFFS_OUT_OF_TREE */
7580
7581 --- a/fs/yaffs2/yaffs_mtdif1.h
7582 +++ b/fs/yaffs2/yaffs_mtdif1.h
7583 @@ -23,6 +23,6 @@ int nandmtd1_ReadChunkWithTagsFromNAND(y
7584  int nandmtd1_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo);
7585
7586  int nandmtd1_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockNo,
7587 -       yaffs_BlockState * state, int *sequenceNumber);
7588 +       yaffs_BlockState * state, __u32 *sequenceNumber);
7589
7590  #endif
7591 --- a/fs/yaffs2/yaffs_mtdif2.h
7592 +++ b/fs/yaffs2/yaffs_mtdif2.h
7593 @@ -24,6 +24,6 @@ int nandmtd2_ReadChunkWithTagsFromNAND(y
7594                                        __u8 * data, yaffs_ExtendedTags * tags);
7595  int nandmtd2_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo);
7596  int nandmtd2_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockNo,
7597 -                           yaffs_BlockState * state, int *sequenceNumber);
7598 +                           yaffs_BlockState * state, __u32 *sequenceNumber);
7599
7600  #endif
7601 --- a/fs/yaffs2/yaffs_checkptrw.c
7602 +++ b/fs/yaffs2/yaffs_checkptrw.c
7603 @@ -12,11 +12,11 @@
7604   */
7605
7606  const char *yaffs_checkptrw_c_version =
7607 -    "$Id: yaffs_checkptrw.c,v 1.14 2007-05-15 20:07:40 charles Exp $";
7608 +    "$Id: yaffs_checkptrw.c,v 1.17 2008-08-12 22:51:57 charles Exp $";
7609
7610
7611  #include "yaffs_checkptrw.h"
7612 -
7613 +#include "yaffs_getblockinfo.h"
7614
7615  static int yaffs_CheckpointSpaceOk(yaffs_Device *dev)
7616  {
7617 @@ -142,7 +142,7 @@ int yaffs_CheckpointOpen(yaffs_Device *d
7618                 return 0;
7619
7620         if(!dev->checkpointBuffer)
7621 -               dev->checkpointBuffer = YMALLOC_DMA(dev->nDataBytesPerChunk);
7622 +               dev->checkpointBuffer = YMALLOC_DMA(dev->totalBytesPerChunk);
7623         if(!dev->checkpointBuffer)
7624                 return 0;
7625
7626 @@ -324,6 +324,7 @@ int yaffs_CheckpointRead(yaffs_Device *d
7627                                                               &tags);
7628
7629                                 if(tags.chunkId != (dev->checkpointPageSequence + 1) ||
7630 +                                  tags.eccResult > YAFFS_ECC_RESULT_FIXED ||
7631                                    tags.sequenceNumber != YAFFS_SEQUENCE_CHECKPOINT_DATA)
7632                                    ok = 0;
7633
7634 --- a/fs/yaffs2/yaffs_tagscompat.c
7635 +++ b/fs/yaffs2/yaffs_tagscompat.c
7636 @@ -14,6 +14,7 @@
7637  #include "yaffs_guts.h"
7638  #include "yaffs_tagscompat.h"
7639  #include "yaffs_ecc.h"
7640 +#include "yaffs_getblockinfo.h"
7641
7642  static void yaffs_HandleReadDataError(yaffs_Device * dev, int chunkInNAND);
7643  #ifdef NOTYET
7644 @@ -252,6 +253,9 @@ static int yaffs_ReadChunkFromNAND(struc
7645                 /* Must allocate enough memory for spare+2*sizeof(int) */
7646                 /* for ecc results from device. */
7647                 struct yaffs_NANDSpare nspare;
7648 +
7649 +               memset(&nspare,0,sizeof(nspare));
7650 +
7651                 retVal =
7652                     dev->readChunkFromNAND(dev, chunkInNAND, data,
7653                                            (yaffs_Spare *) & nspare);
7654 @@ -336,7 +340,7 @@ static void yaffs_HandleReadDataError(ya
7655         int blockInNAND = chunkInNAND / dev->nChunksPerBlock;
7656
7657         /* Mark the block for retirement */
7658 -       yaffs_GetBlockInfo(dev, blockInNAND)->needsRetiring = 1;
7659 +       yaffs_GetBlockInfo(dev, blockInNAND + dev->blockOffset)->needsRetiring = 1;
7660         T(YAFFS_TRACE_ERROR | YAFFS_TRACE_BAD_BLOCKS,
7661           (TSTR("**>>Block %d marked for retirement" TENDSTR), blockInNAND));
7662
7663 @@ -414,7 +418,16 @@ int yaffs_TagsCompatabilityWriteChunkWit
7664         } else {
7665                 tags.objectId = eTags->objectId;
7666                 tags.chunkId = eTags->chunkId;
7667 -               tags.byteCount = eTags->byteCount;
7668 +
7669 +               tags.byteCountLSB = eTags->byteCount & 0x3ff;
7670 +
7671 +               if(dev->nDataBytesPerChunk >= 1024){
7672 +                       tags.byteCountMSB = (eTags->byteCount >> 10) & 3;
7673 +               } else {
7674 +                       tags.byteCountMSB = 3;
7675 +               }
7676 +
7677 +
7678                 tags.serialNumber = eTags->serialNumber;
7679
7680                 if (!dev->useNANDECC && data) {
7681 @@ -435,10 +448,10 @@ int yaffs_TagsCompatabilityReadChunkWith
7682
7683         yaffs_Spare spare;
7684         yaffs_Tags tags;
7685 -       yaffs_ECCResult eccResult;
7686 +       yaffs_ECCResult eccResult = YAFFS_ECC_RESULT_UNKNOWN;
7687
7688         static yaffs_Spare spareFF;
7689 -       static int init;
7690 +       static int init = 0;
7691
7692         if (!init) {
7693                 memset(&spareFF, 0xFF, sizeof(spareFF));
7694 @@ -466,7 +479,11 @@ int yaffs_TagsCompatabilityReadChunkWith
7695
7696                                 eTags->objectId = tags.objectId;
7697                                 eTags->chunkId = tags.chunkId;
7698 -                               eTags->byteCount = tags.byteCount;
7699 +                               eTags->byteCount = tags.byteCountLSB;
7700 +
7701 +                               if(dev->nDataBytesPerChunk >= 1024)
7702 +                                       eTags->byteCount |= (((unsigned) tags.byteCountMSB) << 10);
7703 +
7704                                 eTags->serialNumber = tags.serialNumber;
7705                         }
7706                 }
7707 @@ -497,9 +514,9 @@ int yaffs_TagsCompatabilityMarkNANDBlock
7708  }
7709
7710  int yaffs_TagsCompatabilityQueryNANDBlock(struct yaffs_DeviceStruct *dev,
7711 -                                         int blockNo, yaffs_BlockState *
7712 -                                         state,
7713 -                                         int *sequenceNumber)
7714 +                                         int blockNo,
7715 +                                         yaffs_BlockState *state,
7716 +                                         __u32 *sequenceNumber)
7717  {
7718
7719         yaffs_Spare spare0, spare1;
7720 --- a/fs/yaffs2/yaffs_mtdif.c
7721 +++ b/fs/yaffs2/yaffs_mtdif.c
7722 @@ -12,7 +12,7 @@
7723   */
7724
7725  const char *yaffs_mtdif_c_version =
7726 -    "$Id: yaffs_mtdif.c,v 1.19 2007-02-14 01:09:06 wookey Exp $";
7727 +    "$Id: yaffs_mtdif.c,v 1.21 2007-12-13 15:35:18 wookey Exp $";
7728
7729  #include "yportenv.h"
7730
7731 @@ -24,7 +24,7 @@ const char *yaffs_mtdif_c_version =
7732  #include "linux/time.h"
7733  #include "linux/mtd/nand.h"
7734
7735 -#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,18))
7736 +#if (MTD_VERSION_CODE < MTD_VERSION(2,6,18))
7737  static struct nand_oobinfo yaffs_oobinfo = {
7738         .useecc = 1,
7739         .eccbytes = 6,
7740 @@ -36,7 +36,7 @@ static struct nand_oobinfo yaffs_noeccin
7741  };
7742  #endif
7743
7744 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
7745 +#if (MTD_VERSION_CODE > MTD_VERSION(2,6,17))
7746  static inline void translate_spare2oob(const yaffs_Spare *spare, __u8 *oob)
7747  {
7748         oob[0] = spare->tagByte0;
7749 @@ -75,14 +75,14 @@ int nandmtd_WriteChunkToNAND(yaffs_Devic
7750                              const __u8 * data, const yaffs_Spare * spare)
7751  {
7752         struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice);
7753 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
7754 +#if (MTD_VERSION_CODE > MTD_VERSION(2,6,17))
7755         struct mtd_oob_ops ops;
7756  #endif
7757         size_t dummy;
7758         int retval = 0;
7759
7760         loff_t addr = ((loff_t) chunkInNAND) * dev->nDataBytesPerChunk;
7761 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
7762 +#if (MTD_VERSION_CODE > MTD_VERSION(2,6,17))
7763         __u8 spareAsBytes[8]; /* OOB */
7764
7765         if (data && !spare)
7766 @@ -139,14 +139,14 @@ int nandmtd_ReadChunkFromNAND(yaffs_Devi
7767                               yaffs_Spare * spare)
7768  {
7769         struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice);
7770 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
7771 +#if (MTD_VERSION_CODE > MTD_VERSION(2,6,17))
7772         struct mtd_oob_ops ops;
7773  #endif
7774         size_t dummy;
7775         int retval = 0;
7776
7777         loff_t addr = ((loff_t) chunkInNAND) * dev->nDataBytesPerChunk;
7778 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
7779 +#if (MTD_VERSION_CODE > MTD_VERSION(2,6,17))
7780         __u8 spareAsBytes[8]; /* OOB */
7781
7782         if (data && !spare)
7783 --- a/fs/yaffs2/yaffs_nandemul2k.h
7784 +++ b/fs/yaffs2/yaffs_nandemul2k.h
7785 @@ -22,13 +22,13 @@
7786
7787  int nandemul2k_WriteChunkWithTagsToNAND(struct yaffs_DeviceStruct *dev,
7788                                         int chunkInNAND, const __u8 * data,
7789 -                                       yaffs_ExtendedTags * tags);
7790 +                                       const yaffs_ExtendedTags * tags);
7791  int nandemul2k_ReadChunkWithTagsFromNAND(struct yaffs_DeviceStruct *dev,
7792                                          int chunkInNAND, __u8 * data,
7793                                          yaffs_ExtendedTags * tags);
7794  int nandemul2k_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo);
7795  int nandemul2k_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockNo,
7796 -                             yaffs_BlockState * state, int *sequenceNumber);
7797 +                             yaffs_BlockState * state, __u32 *sequenceNumber);
7798  int nandemul2k_EraseBlockInNAND(struct yaffs_DeviceStruct *dev,
7799                                 int blockInNAND);
7800  int nandemul2k_InitialiseNAND(struct yaffs_DeviceStruct *dev);