target/linux/generic/patches-3.3/501-yaffs_cvs_2009_04_24.patch

   1 --- a/fs/yaffs2/devextras.h
   2 +++ b/fs/yaffs2/devextras.h
   3 @@ -14,194 +14,135 @@
   4   */
   5
   6  /*
   7 - * This file is just holds extra declarations used during development.
   8 - * Most of these are from kernel includes placed here so we can use them in
   9 - * applications.
  10 + * This file is just holds extra declarations of macros that would normally
  11 + * be providesd in the Linux kernel. These macros have been written from
  12 + * scratch but are functionally equivalent to the Linux ones.
  13   *
  14   */
  15
  16  #ifndef __EXTRAS_H__
  17  #define __EXTRAS_H__
  18
  19 -#if defined WIN32
  20 -#define __inline__ __inline
  21 -#define new newHack
  22 -#endif
  23 -
  24 -#if !(defined __KERNEL__) || (defined WIN32)
  25
  26 -/* User space defines */
  27 +#if !(defined __KERNEL__)
  28
  29 +/* Definition of types */
  30  typedef unsigned char __u8;
  31  typedef unsigned short __u16;
  32  typedef unsigned __u32;
  33
  34 +#endif
  35 +
  36  /*
  37 - * Simple doubly linked list implementation.
  38 - *
  39 - * Some of the internal functions ("__xxx") are useful when
  40 - * manipulating whole lists rather than single entries, as
  41 - * sometimes we already know the next/prev entries and we can
  42 - * generate better code by using them directly rather than
  43 - * using the generic single-entry routines.
  44 + * This is a simple doubly linked list implementation that matches the
  45 + * way the Linux kernel doubly linked list implementation works.
  46   */
  47
  48 -#define prefetch(x) 1
  49 -
  50 -struct list_head {
  51 -       struct list_head *next, *prev;
  52 +struct ylist_head {
  53 +       struct ylist_head *next; /* next in chain */
  54 +       struct ylist_head *prev; /* previous in chain */
  55  };
  56
  57 -#define LIST_HEAD_INIT(name) { &(name), &(name) }
  58
  59 -#define LIST_HEAD(name) \
  60 -       struct list_head name = LIST_HEAD_INIT(name)
  61 +/* Initialise a static list */
  62 +#define YLIST_HEAD(name) \
  63 +struct ylist_head name = { &(name), &(name)}
  64 +
  65
  66 -#define INIT_LIST_HEAD(ptr) do { \
  67 -       (ptr)->next = (ptr); (ptr)->prev = (ptr); \
  68 +
  69 +/* Initialise a list head to an empty list */
  70 +#define YINIT_LIST_HEAD(p) \
  71 +do { \
  72 +       (p)->next = (p);\
  73 +       (p)->prev = (p); \
  74  } while (0)
  75
  76 -/*
  77 - * Insert a new entry between two known consecutive entries.
  78 - *
  79 - * This is only for internal list manipulation where we know
  80 - * the prev/next entries already!
  81 - */
  82 -static __inline__ void __list_add(struct list_head *new,
  83 -                                 struct list_head *prev,
  84 -                                 struct list_head *next)
  85 -{
  86 -       next->prev = new;
  87 -       new->next = next;
  88 -       new->prev = prev;
  89 -       prev->next = new;
  90 -}
  91
  92 -/**
  93 - * list_add - add a new entry
  94 - * @new: new entry to be added
  95 - * @head: list head to add it after
  96 - *
  97 - * Insert a new entry after the specified head.
  98 - * This is good for implementing stacks.
  99 - */
 100 -static __inline__ void list_add(struct list_head *new, struct list_head *head)
 101 +/* Add an element to a list */
 102 +static __inline__ void ylist_add(struct ylist_head *newEntry,
 103 +                               struct ylist_head *list)
 104  {
 105 -       __list_add(new, head, head->next);
 106 -}
 107 +       struct ylist_head *listNext = list->next;
 108 +
 109 +       list->next = newEntry;
 110 +       newEntry->prev = list;
 111 +       newEntry->next = listNext;
 112 +       listNext->prev = newEntry;
 113
 114 -/**
 115 - * list_add_tail - add a new entry
 116 - * @new: new entry to be added
 117 - * @head: list head to add it before
 118 - *
 119 - * Insert a new entry before the specified head.
 120 - * This is useful for implementing queues.
 121 - */
 122 -static __inline__ void list_add_tail(struct list_head *new,
 123 -                                    struct list_head *head)
 124 -{
 125 -       __list_add(new, head->prev, head);
 126  }
 127
 128 -/*
 129 - * Delete a list entry by making the prev/next entries
 130 - * point to each other.
 131 - *
 132 - * This is only for internal list manipulation where we know
 133 - * the prev/next entries already!
 134 - */
 135 -static __inline__ void __list_del(struct list_head *prev,
 136 -                                 struct list_head *next)
 137 +static __inline__ void ylist_add_tail(struct ylist_head *newEntry,
 138 +                                struct ylist_head *list)
 139  {
 140 -       next->prev = prev;
 141 -       prev->next = next;
 142 +       struct ylist_head *listPrev = list->prev;
 143 +
 144 +       list->prev = newEntry;
 145 +       newEntry->next = list;
 146 +       newEntry->prev = listPrev;
 147 +       listPrev->next = newEntry;
 148 +
 149  }
 150
 151 -/**
 152 - * list_del - deletes entry from list.
 153 - * @entry: the element to delete from the list.
 154 - * Note: list_empty on entry does not return true after this, the entry is
 155 - * in an undefined state.
 156 - */
 157 -static __inline__ void list_del(struct list_head *entry)
 158 +
 159 +/* Take an element out of its current list, with or without
 160 + * reinitialising the links.of the entry*/
 161 +static __inline__ void ylist_del(struct ylist_head *entry)
 162  {
 163 -       __list_del(entry->prev, entry->next);
 164 +       struct ylist_head *listNext = entry->next;
 165 +       struct ylist_head *listPrev = entry->prev;
 166 +
 167 +       listNext->prev = listPrev;
 168 +       listPrev->next = listNext;
 169 +
 170  }
 171
 172 -/**
 173 - * list_del_init - deletes entry from list and reinitialize it.
 174 - * @entry: the element to delete from the list.
 175 - */
 176 -static __inline__ void list_del_init(struct list_head *entry)
 177 +static __inline__ void ylist_del_init(struct ylist_head *entry)
 178  {
 179 -       __list_del(entry->prev, entry->next);
 180 -       INIT_LIST_HEAD(entry);
 181 +       ylist_del(entry);
 182 +       entry->next = entry->prev = entry;
 183  }
 184
 185 -/**
 186 - * list_empty - tests whether a list is empty
 187 - * @head: the list to test.
 188 - */
 189 -static __inline__ int list_empty(struct list_head *head)
 190 +
 191 +/* Test if the list is empty */
 192 +static __inline__ int ylist_empty(struct ylist_head *entry)
 193  {
 194 -       return head->next == head;
 195 +       return (entry->next == entry);
 196  }
 197
 198 -/**
 199 - * list_splice - join two lists
 200 - * @list: the new list to add.
 201 - * @head: the place to add it in the first list.
 202 +
 203 +/* ylist_entry takes a pointer to a list entry and offsets it to that
 204 + * we can find a pointer to the object it is embedded in.
 205   */
 206 -static __inline__ void list_splice(struct list_head *list,
 207 -                                  struct list_head *head)
 208 -{
 209 -       struct list_head *first = list->next;
 210
 211 -       if (first != list) {
 212 -               struct list_head *last = list->prev;
 213 -               struct list_head *at = head->next;
 214 -
 215 -               first->prev = head;
 216 -               head->next = first;
 217 -
 218 -               last->next = at;
 219 -               at->prev = last;
 220 -       }
 221 -}
 222
 223 -/**
 224 - * list_entry - get the struct for this entry
 225 - * @ptr:       the &struct list_head pointer.
 226 - * @type:      the type of the struct this is embedded in.
 227 - * @member:    the name of the list_struct within the struct.
 228 - */
 229 -#define list_entry(ptr, type, member) \
 230 -       ((type *)((char *)(ptr)-(unsigned long)(&((type *)0)->member)))
 231 -
 232 -/**
 233 - * list_for_each       -       iterate over a list
 234 - * @pos:       the &struct list_head to use as a loop counter.
 235 - * @head:      the head for your list.
 236 - */
 237 -#define list_for_each(pos, head) \
 238 -       for (pos = (head)->next, prefetch(pos->next); pos != (head); \
 239 -               pos = pos->next, prefetch(pos->next))
 240 -
 241 -/**
 242 - * list_for_each_safe  -       iterate over a list safe against removal
 243 - *                              of list entry
 244 - * @pos:       the &struct list_head to use as a loop counter.
 245 - * @n:         another &struct list_head to use as temporary storage
 246 - * @head:      the head for your list.
 247 - */
 248 -#define list_for_each_safe(pos, n, head) \
 249 -       for (pos = (head)->next, n = pos->next; pos != (head); \
 250 -               pos = n, n = pos->next)
 251 +#define ylist_entry(entry, type, member) \
 252 +       ((type *)((char *)(entry)-(unsigned long)(&((type *)NULL)->member)))
 253
 254 -/*
 255 - * File types
 256 +
 257 +/* ylist_for_each and list_for_each_safe  iterate over lists.
 258 + * ylist_for_each_safe uses temporary storage to make the list delete safe
 259   */
 260 +
 261 +#define ylist_for_each(itervar, list) \
 262 +       for (itervar = (list)->next; itervar != (list); itervar = itervar->next)
 263 +
 264 +#define ylist_for_each_safe(itervar, saveVar, list) \
 265 +       for (itervar = (list)->next, saveVar = (list)->next->next; \
 266 +               itervar != (list); itervar = saveVar, saveVar = saveVar->next)
 267 +
 268 +
 269 +#if !(defined __KERNEL__)
 270 +
 271 +
 272 +#ifndef WIN32
 273 +#include <sys/stat.h>
 274 +#endif
 275 +
 276 +
 277 +#ifdef CONFIG_YAFFS_PROVIDE_DEFS
 278 +/* File types */
 279 +
 280 +
 281  #define DT_UNKNOWN     0
 282  #define DT_FIFO                1
 283  #define DT_CHR         2
 284 @@ -212,6 +153,7 @@ static __inline__ void list_splice(struc
 285  #define DT_SOCK                12
 286  #define DT_WHT         14
 287
 288 +
 289  #ifndef WIN32
 290  #include <sys/stat.h>
 291  #endif
 292 @@ -227,10 +169,6 @@ static __inline__ void list_splice(struc
 293  #define ATTR_ATIME     16
 294  #define ATTR_MTIME     32
 295  #define ATTR_CTIME     64
 296 -#define ATTR_ATIME_SET 128
 297 -#define ATTR_MTIME_SET 256
 298 -#define ATTR_FORCE     512     /* Not a change, but a change it */
 299 -#define ATTR_ATTR_FLAG 1024
 300
 301  struct iattr {
 302         unsigned int ia_valid;
 303 @@ -244,21 +182,15 @@ struct iattr {
 304         unsigned int ia_attr_flags;
 305  };
 306
 307 -#define KERN_DEBUG
 308 +#endif
 309
 310  #else
 311
 312 -#ifndef WIN32
 313  #include <linux/types.h>
 314 -#include <linux/list.h>
 315  #include <linux/fs.h>
 316  #include <linux/stat.h>
 317 -#endif
 318
 319  #endif
 320
 321 -#if defined WIN32
 322 -#undef new
 323 -#endif
 324
 325  #endif
 326 --- a/fs/yaffs2/Kconfig
 327 +++ b/fs/yaffs2/Kconfig
 328 @@ -5,7 +5,7 @@
 329  config YAFFS_FS
 330         tristate "YAFFS2 file system support"
 331         default n
 332 -       depends on MTD
 333 +       depends on MTD_BLOCK
 334         select YAFFS_YAFFS1
 335         select YAFFS_YAFFS2
 336         help
 337 @@ -43,7 +43,8 @@ config YAFFS_9BYTE_TAGS
 338           format that you need to continue to support.  New data written
 339           also uses the older-style format.  Note: Use of this option
 340           generally requires that MTD's oob layout be adjusted to use the
 341 -         older-style format.  See notes on tags formats and MTD versions.
 342 +         older-style format.  See notes on tags formats and MTD versions
 343 +         in yaffs_mtdif1.c.
 344
 345           If unsure, say N.
 346
 347 @@ -109,26 +110,6 @@ config YAFFS_DISABLE_LAZY_LOAD
 348
 349           If unsure, say N.
 350
 351 -config YAFFS_CHECKPOINT_RESERVED_BLOCKS
 352 -       int "Reserved blocks for checkpointing"
 353 -       depends on YAFFS_YAFFS2
 354 -       default 10
 355 -       help
 356 -          Give the number of Blocks to reserve for checkpointing.
 357 -         Checkpointing saves the state at unmount so that mounting is
 358 -         much faster as a scan of all the flash to regenerate this state
 359 -         is not needed.  These Blocks are reserved per partition, so if
 360 -         you have very small partitions the default (10) may be a mess
 361 -         for you.  You can set this value to 0, but that does not mean
 362 -         checkpointing is disabled at all. There only won't be any
 363 -         specially reserved blocks for checkpointing, so if there is
 364 -         enough free space on the filesystem, it will be used for
 365 -         checkpointing.
 366 -
 367 -         If unsure, leave at default (10), but don't wonder if there are
 368 -         always 2MB used on your large page device partition (10 x 2k
 369 -         pagesize). When using small partitions or when being very small
 370 -         on space, you probably want to set this to zero.
 371
 372  config YAFFS_DISABLE_WIDE_TNODES
 373         bool "Turn off wide tnodes"
 374 --- a/fs/yaffs2/Makefile
 375 +++ b/fs/yaffs2/Makefile
 376 @@ -5,7 +5,6 @@
 377  obj-$(CONFIG_YAFFS_FS) += yaffs.o
 378
 379  yaffs-y := yaffs_ecc.o yaffs_fs.o yaffs_guts.o yaffs_checkptrw.o
 380 -yaffs-y += yaffs_packedtags2.o yaffs_nand.o yaffs_qsort.o
 381 +yaffs-y += yaffs_packedtags1.o yaffs_packedtags2.o yaffs_nand.o yaffs_qsort.o
 382  yaffs-y += yaffs_tagscompat.o yaffs_tagsvalidity.o
 383 -yaffs-y += yaffs_mtdif1.o yaffs_packedtags1.o
 384 -yaffs-y += yaffs_mtdif.o yaffs_mtdif2.o
 385 +yaffs-y += yaffs_mtdif.o yaffs_mtdif1.o yaffs_mtdif2.o
 386 --- a/fs/yaffs2/moduleconfig.h
 387 +++ b/fs/yaffs2/moduleconfig.h
 388 @@ -27,12 +27,12 @@
 389
 390  /* Default: Not selected */
 391  /* Meaning: Yaffs does its own ECC, rather than using MTD ECC */
 392 -//#define CONFIG_YAFFS_DOES_ECC
 393 +/* #define CONFIG_YAFFS_DOES_ECC */
 394
 395  /* Default: Not selected */
 396  /* Meaning: ECC byte order is 'wrong'.  Only meaningful if */
 397  /*          CONFIG_YAFFS_DOES_ECC is set */
 398 -//#define CONFIG_YAFFS_ECC_WRONG_ORDER
 399 +/* #define CONFIG_YAFFS_ECC_WRONG_ORDER */
 400
 401  /* Default: Selected */
 402  /* Meaning: Disables testing whether chunks are erased before writing to them*/
 403 @@ -54,11 +54,11 @@ that you need to continue to support.  N
 404  older-style format.
 405  Note: Use of this option generally requires that MTD's oob layout be
 406  adjusted to use the older-style format.  See notes on tags formats and
 407 -MTD versions.
 408 +MTD versions in yaffs_mtdif1.c.
 409  */
 410  /* Default: Not selected */
 411  /* Meaning: Use older-style on-NAND data format with pageStatus byte */
 412 -#define CONFIG_YAFFS_9BYTE_TAGS
 413 +/* #define CONFIG_YAFFS_9BYTE_TAGS */
 414
 415  #endif /* YAFFS_OUT_OF_TREE */
 416
 417 --- a/fs/yaffs2/yaffs_checkptrw.c
 418 +++ b/fs/yaffs2/yaffs_checkptrw.c
 419 @@ -12,48 +12,43 @@
 420   */
 421
 422  const char *yaffs_checkptrw_c_version =
 423 -    "$Id: yaffs_checkptrw.c,v 1.14 2007-05-15 20:07:40 charles Exp $";
 424 +       "$Id: yaffs_checkptrw.c,v 1.18 2009-03-06 17:20:49 wookey Exp $";
 425
 426
 427  #include "yaffs_checkptrw.h"
 428 -
 429 +#include "yaffs_getblockinfo.h"
 430
 431  static int yaffs_CheckpointSpaceOk(yaffs_Device *dev)
 432  {
 433 -
 434         int blocksAvailable = dev->nErasedBlocks - dev->nReservedBlocks;
 435
 436         T(YAFFS_TRACE_CHECKPOINT,
 437                 (TSTR("checkpt blocks available = %d" TENDSTR),
 438                 blocksAvailable));
 439
 440 -
 441         return (blocksAvailable <= 0) ? 0 : 1;
 442  }
 443
 444
 445  static int yaffs_CheckpointErase(yaffs_Device *dev)
 446  {
 447 -
 448         int i;
 449
 450 -
 451 -       if(!dev->eraseBlockInNAND)
 452 +       if (!dev->eraseBlockInNAND)
 453                 return 0;
 454 -       T(YAFFS_TRACE_CHECKPOINT,(TSTR("checking blocks %d to %d"TENDSTR),
 455 -               dev->internalStartBlock,dev->internalEndBlock));
 456 +       T(YAFFS_TRACE_CHECKPOINT, (TSTR("checking blocks %d to %d"TENDSTR),
 457 +               dev->internalStartBlock, dev->internalEndBlock));
 458
 459 -       for(i = dev->internalStartBlock; i <= dev->internalEndBlock; i++) {
 460 -               yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev,i);
 461 -               if(bi->blockState == YAFFS_BLOCK_STATE_CHECKPOINT){
 462 -                       T(YAFFS_TRACE_CHECKPOINT,(TSTR("erasing checkpt block %d"TENDSTR),i));
 463 -                       if(dev->eraseBlockInNAND(dev,i- dev->blockOffset /* realign */)){
 464 +       for (i = dev->internalStartBlock; i <= dev->internalEndBlock; i++) {
 465 +               yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, i);
 466 +               if (bi->blockState == YAFFS_BLOCK_STATE_CHECKPOINT) {
 467 +                       T(YAFFS_TRACE_CHECKPOINT, (TSTR("erasing checkpt block %d"TENDSTR), i));
 468 +                       if (dev->eraseBlockInNAND(dev, i - dev->blockOffset /* realign */)) {
 469                                 bi->blockState = YAFFS_BLOCK_STATE_EMPTY;
 470                                 dev->nErasedBlocks++;
 471                                 dev->nFreeChunks += dev->nChunksPerBlock;
 472 -                       }
 473 -                       else {
 474 -                               dev->markNANDBlockBad(dev,i);
 475 +                       } else {
 476 +                               dev->markNANDBlockBad(dev, i);
 477                                 bi->blockState = YAFFS_BLOCK_STATE_DEAD;
 478                         }
 479                 }
 480 @@ -71,23 +66,23 @@ static void yaffs_CheckpointFindNextEras
 481         int blocksAvailable = dev->nErasedBlocks - dev->nReservedBlocks;
 482         T(YAFFS_TRACE_CHECKPOINT,
 483                 (TSTR("allocating checkpt block: erased %d reserved %d avail %d next %d "TENDSTR),
 484 -               dev->nErasedBlocks,dev->nReservedBlocks,blocksAvailable,dev->checkpointNextBlock));
 485 +               dev->nErasedBlocks, dev->nReservedBlocks, blocksAvailable, dev->checkpointNextBlock));
 486
 487 -       if(dev->checkpointNextBlock >= 0 &&
 488 -          dev->checkpointNextBlock <= dev->internalEndBlock &&
 489 -          blocksAvailable > 0){
 490 -
 491 -               for(i = dev->checkpointNextBlock; i <= dev->internalEndBlock; i++){
 492 -                       yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev,i);
 493 -                       if(bi->blockState == YAFFS_BLOCK_STATE_EMPTY){
 494 +       if (dev->checkpointNextBlock >= 0 &&
 495 +                       dev->checkpointNextBlock <= dev->internalEndBlock &&
 496 +                       blocksAvailable > 0) {
 497 +
 498 +               for (i = dev->checkpointNextBlock; i <= dev->internalEndBlock; i++) {
 499 +                       yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, i);
 500 +                       if (bi->blockState == YAFFS_BLOCK_STATE_EMPTY) {
 501                                 dev->checkpointNextBlock = i + 1;
 502                                 dev->checkpointCurrentBlock = i;
 503 -                               T(YAFFS_TRACE_CHECKPOINT,(TSTR("allocating checkpt block %d"TENDSTR),i));
 504 +                               T(YAFFS_TRACE_CHECKPOINT, (TSTR("allocating checkpt block %d"TENDSTR), i));
 505                                 return;
 506                         }
 507                 }
 508         }
 509 -       T(YAFFS_TRACE_CHECKPOINT,(TSTR("out of checkpt blocks"TENDSTR)));
 510 +       T(YAFFS_TRACE_CHECKPOINT, (TSTR("out of checkpt blocks"TENDSTR)));
 511
 512         dev->checkpointNextBlock = -1;
 513         dev->checkpointCurrentBlock = -1;
 514 @@ -98,30 +93,31 @@ static void yaffs_CheckpointFindNextChec
 515         int  i;
 516         yaffs_ExtendedTags tags;
 517
 518 -       T(YAFFS_TRACE_CHECKPOINT,(TSTR("find next checkpt block: start:  blocks %d next %d" TENDSTR),
 519 +       T(YAFFS_TRACE_CHECKPOINT, (TSTR("find next checkpt block: start:  blocks %d next %d" TENDSTR),
 520                 dev->blocksInCheckpoint, dev->checkpointNextBlock));
 521
 522 -       if(dev->blocksInCheckpoint < dev->checkpointMaxBlocks)
 523 -               for(i = dev->checkpointNextBlock; i <= dev->internalEndBlock; i++){
 524 +       if (dev->blocksInCheckpoint < dev->checkpointMaxBlocks)
 525 +               for (i = dev->checkpointNextBlock; i <= dev->internalEndBlock; i++) {
 526                         int chunk = i * dev->nChunksPerBlock;
 527                         int realignedChunk = chunk - dev->chunkOffset;
 528
 529 -                       dev->readChunkWithTagsFromNAND(dev,realignedChunk,NULL,&tags);
 530 -                       T(YAFFS_TRACE_CHECKPOINT,(TSTR("find next checkpt block: search: block %d oid %d seq %d eccr %d" TENDSTR),
 531 -                               i, tags.objectId,tags.sequenceNumber,tags.eccResult));
 532 +                       dev->readChunkWithTagsFromNAND(dev, realignedChunk,
 533 +                                       NULL, &tags);
 534 +                       T(YAFFS_TRACE_CHECKPOINT, (TSTR("find next checkpt block: search: block %d oid %d seq %d eccr %d" TENDSTR),
 535 +                               i, tags.objectId, tags.sequenceNumber, tags.eccResult));
 536
 537 -                       if(tags.sequenceNumber == YAFFS_SEQUENCE_CHECKPOINT_DATA){
 538 +                       if (tags.sequenceNumber == YAFFS_SEQUENCE_CHECKPOINT_DATA) {
 539                                 /* Right kind of block */
 540                                 dev->checkpointNextBlock = tags.objectId;
 541                                 dev->checkpointCurrentBlock = i;
 542                                 dev->checkpointBlockList[dev->blocksInCheckpoint] = i;
 543                                 dev->blocksInCheckpoint++;
 544 -                               T(YAFFS_TRACE_CHECKPOINT,(TSTR("found checkpt block %d"TENDSTR),i));
 545 +                               T(YAFFS_TRACE_CHECKPOINT, (TSTR("found checkpt block %d"TENDSTR), i));
 546                                 return;
 547                         }
 548                 }
 549
 550 -       T(YAFFS_TRACE_CHECKPOINT,(TSTR("found no more checkpt blocks"TENDSTR)));
 551 +       T(YAFFS_TRACE_CHECKPOINT, (TSTR("found no more checkpt blocks"TENDSTR)));
 552
 553         dev->checkpointNextBlock = -1;
 554         dev->checkpointCurrentBlock = -1;
 555 @@ -133,17 +129,17 @@ int yaffs_CheckpointOpen(yaffs_Device *d
 556
 557         /* Got the functions we need? */
 558         if (!dev->writeChunkWithTagsToNAND ||
 559 -           !dev->readChunkWithTagsFromNAND ||
 560 -           !dev->eraseBlockInNAND ||
 561 -           !dev->markNANDBlockBad)
 562 +                       !dev->readChunkWithTagsFromNAND ||
 563 +                       !dev->eraseBlockInNAND ||
 564 +                       !dev->markNANDBlockBad)
 565                 return 0;
 566
 567 -       if(forWriting && !yaffs_CheckpointSpaceOk(dev))
 568 +       if (forWriting && !yaffs_CheckpointSpaceOk(dev))
 569                 return 0;
 570
 571 -       if(!dev->checkpointBuffer)
 572 -               dev->checkpointBuffer = YMALLOC_DMA(dev->nDataBytesPerChunk);
 573 -       if(!dev->checkpointBuffer)
 574 +       if (!dev->checkpointBuffer)
 575 +               dev->checkpointBuffer = YMALLOC_DMA(dev->totalBytesPerChunk);
 576 +       if (!dev->checkpointBuffer)
 577                 return 0;
 578
 579
 580 @@ -159,12 +155,10 @@ int yaffs_CheckpointOpen(yaffs_Device *d
 581         dev->checkpointNextBlock = dev->internalStartBlock;
 582
 583         /* Erase all the blocks in the checkpoint area */
 584 -       if(forWriting){
 585 -               memset(dev->checkpointBuffer,0,dev->nDataBytesPerChunk);
 586 +       if (forWriting) {
 587 +               memset(dev->checkpointBuffer, 0, dev->nDataBytesPerChunk);
 588                 dev->checkpointByteOffset = 0;
 589                 return yaffs_CheckpointErase(dev);
 590 -
 591 -
 592         } else {
 593                 int i;
 594                 /* Set to a value that will kick off a read */
 595 @@ -174,7 +168,7 @@ int yaffs_CheckpointOpen(yaffs_Device *d
 596                 dev->blocksInCheckpoint = 0;
 597                 dev->checkpointMaxBlocks = (dev->internalEndBlock - dev->internalStartBlock)/16 + 2;
 598                 dev->checkpointBlockList = YMALLOC(sizeof(int) * dev->checkpointMaxBlocks);
 599 -               for(i = 0; i < dev->checkpointMaxBlocks; i++)
 600 +               for (i = 0; i < dev->checkpointMaxBlocks; i++)
 601                         dev->checkpointBlockList[i] = -1;
 602         }
 603
 604 @@ -191,18 +185,17 @@ int yaffs_GetCheckpointSum(yaffs_Device
 605
 606  static int yaffs_CheckpointFlushBuffer(yaffs_Device *dev)
 607  {
 608 -
 609         int chunk;
 610         int realignedChunk;
 611
 612         yaffs_ExtendedTags tags;
 613
 614 -       if(dev->checkpointCurrentBlock < 0){
 615 +       if (dev->checkpointCurrentBlock < 0) {
 616                 yaffs_CheckpointFindNextErasedBlock(dev);
 617                 dev->checkpointCurrentChunk = 0;
 618         }
 619
 620 -       if(dev->checkpointCurrentBlock < 0)
 621 +       if (dev->checkpointCurrentBlock < 0)
 622                 return 0;
 623
 624         tags.chunkDeleted = 0;
 625 @@ -210,10 +203,10 @@ static int yaffs_CheckpointFlushBuffer(y
 626         tags.chunkId = dev->checkpointPageSequence + 1;
 627         tags.sequenceNumber =  YAFFS_SEQUENCE_CHECKPOINT_DATA;
 628         tags.byteCount = dev->nDataBytesPerChunk;
 629 -       if(dev->checkpointCurrentChunk == 0){
 630 +       if (dev->checkpointCurrentChunk == 0) {
 631                 /* First chunk we write for the block? Set block state to
 632                    checkpoint */
 633 -               yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev,dev->checkpointCurrentBlock);
 634 +               yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, dev->checkpointCurrentBlock);
 635                 bi->blockState = YAFFS_BLOCK_STATE_CHECKPOINT;
 636                 dev->blocksInCheckpoint++;
 637         }
 638 @@ -221,28 +214,29 @@ static int yaffs_CheckpointFlushBuffer(y
 639         chunk = dev->checkpointCurrentBlock * dev->nChunksPerBlock + dev->checkpointCurrentChunk;
 640
 641
 642 -       T(YAFFS_TRACE_CHECKPOINT,(TSTR("checkpoint wite buffer nand %d(%d:%d) objid %d chId %d" TENDSTR),
 643 -               chunk, dev->checkpointCurrentBlock, dev->checkpointCurrentChunk,tags.objectId,tags.chunkId));
 644 +       T(YAFFS_TRACE_CHECKPOINT, (TSTR("checkpoint wite buffer nand %d(%d:%d) objid %d chId %d" TENDSTR),
 645 +               chunk, dev->checkpointCurrentBlock, dev->checkpointCurrentChunk, tags.objectId, tags.chunkId));
 646
 647         realignedChunk = chunk - dev->chunkOffset;
 648
 649 -       dev->writeChunkWithTagsToNAND(dev,realignedChunk,dev->checkpointBuffer,&tags);
 650 +       dev->writeChunkWithTagsToNAND(dev, realignedChunk,
 651 +                       dev->checkpointBuffer, &tags);
 652         dev->checkpointByteOffset = 0;
 653         dev->checkpointPageSequence++;
 654         dev->checkpointCurrentChunk++;
 655 -       if(dev->checkpointCurrentChunk >= dev->nChunksPerBlock){
 656 +       if (dev->checkpointCurrentChunk >= dev->nChunksPerBlock) {
 657                 dev->checkpointCurrentChunk = 0;
 658                 dev->checkpointCurrentBlock = -1;
 659         }
 660 -       memset(dev->checkpointBuffer,0,dev->nDataBytesPerChunk);
 661 +       memset(dev->checkpointBuffer, 0, dev->nDataBytesPerChunk);
 662
 663         return 1;
 664  }
 665
 666
 667 -int yaffs_CheckpointWrite(yaffs_Device *dev,const void *data, int nBytes)
 668 +int yaffs_CheckpointWrite(yaffs_Device *dev, const void *data, int nBytes)
 669  {
 670 -       int i=0;
 671 +       int i = 0;
 672         int ok = 1;
 673
 674
 675 @@ -250,17 +244,14 @@ int yaffs_CheckpointWrite(yaffs_Device *
 676
 677
 678
 679 -       if(!dev->checkpointBuffer)
 680 +       if (!dev->checkpointBuffer)
 681                 return 0;
 682
 683 -       if(!dev->checkpointOpenForWrite)
 684 +       if (!dev->checkpointOpenForWrite)
 685                 return -1;
 686
 687 -       while(i < nBytes && ok) {
 688 -
 689 -
 690 -
 691 -               dev->checkpointBuffer[dev->checkpointByteOffset] = *dataBytes ;
 692 +       while (i < nBytes && ok) {
 693 +               dev->checkpointBuffer[dev->checkpointByteOffset] = *dataBytes;
 694                 dev->checkpointSum += *dataBytes;
 695                 dev->checkpointXor ^= *dataBytes;
 696
 697 @@ -270,18 +261,17 @@ int yaffs_CheckpointWrite(yaffs_Device *
 698                 dev->checkpointByteCount++;
 699
 700
 701 -               if(dev->checkpointByteOffset < 0 ||
 702 +               if (dev->checkpointByteOffset < 0 ||
 703                    dev->checkpointByteOffset >= dev->nDataBytesPerChunk)
 704                         ok = yaffs_CheckpointFlushBuffer(dev);
 705 -
 706         }
 707
 708 -       return  i;
 709 +       return i;
 710  }
 711
 712  int yaffs_CheckpointRead(yaffs_Device *dev, void *data, int nBytes)
 713  {
 714 -       int i=0;
 715 +       int i = 0;
 716         int ok = 1;
 717         yaffs_ExtendedTags tags;
 718
 719 @@ -291,52 +281,54 @@ int yaffs_CheckpointRead(yaffs_Device *d
 720
 721         __u8 *dataBytes = (__u8 *)data;
 722
 723 -       if(!dev->checkpointBuffer)
 724 +       if (!dev->checkpointBuffer)
 725                 return 0;
 726
 727 -       if(dev->checkpointOpenForWrite)
 728 +       if (dev->checkpointOpenForWrite)
 729                 return -1;
 730
 731 -       while(i < nBytes && ok) {
 732 +       while (i < nBytes && ok) {
 733
 734
 735 -               if(dev->checkpointByteOffset < 0 ||
 736 -                  dev->checkpointByteOffset >= dev->nDataBytesPerChunk) {
 737 +               if (dev->checkpointByteOffset < 0 ||
 738 +                       dev->checkpointByteOffset >= dev->nDataBytesPerChunk) {
 739
 740 -                       if(dev->checkpointCurrentBlock < 0){
 741 +                       if (dev->checkpointCurrentBlock < 0) {
 742                                 yaffs_CheckpointFindNextCheckpointBlock(dev);
 743                                 dev->checkpointCurrentChunk = 0;
 744                         }
 745
 746 -                       if(dev->checkpointCurrentBlock < 0)
 747 +                       if (dev->checkpointCurrentBlock < 0)
 748                                 ok = 0;
 749                         else {
 750 -
 751 -                               chunk = dev->checkpointCurrentBlock * dev->nChunksPerBlock +
 752 -                                         dev->checkpointCurrentChunk;
 753 +                               chunk = dev->checkpointCurrentBlock *
 754 +                                       dev->nChunksPerBlock +
 755 +                                       dev->checkpointCurrentChunk;
 756
 757                                 realignedChunk = chunk - dev->chunkOffset;
 758
 759 -                               /* read in the next chunk */
 760 -                               /* printf("read checkpoint page %d\n",dev->checkpointPage); */
 761 -                               dev->readChunkWithTagsFromNAND(dev, realignedChunk,
 762 -                                                              dev->checkpointBuffer,
 763 -                                                             &tags);
 764 -
 765 -                               if(tags.chunkId != (dev->checkpointPageSequence + 1) ||
 766 -                                  tags.sequenceNumber != YAFFS_SEQUENCE_CHECKPOINT_DATA)
 767 -                                  ok = 0;
 768 +                               /* read in the next chunk */
 769 +                               /* printf("read checkpoint page %d\n",dev->checkpointPage); */
 770 +                               dev->readChunkWithTagsFromNAND(dev,
 771 +                                               realignedChunk,
 772 +                                               dev->checkpointBuffer,
 773 +                                               &tags);
 774 +
 775 +                               if (tags.chunkId != (dev->checkpointPageSequence + 1) ||
 776 +                                       tags.eccResult > YAFFS_ECC_RESULT_FIXED ||
 777 +                                       tags.sequenceNumber != YAFFS_SEQUENCE_CHECKPOINT_DATA)
 778 +                                       ok = 0;
 779
 780                                 dev->checkpointByteOffset = 0;
 781                                 dev->checkpointPageSequence++;
 782                                 dev->checkpointCurrentChunk++;
 783
 784 -                               if(dev->checkpointCurrentChunk >= dev->nChunksPerBlock)
 785 +                               if (dev->checkpointCurrentChunk >= dev->nChunksPerBlock)
 786                                         dev->checkpointCurrentBlock = -1;
 787                         }
 788                 }
 789
 790 -               if(ok){
 791 +               if (ok) {
 792                         *dataBytes = dev->checkpointBuffer[dev->checkpointByteOffset];
 793                         dev->checkpointSum += *dataBytes;
 794                         dev->checkpointXor ^= *dataBytes;
 795 @@ -353,17 +345,17 @@ int yaffs_CheckpointRead(yaffs_Device *d
 796  int yaffs_CheckpointClose(yaffs_Device *dev)
 797  {
 798
 799 -       if(dev->checkpointOpenForWrite){
 800 -               if(dev->checkpointByteOffset != 0)
 801 +       if (dev->checkpointOpenForWrite) {
 802 +               if (dev->checkpointByteOffset != 0)
 803                         yaffs_CheckpointFlushBuffer(dev);
 804         } else {
 805                 int i;
 806 -               for(i = 0; i < dev->blocksInCheckpoint && dev->checkpointBlockList[i] >= 0; i++){
 807 -                       yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev,dev->checkpointBlockList[i]);
 808 -                       if(bi->blockState == YAFFS_BLOCK_STATE_EMPTY)
 809 +               for (i = 0; i < dev->blocksInCheckpoint && dev->checkpointBlockList[i] >= 0; i++) {
 810 +                       yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, dev->checkpointBlockList[i]);
 811 +                       if (bi->blockState == YAFFS_BLOCK_STATE_EMPTY)
 812                                 bi->blockState = YAFFS_BLOCK_STATE_CHECKPOINT;
 813                         else {
 814 -                               // Todo this looks odd...
 815 +                               /* Todo this looks odd... */
 816                         }
 817                 }
 818                 YFREE(dev->checkpointBlockList);
 819 @@ -374,27 +366,25 @@ int yaffs_CheckpointClose(yaffs_Device *
 820         dev->nErasedBlocks -= dev->blocksInCheckpoint;
 821
 822
 823 -       T(YAFFS_TRACE_CHECKPOINT,(TSTR("checkpoint byte count %d" TENDSTR),
 824 +       T(YAFFS_TRACE_CHECKPOINT, (TSTR("checkpoint byte count %d" TENDSTR),
 825                         dev->checkpointByteCount));
 826
 827 -       if(dev->checkpointBuffer){
 828 +       if (dev->checkpointBuffer) {
 829                 /* free the buffer */
 830                 YFREE(dev->checkpointBuffer);
 831                 dev->checkpointBuffer = NULL;
 832                 return 1;
 833 -       }
 834 -       else
 835 +       } else
 836                 return 0;
 837 -
 838  }
 839
 840  int yaffs_CheckpointInvalidateStream(yaffs_Device *dev)
 841  {
 842         /* Erase the first checksum block */
 843
 844 -       T(YAFFS_TRACE_CHECKPOINT,(TSTR("checkpoint invalidate"TENDSTR)));
 845 +       T(YAFFS_TRACE_CHECKPOINT, (TSTR("checkpoint invalidate"TENDSTR)));
 846
 847 -       if(!yaffs_CheckpointSpaceOk(dev))
 848 +       if (!yaffs_CheckpointSpaceOk(dev))
 849                 return 0;
 850
 851         return yaffs_CheckpointErase(dev);
 852 --- a/fs/yaffs2/yaffs_checkptrw.h
 853 +++ b/fs/yaffs2/yaffs_checkptrw.h
 854 @@ -20,9 +20,9 @@
 855
 856  int yaffs_CheckpointOpen(yaffs_Device *dev, int forWriting);
 857
 858 -int yaffs_CheckpointWrite(yaffs_Device *dev,const void *data, int nBytes);
 859 +int yaffs_CheckpointWrite(yaffs_Device *dev, const void *data, int nBytes);
 860
 861 -int yaffs_CheckpointRead(yaffs_Device *dev,void *data, int nBytes);
 862 +int yaffs_CheckpointRead(yaffs_Device *dev, void *data, int nBytes);
 863
 864  int yaffs_GetCheckpointSum(yaffs_Device *dev, __u32 *sum);
 865
 866 --- a/fs/yaffs2/yaffs_ecc.c
 867 +++ b/fs/yaffs2/yaffs_ecc.c
 868 @@ -29,7 +29,7 @@
 869   */
 870
 871  const char *yaffs_ecc_c_version =
 872 -    "$Id: yaffs_ecc.c,v 1.9 2007-02-14 01:09:06 wookey Exp $";
 873 +       "$Id: yaffs_ecc.c,v 1.11 2009-03-06 17:20:50 wookey Exp $";
 874
 875  #include "yportenv.h"
 876
 877 @@ -109,12 +109,10 @@ void yaffs_ECCCalculate(const unsigned c
 878                 b = column_parity_table[*data++];
 879                 col_parity ^= b;
 880
 881 -               if (b & 0x01)   // odd number of bits in the byte
 882 -               {
 883 +               if (b & 0x01) {         /* odd number of bits in the byte */
 884                         line_parity ^= i;
 885                         line_parity_prime ^= ~i;
 886                 }
 887 -
 888         }
 889
 890         ecc[2] = (~col_parity) | 0x03;
 891 @@ -158,7 +156,7 @@ void yaffs_ECCCalculate(const unsigned c
 892         ecc[0] = ~t;
 893
 894  #ifdef CONFIG_YAFFS_ECC_WRONG_ORDER
 895 -       // Swap the bytes into the wrong order
 896 +       /* Swap the bytes into the wrong order */
 897         t = ecc[0];
 898         ecc[0] = ecc[1];
 899         ecc[1] = t;
 900 @@ -189,7 +187,7 @@ int yaffs_ECCCorrect(unsigned char *data
 901                 unsigned bit;
 902
 903  #ifdef CONFIG_YAFFS_ECC_WRONG_ORDER
 904 -               // swap the bytes to correct for the wrong order
 905 +               /* swap the bytes to correct for the wrong order */
 906                 unsigned char t;
 907
 908                 t = d0;
 909 @@ -251,7 +249,7 @@ int yaffs_ECCCorrect(unsigned char *data
 910   * ECCxxxOther does ECC calcs on arbitrary n bytes of data
 911   */
 912  void yaffs_ECCCalculateOther(const unsigned char *data, unsigned nBytes,
 913 -                            yaffs_ECCOther * eccOther)
 914 +                               yaffs_ECCOther *eccOther)
 915  {
 916         unsigned int i;
 917
 918 @@ -278,8 +276,8 @@ void yaffs_ECCCalculateOther(const unsig
 919  }
 920
 921  int yaffs_ECCCorrectOther(unsigned char *data, unsigned nBytes,
 922 -                         yaffs_ECCOther * read_ecc,
 923 -                         const yaffs_ECCOther * test_ecc)
 924 +                       yaffs_ECCOther *read_ecc,
 925 +                       const yaffs_ECCOther *test_ecc)
 926  {
 927         unsigned char cDelta;   /* column parity delta */
 928         unsigned lDelta;        /* line parity delta */
 929 @@ -294,8 +292,7 @@ int yaffs_ECCCorrectOther(unsigned char
 930                 return 0; /* no error */
 931
 932         if (lDelta == ~lDeltaPrime &&
 933 -           (((cDelta ^ (cDelta >> 1)) & 0x15) == 0x15))
 934 -       {
 935 +           (((cDelta ^ (cDelta >> 1)) & 0x15) == 0x15)) {
 936                 /* Single bit (recoverable) error in data */
 937
 938                 bit = 0;
 939 @@ -307,7 +304,7 @@ int yaffs_ECCCorrectOther(unsigned char
 940                 if (cDelta & 0x02)
 941                         bit |= 0x01;
 942
 943 -               if(lDelta >= nBytes)
 944 +               if (lDelta >= nBytes)
 945                         return -1;
 946
 947                 data[lDelta] ^= (1 << bit);
 948 @@ -316,7 +313,7 @@ int yaffs_ECCCorrectOther(unsigned char
 949         }
 950
 951         if ((yaffs_CountBits32(lDelta) + yaffs_CountBits32(lDeltaPrime) +
 952 -            yaffs_CountBits(cDelta)) == 1) {
 953 +                       yaffs_CountBits(cDelta)) == 1) {
 954                 /* Reccoverable error in ecc */
 955
 956                 *read_ecc = *test_ecc;
 957 @@ -326,6 +323,4 @@ int yaffs_ECCCorrectOther(unsigned char
 958         /* Unrecoverable error */
 959
 960         return -1;
 961 -
 962  }
 963 -
 964 --- a/fs/yaffs2/yaffs_ecc.h
 965 +++ b/fs/yaffs2/yaffs_ecc.h
 966 @@ -13,15 +13,15 @@
 967   * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL.
 968   */
 969
 970 - /*
 971 -  * This code implements the ECC algorithm used in SmartMedia.
 972 -  *
 973 -  * The ECC comprises 22 bits of parity information and is stuffed into 3 bytes.
 974 -  * The two unused bit are set to 1.
 975 -  * The ECC can correct single bit errors in a 256-byte page of data. Thus, two such ECC
 976 -  * blocks are used on a 512-byte NAND page.
 977 -  *
 978 -  */
 979 +/*
 980 + * This code implements the ECC algorithm used in SmartMedia.
 981 + *
 982 + * The ECC comprises 22 bits of parity information and is stuffed into 3 bytes.
 983 + * The two unused bit are set to 1.
 984 + * The ECC can correct single bit errors in a 256-byte page of data. Thus, two such ECC
 985 + * blocks are used on a 512-byte NAND page.
 986 + *
 987 + */
 988
 989  #ifndef __YAFFS_ECC_H__
 990  #define __YAFFS_ECC_H__
 991 @@ -34,11 +34,11 @@ typedef struct {
 992
 993  void yaffs_ECCCalculate(const unsigned char *data, unsigned char *ecc);
 994  int yaffs_ECCCorrect(unsigned char *data, unsigned char *read_ecc,
 995 -                    const unsigned char *test_ecc);
 996 +               const unsigned char *test_ecc);
 997
 998  void yaffs_ECCCalculateOther(const unsigned char *data, unsigned nBytes,
 999 -                            yaffs_ECCOther * ecc);
1000 +                       yaffs_ECCOther *ecc);
1001  int yaffs_ECCCorrectOther(unsigned char *data, unsigned nBytes,
1002 -                         yaffs_ECCOther * read_ecc,
1003 -                         const yaffs_ECCOther * test_ecc);
1004 +                       yaffs_ECCOther *read_ecc,
1005 +                       const yaffs_ECCOther *test_ecc);
1006  #endif
1007 --- a/fs/yaffs2/yaffs_fs.c
1008 +++ b/fs/yaffs2/yaffs_fs.c
1009 @@ -1,7 +1,7 @@
1010  /*
1011   * YAFFS: Yet Another Flash File System. A NAND-flash specific file system.
1012   *
1013 - * Copyright (C) 2002-2007 Aleph One Ltd.
1014 + * Copyright (C) 2002-2009 Aleph One Ltd.
1015   *   for Toby Churchill Ltd and Brightstar Engineering
1016   *
1017   * Created by Charles Manning <charles@aleph1.co.uk>
1018 @@ -32,18 +32,17 @@
1019   */
1020
1021  const char *yaffs_fs_c_version =
1022 -    "$Id: yaffs_fs.c,v 1.63 2007-09-19 20:35:40 imcd Exp $";
1023 +    "$Id: yaffs_fs.c,v 1.79 2009-03-17 01:12:00 wookey Exp $";
1024  extern const char *yaffs_guts_c_version;
1025
1026  #include <linux/version.h>
1027 -#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19))
1028 +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 19))
1029  #include <linux/config.h>
1030  #endif
1031  #include <linux/kernel.h>
1032  #include <linux/module.h>
1033  #include <linux/slab.h>
1034  #include <linux/init.h>
1035 -#include <linux/list.h>
1036  #include <linux/fs.h>
1037  #include <linux/proc_fs.h>
1038  #include <linux/smp_lock.h>
1039 @@ -53,10 +52,12 @@ extern const char *yaffs_guts_c_version;
1040  #include <linux/string.h>
1041  #include <linux/ctype.h>
1042
1043 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
1044 +#include "asm/div64.h"
1045 +
1046 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0))
1047
1048  #include <linux/statfs.h>      /* Added NCB 15-8-2003 */
1049 -#include <asm/statfs.h>
1050 +#include <linux/statfs.h>
1051  #define UnlockPage(p) unlock_page(p)
1052  #define Page_Uptodate(page)    test_bit(PG_uptodate, &(page)->flags)
1053
1054 @@ -69,22 +70,45 @@ extern const char *yaffs_guts_c_version;
1055  #define        BDEVNAME_SIZE           0
1056  #define        yaffs_devname(sb, buf)  kdevname(sb->s_dev)
1057
1058 -#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
1059 +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 5, 0))
1060  /* added NCB 26/5/2006 for 2.4.25-vrs2-tcl1 kernel */
1061  #define __user
1062  #endif
1063
1064  #endif
1065
1066 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
1067 +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 26))
1068 +#define YPROC_ROOT  (&proc_root)
1069 +#else
1070 +#define YPROC_ROOT  NULL
1071 +#endif
1072 +
1073 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17))
1074  #define WRITE_SIZE_STR "writesize"
1075 -#define WRITE_SIZE(mtd) (mtd)->writesize
1076 +#define WRITE_SIZE(mtd) ((mtd)->writesize)
1077  #else
1078  #define WRITE_SIZE_STR "oobblock"
1079 -#define WRITE_SIZE(mtd) (mtd)->oobblock
1080 +#define WRITE_SIZE(mtd) ((mtd)->oobblock)
1081  #endif
1082
1083 -#include <asm/uaccess.h>
1084 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 27))
1085 +#define YAFFS_USE_WRITE_BEGIN_END 1
1086 +#else
1087 +#define YAFFS_USE_WRITE_BEGIN_END 0
1088 +#endif
1089 +
1090 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 28))
1091 +static uint32_t YCALCBLOCKS(uint64_t partition_size, uint32_t block_size)
1092 +{
1093 +       uint64_t result = partition_size;
1094 +       do_div(result, block_size);
1095 +       return (uint32_t)result;
1096 +}
1097 +#else
1098 +#define YCALCBLOCKS(s, b) ((s)/(b))
1099 +#endif
1100 +
1101 +#include <linux/uaccess.h>
1102
1103  #include "yportenv.h"
1104  #include "yaffs_guts.h"
1105 @@ -96,28 +120,44 @@ extern const char *yaffs_guts_c_version;
1106
1107  unsigned int yaffs_traceMask = YAFFS_TRACE_BAD_BLOCKS;
1108  unsigned int yaffs_wr_attempts = YAFFS_WR_ATTEMPTS;
1109 +unsigned int yaffs_auto_checkpoint = 1;
1110
1111  /* Module Parameters */
1112 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
1113 -module_param(yaffs_traceMask,uint,0644);
1114 -module_param(yaffs_wr_attempts,uint,0644);
1115 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0))
1116 +module_param(yaffs_traceMask, uint, 0644);
1117 +module_param(yaffs_wr_attempts, uint, 0644);
1118 +module_param(yaffs_auto_checkpoint, uint, 0644);
1119 +#else
1120 +MODULE_PARM(yaffs_traceMask, "i");
1121 +MODULE_PARM(yaffs_wr_attempts, "i");
1122 +MODULE_PARM(yaffs_auto_checkpoint, "i");
1123 +#endif
1124 +
1125 +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 25))
1126 +/* use iget and read_inode */
1127 +#define Y_IGET(sb, inum) iget((sb), (inum))
1128 +static void yaffs_read_inode(struct inode *inode);
1129 +
1130  #else
1131 -MODULE_PARM(yaffs_traceMask,"i");
1132 -MODULE_PARM(yaffs_wr_attempts,"i");
1133 +/* Call local equivalent */
1134 +#define YAFFS_USE_OWN_IGET
1135 +#define Y_IGET(sb, inum) yaffs_iget((sb), (inum))
1136 +
1137 +static struct inode *yaffs_iget(struct super_block *sb, unsigned long ino);
1138  #endif
1139
1140  /*#define T(x) printk x */
1141
1142 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,18))
1143 -#define yaffs_InodeToObjectLV(iptr) (iptr)->i_private
1144 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 18))
1145 +#define yaffs_InodeToObjectLV(iptr) ((iptr)->i_private)
1146  #else
1147 -#define yaffs_InodeToObjectLV(iptr) (iptr)->u.generic_ip
1148 +#define yaffs_InodeToObjectLV(iptr) ((iptr)->u.generic_ip)
1149  #endif
1150
1151  #define yaffs_InodeToObject(iptr) ((yaffs_Object *)(yaffs_InodeToObjectLV(iptr)))
1152  #define yaffs_DentryToObject(dptr) yaffs_InodeToObject((dptr)->d_inode)
1153
1154 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
1155 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0))
1156  #define yaffs_SuperToDevice(sb)        ((yaffs_Device *)sb->s_fs_info)
1157  #else
1158  #define yaffs_SuperToDevice(sb)        ((yaffs_Device *)sb->u.generic_sbp)
1159 @@ -126,47 +166,49 @@ MODULE_PARM(yaffs_wr_attempts,"i");
1160  static void yaffs_put_super(struct super_block *sb);
1161
1162  static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n,
1163 -                               loff_t * pos);
1164 +                               loff_t *pos);
1165 +static ssize_t yaffs_hold_space(struct file *f);
1166 +static void yaffs_release_space(struct file *f);
1167
1168 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
1169 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17))
1170  static int yaffs_file_flush(struct file *file, fl_owner_t id);
1171  #else
1172  static int yaffs_file_flush(struct file *file);
1173  #endif
1174
1175  static int yaffs_sync_object(struct file *file, struct dentry *dentry,
1176 -                            int datasync);
1177 +                               int datasync);
1178
1179  static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir);
1180
1181 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
1182 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0))
1183  static int yaffs_create(struct inode *dir, struct dentry *dentry, int mode,
1184                         struct nameidata *n);
1185  static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry,
1186 -                                  struct nameidata *n);
1187 +                                       struct nameidata *n);
1188  #else
1189  static int yaffs_create(struct inode *dir, struct dentry *dentry, int mode);
1190  static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry);
1191  #endif
1192  static int yaffs_link(struct dentry *old_dentry, struct inode *dir,
1193 -                     struct dentry *dentry);
1194 +                       struct dentry *dentry);
1195  static int yaffs_unlink(struct inode *dir, struct dentry *dentry);
1196  static int yaffs_symlink(struct inode *dir, struct dentry *dentry,
1197 -                        const char *symname);
1198 +                       const char *symname);
1199  static int yaffs_mkdir(struct inode *dir, struct dentry *dentry, int mode);
1200
1201 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
1202 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0))
1203  static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode,
1204 -                      dev_t dev);
1205 +                       dev_t dev);
1206  #else
1207  static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode,
1208 -                      int dev);
1209 +                       int dev);
1210  #endif
1211  static int yaffs_rename(struct inode *old_dir, struct dentry *old_dentry,
1212                         struct inode *new_dir, struct dentry *new_dentry);
1213  static int yaffs_setattr(struct dentry *dentry, struct iattr *attr);
1214
1215 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
1216 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17))
1217  static int yaffs_sync_fs(struct super_block *sb, int wait);
1218  static void yaffs_write_super(struct super_block *sb);
1219  #else
1220 @@ -174,33 +216,47 @@ static int yaffs_sync_fs(struct super_bl
1221  static int yaffs_write_super(struct super_block *sb);
1222  #endif
1223
1224 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
1225 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17))
1226  static int yaffs_statfs(struct dentry *dentry, struct kstatfs *buf);
1227 -#elif (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
1228 +#elif (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0))
1229  static int yaffs_statfs(struct super_block *sb, struct kstatfs *buf);
1230  #else
1231  static int yaffs_statfs(struct super_block *sb, struct statfs *buf);
1232  #endif
1233 -static void yaffs_read_inode(struct inode *inode);
1234
1235 +#ifdef YAFFS_HAS_PUT_INODE
1236  static void yaffs_put_inode(struct inode *inode);
1237 +#endif
1238 +
1239  static void yaffs_delete_inode(struct inode *);
1240  static void yaffs_clear_inode(struct inode *);
1241
1242  static int yaffs_readpage(struct file *file, struct page *page);
1243 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
1244 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0))
1245  static int yaffs_writepage(struct page *page, struct writeback_control *wbc);
1246  #else
1247  static int yaffs_writepage(struct page *page);
1248  #endif
1249 +
1250 +
1251 +#if (YAFFS_USE_WRITE_BEGIN_END != 0)
1252 +static int yaffs_write_begin(struct file *filp, struct address_space *mapping,
1253 +                               loff_t pos, unsigned len, unsigned flags,
1254 +                               struct page **pagep, void **fsdata);
1255 +static int yaffs_write_end(struct file *filp, struct address_space *mapping,
1256 +                               loff_t pos, unsigned len, unsigned copied,
1257 +                               struct page *pg, void *fsdadata);
1258 +#else
1259  static int yaffs_prepare_write(struct file *f, struct page *pg,
1260 -                              unsigned offset, unsigned to);
1261 +                               unsigned offset, unsigned to);
1262  static int yaffs_commit_write(struct file *f, struct page *pg, unsigned offset,
1263 -                             unsigned to);
1264 +                               unsigned to);
1265
1266 -static int yaffs_readlink(struct dentry *dentry, char __user * buffer,
1267 -                         int buflen);
1268 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,13))
1269 +#endif
1270 +
1271 +static int yaffs_readlink(struct dentry *dentry, char __user *buffer,
1272 +                               int buflen);
1273 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 13))
1274  static void *yaffs_follow_link(struct dentry *dentry, struct nameidata *nd);
1275  #else
1276  static int yaffs_follow_link(struct dentry *dentry, struct nameidata *nd);
1277 @@ -209,12 +265,17 @@ static int yaffs_follow_link(struct dent
1278  static struct address_space_operations yaffs_file_address_operations = {
1279         .readpage = yaffs_readpage,
1280         .writepage = yaffs_writepage,
1281 +#if (YAFFS_USE_WRITE_BEGIN_END > 0)
1282 +       .write_begin = yaffs_write_begin,
1283 +       .write_end = yaffs_write_end,
1284 +#else
1285         .prepare_write = yaffs_prepare_write,
1286         .commit_write = yaffs_commit_write,
1287 +#endif
1288  };
1289
1290 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,22))
1291 -static struct file_operations yaffs_file_operations = {
1292 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 22))
1293 +static const struct file_operations yaffs_file_operations = {
1294         .read = do_sync_read,
1295         .write = do_sync_write,
1296         .aio_read = generic_file_aio_read,
1297 @@ -224,11 +285,12 @@ static struct file_operations yaffs_file
1298         .fsync = yaffs_sync_object,
1299         .splice_read = generic_file_splice_read,
1300         .splice_write = generic_file_splice_write,
1301 +       .llseek = generic_file_llseek,
1302  };
1303
1304 -#elif (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,18))
1305 +#elif (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 18))
1306
1307 -static struct file_operations yaffs_file_operations = {
1308 +static const struct file_operations yaffs_file_operations = {
1309         .read = do_sync_read,
1310         .write = do_sync_write,
1311         .aio_read = generic_file_aio_read,
1312 @@ -241,29 +303,29 @@ static struct file_operations yaffs_file
1313
1314  #else
1315
1316 -static struct file_operations yaffs_file_operations = {
1317 +static const struct file_operations yaffs_file_operations = {
1318         .read = generic_file_read,
1319         .write = generic_file_write,
1320         .mmap = generic_file_mmap,
1321         .flush = yaffs_file_flush,
1322         .fsync = yaffs_sync_object,
1323 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
1324 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0))
1325         .sendfile = generic_file_sendfile,
1326  #endif
1327  };
1328  #endif
1329
1330 -static struct inode_operations yaffs_file_inode_operations = {
1331 +static const struct inode_operations yaffs_file_inode_operations = {
1332         .setattr = yaffs_setattr,
1333  };
1334
1335 -static struct inode_operations yaffs_symlink_inode_operations = {
1336 +static const struct inode_operations yaffs_symlink_inode_operations = {
1337         .readlink = yaffs_readlink,
1338         .follow_link = yaffs_follow_link,
1339         .setattr = yaffs_setattr,
1340  };
1341
1342 -static struct inode_operations yaffs_dir_inode_operations = {
1343 +static const struct inode_operations yaffs_dir_inode_operations = {
1344         .create = yaffs_create,
1345         .lookup = yaffs_lookup,
1346         .link = yaffs_link,
1347 @@ -276,16 +338,21 @@ static struct inode_operations yaffs_dir
1348         .setattr = yaffs_setattr,
1349  };
1350
1351 -static struct file_operations yaffs_dir_operations = {
1352 +static const struct file_operations yaffs_dir_operations = {
1353         .read = generic_read_dir,
1354         .readdir = yaffs_readdir,
1355         .fsync = yaffs_sync_object,
1356  };
1357
1358 -static struct super_operations yaffs_super_ops = {
1359 +static const struct super_operations yaffs_super_ops = {
1360         .statfs = yaffs_statfs,
1361 +
1362 +#ifndef YAFFS_USE_OWN_IGET
1363         .read_inode = yaffs_read_inode,
1364 +#endif
1365 +#ifdef YAFFS_HAS_PUT_INODE
1366         .put_inode = yaffs_put_inode,
1367 +#endif
1368         .put_super = yaffs_put_super,
1369         .delete_inode = yaffs_delete_inode,
1370         .clear_inode = yaffs_clear_inode,
1371 @@ -293,22 +360,21 @@ static struct super_operations yaffs_sup
1372         .write_super = yaffs_write_super,
1373  };
1374
1375 -static void yaffs_GrossLock(yaffs_Device * dev)
1376 +static void yaffs_GrossLock(yaffs_Device *dev)
1377  {
1378 -       T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs locking\n"));
1379 -
1380 +       T(YAFFS_TRACE_OS, ("yaffs locking %p\n", current));
1381         down(&dev->grossLock);
1382 +       T(YAFFS_TRACE_OS, ("yaffs locked %p\n", current));
1383  }
1384
1385 -static void yaffs_GrossUnlock(yaffs_Device * dev)
1386 +static void yaffs_GrossUnlock(yaffs_Device *dev)
1387  {
1388 -       T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs unlocking\n"));
1389 +       T(YAFFS_TRACE_OS, ("yaffs unlocking %p\n", current));
1390         up(&dev->grossLock);
1391 -
1392  }
1393
1394 -static int yaffs_readlink(struct dentry *dentry, char __user * buffer,
1395 -                         int buflen)
1396 +static int yaffs_readlink(struct dentry *dentry, char __user *buffer,
1397 +                       int buflen)
1398  {
1399         unsigned char *alias;
1400         int ret;
1401 @@ -329,7 +395,7 @@ static int yaffs_readlink(struct dentry
1402         return ret;
1403  }
1404
1405 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,13))
1406 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 13))
1407  static void *yaffs_follow_link(struct dentry *dentry, struct nameidata *nd)
1408  #else
1409  static int yaffs_follow_link(struct dentry *dentry, struct nameidata *nd)
1410 @@ -345,32 +411,31 @@ static int yaffs_follow_link(struct dent
1411
1412         yaffs_GrossUnlock(dev);
1413
1414 -       if (!alias)
1415 -        {
1416 +       if (!alias) {
1417                 ret = -ENOMEM;
1418                 goto out;
1419 -        }
1420 +       }
1421
1422         ret = vfs_follow_link(nd, alias);
1423         kfree(alias);
1424  out:
1425 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,13))
1426 -       return ERR_PTR (ret);
1427 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 13))
1428 +       return ERR_PTR(ret);
1429  #else
1430         return ret;
1431  #endif
1432  }
1433
1434  struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev,
1435 -                             yaffs_Object * obj);
1436 +                               yaffs_Object *obj);
1437
1438  /*
1439   * Lookup is used to find objects in the fs
1440   */
1441 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
1442 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0))
1443
1444  static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry,
1445 -                                  struct nameidata *n)
1446 +                               struct nameidata *n)
1447  #else
1448  static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry)
1449  #endif
1450 @@ -383,12 +448,11 @@ static struct dentry *yaffs_lookup(struc
1451         yaffs_GrossLock(dev);
1452
1453         T(YAFFS_TRACE_OS,
1454 -         (KERN_DEBUG "yaffs_lookup for %d:%s\n",
1455 -          yaffs_InodeToObject(dir)->objectId, dentry->d_name.name));
1456 +               ("yaffs_lookup for %d:%s\n",
1457 +               yaffs_InodeToObject(dir)->objectId, dentry->d_name.name));
1458
1459 -       obj =
1460 -           yaffs_FindObjectByName(yaffs_InodeToObject(dir),
1461 -                                  dentry->d_name.name);
1462 +       obj = yaffs_FindObjectByName(yaffs_InodeToObject(dir),
1463 +                                       dentry->d_name.name);
1464
1465         obj = yaffs_GetEquivalentObject(obj);   /* in case it was a hardlink */
1466
1467 @@ -397,13 +461,13 @@ static struct dentry *yaffs_lookup(struc
1468
1469         if (obj) {
1470                 T(YAFFS_TRACE_OS,
1471 -                 (KERN_DEBUG "yaffs_lookup found %d\n", obj->objectId));
1472 +                       ("yaffs_lookup found %d\n", obj->objectId));
1473
1474                 inode = yaffs_get_inode(dir->i_sb, obj->yst_mode, 0, obj);
1475
1476                 if (inode) {
1477                         T(YAFFS_TRACE_OS,
1478 -                         (KERN_DEBUG "yaffs_loookup dentry \n"));
1479 +                               ("yaffs_loookup dentry \n"));
1480  /* #if 0 asserted by NCB for 2.5/6 compatability - falls through to
1481   * d_add even if NULL inode */
1482  #if 0
1483 @@ -416,7 +480,7 @@ static struct dentry *yaffs_lookup(struc
1484                 }
1485
1486         } else {
1487 -               T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_lookup not found\n"));
1488 +               T(YAFFS_TRACE_OS, ("yaffs_lookup not found\n"));
1489
1490         }
1491
1492 @@ -425,20 +489,22 @@ static struct dentry *yaffs_lookup(struc
1493         d_add(dentry, inode);
1494
1495         return NULL;
1496 -       /*      return (ERR_PTR(-EIO)); */
1497 -
1498  }
1499
1500 +
1501 +#ifdef YAFFS_HAS_PUT_INODE
1502 +
1503  /* For now put inode is just for debugging
1504   * Put inode is called when the inode **structure** is put.
1505   */
1506  static void yaffs_put_inode(struct inode *inode)
1507  {
1508         T(YAFFS_TRACE_OS,
1509 -         ("yaffs_put_inode: ino %d, count %d\n", (int)inode->i_ino,
1510 -          atomic_read(&inode->i_count)));
1511 +               ("yaffs_put_inode: ino %d, count %d\n", (int)inode->i_ino,
1512 +               atomic_read(&inode->i_count)));
1513
1514  }
1515 +#endif
1516
1517  /* clear is called to tell the fs to release any per-inode data it holds */
1518  static void yaffs_clear_inode(struct inode *inode)
1519 @@ -449,9 +515,9 @@ static void yaffs_clear_inode(struct ino
1520         obj = yaffs_InodeToObject(inode);
1521
1522         T(YAFFS_TRACE_OS,
1523 -         ("yaffs_clear_inode: ino %d, count %d %s\n", (int)inode->i_ino,
1524 -          atomic_read(&inode->i_count),
1525 -          obj ? "object exists" : "null object"));
1526 +               ("yaffs_clear_inode: ino %d, count %d %s\n", (int)inode->i_ino,
1527 +               atomic_read(&inode->i_count),
1528 +               obj ? "object exists" : "null object"));
1529
1530         if (obj) {
1531                 dev = obj->myDev;
1532 @@ -486,23 +552,23 @@ static void yaffs_delete_inode(struct in
1533         yaffs_Device *dev;
1534
1535         T(YAFFS_TRACE_OS,
1536 -         ("yaffs_delete_inode: ino %d, count %d %s\n", (int)inode->i_ino,
1537 -          atomic_read(&inode->i_count),
1538 -          obj ? "object exists" : "null object"));
1539 +               ("yaffs_delete_inode: ino %d, count %d %s\n", (int)inode->i_ino,
1540 +               atomic_read(&inode->i_count),
1541 +               obj ? "object exists" : "null object"));
1542
1543         if (obj) {
1544                 dev = obj->myDev;
1545                 yaffs_GrossLock(dev);
1546 -               yaffs_DeleteFile(obj);
1547 +               yaffs_DeleteObject(obj);
1548                 yaffs_GrossUnlock(dev);
1549         }
1550 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,13))
1551 -        truncate_inode_pages (&inode->i_data, 0);
1552 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 13))
1553 +       truncate_inode_pages(&inode->i_data, 0);
1554  #endif
1555         clear_inode(inode);
1556  }
1557
1558 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
1559 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17))
1560  static int yaffs_file_flush(struct file *file, fl_owner_t id)
1561  #else
1562  static int yaffs_file_flush(struct file *file)
1563 @@ -513,8 +579,8 @@ static int yaffs_file_flush(struct file
1564         yaffs_Device *dev = obj->myDev;
1565
1566         T(YAFFS_TRACE_OS,
1567 -         (KERN_DEBUG "yaffs_file_flush object %d (%s)\n", obj->objectId,
1568 -          obj->dirty ? "dirty" : "clean"));
1569 +               ("yaffs_file_flush object %d (%s)\n", obj->objectId,
1570 +               obj->dirty ? "dirty" : "clean"));
1571
1572         yaffs_GrossLock(dev);
1573
1574 @@ -535,15 +601,15 @@ static int yaffs_readpage_nolock(struct
1575
1576         yaffs_Device *dev;
1577
1578 -       T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_readpage at %08x, size %08x\n",
1579 -                          (unsigned)(pg->index << PAGE_CACHE_SHIFT),
1580 -                          (unsigned)PAGE_CACHE_SIZE));
1581 +       T(YAFFS_TRACE_OS, ("yaffs_readpage at %08x, size %08x\n",
1582 +                       (unsigned)(pg->index << PAGE_CACHE_SHIFT),
1583 +                       (unsigned)PAGE_CACHE_SIZE));
1584
1585         obj = yaffs_DentryToObject(f->f_dentry);
1586
1587         dev = obj->myDev;
1588
1589 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
1590 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0))
1591         BUG_ON(!PageLocked(pg));
1592  #else
1593         if (!PageLocked(pg))
1594 @@ -555,9 +621,9 @@ static int yaffs_readpage_nolock(struct
1595
1596         yaffs_GrossLock(dev);
1597
1598 -       ret =
1599 -           yaffs_ReadDataFromFile(obj, pg_buf, pg->index << PAGE_CACHE_SHIFT,
1600 -                                  PAGE_CACHE_SIZE);
1601 +       ret = yaffs_ReadDataFromFile(obj, pg_buf,
1602 +                               pg->index << PAGE_CACHE_SHIFT,
1603 +                               PAGE_CACHE_SIZE);
1604
1605         yaffs_GrossUnlock(dev);
1606
1607 @@ -575,7 +641,7 @@ static int yaffs_readpage_nolock(struct
1608         flush_dcache_page(pg);
1609         kunmap(pg);
1610
1611 -       T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_readpage done\n"));
1612 +       T(YAFFS_TRACE_OS, ("yaffs_readpage done\n"));
1613         return ret;
1614  }
1615
1616 @@ -593,7 +659,7 @@ static int yaffs_readpage(struct file *f
1617
1618  /* writepage inspired by/stolen from smbfs */
1619
1620 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
1621 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0))
1622  static int yaffs_writepage(struct page *page, struct writeback_control *wbc)
1623  #else
1624  static int yaffs_writepage(struct page *page)
1625 @@ -616,12 +682,11 @@ static int yaffs_writepage(struct page *
1626
1627         if (offset > inode->i_size) {
1628                 T(YAFFS_TRACE_OS,
1629 -                 (KERN_DEBUG
1630 -                  "yaffs_writepage at %08x, inode size = %08x!!!\n",
1631 -                  (unsigned)(page->index << PAGE_CACHE_SHIFT),
1632 -                  (unsigned)inode->i_size));
1633 +                       ("yaffs_writepage at %08x, inode size = %08x!!!\n",
1634 +                       (unsigned)(page->index << PAGE_CACHE_SHIFT),
1635 +                       (unsigned)inode->i_size));
1636                 T(YAFFS_TRACE_OS,
1637 -                 (KERN_DEBUG "                -> don't care!!\n"));
1638 +                       ("                -> don't care!!\n"));
1639                 unlock_page(page);
1640                 return 0;
1641         }
1642 @@ -629,11 +694,10 @@ static int yaffs_writepage(struct page *
1643         end_index = inode->i_size >> PAGE_CACHE_SHIFT;
1644
1645         /* easy case */
1646 -       if (page->index < end_index) {
1647 +       if (page->index < end_index)
1648                 nBytes = PAGE_CACHE_SIZE;
1649 -       } else {
1650 +       else
1651                 nBytes = inode->i_size & (PAGE_CACHE_SIZE - 1);
1652 -       }
1653
1654         get_page(page);
1655
1656 @@ -643,19 +707,18 @@ static int yaffs_writepage(struct page *
1657         yaffs_GrossLock(obj->myDev);
1658
1659         T(YAFFS_TRACE_OS,
1660 -         (KERN_DEBUG "yaffs_writepage at %08x, size %08x\n",
1661 -          (unsigned)(page->index << PAGE_CACHE_SHIFT), nBytes));
1662 +               ("yaffs_writepage at %08x, size %08x\n",
1663 +               (unsigned)(page->index << PAGE_CACHE_SHIFT), nBytes));
1664         T(YAFFS_TRACE_OS,
1665 -         (KERN_DEBUG "writepag0: obj = %05x, ino = %05x\n",
1666 -          (int)obj->variant.fileVariant.fileSize, (int)inode->i_size));
1667 +               ("writepag0: obj = %05x, ino = %05x\n",
1668 +               (int)obj->variant.fileVariant.fileSize, (int)inode->i_size));
1669
1670 -       nWritten =
1671 -           yaffs_WriteDataToFile(obj, buffer, page->index << PAGE_CACHE_SHIFT,
1672 -                                 nBytes, 0);
1673 +       nWritten = yaffs_WriteDataToFile(obj, buffer,
1674 +                       page->index << PAGE_CACHE_SHIFT, nBytes, 0);
1675
1676         T(YAFFS_TRACE_OS,
1677 -         (KERN_DEBUG "writepag1: obj = %05x, ino = %05x\n",
1678 -          (int)obj->variant.fileVariant.fileSize, (int)inode->i_size));
1679 +               ("writepag1: obj = %05x, ino = %05x\n",
1680 +               (int)obj->variant.fileVariant.fileSize, (int)inode->i_size));
1681
1682         yaffs_GrossUnlock(obj->myDev);
1683
1684 @@ -667,100 +730,207 @@ static int yaffs_writepage(struct page *
1685         return (nWritten == nBytes) ? 0 : -ENOSPC;
1686  }
1687
1688 +
1689 +#if (YAFFS_USE_WRITE_BEGIN_END > 0)
1690 +static int yaffs_write_begin(struct file *filp, struct address_space *mapping,
1691 +                               loff_t pos, unsigned len, unsigned flags,
1692 +                               struct page **pagep, void **fsdata)
1693 +{
1694 +       struct page *pg = NULL;
1695 +       pgoff_t index = pos >> PAGE_CACHE_SHIFT;
1696 +       uint32_t offset = pos & (PAGE_CACHE_SIZE - 1);
1697 +       uint32_t to = offset + len;
1698 +
1699 +       int ret = 0;
1700 +       int space_held = 0;
1701 +
1702 +       T(YAFFS_TRACE_OS, ("start yaffs_write_begin\n"));
1703 +       /* Get a page */
1704 +#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 28)
1705 +       pg = grab_cache_page_write_begin(mapping, index, flags);
1706 +#else
1707 +       pg = __grab_cache_page(mapping, index);
1708 +#endif
1709 +
1710 +       *pagep = pg;
1711 +       if (!pg) {
1712 +               ret =  -ENOMEM;
1713 +               goto out;
1714 +       }
1715 +       /* Get fs space */
1716 +       space_held = yaffs_hold_space(filp);
1717 +
1718 +       if (!space_held) {
1719 +               ret = -ENOSPC;
1720 +               goto out;
1721 +       }
1722 +
1723 +       /* Update page if required */
1724 +
1725 +       if (!Page_Uptodate(pg) && (offset || to < PAGE_CACHE_SIZE))
1726 +               ret = yaffs_readpage_nolock(filp, pg);
1727 +
1728 +       if (ret)
1729 +               goto out;
1730 +
1731 +       /* Happy path return */
1732 +       T(YAFFS_TRACE_OS, ("end yaffs_write_begin - ok\n"));
1733 +
1734 +       return 0;
1735 +
1736 +out:
1737 +       T(YAFFS_TRACE_OS, ("end yaffs_write_begin fail returning %d\n", ret));
1738 +       if (space_held)
1739 +               yaffs_release_space(filp);
1740 +       if (pg) {
1741 +               unlock_page(pg);
1742 +               page_cache_release(pg);
1743 +       }
1744 +       return ret;
1745 +}
1746 +
1747 +#else
1748 +
1749  static int yaffs_prepare_write(struct file *f, struct page *pg,
1750 -                              unsigned offset, unsigned to)
1751 +                               unsigned offset, unsigned to)
1752  {
1753 +       T(YAFFS_TRACE_OS, ("yaffs_prepair_write\n"));
1754
1755 -       T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_prepair_write\n"));
1756         if (!Page_Uptodate(pg) && (offset || to < PAGE_CACHE_SIZE))
1757                 return yaffs_readpage_nolock(f, pg);
1758 -
1759         return 0;
1760 +}
1761 +#endif
1762 +
1763 +#if (YAFFS_USE_WRITE_BEGIN_END > 0)
1764 +static int yaffs_write_end(struct file *filp, struct address_space *mapping,
1765 +                               loff_t pos, unsigned len, unsigned copied,
1766 +                               struct page *pg, void *fsdadata)
1767 +{
1768 +       int ret = 0;
1769 +       void *addr, *kva;
1770 +       uint32_t offset_into_page = pos & (PAGE_CACHE_SIZE - 1);
1771 +
1772 +       kva = kmap(pg);
1773 +       addr = kva + offset_into_page;
1774 +
1775 +       T(YAFFS_TRACE_OS,
1776 +               ("yaffs_write_end addr %x pos %x nBytes %d\n",
1777 +               (unsigned) addr,
1778 +               (int)pos, copied));
1779 +
1780 +       ret = yaffs_file_write(filp, addr, copied, &pos);
1781 +
1782 +       if (ret != copied) {
1783 +               T(YAFFS_TRACE_OS,
1784 +                       ("yaffs_write_end not same size ret %d  copied %d\n",
1785 +                       ret, copied));
1786 +               SetPageError(pg);
1787 +               ClearPageUptodate(pg);
1788 +       } else {
1789 +               SetPageUptodate(pg);
1790 +       }
1791 +
1792 +       kunmap(pg);
1793
1794 +       yaffs_release_space(filp);
1795 +       unlock_page(pg);
1796 +       page_cache_release(pg);
1797 +       return ret;
1798  }
1799 +#else
1800
1801  static int yaffs_commit_write(struct file *f, struct page *pg, unsigned offset,
1802 -                             unsigned to)
1803 +                               unsigned to)
1804  {
1805 +       void *addr, *kva;
1806
1807 -       void *addr = page_address(pg) + offset;
1808         loff_t pos = (((loff_t) pg->index) << PAGE_CACHE_SHIFT) + offset;
1809         int nBytes = to - offset;
1810         int nWritten;
1811
1812         unsigned spos = pos;
1813 -       unsigned saddr = (unsigned)addr;
1814 +       unsigned saddr;
1815 +
1816 +       kva = kmap(pg);
1817 +       addr = kva + offset;
1818 +
1819 +       saddr = (unsigned) addr;
1820
1821         T(YAFFS_TRACE_OS,
1822 -         (KERN_DEBUG "yaffs_commit_write addr %x pos %x nBytes %d\n", saddr,
1823 -          spos, nBytes));
1824 +               ("yaffs_commit_write addr %x pos %x nBytes %d\n",
1825 +               saddr, spos, nBytes));
1826
1827         nWritten = yaffs_file_write(f, addr, nBytes, &pos);
1828
1829         if (nWritten != nBytes) {
1830                 T(YAFFS_TRACE_OS,
1831 -                 (KERN_DEBUG
1832 -                  "yaffs_commit_write not same size nWritten %d  nBytes %d\n",
1833 -                  nWritten, nBytes));
1834 +                       ("yaffs_commit_write not same size nWritten %d  nBytes %d\n",
1835 +                       nWritten, nBytes));
1836                 SetPageError(pg);
1837                 ClearPageUptodate(pg);
1838         } else {
1839                 SetPageUptodate(pg);
1840         }
1841
1842 +       kunmap(pg);
1843 +
1844         T(YAFFS_TRACE_OS,
1845 -         (KERN_DEBUG "yaffs_commit_write returning %d\n",
1846 -          nWritten == nBytes ? 0 : nWritten));
1847 +               ("yaffs_commit_write returning %d\n",
1848 +               nWritten == nBytes ? 0 : nWritten));
1849
1850         return nWritten == nBytes ? 0 : nWritten;
1851 -
1852  }
1853 +#endif
1854 +
1855
1856 -static void yaffs_FillInodeFromObject(struct inode *inode, yaffs_Object * obj)
1857 +static void yaffs_FillInodeFromObject(struct inode *inode, yaffs_Object *obj)
1858  {
1859         if (inode && obj) {
1860
1861
1862                 /* Check mode against the variant type and attempt to repair if broken. */
1863 -               __u32 mode = obj->yst_mode;
1864 -               switch( obj->variantType ){
1865 -               case YAFFS_OBJECT_TYPE_FILE :
1866 -                       if( ! S_ISREG(mode) ){
1867 -                               obj->yst_mode &= ~S_IFMT;
1868 -                               obj->yst_mode |= S_IFREG;
1869 -                       }
1870 -
1871 -                       break;
1872 -               case YAFFS_OBJECT_TYPE_SYMLINK :
1873 -                       if( ! S_ISLNK(mode) ){
1874 -                               obj->yst_mode &= ~S_IFMT;
1875 -                               obj->yst_mode |= S_IFLNK;
1876 -                       }
1877 -
1878 -                       break;
1879 -               case YAFFS_OBJECT_TYPE_DIRECTORY :
1880 -                       if( ! S_ISDIR(mode) ){
1881 -                               obj->yst_mode &= ~S_IFMT;
1882 -                               obj->yst_mode |= S_IFDIR;
1883 -                       }
1884 -
1885 -                       break;
1886 -               case YAFFS_OBJECT_TYPE_UNKNOWN :
1887 -               case YAFFS_OBJECT_TYPE_HARDLINK :
1888 -               case YAFFS_OBJECT_TYPE_SPECIAL :
1889 -               default:
1890 -                       /* TODO? */
1891 -                       break;
1892 -               }
1893 +               __u32 mode = obj->yst_mode;
1894 +               switch (obj->variantType) {
1895 +               case YAFFS_OBJECT_TYPE_FILE:
1896 +                       if (!S_ISREG(mode)) {
1897 +                               obj->yst_mode &= ~S_IFMT;
1898 +                               obj->yst_mode |= S_IFREG;
1899 +                       }
1900 +
1901 +                       break;
1902 +               case YAFFS_OBJECT_TYPE_SYMLINK:
1903 +                       if (!S_ISLNK(mode)) {
1904 +                               obj->yst_mode &= ~S_IFMT;
1905 +                               obj->yst_mode |= S_IFLNK;
1906 +                       }
1907 +
1908 +                       break;
1909 +               case YAFFS_OBJECT_TYPE_DIRECTORY:
1910 +                       if (!S_ISDIR(mode)) {
1911 +                               obj->yst_mode &= ~S_IFMT;
1912 +                               obj->yst_mode |= S_IFDIR;
1913 +                       }
1914 +
1915 +                       break;
1916 +               case YAFFS_OBJECT_TYPE_UNKNOWN:
1917 +               case YAFFS_OBJECT_TYPE_HARDLINK:
1918 +               case YAFFS_OBJECT_TYPE_SPECIAL:
1919 +               default:
1920 +                       /* TODO? */
1921 +                       break;
1922 +               }
1923 +
1924 +               inode->i_flags |= S_NOATIME;
1925
1926                 inode->i_ino = obj->objectId;
1927                 inode->i_mode = obj->yst_mode;
1928                 inode->i_uid = obj->yst_uid;
1929                 inode->i_gid = obj->yst_gid;
1930 -#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19))
1931 +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 19))
1932                 inode->i_blksize = inode->i_sb->s_blocksize;
1933  #endif
1934 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
1935 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0))
1936
1937                 inode->i_rdev = old_decode_dev(obj->yst_rdev);
1938                 inode->i_atime.tv_sec = (time_t) (obj->yst_atime);
1939 @@ -781,26 +951,25 @@ static void yaffs_FillInodeFromObject(st
1940                 inode->i_nlink = yaffs_GetObjectLinkCount(obj);
1941
1942                 T(YAFFS_TRACE_OS,
1943 -                 (KERN_DEBUG
1944 -                  "yaffs_FillInode mode %x uid %d gid %d size %d count %d\n",
1945 -                  inode->i_mode, inode->i_uid, inode->i_gid,
1946 -                  (int)inode->i_size, atomic_read(&inode->i_count)));
1947 +                       ("yaffs_FillInode mode %x uid %d gid %d size %d count %d\n",
1948 +                       inode->i_mode, inode->i_uid, inode->i_gid,
1949 +                       (int)inode->i_size, atomic_read(&inode->i_count)));
1950
1951                 switch (obj->yst_mode & S_IFMT) {
1952                 default:        /* fifo, device or socket */
1953 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
1954 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0))
1955                         init_special_inode(inode, obj->yst_mode,
1956 -                                          old_decode_dev(obj->yst_rdev));
1957 +                                       old_decode_dev(obj->yst_rdev));
1958  #else
1959                         init_special_inode(inode, obj->yst_mode,
1960 -                                          (dev_t) (obj->yst_rdev));
1961 +                                       (dev_t) (obj->yst_rdev));
1962  #endif
1963                         break;
1964                 case S_IFREG:   /* file */
1965                         inode->i_op = &yaffs_file_inode_operations;
1966                         inode->i_fop = &yaffs_file_operations;
1967                         inode->i_mapping->a_ops =
1968 -                           &yaffs_file_address_operations;
1969 +                               &yaffs_file_address_operations;
1970                         break;
1971                 case S_IFDIR:   /* directory */
1972                         inode->i_op = &yaffs_dir_inode_operations;
1973 @@ -817,34 +986,36 @@ static void yaffs_FillInodeFromObject(st
1974
1975         } else {
1976                 T(YAFFS_TRACE_OS,
1977 -                 (KERN_DEBUG "yaffs_FileInode invalid parameters\n"));
1978 +                       ("yaffs_FileInode invalid parameters\n"));
1979         }
1980
1981  }
1982
1983  struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev,
1984 -                             yaffs_Object * obj)
1985 +                               yaffs_Object *obj)
1986  {
1987         struct inode *inode;
1988
1989         if (!sb) {
1990                 T(YAFFS_TRACE_OS,
1991 -                 (KERN_DEBUG "yaffs_get_inode for NULL super_block!!\n"));
1992 +                       ("yaffs_get_inode for NULL super_block!!\n"));
1993                 return NULL;
1994
1995         }
1996
1997         if (!obj) {
1998                 T(YAFFS_TRACE_OS,
1999 -                 (KERN_DEBUG "yaffs_get_inode for NULL object!!\n"));
2000 +                       ("yaffs_get_inode for NULL object!!\n"));
2001                 return NULL;
2002
2003         }
2004
2005         T(YAFFS_TRACE_OS,
2006 -         (KERN_DEBUG "yaffs_get_inode for object %d\n", obj->objectId));
2007 +               ("yaffs_get_inode for object %d\n", obj->objectId));
2008
2009 -       inode = iget(sb, obj->objectId);
2010 +       inode = Y_IGET(sb, obj->objectId);
2011 +       if (IS_ERR(inode))
2012 +               return NULL;
2013
2014         /* NB Side effect: iget calls back to yaffs_read_inode(). */
2015         /* iget also increments the inode's i_count */
2016 @@ -854,7 +1025,7 @@ struct inode *yaffs_get_inode(struct sup
2017  }
2018
2019  static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n,
2020 -                               loff_t * pos)
2021 +                               loff_t *pos)
2022  {
2023         yaffs_Object *obj;
2024         int nWritten, ipos;
2025 @@ -869,28 +1040,26 @@ static ssize_t yaffs_file_write(struct f
2026
2027         inode = f->f_dentry->d_inode;
2028
2029 -       if (!S_ISBLK(inode->i_mode) && f->f_flags & O_APPEND) {
2030 +       if (!S_ISBLK(inode->i_mode) && f->f_flags & O_APPEND)
2031                 ipos = inode->i_size;
2032 -       } else {
2033 +       else
2034                 ipos = *pos;
2035 -       }
2036
2037 -       if (!obj) {
2038 +       if (!obj)
2039                 T(YAFFS_TRACE_OS,
2040 -                 (KERN_DEBUG "yaffs_file_write: hey obj is null!\n"));
2041 -       } else {
2042 +                       ("yaffs_file_write: hey obj is null!\n"));
2043 +       else
2044                 T(YAFFS_TRACE_OS,
2045 -                 (KERN_DEBUG
2046 -                  "yaffs_file_write about to write writing %d bytes"
2047 -                  "to object %d at %d\n",
2048 -                  n, obj->objectId, ipos));
2049 -       }
2050 +                       ("yaffs_file_write about to write writing %zu bytes"
2051 +                       "to object %d at %d\n",
2052 +                       n, obj->objectId, ipos));
2053
2054         nWritten = yaffs_WriteDataToFile(obj, buf, ipos, n, 0);
2055
2056         T(YAFFS_TRACE_OS,
2057 -         (KERN_DEBUG "yaffs_file_write writing %d bytes, %d written at %d\n",
2058 -          n, nWritten, ipos));
2059 +               ("yaffs_file_write writing %zu bytes, %d written at %d\n",
2060 +               n, nWritten, ipos));
2061 +
2062         if (nWritten > 0) {
2063                 ipos += nWritten;
2064                 *pos = ipos;
2065 @@ -899,10 +1068,9 @@ static ssize_t yaffs_file_write(struct f
2066                         inode->i_blocks = (ipos + 511) >> 9;
2067
2068                         T(YAFFS_TRACE_OS,
2069 -                         (KERN_DEBUG
2070 -                          "yaffs_file_write size updated to %d bytes, "
2071 -                          "%d blocks\n",
2072 -                          ipos, (int)(inode->i_blocks)));
2073 +                               ("yaffs_file_write size updated to %d bytes, "
2074 +                               "%d blocks\n",
2075 +                               ipos, (int)(inode->i_blocks)));
2076                 }
2077
2078         }
2079 @@ -910,13 +1078,54 @@ static ssize_t yaffs_file_write(struct f
2080         return nWritten == 0 ? -ENOSPC : nWritten;
2081  }
2082
2083 +/* Space holding and freeing is done to ensure we have space available for write_begin/end */
2084 +/* For now we just assume few parallel writes and check against a small number. */
2085 +/* Todo: need to do this with a counter to handle parallel reads better */
2086 +
2087 +static ssize_t yaffs_hold_space(struct file *f)
2088 +{
2089 +       yaffs_Object *obj;
2090 +       yaffs_Device *dev;
2091 +
2092 +       int nFreeChunks;
2093 +
2094 +
2095 +       obj = yaffs_DentryToObject(f->f_dentry);
2096 +
2097 +       dev = obj->myDev;
2098 +
2099 +       yaffs_GrossLock(dev);
2100 +
2101 +       nFreeChunks = yaffs_GetNumberOfFreeChunks(dev);
2102 +
2103 +       yaffs_GrossUnlock(dev);
2104 +
2105 +       return (nFreeChunks > 20) ? 1 : 0;
2106 +}
2107 +
2108 +static void yaffs_release_space(struct file *f)
2109 +{
2110 +       yaffs_Object *obj;
2111 +       yaffs_Device *dev;
2112 +
2113 +
2114 +       obj = yaffs_DentryToObject(f->f_dentry);
2115 +
2116 +       dev = obj->myDev;
2117 +
2118 +       yaffs_GrossLock(dev);
2119 +
2120 +
2121 +       yaffs_GrossUnlock(dev);
2122 +}
2123 +
2124  static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir)
2125  {
2126         yaffs_Object *obj;
2127         yaffs_Device *dev;
2128         struct inode *inode = f->f_dentry->d_inode;
2129         unsigned long offset, curoffs;
2130 -       struct list_head *i;
2131 +       struct ylist_head *i;
2132         yaffs_Object *l;
2133
2134         char name[YAFFS_MAX_NAME_LENGTH + 1];
2135 @@ -932,24 +1141,20 @@ static int yaffs_readdir(struct file *f,
2136
2137         if (offset == 0) {
2138                 T(YAFFS_TRACE_OS,
2139 -                 (KERN_DEBUG "yaffs_readdir: entry . ino %d \n",
2140 -                  (int)inode->i_ino));
2141 -               if (filldir(dirent, ".", 1, offset, inode->i_ino, DT_DIR)
2142 -                   < 0) {
2143 +                       ("yaffs_readdir: entry . ino %d \n",
2144 +                       (int)inode->i_ino));
2145 +               if (filldir(dirent, ".", 1, offset, inode->i_ino, DT_DIR) < 0)
2146                         goto out;
2147 -               }
2148                 offset++;
2149                 f->f_pos++;
2150         }
2151         if (offset == 1) {
2152                 T(YAFFS_TRACE_OS,
2153 -                 (KERN_DEBUG "yaffs_readdir: entry .. ino %d \n",
2154 -                  (int)f->f_dentry->d_parent->d_inode->i_ino));
2155 -               if (filldir
2156 -                   (dirent, "..", 2, offset,
2157 -                    f->f_dentry->d_parent->d_inode->i_ino, DT_DIR) < 0) {
2158 +                       ("yaffs_readdir: entry .. ino %d \n",
2159 +                       (int)f->f_dentry->d_parent->d_inode->i_ino));
2160 +               if (filldir(dirent, "..", 2, offset,
2161 +                       f->f_dentry->d_parent->d_inode->i_ino, DT_DIR) < 0)
2162                         goto out;
2163 -               }
2164                 offset++;
2165                 f->f_pos++;
2166         }
2167 @@ -965,35 +1170,32 @@ static int yaffs_readdir(struct file *f,
2168                 f->f_version = inode->i_version;
2169         }
2170
2171 -       list_for_each(i, &obj->variant.directoryVariant.children) {
2172 +       ylist_for_each(i, &obj->variant.directoryVariant.children) {
2173                 curoffs++;
2174                 if (curoffs >= offset) {
2175 -                       l = list_entry(i, yaffs_Object, siblings);
2176 +                       l = ylist_entry(i, yaffs_Object, siblings);
2177
2178                         yaffs_GetObjectName(l, name,
2179                                             YAFFS_MAX_NAME_LENGTH + 1);
2180                         T(YAFFS_TRACE_OS,
2181 -                         (KERN_DEBUG "yaffs_readdir: %s inode %d\n", name,
2182 +                         ("yaffs_readdir: %s inode %d\n", name,
2183                            yaffs_GetObjectInode(l)));
2184
2185                         if (filldir(dirent,
2186 -                                   name,
2187 -                                   strlen(name),
2188 -                                   offset,
2189 -                                   yaffs_GetObjectInode(l),
2190 -                                   yaffs_GetObjectType(l))
2191 -                           < 0) {
2192 +                                       name,
2193 +                                       strlen(name),
2194 +                                       offset,
2195 +                                       yaffs_GetObjectInode(l),
2196 +                                       yaffs_GetObjectType(l)) < 0)
2197                                 goto up_and_out;
2198 -                       }
2199
2200                         offset++;
2201                         f->f_pos++;
2202                 }
2203         }
2204
2205 -      up_and_out:
2206 -      out:
2207 -
2208 +up_and_out:
2209 +out:
2210         yaffs_GrossUnlock(dev);
2211
2212         return 0;
2213 @@ -1002,12 +1204,19 @@ static int yaffs_readdir(struct file *f,
2214  /*
2215   * File creation. Allocate an inode, and we're done..
2216   */
2217 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
2218 +
2219 +#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 29)
2220 +#define YCRED(x) x
2221 +#else
2222 +#define YCRED(x) (x->cred)
2223 +#endif
2224 +
2225 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0))
2226  static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode,
2227 -                      dev_t rdev)
2228 +                       dev_t rdev)
2229  #else
2230  static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode,
2231 -                      int rdev)
2232 +                       int rdev)
2233  #endif
2234  {
2235         struct inode *inode;
2236 @@ -1018,25 +1227,25 @@ static int yaffs_mknod(struct inode *dir
2237         yaffs_Object *parent = yaffs_InodeToObject(dir);
2238
2239         int error = -ENOSPC;
2240 -       uid_t uid = current->fsuid;
2241 -       gid_t gid = (dir->i_mode & S_ISGID) ? dir->i_gid : current->fsgid;
2242 +       uid_t uid = YCRED(current)->fsuid;
2243 +       gid_t gid = (dir->i_mode & S_ISGID) ? dir->i_gid : YCRED(current)->fsgid;
2244
2245 -       if((dir->i_mode & S_ISGID) && S_ISDIR(mode))
2246 +       if ((dir->i_mode & S_ISGID) && S_ISDIR(mode))
2247                 mode |= S_ISGID;
2248
2249         if (parent) {
2250                 T(YAFFS_TRACE_OS,
2251 -                 (KERN_DEBUG "yaffs_mknod: parent object %d type %d\n",
2252 -                  parent->objectId, parent->variantType));
2253 +                       ("yaffs_mknod: parent object %d type %d\n",
2254 +                       parent->objectId, parent->variantType));
2255         } else {
2256                 T(YAFFS_TRACE_OS,
2257 -                 (KERN_DEBUG "yaffs_mknod: could not get parent object\n"));
2258 +                       ("yaffs_mknod: could not get parent object\n"));
2259                 return -EPERM;
2260         }
2261
2262         T(YAFFS_TRACE_OS, ("yaffs_mknod: making oject for %s, "
2263 -                          "mode %x dev %x\n",
2264 -                          dentry->d_name.name, mode, rdev));
2265 +                       "mode %x dev %x\n",
2266 +                       dentry->d_name.name, mode, rdev));
2267
2268         dev = parent->myDev;
2269
2270 @@ -1045,33 +1254,28 @@ static int yaffs_mknod(struct inode *dir
2271         switch (mode & S_IFMT) {
2272         default:
2273                 /* Special (socket, fifo, device...) */
2274 -               T(YAFFS_TRACE_OS, (KERN_DEBUG
2275 -                                  "yaffs_mknod: making special\n"));
2276 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
2277 -               obj =
2278 -                   yaffs_MknodSpecial(parent, dentry->d_name.name, mode, uid,
2279 -                                      gid, old_encode_dev(rdev));
2280 -#else
2281 -               obj =
2282 -                   yaffs_MknodSpecial(parent, dentry->d_name.name, mode, uid,
2283 -                                      gid, rdev);
2284 +               T(YAFFS_TRACE_OS, ("yaffs_mknod: making special\n"));
2285 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0))
2286 +               obj = yaffs_MknodSpecial(parent, dentry->d_name.name, mode, uid,
2287 +                               gid, old_encode_dev(rdev));
2288 +#else
2289 +               obj = yaffs_MknodSpecial(parent, dentry->d_name.name, mode, uid,
2290 +                               gid, rdev);
2291  #endif
2292                 break;
2293         case S_IFREG:           /* file          */
2294 -               T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_mknod: making file\n"));
2295 -               obj =
2296 -                   yaffs_MknodFile(parent, dentry->d_name.name, mode, uid,
2297 -                                   gid);
2298 +               T(YAFFS_TRACE_OS, ("yaffs_mknod: making file\n"));
2299 +               obj = yaffs_MknodFile(parent, dentry->d_name.name, mode, uid,
2300 +                               gid);
2301                 break;
2302         case S_IFDIR:           /* directory */
2303                 T(YAFFS_TRACE_OS,
2304 -                 (KERN_DEBUG "yaffs_mknod: making directory\n"));
2305 -               obj =
2306 -                   yaffs_MknodDirectory(parent, dentry->d_name.name, mode,
2307 -                                        uid, gid);
2308 +                       ("yaffs_mknod: making directory\n"));
2309 +               obj = yaffs_MknodDirectory(parent, dentry->d_name.name, mode,
2310 +                                       uid, gid);
2311                 break;
2312         case S_IFLNK:           /* symlink */
2313 -               T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_mknod: making file\n"));
2314 +               T(YAFFS_TRACE_OS, ("yaffs_mknod: making symlink\n"));
2315                 obj = NULL;     /* Do we ever get here? */
2316                 break;
2317         }
2318 @@ -1083,12 +1287,12 @@ static int yaffs_mknod(struct inode *dir
2319                 inode = yaffs_get_inode(dir->i_sb, mode, rdev, obj);
2320                 d_instantiate(dentry, inode);
2321                 T(YAFFS_TRACE_OS,
2322 -                 (KERN_DEBUG "yaffs_mknod created object %d count = %d\n",
2323 -                  obj->objectId, atomic_read(&inode->i_count)));
2324 +                       ("yaffs_mknod created object %d count = %d\n",
2325 +                       obj->objectId, atomic_read(&inode->i_count)));
2326                 error = 0;
2327         } else {
2328                 T(YAFFS_TRACE_OS,
2329 -                 (KERN_DEBUG "yaffs_mknod failed making object\n"));
2330 +                       ("yaffs_mknod failed making object\n"));
2331                 error = -ENOMEM;
2332         }
2333
2334 @@ -1098,25 +1302,19 @@ static int yaffs_mknod(struct inode *dir
2335  static int yaffs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
2336  {
2337         int retVal;
2338 -       T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_mkdir\n"));
2339 +       T(YAFFS_TRACE_OS, ("yaffs_mkdir\n"));
2340         retVal = yaffs_mknod(dir, dentry, mode | S_IFDIR, 0);
2341 -#if 0
2342 -       /* attempt to fix dir bug - didn't work */
2343 -       if (!retVal) {
2344 -               dget(dentry);
2345 -       }
2346 -#endif
2347         return retVal;
2348  }
2349
2350 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
2351 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0))
2352  static int yaffs_create(struct inode *dir, struct dentry *dentry, int mode,
2353                         struct nameidata *n)
2354  #else
2355  static int yaffs_create(struct inode *dir, struct dentry *dentry, int mode)
2356  #endif
2357  {
2358 -       T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_create\n"));
2359 +       T(YAFFS_TRACE_OS, ("yaffs_create\n"));
2360         return yaffs_mknod(dir, dentry, mode | S_IFREG, 0);
2361  }
2362
2363 @@ -1127,8 +1325,8 @@ static int yaffs_unlink(struct inode *di
2364         yaffs_Device *dev;
2365
2366         T(YAFFS_TRACE_OS,
2367 -         (KERN_DEBUG "yaffs_unlink %d:%s\n", (int)(dir->i_ino),
2368 -          dentry->d_name.name));
2369 +               ("yaffs_unlink %d:%s\n", (int)(dir->i_ino),
2370 +               dentry->d_name.name));
2371
2372         dev = yaffs_InodeToObject(dir)->myDev;
2373
2374 @@ -1151,82 +1349,74 @@ static int yaffs_unlink(struct inode *di
2375   * Create a link...
2376   */
2377  static int yaffs_link(struct dentry *old_dentry, struct inode *dir,
2378 -                     struct dentry *dentry)
2379 +                       struct dentry *dentry)
2380  {
2381         struct inode *inode = old_dentry->d_inode;
2382         yaffs_Object *obj = NULL;
2383         yaffs_Object *link = NULL;
2384         yaffs_Device *dev;
2385
2386 -       T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_link\n"));
2387 +       T(YAFFS_TRACE_OS, ("yaffs_link\n"));
2388
2389         obj = yaffs_InodeToObject(inode);
2390         dev = obj->myDev;
2391
2392         yaffs_GrossLock(dev);
2393
2394 -       if (!S_ISDIR(inode->i_mode))    /* Don't link directories */
2395 -       {
2396 -               link =
2397 -                   yaffs_Link(yaffs_InodeToObject(dir), dentry->d_name.name,
2398 -                              obj);
2399 -       }
2400 +       if (!S_ISDIR(inode->i_mode))            /* Don't link directories */
2401 +               link = yaffs_Link(yaffs_InodeToObject(dir), dentry->d_name.name,
2402 +                       obj);
2403
2404         if (link) {
2405                 old_dentry->d_inode->i_nlink = yaffs_GetObjectLinkCount(obj);
2406                 d_instantiate(dentry, old_dentry->d_inode);
2407                 atomic_inc(&old_dentry->d_inode->i_count);
2408                 T(YAFFS_TRACE_OS,
2409 -                 (KERN_DEBUG "yaffs_link link count %d i_count %d\n",
2410 -                  old_dentry->d_inode->i_nlink,
2411 -                  atomic_read(&old_dentry->d_inode->i_count)));
2412 -
2413 +                       ("yaffs_link link count %d i_count %d\n",
2414 +                       old_dentry->d_inode->i_nlink,
2415 +                       atomic_read(&old_dentry->d_inode->i_count)));
2416         }
2417
2418         yaffs_GrossUnlock(dev);
2419
2420 -       if (link) {
2421 -
2422 +       if (link)
2423                 return 0;
2424 -       }
2425
2426         return -EPERM;
2427  }
2428
2429  static int yaffs_symlink(struct inode *dir, struct dentry *dentry,
2430 -                        const char *symname)
2431 +                               const char *symname)
2432  {
2433         yaffs_Object *obj;
2434         yaffs_Device *dev;
2435 -       uid_t uid = current->fsuid;
2436 -       gid_t gid = (dir->i_mode & S_ISGID) ? dir->i_gid : current->fsgid;
2437 +       uid_t uid = YCRED(current)->fsuid;
2438 +       gid_t gid = (dir->i_mode & S_ISGID) ? dir->i_gid : YCRED(current)->fsgid;
2439
2440 -       T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_symlink\n"));
2441 +       T(YAFFS_TRACE_OS, ("yaffs_symlink\n"));
2442
2443         dev = yaffs_InodeToObject(dir)->myDev;
2444         yaffs_GrossLock(dev);
2445         obj = yaffs_MknodSymLink(yaffs_InodeToObject(dir), dentry->d_name.name,
2446 -                                S_IFLNK | S_IRWXUGO, uid, gid, symname);
2447 +                               S_IFLNK | S_IRWXUGO, uid, gid, symname);
2448         yaffs_GrossUnlock(dev);
2449
2450         if (obj) {
2451 -
2452                 struct inode *inode;
2453
2454                 inode = yaffs_get_inode(dir->i_sb, obj->yst_mode, 0, obj);
2455                 d_instantiate(dentry, inode);
2456 -               T(YAFFS_TRACE_OS, (KERN_DEBUG "symlink created OK\n"));
2457 +               T(YAFFS_TRACE_OS, ("symlink created OK\n"));
2458                 return 0;
2459         } else {
2460 -               T(YAFFS_TRACE_OS, (KERN_DEBUG "symlink not created\n"));
2461 -
2462 +               T(YAFFS_TRACE_OS, ("symlink not created\n"));
2463         }
2464
2465         return -ENOMEM;
2466  }
2467
2468  static int yaffs_sync_object(struct file *file, struct dentry *dentry,
2469 -                            int datasync)
2470 +                               int datasync)
2471  {
2472
2473         yaffs_Object *obj;
2474 @@ -1236,7 +1426,7 @@ static int yaffs_sync_object(struct file
2475
2476         dev = obj->myDev;
2477
2478 -       T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_sync_object\n"));
2479 +       T(YAFFS_TRACE_OS, ("yaffs_sync_object\n"));
2480         yaffs_GrossLock(dev);
2481         yaffs_FlushFile(obj, 1);
2482         yaffs_GrossUnlock(dev);
2483 @@ -1255,41 +1445,36 @@ static int yaffs_rename(struct inode *ol
2484         int retVal = YAFFS_FAIL;
2485         yaffs_Object *target;
2486
2487 -        T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_rename\n"));
2488 +       T(YAFFS_TRACE_OS, ("yaffs_rename\n"));
2489         dev = yaffs_InodeToObject(old_dir)->myDev;
2490
2491         yaffs_GrossLock(dev);
2492
2493         /* Check if the target is an existing directory that is not empty. */
2494 -       target =
2495 -           yaffs_FindObjectByName(yaffs_InodeToObject(new_dir),
2496 -                                  new_dentry->d_name.name);
2497 +       target = yaffs_FindObjectByName(yaffs_InodeToObject(new_dir),
2498 +                               new_dentry->d_name.name);
2499
2500
2501
2502 -       if (target &&
2503 -           target->variantType == YAFFS_OBJECT_TYPE_DIRECTORY &&
2504 -           !list_empty(&target->variant.directoryVariant.children)) {
2505 +       if (target && target->variantType == YAFFS_OBJECT_TYPE_DIRECTORY &&
2506 +               !ylist_empty(&target->variant.directoryVariant.children)) {
2507
2508 -               T(YAFFS_TRACE_OS, (KERN_DEBUG "target is non-empty dir\n"));
2509 +               T(YAFFS_TRACE_OS, ("target is non-empty dir\n"));
2510
2511                 retVal = YAFFS_FAIL;
2512         } else {
2513 -
2514                 /* Now does unlinking internally using shadowing mechanism */
2515 -               T(YAFFS_TRACE_OS, (KERN_DEBUG "calling yaffs_RenameObject\n"));
2516 -
2517 -               retVal =
2518 -                   yaffs_RenameObject(yaffs_InodeToObject(old_dir),
2519 -                                      old_dentry->d_name.name,
2520 -                                      yaffs_InodeToObject(new_dir),
2521 -                                      new_dentry->d_name.name);
2522 +               T(YAFFS_TRACE_OS, ("calling yaffs_RenameObject\n"));
2523
2524 +               retVal = yaffs_RenameObject(yaffs_InodeToObject(old_dir),
2525 +                               old_dentry->d_name.name,
2526 +                               yaffs_InodeToObject(new_dir),
2527 +                               new_dentry->d_name.name);
2528         }
2529         yaffs_GrossUnlock(dev);
2530
2531         if (retVal == YAFFS_OK) {
2532 -               if(target) {
2533 +               if (target) {
2534                         new_dentry->d_inode->i_nlink--;
2535                         mark_inode_dirty(new_dentry->d_inode);
2536                 }
2537 @@ -1298,7 +1483,6 @@ static int yaffs_rename(struct inode *ol
2538         } else {
2539                 return -ENOTEMPTY;
2540         }
2541 -
2542  }
2543
2544  static int yaffs_setattr(struct dentry *dentry, struct iattr *attr)
2545 @@ -1308,15 +1492,15 @@ static int yaffs_setattr(struct dentry *
2546         yaffs_Device *dev;
2547
2548         T(YAFFS_TRACE_OS,
2549 -         (KERN_DEBUG "yaffs_setattr of object %d\n",
2550 -          yaffs_InodeToObject(inode)->objectId));
2551 -
2552 -       if ((error = inode_change_ok(inode, attr)) == 0) {
2553 +               ("yaffs_setattr of object %d\n",
2554 +               yaffs_InodeToObject(inode)->objectId));
2555
2556 +       error = inode_change_ok(inode, attr);
2557 +       if (error == 0) {
2558                 dev = yaffs_InodeToObject(inode)->myDev;
2559                 yaffs_GrossLock(dev);
2560                 if (yaffs_SetAttributes(yaffs_InodeToObject(inode), attr) ==
2561 -                   YAFFS_OK) {
2562 +                               YAFFS_OK) {
2563                         error = 0;
2564                 } else {
2565                         error = -EPERM;
2566 @@ -1328,12 +1512,12 @@ static int yaffs_setattr(struct dentry *
2567         return error;
2568  }
2569
2570 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
2571 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17))
2572  static int yaffs_statfs(struct dentry *dentry, struct kstatfs *buf)
2573  {
2574         yaffs_Device *dev = yaffs_DentryToObject(dentry)->myDev;
2575         struct super_block *sb = dentry->d_sb;
2576 -#elif (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
2577 +#elif (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0))
2578  static int yaffs_statfs(struct super_block *sb, struct kstatfs *buf)
2579  {
2580         yaffs_Device *dev = yaffs_SuperToDevice(sb);
2581 @@ -1343,32 +1527,53 @@ static int yaffs_statfs(struct super_blo
2582         yaffs_Device *dev = yaffs_SuperToDevice(sb);
2583  #endif
2584
2585 -       T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_statfs\n"));
2586 +       T(YAFFS_TRACE_OS, ("yaffs_statfs\n"));
2587
2588         yaffs_GrossLock(dev);
2589
2590         buf->f_type = YAFFS_MAGIC;
2591         buf->f_bsize = sb->s_blocksize;
2592         buf->f_namelen = 255;
2593 -       if (sb->s_blocksize > dev->nDataBytesPerChunk) {
2594 +
2595 +       if (dev->nDataBytesPerChunk & (dev->nDataBytesPerChunk - 1)) {
2596 +               /* Do this if chunk size is not a power of 2 */
2597 +
2598 +               uint64_t bytesInDev;
2599 +               uint64_t bytesFree;
2600 +
2601 +               bytesInDev = ((uint64_t)((dev->endBlock - dev->startBlock + 1))) *
2602 +                       ((uint64_t)(dev->nChunksPerBlock * dev->nDataBytesPerChunk));
2603 +
2604 +               do_div(bytesInDev, sb->s_blocksize); /* bytesInDev becomes the number of blocks */
2605 +               buf->f_blocks = bytesInDev;
2606 +
2607 +               bytesFree  = ((uint64_t)(yaffs_GetNumberOfFreeChunks(dev))) *
2608 +                       ((uint64_t)(dev->nDataBytesPerChunk));
2609 +
2610 +               do_div(bytesFree, sb->s_blocksize);
2611 +
2612 +               buf->f_bfree = bytesFree;
2613 +
2614 +       } else if (sb->s_blocksize > dev->nDataBytesPerChunk) {
2615
2616                 buf->f_blocks =
2617 -                   (dev->endBlock - dev->startBlock +
2618 -                    1) * dev->nChunksPerBlock / (sb->s_blocksize /
2619 -                                                 dev->nDataBytesPerChunk);
2620 +                       (dev->endBlock - dev->startBlock + 1) *
2621 +                       dev->nChunksPerBlock /
2622 +                       (sb->s_blocksize / dev->nDataBytesPerChunk);
2623                 buf->f_bfree =
2624 -                   yaffs_GetNumberOfFreeChunks(dev) / (sb->s_blocksize /
2625 -                                                       dev->nDataBytesPerChunk);
2626 +                       yaffs_GetNumberOfFreeChunks(dev) /
2627 +                       (sb->s_blocksize / dev->nDataBytesPerChunk);
2628         } else {
2629 -
2630                 buf->f_blocks =
2631 -                   (dev->endBlock - dev->startBlock +
2632 -                    1) * dev->nChunksPerBlock * (dev->nDataBytesPerChunk /
2633 -                                                 sb->s_blocksize);
2634 +                       (dev->endBlock - dev->startBlock + 1) *
2635 +                       dev->nChunksPerBlock *
2636 +                       (dev->nDataBytesPerChunk / sb->s_blocksize);
2637 +
2638                 buf->f_bfree =
2639 -                   yaffs_GetNumberOfFreeChunks(dev) * (dev->nDataBytesPerChunk /
2640 -                                                       sb->s_blocksize);
2641 +                       yaffs_GetNumberOfFreeChunks(dev) *
2642 +                       (dev->nDataBytesPerChunk / sb->s_blocksize);
2643         }
2644 +
2645         buf->f_files = 0;
2646         buf->f_ffree = 0;
2647         buf->f_bavail = buf->f_bfree;
2648 @@ -1378,18 +1583,19 @@ static int yaffs_statfs(struct super_blo
2649  }
2650
2651
2652 -/**
2653  static int yaffs_do_sync_fs(struct super_block *sb)
2654  {
2655
2656         yaffs_Device *dev = yaffs_SuperToDevice(sb);
2657 -       T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_do_sync_fs\n"));
2658 +       T(YAFFS_TRACE_OS, ("yaffs_do_sync_fs\n"));
2659
2660 -       if(sb->s_dirt) {
2661 +       if (sb->s_dirt) {
2662                 yaffs_GrossLock(dev);
2663
2664 -               if(dev)
2665 +               if (dev) {
2666 +                       yaffs_FlushEntireDeviceCache(dev);
2667                         yaffs_CheckpointSave(dev);
2668 +               }
2669
2670                 yaffs_GrossUnlock(dev);
2671
2672 @@ -1397,35 +1603,73 @@ static int yaffs_do_sync_fs(struct super
2673         }
2674         return 0;
2675  }
2676 -**/
2677
2678 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
2679 +
2680 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17))
2681  static void yaffs_write_super(struct super_block *sb)
2682  #else
2683  static int yaffs_write_super(struct super_block *sb)
2684  #endif
2685  {
2686
2687 -       T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_write_super\n"));
2688 -#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,18))
2689 -       return 0; /* yaffs_do_sync_fs(sb);*/
2690 +       T(YAFFS_TRACE_OS, ("yaffs_write_super\n"));
2691 +       if (yaffs_auto_checkpoint >= 2)
2692 +               yaffs_do_sync_fs(sb);
2693 +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 18))
2694 +       return 0;
2695  #endif
2696  }
2697
2698
2699 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
2700 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17))
2701  static int yaffs_sync_fs(struct super_block *sb, int wait)
2702  #else
2703  static int yaffs_sync_fs(struct super_block *sb)
2704  #endif
2705  {
2706 +       T(YAFFS_TRACE_OS, ("yaffs_sync_fs\n"));
2707 +
2708 +       if (yaffs_auto_checkpoint >= 1)
2709 +               yaffs_do_sync_fs(sb);
2710 +
2711 +       return 0;
2712 +}
2713 +
2714 +#ifdef YAFFS_USE_OWN_IGET
2715 +
2716 +static struct inode *yaffs_iget(struct super_block *sb, unsigned long ino)
2717 +{
2718 +       struct inode *inode;
2719 +       yaffs_Object *obj;
2720 +       yaffs_Device *dev = yaffs_SuperToDevice(sb);
2721 +
2722 +       T(YAFFS_TRACE_OS,
2723 +               ("yaffs_iget for %lu\n", ino));
2724
2725 -       T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_sync_fs\n"));
2726 +       inode = iget_locked(sb, ino);
2727 +       if (!inode)
2728 +               return ERR_PTR(-ENOMEM);
2729 +       if (!(inode->i_state & I_NEW))
2730 +               return inode;
2731 +
2732 +       /* NB This is called as a side effect of other functions, but
2733 +        * we had to release the lock to prevent deadlocks, so
2734 +        * need to lock again.
2735 +        */
2736
2737 -       return 0; /* yaffs_do_sync_fs(sb);*/
2738 +       yaffs_GrossLock(dev);
2739
2740 +       obj = yaffs_FindObjectByNumber(dev, inode->i_ino);
2741 +
2742 +       yaffs_FillInodeFromObject(inode, obj);
2743 +
2744 +       yaffs_GrossUnlock(dev);
2745 +
2746 +       unlock_new_inode(inode);
2747 +       return inode;
2748  }
2749
2750 +#else
2751
2752  static void yaffs_read_inode(struct inode *inode)
2753  {
2754 @@ -1438,7 +1682,7 @@ static void yaffs_read_inode(struct inod
2755         yaffs_Device *dev = yaffs_SuperToDevice(inode->i_sb);
2756
2757         T(YAFFS_TRACE_OS,
2758 -         (KERN_DEBUG "yaffs_read_inode for %d\n", (int)inode->i_ino));
2759 +               ("yaffs_read_inode for %d\n", (int)inode->i_ino));
2760
2761         yaffs_GrossLock(dev);
2762
2763 @@ -1449,18 +1693,20 @@ static void yaffs_read_inode(struct inod
2764         yaffs_GrossUnlock(dev);
2765  }
2766
2767 -static LIST_HEAD(yaffs_dev_list);
2768 +#endif
2769 +
2770 +static YLIST_HEAD(yaffs_dev_list);
2771
2772 -#if 0 // not used
2773 +#if 0 /* not used */
2774  static int yaffs_remount_fs(struct super_block *sb, int *flags, char *data)
2775  {
2776         yaffs_Device    *dev = yaffs_SuperToDevice(sb);
2777
2778 -       if( *flags & MS_RDONLY ) {
2779 +       if (*flags & MS_RDONLY) {
2780                 struct mtd_info *mtd = yaffs_SuperToDevice(sb)->genericDevice;
2781
2782                 T(YAFFS_TRACE_OS,
2783 -                       (KERN_DEBUG "yaffs_remount_fs: %s: RO\n", dev->name ));
2784 +                       ("yaffs_remount_fs: %s: RO\n", dev->name));
2785
2786                 yaffs_GrossLock(dev);
2787
2788 @@ -1472,10 +1718,9 @@ static int yaffs_remount_fs(struct super
2789                         mtd->sync(mtd);
2790
2791                 yaffs_GrossUnlock(dev);
2792 -       }
2793 -       else {
2794 +       } else {
2795                 T(YAFFS_TRACE_OS,
2796 -                       (KERN_DEBUG "yaffs_remount_fs: %s: RW\n", dev->name ));
2797 +                       ("yaffs_remount_fs: %s: RW\n", dev->name));
2798         }
2799
2800         return 0;
2801 @@ -1486,7 +1731,7 @@ static void yaffs_put_super(struct super
2802  {
2803         yaffs_Device *dev = yaffs_SuperToDevice(sb);
2804
2805 -       T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_put_super\n"));
2806 +       T(YAFFS_TRACE_OS, ("yaffs_put_super\n"));
2807
2808         yaffs_GrossLock(dev);
2809
2810 @@ -1494,18 +1739,17 @@ static void yaffs_put_super(struct super
2811
2812         yaffs_CheckpointSave(dev);
2813
2814 -       if (dev->putSuperFunc) {
2815 +       if (dev->putSuperFunc)
2816                 dev->putSuperFunc(sb);
2817 -       }
2818
2819         yaffs_Deinitialise(dev);
2820
2821         yaffs_GrossUnlock(dev);
2822
2823         /* we assume this is protected by lock_kernel() in mount/umount */
2824 -       list_del(&dev->devList);
2825 +       ylist_del(&dev->devList);
2826
2827 -       if(dev->spareBuffer){
2828 +       if (dev->spareBuffer) {
2829                 YFREE(dev->spareBuffer);
2830                 dev->spareBuffer = NULL;
2831         }
2832 @@ -1516,12 +1760,10 @@ static void yaffs_put_super(struct super
2833
2834  static void yaffs_MTDPutSuper(struct super_block *sb)
2835  {
2836 -
2837         struct mtd_info *mtd = yaffs_SuperToDevice(sb)->genericDevice;
2838
2839 -       if (mtd->sync) {
2840 +       if (mtd->sync)
2841                 mtd->sync(mtd);
2842 -       }
2843
2844         put_mtd_device(mtd);
2845  }
2846 @@ -1531,9 +1773,9 @@ static void yaffs_MarkSuperBlockDirty(vo
2847  {
2848         struct super_block *sb = (struct super_block *)vsb;
2849
2850 -       T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_MarkSuperBlockDirty() sb = %p\n",sb));
2851 -//     if(sb)
2852 -//             sb->s_dirt = 1;
2853 +       T(YAFFS_TRACE_OS, ("yaffs_MarkSuperBlockDirty() sb = %p\n", sb));
2854 +       if (sb)
2855 +               sb->s_dirt = 1;
2856  }
2857
2858  typedef struct {
2859 @@ -1546,48 +1788,48 @@ typedef struct {
2860  #define MAX_OPT_LEN 20
2861  static int yaffs_parse_options(yaffs_options *options, const char *options_str)
2862  {
2863 -       char cur_opt[MAX_OPT_LEN+1];
2864 +       char cur_opt[MAX_OPT_LEN + 1];
2865         int p;
2866         int error = 0;
2867
2868         /* Parse through the options which is a comma seperated list */
2869
2870 -       while(options_str && *options_str && !error){
2871 -               memset(cur_opt,0,MAX_OPT_LEN+1);
2872 +       while (options_str && *options_str && !error) {
2873 +               memset(cur_opt, 0, MAX_OPT_LEN + 1);
2874                 p = 0;
2875
2876 -               while(*options_str && *options_str != ','){
2877 -                       if(p < MAX_OPT_LEN){
2878 +               while (*options_str && *options_str != ',') {
2879 +                       if (p < MAX_OPT_LEN) {
2880                                 cur_opt[p] = *options_str;
2881                                 p++;
2882                         }
2883                         options_str++;
2884                 }
2885
2886 -               if(!strcmp(cur_opt,"inband-tags"))
2887 +               if (!strcmp(cur_opt, "inband-tags"))
2888                         options->inband_tags = 1;
2889 -               else if(!strcmp(cur_opt,"no-cache"))
2890 +               else if (!strcmp(cur_opt, "no-cache"))
2891                         options->no_cache = 1;
2892 -               else if(!strcmp(cur_opt,"no-checkpoint-read"))
2893 +               else if (!strcmp(cur_opt, "no-checkpoint-read"))
2894                         options->skip_checkpoint_read = 1;
2895 -               else if(!strcmp(cur_opt,"no-checkpoint-write"))
2896 +               else if (!strcmp(cur_opt, "no-checkpoint-write"))
2897                         options->skip_checkpoint_write = 1;
2898 -               else if(!strcmp(cur_opt,"no-checkpoint")){
2899 +               else if (!strcmp(cur_opt, "no-checkpoint")) {
2900                         options->skip_checkpoint_read = 1;
2901                         options->skip_checkpoint_write = 1;
2902                 } else {
2903 -                       printk(KERN_INFO "yaffs: Bad mount option \"%s\"\n",cur_opt);
2904 +                       printk(KERN_INFO "yaffs: Bad mount option \"%s\"\n",
2905 +                                       cur_opt);
2906                         error = 1;
2907                 }
2908 -
2909         }
2910
2911         return error;
2912  }
2913
2914  static struct super_block *yaffs_internal_read_super(int yaffsVersion,
2915 -                                                    struct super_block *sb,
2916 -                                                    void *data, int silent)
2917 +                                               struct super_block *sb,
2918 +                                               void *data, int silent)
2919  {
2920         int nBlocks;
2921         struct inode *inode = NULL;
2922 @@ -1602,6 +1844,7 @@ static struct super_block *yaffs_interna
2923
2924         sb->s_magic = YAFFS_MAGIC;
2925         sb->s_op = &yaffs_super_ops;
2926 +       sb->s_flags |= MS_NOATIME;
2927
2928         if (!sb)
2929                 printk(KERN_INFO "yaffs: sb is NULL\n");
2930 @@ -1614,14 +1857,14 @@ static struct super_block *yaffs_interna
2931                        sb->s_dev,
2932                        yaffs_devname(sb, devname_buf));
2933
2934 -       if(!data_str)
2935 +       if (!data_str)
2936                 data_str = "";
2937
2938 -       printk(KERN_INFO "yaffs: passed flags \"%s\"\n",data_str);
2939 +       printk(KERN_INFO "yaffs: passed flags \"%s\"\n", data_str);
2940
2941 -       memset(&options,0,sizeof(options));
2942 +       memset(&options, 0, sizeof(options));
2943
2944 -       if(yaffs_parse_options(&options,data_str)){
2945 +       if (yaffs_parse_options(&options, data_str)) {
2946                 /* Option parsing failed */
2947                 return NULL;
2948         }
2949 @@ -1645,9 +1888,9 @@ static struct super_block *yaffs_interna
2950                                yaffs_devname(sb, devname_buf)));
2951
2952         /* Check it's an mtd device..... */
2953 -       if (MAJOR(sb->s_dev) != MTD_BLOCK_MAJOR) {
2954 +       if (MAJOR(sb->s_dev) != MTD_BLOCK_MAJOR)
2955                 return NULL;    /* This isn't an mtd device */
2956 -       }
2957 +
2958         /* Get the device */
2959         mtd = get_mtd_device(NULL, MINOR(sb->s_dev));
2960         if (!mtd) {
2961 @@ -1673,29 +1916,23 @@ static struct super_block *yaffs_interna
2962         T(YAFFS_TRACE_OS, (" %s %d\n", WRITE_SIZE_STR, WRITE_SIZE(mtd)));
2963         T(YAFFS_TRACE_OS, (" oobsize %d\n", mtd->oobsize));
2964         T(YAFFS_TRACE_OS, (" erasesize %d\n", mtd->erasesize));
2965 -       T(YAFFS_TRACE_OS, (" size %d\n", mtd->size));
2966 +#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 29)
2967 +       T(YAFFS_TRACE_OS, (" size %u\n", mtd->size));
2968 +#else
2969 +       T(YAFFS_TRACE_OS, (" size %lld\n", mtd->size));
2970 +#endif
2971
2972  #ifdef CONFIG_YAFFS_AUTO_YAFFS2
2973
2974 -       if (yaffsVersion == 1 &&
2975 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
2976 -           mtd->writesize >= 2048) {
2977 -#else
2978 -           mtd->oobblock >= 2048) {
2979 -#endif
2980 -           T(YAFFS_TRACE_ALWAYS,("yaffs: auto selecting yaffs2\n"));
2981 -           yaffsVersion = 2;
2982 +       if (yaffsVersion == 1 && WRITE_SIZE(mtd) >= 2048) {
2983 +               T(YAFFS_TRACE_ALWAYS, ("yaffs: auto selecting yaffs2\n"));
2984 +               yaffsVersion = 2;
2985         }
2986
2987         /* Added NCB 26/5/2006 for completeness */
2988 -       if (yaffsVersion == 2 &&
2989 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
2990 -           mtd->writesize == 512) {
2991 -#else
2992 -           mtd->oobblock == 512) {
2993 -#endif
2994 -           T(YAFFS_TRACE_ALWAYS,("yaffs: auto selecting yaffs1\n"));
2995 -           yaffsVersion = 1;
2996 +       if (yaffsVersion == 2 && !options.inband_tags && WRITE_SIZE(mtd) == 512) {
2997 +               T(YAFFS_TRACE_ALWAYS, ("yaffs: auto selecting yaffs1\n"));
2998 +               yaffsVersion = 1;
2999         }
3000
3001  #endif
3002 @@ -1707,7 +1944,7 @@ static struct super_block *yaffs_interna
3003                     !mtd->block_markbad ||
3004                     !mtd->read ||
3005                     !mtd->write ||
3006 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
3007 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17))
3008                     !mtd->read_oob || !mtd->write_oob) {
3009  #else
3010                     !mtd->write_ecc ||
3011 @@ -1719,12 +1956,9 @@ static struct super_block *yaffs_interna
3012                         return NULL;
3013                 }
3014
3015 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
3016 -               if (mtd->writesize < YAFFS_MIN_YAFFS2_CHUNK_SIZE ||
3017 -#else
3018 -               if (mtd->oobblock < YAFFS_MIN_YAFFS2_CHUNK_SIZE ||
3019 -#endif
3020 -                   mtd->oobsize < YAFFS_MIN_YAFFS2_SPARE_SIZE) {
3021 +               if ((WRITE_SIZE(mtd) < YAFFS_MIN_YAFFS2_CHUNK_SIZE ||
3022 +                   mtd->oobsize < YAFFS_MIN_YAFFS2_SPARE_SIZE) &&
3023 +                   !options.inband_tags) {
3024                         T(YAFFS_TRACE_ALWAYS,
3025                           ("yaffs: MTD device does not have the "
3026                            "right page sizes\n"));
3027 @@ -1735,7 +1969,7 @@ static struct super_block *yaffs_interna
3028                 if (!mtd->erase ||
3029                     !mtd->read ||
3030                     !mtd->write ||
3031 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
3032 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17))
3033                     !mtd->read_oob || !mtd->write_oob) {
3034  #else
3035                     !mtd->write_ecc ||
3036 @@ -1761,7 +1995,7 @@ static struct super_block *yaffs_interna
3037          * Set the yaffs_Device up for mtd
3038          */
3039
3040 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
3041 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0))
3042         sb->s_fs_info = dev = kmalloc(sizeof(yaffs_Device), GFP_KERNEL);
3043  #else
3044         sb->u.generic_sbp = dev = kmalloc(sizeof(yaffs_Device), GFP_KERNEL);
3045 @@ -1780,13 +2014,15 @@ static struct super_block *yaffs_interna
3046
3047         /* Set up the memory size parameters.... */
3048
3049 -       nBlocks = mtd->size / (YAFFS_CHUNKS_PER_BLOCK * YAFFS_BYTES_PER_CHUNK);
3050 +       nBlocks = YCALCBLOCKS(mtd->size, (YAFFS_CHUNKS_PER_BLOCK * YAFFS_BYTES_PER_CHUNK));
3051 +
3052         dev->startBlock = 0;
3053         dev->endBlock = nBlocks - 1;
3054         dev->nChunksPerBlock = YAFFS_CHUNKS_PER_BLOCK;
3055 -       dev->nDataBytesPerChunk = YAFFS_BYTES_PER_CHUNK;
3056 +       dev->totalBytesPerChunk = YAFFS_BYTES_PER_CHUNK;
3057         dev->nReservedBlocks = 5;
3058         dev->nShortOpCaches = (options.no_cache) ? 0 : 10;
3059 +       dev->inbandTags = options.inband_tags;
3060
3061         /* ... and the functions. */
3062         if (yaffsVersion == 2) {
3063 @@ -1798,20 +2034,19 @@ static struct super_block *yaffs_interna
3064                 dev->queryNANDBlock = nandmtd2_QueryNANDBlock;
3065                 dev->spareBuffer = YMALLOC(mtd->oobsize);
3066                 dev->isYaffs2 = 1;
3067 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
3068 -               dev->nDataBytesPerChunk = mtd->writesize;
3069 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17))
3070 +               dev->totalBytesPerChunk = mtd->writesize;
3071                 dev->nChunksPerBlock = mtd->erasesize / mtd->writesize;
3072  #else
3073 -               dev->nDataBytesPerChunk = mtd->oobblock;
3074 +               dev->totalBytesPerChunk = mtd->oobblock;
3075                 dev->nChunksPerBlock = mtd->erasesize / mtd->oobblock;
3076  #endif
3077 -               nBlocks = mtd->size / mtd->erasesize;
3078 +               nBlocks = YCALCBLOCKS(mtd->size, mtd->erasesize);
3079
3080 -               dev->nCheckpointReservedBlocks = CONFIG_YAFFS_CHECKPOINT_RESERVED_BLOCKS;
3081                 dev->startBlock = 0;
3082                 dev->endBlock = nBlocks - 1;
3083         } else {
3084 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
3085 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17))
3086                 /* use the MTD interface in yaffs_mtdif1.c */
3087                 dev->writeChunkWithTagsToNAND =
3088                         nandmtd1_WriteChunkWithTagsToNAND;
3089 @@ -1847,7 +2082,7 @@ static struct super_block *yaffs_interna
3090         dev->skipCheckpointWrite = options.skip_checkpoint_write;
3091
3092         /* we assume this is protected by lock_kernel() in mount/umount */
3093 -       list_add_tail(&dev->devList, &yaffs_dev_list);
3094 +       ylist_add_tail(&dev->devList, &yaffs_dev_list);
3095
3096         init_MUTEX(&dev->grossLock);
3097
3098 @@ -1884,20 +2119,23 @@ static struct super_block *yaffs_interna
3099                 return NULL;
3100         }
3101         sb->s_root = root;
3102 +       sb->s_dirt = !dev->isCheckpointed;
3103 +       T(YAFFS_TRACE_ALWAYS,
3104 +         ("yaffs_read_super: isCheckpointed %d\n", dev->isCheckpointed));
3105
3106         T(YAFFS_TRACE_OS, ("yaffs_read_super: done\n"));
3107         return sb;
3108  }
3109
3110
3111 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
3112 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0))
3113  static int yaffs_internal_read_super_mtd(struct super_block *sb, void *data,
3114                                          int silent)
3115  {
3116         return yaffs_internal_read_super(1, sb, data, silent) ? 0 : -EINVAL;
3117  }
3118
3119 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
3120 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17))
3121  static int yaffs_read_super(struct file_system_type *fs,
3122                             int flags, const char *dev_name,
3123                             void *data, struct vfsmount *mnt)
3124 @@ -1938,14 +2176,14 @@ static DECLARE_FSTYPE(yaffs_fs_type, "ya
3125
3126  #ifdef CONFIG_YAFFS_YAFFS2
3127
3128 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
3129 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0))
3130  static int yaffs2_internal_read_super_mtd(struct super_block *sb, void *data,
3131                                           int silent)
3132  {
3133         return yaffs_internal_read_super(2, sb, data, silent) ? 0 : -EINVAL;
3134  }
3135
3136 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
3137 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17))
3138  static int yaffs2_read_super(struct file_system_type *fs,
3139                         int flags, const char *dev_name, void *data,
3140                         struct vfsmount *mnt)
3141 @@ -1990,12 +2228,12 @@ static char *yaffs_dump_dev(char *buf, y
3142  {
3143         buf += sprintf(buf, "startBlock......... %d\n", dev->startBlock);
3144         buf += sprintf(buf, "endBlock........... %d\n", dev->endBlock);
3145 +       buf += sprintf(buf, "totalBytesPerChunk. %d\n", dev->totalBytesPerChunk);
3146         buf += sprintf(buf, "nDataBytesPerChunk. %d\n", dev->nDataBytesPerChunk);
3147         buf += sprintf(buf, "chunkGroupBits..... %d\n", dev->chunkGroupBits);
3148         buf += sprintf(buf, "chunkGroupSize..... %d\n", dev->chunkGroupSize);
3149         buf += sprintf(buf, "nErasedBlocks...... %d\n", dev->nErasedBlocks);
3150         buf += sprintf(buf, "nReservedBlocks.... %d\n", dev->nReservedBlocks);
3151 -       buf += sprintf(buf, "nCheckptResBlocks.. %d\n", dev->nCheckpointReservedBlocks);
3152         buf += sprintf(buf, "blocksInCheckpoint. %d\n", dev->blocksInCheckpoint);
3153         buf += sprintf(buf, "nTnodesCreated..... %d\n", dev->nTnodesCreated);
3154         buf += sprintf(buf, "nFreeTnodes........ %d\n", dev->nFreeTnodes);
3155 @@ -2006,10 +2244,8 @@ static char *yaffs_dump_dev(char *buf, y
3156         buf += sprintf(buf, "nPageReads......... %d\n", dev->nPageReads);
3157         buf += sprintf(buf, "nBlockErasures..... %d\n", dev->nBlockErasures);
3158         buf += sprintf(buf, "nGCCopies.......... %d\n", dev->nGCCopies);
3159 -       buf +=
3160 -           sprintf(buf, "garbageCollections. %d\n", dev->garbageCollections);
3161 -       buf +=
3162 -           sprintf(buf, "passiveGCs......... %d\n",
3163 +       buf += sprintf(buf, "garbageCollections. %d\n", dev->garbageCollections);
3164 +       buf += sprintf(buf, "passiveGCs......... %d\n",
3165                     dev->passiveGarbageCollections);
3166         buf += sprintf(buf, "nRetriedWrites..... %d\n", dev->nRetriedWrites);
3167         buf += sprintf(buf, "nShortOpCaches..... %d\n", dev->nShortOpCaches);
3168 @@ -2025,6 +2261,7 @@ static char *yaffs_dump_dev(char *buf, y
3169             sprintf(buf, "nBackgroudDeletions %d\n", dev->nBackgroundDeletions);
3170         buf += sprintf(buf, "useNANDECC......... %d\n", dev->useNANDECC);
3171         buf += sprintf(buf, "isYaffs2........... %d\n", dev->isYaffs2);
3172 +       buf += sprintf(buf, "inbandTags......... %d\n", dev->inbandTags);
3173
3174         return buf;
3175  }
3176 @@ -2033,7 +2270,7 @@ static int yaffs_proc_read(char *page,
3177                            char **start,
3178                            off_t offset, int count, int *eof, void *data)
3179  {
3180 -       struct list_head *item;
3181 +       struct ylist_head *item;
3182         char *buf = page;
3183         int step = offset;
3184         int n = 0;
3185 @@ -2057,8 +2294,8 @@ static int yaffs_proc_read(char *page,
3186         lock_kernel();
3187
3188         /* Locate and print the Nth entry.  Order N-squared but N is small. */
3189 -       list_for_each(item, &yaffs_dev_list) {
3190 -               yaffs_Device *dev = list_entry(item, yaffs_Device, devList);
3191 +       ylist_for_each(item, &yaffs_dev_list) {
3192 +               yaffs_Device *dev = ylist_entry(item, yaffs_Device, devList);
3193                 if (n < step) {
3194                         n++;
3195                         continue;
3196 @@ -2119,7 +2356,7 @@ static int yaffs_proc_write(struct file
3197         char *end;
3198         char *mask_name;
3199         const char *x;
3200 -       char substring[MAX_MASK_NAME_LENGTH+1];
3201 +       char substring[MAX_MASK_NAME_LENGTH + 1];
3202         int i;
3203         int done = 0;
3204         int add, len = 0;
3205 @@ -2129,9 +2366,8 @@ static int yaffs_proc_write(struct file
3206
3207         while (!done && (pos < count)) {
3208                 done = 1;
3209 -               while ((pos < count) && isspace(buf[pos])) {
3210 +               while ((pos < count) && isspace(buf[pos]))
3211                         pos++;
3212 -               }
3213
3214                 switch (buf[pos]) {
3215                 case '+':
3216 @@ -2148,20 +2384,21 @@ static int yaffs_proc_write(struct file
3217                 mask_name = NULL;
3218
3219                 mask_bitfield = simple_strtoul(buf + pos, &end, 0);
3220 +
3221                 if (end > buf + pos) {
3222                         mask_name = "numeral";
3223                         len = end - (buf + pos);
3224                         pos += len;
3225                         done = 0;
3226                 } else {
3227 -                       for(x = buf + pos, i = 0;
3228 -                           (*x == '_' || (*x >='a' && *x <= 'z')) &&
3229 -                           i <MAX_MASK_NAME_LENGTH; x++, i++, pos++)
3230 -                           substring[i] = *x;
3231 +                       for (x = buf + pos, i = 0;
3232 +                           (*x == '_' || (*x >= 'a' && *x <= 'z')) &&
3233 +                           i < MAX_MASK_NAME_LENGTH; x++, i++, pos++)
3234 +                               substring[i] = *x;
3235                         substring[i] = '\0';
3236
3237                         for (i = 0; mask_flags[i].mask_name != NULL; i++) {
3238 -                               if(strcmp(substring,mask_flags[i].mask_name) == 0){
3239 +                               if (strcmp(substring, mask_flags[i].mask_name) == 0) {
3240                                         mask_name = mask_flags[i].mask_name;
3241                                         mask_bitfield = mask_flags[i].mask_bitfield;
3242                                         done = 0;
3243 @@ -2172,7 +2409,7 @@ static int yaffs_proc_write(struct file
3244
3245                 if (mask_name != NULL) {
3246                         done = 0;
3247 -                       switch(add) {
3248 +                       switch (add) {
3249                         case '-':
3250                                 rg &= ~mask_bitfield;
3251                                 break;
3252 @@ -2191,13 +2428,13 @@ static int yaffs_proc_write(struct file
3253
3254         yaffs_traceMask = rg | YAFFS_TRACE_ALWAYS;
3255
3256 -       printk("new trace = 0x%08X\n",yaffs_traceMask);
3257 +       printk(KERN_DEBUG "new trace = 0x%08X\n", yaffs_traceMask);
3258
3259         if (rg & YAFFS_TRACE_ALWAYS) {
3260                 for (i = 0; mask_flags[i].mask_name != NULL; i++) {
3261                         char flag;
3262                         flag = ((rg & mask_flags[i].mask_bitfield) == mask_flags[i].mask_bitfield) ? '+' : '-';
3263 -                       printk("%c%s\n", flag, mask_flags[i].mask_name);
3264 +                       printk(KERN_DEBUG "%c%s\n", flag, mask_flags[i].mask_name);
3265                 }
3266         }
3267
3268 @@ -2211,12 +2448,8 @@ struct file_system_to_install {
3269  };
3270
3271  static struct file_system_to_install fs_to_install[] = {
3272 -//#ifdef CONFIG_YAFFS_YAFFS1
3273         {&yaffs_fs_type, 0},
3274 -//#endif
3275 -//#ifdef CONFIG_YAFFS_YAFFS2
3276         {&yaffs2_fs_type, 0},
3277 -//#endif
3278         {NULL, 0}
3279  };
3280
3281 @@ -2231,15 +2464,14 @@ static int __init init_yaffs_fs(void)
3282         /* Install the proc_fs entry */
3283         my_proc_entry = create_proc_entry("yaffs",
3284                                                S_IRUGO | S_IFREG,
3285 -                                              &proc_root);
3286 +                                              YPROC_ROOT);
3287
3288         if (my_proc_entry) {
3289                 my_proc_entry->write_proc = yaffs_proc_write;
3290                 my_proc_entry->read_proc = yaffs_proc_read;
3291                 my_proc_entry->data = NULL;
3292 -       } else {
3293 +       } else
3294                 return -ENOMEM;
3295 -       }
3296
3297         /* Now add the file system entries */
3298
3299 @@ -2247,9 +2479,8 @@ static int __init init_yaffs_fs(void)
3300
3301         while (fsinst->fst && !error) {
3302                 error = register_filesystem(fsinst->fst);
3303 -               if (!error) {
3304 +               if (!error)
3305                         fsinst->installed = 1;
3306 -               }
3307                 fsinst++;
3308         }
3309
3310 @@ -2277,7 +2508,7 @@ static void __exit exit_yaffs_fs(void)
3311         T(YAFFS_TRACE_ALWAYS, ("yaffs " __DATE__ " " __TIME__
3312                                " removing. \n"));
3313
3314 -       remove_proc_entry("yaffs", &proc_root);
3315 +       remove_proc_entry("yaffs", YPROC_ROOT);
3316
3317         fsinst = fs_to_install;
3318
3319 @@ -2288,7 +2519,6 @@ static void __exit exit_yaffs_fs(void)
3320                 }
3321                 fsinst++;
3322         }
3323 -
3324  }
3325
3326  module_init(init_yaffs_fs)
3327 --- /dev/null
3328 +++ b/fs/yaffs2/yaffs_getblockinfo.h
3329 @@ -0,0 +1,34 @@
3330 +/*
3331 + * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
3332 + *
3333 + * Copyright (C) 2002-2007 Aleph One Ltd.
3334 + *   for Toby Churchill Ltd and Brightstar Engineering
3335 + *
3336 + * Created by Charles Manning <charles@aleph1.co.uk>
3337 + *
3338 + * This program is free software; you can redistribute it and/or modify
3339 + * it under the terms of the GNU Lesser General Public License version 2.1 as
3340 + * published by the Free Software Foundation.
3341 + *
3342 + * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL.
3343 + */
3344 +
3345 +#ifndef __YAFFS_GETBLOCKINFO_H__
3346 +#define __YAFFS_GETBLOCKINFO_H__
3347 +
3348 +#include "yaffs_guts.h"
3349 +
3350 +/* Function to manipulate block info */
3351 +static Y_INLINE yaffs_BlockInfo *yaffs_GetBlockInfo(yaffs_Device * dev, int blk)
3352 +{
3353 +       if (blk < dev->internalStartBlock || blk > dev->internalEndBlock) {
3354 +               T(YAFFS_TRACE_ERROR,
3355 +                 (TSTR
3356 +                  ("**>> yaffs: getBlockInfo block %d is not valid" TENDSTR),
3357 +                  blk));
3358 +               YBUG();
3359 +       }
3360 +       return &dev->blockInfo[blk - dev->internalStartBlock];
3361 +}
3362 +
3363 +#endif
3364 --- a/fs/yaffs2/yaffs_guts.c
3365 +++ b/fs/yaffs2/yaffs_guts.c
3366 @@ -12,16 +12,17 @@
3367   */
3368
3369  const char *yaffs_guts_c_version =
3370 -    "$Id: yaffs_guts.c,v 1.49 2007-05-15 20:07:40 charles Exp $";
3371 +    "$Id: yaffs_guts.c,v 1.82 2009-03-09 04:24:17 charles Exp $";
3372
3373  #include "yportenv.h"
3374
3375  #include "yaffsinterface.h"
3376  #include "yaffs_guts.h"
3377  #include "yaffs_tagsvalidity.h"
3378 +#include "yaffs_getblockinfo.h"
3379
3380  #include "yaffs_tagscompat.h"
3381 -#ifndef  CONFIG_YAFFS_USE_OWN_SORT
3382 +#ifndef CONFIG_YAFFS_USE_OWN_SORT
3383  #include "yaffs_qsort.h"
3384  #endif
3385  #include "yaffs_nand.h"
3386 @@ -32,116 +33,116 @@ const char *yaffs_guts_c_version =
3387  #include "yaffs_packedtags2.h"
3388
3389
3390 -#ifdef CONFIG_YAFFS_WINCE
3391 -void yfsd_LockYAFFS(BOOL fsLockOnly);
3392 -void yfsd_UnlockYAFFS(BOOL fsLockOnly);
3393 -#endif
3394 -
3395  #define YAFFS_PASSIVE_GC_CHUNKS 2
3396
3397  #include "yaffs_ecc.h"
3398
3399
3400  /* Robustification (if it ever comes about...) */
3401 -static void yaffs_RetireBlock(yaffs_Device * dev, int blockInNAND);
3402 -static void yaffs_HandleWriteChunkError(yaffs_Device * dev, int chunkInNAND, int erasedOk);
3403 -static void yaffs_HandleWriteChunkOk(yaffs_Device * dev, int chunkInNAND,
3404 -                                    const __u8 * data,
3405 -                                    const yaffs_ExtendedTags * tags);
3406 -static void yaffs_HandleUpdateChunk(yaffs_Device * dev, int chunkInNAND,
3407 -                                   const yaffs_ExtendedTags * tags);
3408 +static void yaffs_RetireBlock(yaffs_Device *dev, int blockInNAND);
3409 +static void yaffs_HandleWriteChunkError(yaffs_Device *dev, int chunkInNAND,
3410 +               int erasedOk);
3411 +static void yaffs_HandleWriteChunkOk(yaffs_Device *dev, int chunkInNAND,
3412 +                               const __u8 *data,
3413 +                               const yaffs_ExtendedTags *tags);
3414 +static void yaffs_HandleUpdateChunk(yaffs_Device *dev, int chunkInNAND,
3415 +                               const yaffs_ExtendedTags *tags);
3416
3417  /* Other local prototypes */
3418 -static int yaffs_UnlinkObject( yaffs_Object *obj);
3419 +static int yaffs_UnlinkObject(yaffs_Object *obj);
3420  static int yaffs_ObjectHasCachedWriteData(yaffs_Object *obj);
3421
3422  static void yaffs_HardlinkFixup(yaffs_Device *dev, yaffs_Object *hardList);
3423
3424 -static int yaffs_WriteNewChunkWithTagsToNAND(yaffs_Device * dev,
3425 -                                            const __u8 * buffer,
3426 -                                            yaffs_ExtendedTags * tags,
3427 -                                            int useReserve);
3428 -static int yaffs_PutChunkIntoFile(yaffs_Object * in, int chunkInInode,
3429 -                                 int chunkInNAND, int inScan);
3430 -
3431 -static yaffs_Object *yaffs_CreateNewObject(yaffs_Device * dev, int number,
3432 -                                          yaffs_ObjectType type);
3433 -static void yaffs_AddObjectToDirectory(yaffs_Object * directory,
3434 -                                      yaffs_Object * obj);
3435 -static int yaffs_UpdateObjectHeader(yaffs_Object * in, const YCHAR * name,
3436 -                                   int force, int isShrink, int shadows);
3437 -static void yaffs_RemoveObjectFromDirectory(yaffs_Object * obj);
3438 +static int yaffs_WriteNewChunkWithTagsToNAND(yaffs_Device *dev,
3439 +                                       const __u8 *buffer,
3440 +                                       yaffs_ExtendedTags *tags,
3441 +                                       int useReserve);
3442 +static int yaffs_PutChunkIntoFile(yaffs_Object *in, int chunkInInode,
3443 +                               int chunkInNAND, int inScan);
3444 +
3445 +static yaffs_Object *yaffs_CreateNewObject(yaffs_Device *dev, int number,
3446 +                                       yaffs_ObjectType type);
3447 +static void yaffs_AddObjectToDirectory(yaffs_Object *directory,
3448 +                               yaffs_Object *obj);
3449 +static int yaffs_UpdateObjectHeader(yaffs_Object *in, const YCHAR *name,
3450 +                               int force, int isShrink, int shadows);
3451 +static void yaffs_RemoveObjectFromDirectory(yaffs_Object *obj);
3452  static int yaffs_CheckStructures(void);
3453 -static int yaffs_DeleteWorker(yaffs_Object * in, yaffs_Tnode * tn, __u32 level,
3454 -                             int chunkOffset, int *limit);
3455 -static int yaffs_DoGenericObjectDeletion(yaffs_Object * in);
3456 -
3457 -static yaffs_BlockInfo *yaffs_GetBlockInfo(yaffs_Device * dev, int blockNo);
3458 -
3459 -static __u8 *yaffs_GetTempBuffer(yaffs_Device * dev, int lineNo);
3460 -static void yaffs_ReleaseTempBuffer(yaffs_Device * dev, __u8 * buffer,
3461 -                                   int lineNo);
3462 +static int yaffs_DeleteWorker(yaffs_Object *in, yaffs_Tnode *tn, __u32 level,
3463 +                       int chunkOffset, int *limit);
3464 +static int yaffs_DoGenericObjectDeletion(yaffs_Object *in);
3465 +
3466 +static yaffs_BlockInfo *yaffs_GetBlockInfo(yaffs_Device *dev, int blockNo);
3467
3468 -static int yaffs_CheckChunkErased(struct yaffs_DeviceStruct *dev,
3469 -                                 int chunkInNAND);
3470
3471 -static int yaffs_UnlinkWorker(yaffs_Object * obj);
3472 -static void yaffs_DestroyObject(yaffs_Object * obj);
3473 +static int yaffs_CheckChunkErased(struct yaffs_DeviceStruct *dev,
3474 +                               int chunkInNAND);
3475
3476 -static int yaffs_TagsMatch(const yaffs_ExtendedTags * tags, int objectId,
3477 -                          int chunkInObject);
3478 +static int yaffs_UnlinkWorker(yaffs_Object *obj);
3479
3480 -loff_t yaffs_GetFileSize(yaffs_Object * obj);
3481 +static int yaffs_TagsMatch(const yaffs_ExtendedTags *tags, int objectId,
3482 +                       int chunkInObject);
3483
3484 -static int yaffs_AllocateChunk(yaffs_Device * dev, int useReserve, yaffs_BlockInfo **blockUsedPtr);
3485 +static int yaffs_AllocateChunk(yaffs_Device *dev, int useReserve,
3486 +                               yaffs_BlockInfo **blockUsedPtr);
3487
3488 -static void yaffs_VerifyFreeChunks(yaffs_Device * dev);
3489 +static void yaffs_VerifyFreeChunks(yaffs_Device *dev);
3490
3491  static void yaffs_CheckObjectDetailsLoaded(yaffs_Object *in);
3492
3493 +static void yaffs_VerifyDirectory(yaffs_Object *directory);
3494  #ifdef YAFFS_PARANOID
3495 -static int yaffs_CheckFileSanity(yaffs_Object * in);
3496 +static int yaffs_CheckFileSanity(yaffs_Object *in);
3497  #else
3498  #define yaffs_CheckFileSanity(in)
3499  #endif
3500
3501 -static void yaffs_InvalidateWholeChunkCache(yaffs_Object * in);
3502 -static void yaffs_InvalidateChunkCache(yaffs_Object * object, int chunkId);
3503 +static void yaffs_InvalidateWholeChunkCache(yaffs_Object *in);
3504 +static void yaffs_InvalidateChunkCache(yaffs_Object *object, int chunkId);
3505
3506  static void yaffs_InvalidateCheckpoint(yaffs_Device *dev);
3507
3508 -static int yaffs_FindChunkInFile(yaffs_Object * in, int chunkInInode,
3509 -                                yaffs_ExtendedTags * tags);
3510 +static int yaffs_FindChunkInFile(yaffs_Object *in, int chunkInInode,
3511 +                               yaffs_ExtendedTags *tags);
3512
3513 -static __u32 yaffs_GetChunkGroupBase(yaffs_Device *dev, yaffs_Tnode *tn, unsigned pos);
3514 -static yaffs_Tnode *yaffs_FindLevel0Tnode(yaffs_Device * dev,
3515 -                                         yaffs_FileStructure * fStruct,
3516 -                                         __u32 chunkId);
3517 +static __u32 yaffs_GetChunkGroupBase(yaffs_Device *dev, yaffs_Tnode *tn,
3518 +               unsigned pos);
3519 +static yaffs_Tnode *yaffs_FindLevel0Tnode(yaffs_Device *dev,
3520 +                                       yaffs_FileStructure *fStruct,
3521 +                                       __u32 chunkId);
3522
3523
3524  /* Function to calculate chunk and offset */
3525
3526 -static void yaffs_AddrToChunk(yaffs_Device *dev, loff_t addr, __u32 *chunk, __u32 *offset)
3527 +static void yaffs_AddrToChunk(yaffs_Device *dev, loff_t addr, int *chunkOut,
3528 +               __u32 *offsetOut)
3529  {
3530 -       if(dev->chunkShift){
3531 -               /* Easy-peasy power of 2 case */
3532 -               *chunk  = (__u32)(addr >> dev->chunkShift);
3533 -               *offset = (__u32)(addr & dev->chunkMask);
3534 -       }
3535 -       else if(dev->crumbsPerChunk)
3536 -       {
3537 -               /* Case where we're using "crumbs" */
3538 -               *offset = (__u32)(addr & dev->crumbMask);
3539 -               addr >>= dev->crumbShift;
3540 -               *chunk = ((__u32)addr)/dev->crumbsPerChunk;
3541 -               *offset += ((addr - (*chunk * dev->crumbsPerChunk)) << dev->crumbShift);
3542 +       int chunk;
3543 +       __u32 offset;
3544 +
3545 +       chunk  = (__u32)(addr >> dev->chunkShift);
3546 +
3547 +       if (dev->chunkDiv == 1) {
3548 +               /* easy power of 2 case */
3549 +               offset = (__u32)(addr & dev->chunkMask);
3550 +       } else {
3551 +               /* Non power-of-2 case */
3552 +
3553 +               loff_t chunkBase;
3554 +
3555 +               chunk /= dev->chunkDiv;
3556 +
3557 +               chunkBase = ((loff_t)chunk) * dev->nDataBytesPerChunk;
3558 +               offset = (__u32)(addr - chunkBase);
3559         }
3560 -       else
3561 -               YBUG();
3562 +
3563 +       *chunkOut = chunk;
3564 +       *offsetOut = offset;
3565  }
3566
3567 -/* Function to return the number of shifts for a power of 2 greater than or equal
3568 - * to the given number
3569 +/* Function to return the number of shifts for a power of 2 greater than or
3570 + * equal to the given number
3571   * Note we don't try to cater for all possible numbers and this does not have to
3572   * be hellishly efficient.
3573   */
3574 @@ -153,13 +154,14 @@ static __u32 ShiftsGE(__u32 x)
3575
3576         nShifts = extraBits = 0;
3577
3578 -       while(x>1){
3579 -               if(x & 1) extraBits++;
3580 -               x>>=1;
3581 +       while (x > 1) {
3582 +               if (x & 1)
3583 +                       extraBits++;
3584 +               x >>= 1;
3585                 nShifts++;
3586         }
3587
3588 -       if(extraBits)
3589 +       if (extraBits)
3590                 nShifts++;
3591
3592         return nShifts;
3593 @@ -168,16 +170,17 @@ static __u32 ShiftsGE(__u32 x)
3594  /* Function to return the number of shifts to get a 1 in bit 0
3595   */
3596
3597 -static __u32 ShiftDiv(__u32 x)
3598 +static __u32 Shifts(__u32 x)
3599  {
3600         int nShifts;
3601
3602         nShifts =  0;
3603
3604 -       if(!x) return 0;
3605 +       if (!x)
3606 +               return 0;
3607
3608 -       while( !(x&1)){
3609 -               x>>=1;
3610 +       while (!(x&1)) {
3611 +               x >>= 1;
3612                 nShifts++;
3613         }
3614
3615 @@ -195,21 +198,25 @@ static int yaffs_InitialiseTempBuffers(y
3616         int i;
3617         __u8 *buf = (__u8 *)1;
3618
3619 -       memset(dev->tempBuffer,0,sizeof(dev->tempBuffer));
3620 +       memset(dev->tempBuffer, 0, sizeof(dev->tempBuffer));
3621
3622         for (i = 0; buf && i < YAFFS_N_TEMP_BUFFERS; i++) {
3623                 dev->tempBuffer[i].line = 0;    /* not in use */
3624                 dev->tempBuffer[i].buffer = buf =
3625 -                   YMALLOC_DMA(dev->nDataBytesPerChunk);
3626 +                   YMALLOC_DMA(dev->totalBytesPerChunk);
3627         }
3628
3629         return buf ? YAFFS_OK : YAFFS_FAIL;
3630 -
3631  }
3632
3633 -static __u8 *yaffs_GetTempBuffer(yaffs_Device * dev, int lineNo)
3634 +__u8 *yaffs_GetTempBuffer(yaffs_Device *dev, int lineNo)
3635  {
3636         int i, j;
3637 +
3638 +       dev->tempInUse++;
3639 +       if (dev->tempInUse > dev->maxTemp)
3640 +               dev->maxTemp = dev->tempInUse;
3641 +
3642         for (i = 0; i < YAFFS_N_TEMP_BUFFERS; i++) {
3643                 if (dev->tempBuffer[i].line == 0) {
3644                         dev->tempBuffer[i].line = lineNo;
3645 @@ -227,9 +234,9 @@ static __u8 *yaffs_GetTempBuffer(yaffs_D
3646         T(YAFFS_TRACE_BUFFERS,
3647           (TSTR("Out of temp buffers at line %d, other held by lines:"),
3648            lineNo));
3649 -       for (i = 0; i < YAFFS_N_TEMP_BUFFERS; i++) {
3650 +       for (i = 0; i < YAFFS_N_TEMP_BUFFERS; i++)
3651                 T(YAFFS_TRACE_BUFFERS, (TSTR(" %d "), dev->tempBuffer[i].line));
3652 -       }
3653 +
3654         T(YAFFS_TRACE_BUFFERS, (TSTR(" " TENDSTR)));
3655
3656         /*
3657 @@ -242,10 +249,13 @@ static __u8 *yaffs_GetTempBuffer(yaffs_D
3658
3659  }
3660
3661 -static void yaffs_ReleaseTempBuffer(yaffs_Device * dev, __u8 * buffer,
3662 +void yaffs_ReleaseTempBuffer(yaffs_Device *dev, __u8 *buffer,
3663                                     int lineNo)
3664  {
3665         int i;
3666 +
3667 +       dev->tempInUse--;
3668 +
3669         for (i = 0; i < YAFFS_N_TEMP_BUFFERS; i++) {
3670                 if (dev->tempBuffer[i].buffer == buffer) {
3671                         dev->tempBuffer[i].line = 0;
3672 @@ -267,27 +277,26 @@ static void yaffs_ReleaseTempBuffer(yaff
3673  /*
3674   * Determine if we have a managed buffer.
3675   */
3676 -int yaffs_IsManagedTempBuffer(yaffs_Device * dev, const __u8 * buffer)
3677 +int yaffs_IsManagedTempBuffer(yaffs_Device *dev, const __u8 *buffer)
3678  {
3679         int i;
3680 +
3681         for (i = 0; i < YAFFS_N_TEMP_BUFFERS; i++) {
3682                 if (dev->tempBuffer[i].buffer == buffer)
3683                         return 1;
3684 +       }
3685
3686 +       for (i = 0; i < dev->nShortOpCaches; i++) {
3687 +               if (dev->srCache[i].data == buffer)
3688 +                       return 1;
3689         }
3690
3691 -    for (i = 0; i < dev->nShortOpCaches; i++) {
3692 -        if( dev->srCache[i].data == buffer )
3693 -            return 1;
3694 -
3695 -    }
3696 -
3697 -    if (buffer == dev->checkpointBuffer)
3698 -      return 1;
3699 -
3700 -    T(YAFFS_TRACE_ALWAYS,
3701 -         (TSTR("yaffs: unmaged buffer detected.\n" TENDSTR)));
3702 -    return 0;
3703 +       if (buffer == dev->checkpointBuffer)
3704 +               return 1;
3705 +
3706 +       T(YAFFS_TRACE_ALWAYS,
3707 +               (TSTR("yaffs: unmaged buffer detected.\n" TENDSTR)));
3708 +       return 0;
3709  }
3710
3711
3712 @@ -296,62 +305,63 @@ int yaffs_IsManagedTempBuffer(yaffs_Devi
3713   * Chunk bitmap manipulations
3714   */
3715
3716 -static Y_INLINE __u8 *yaffs_BlockBits(yaffs_Device * dev, int blk)
3717 +static Y_INLINE __u8 *yaffs_BlockBits(yaffs_Device *dev, int blk)
3718  {
3719         if (blk < dev->internalStartBlock || blk > dev->internalEndBlock) {
3720                 T(YAFFS_TRACE_ERROR,
3721 -                 (TSTR("**>> yaffs: BlockBits block %d is not valid" TENDSTR),
3722 -                  blk));
3723 +                       (TSTR("**>> yaffs: BlockBits block %d is not valid" TENDSTR),
3724 +                       blk));
3725                 YBUG();
3726         }
3727         return dev->chunkBits +
3728 -           (dev->chunkBitmapStride * (blk - dev->internalStartBlock));
3729 +               (dev->chunkBitmapStride * (blk - dev->internalStartBlock));
3730  }
3731
3732  static Y_INLINE void yaffs_VerifyChunkBitId(yaffs_Device *dev, int blk, int chunk)
3733  {
3734 -       if(blk < dev->internalStartBlock || blk > dev->internalEndBlock ||
3735 -          chunk < 0 || chunk >= dev->nChunksPerBlock) {
3736 -          T(YAFFS_TRACE_ERROR,
3737 -           (TSTR("**>> yaffs: Chunk Id (%d:%d) invalid"TENDSTR),blk,chunk));
3738 -           YBUG();
3739 +       if (blk < dev->internalStartBlock || blk > dev->internalEndBlock ||
3740 +                       chunk < 0 || chunk >= dev->nChunksPerBlock) {
3741 +               T(YAFFS_TRACE_ERROR,
3742 +               (TSTR("**>> yaffs: Chunk Id (%d:%d) invalid"TENDSTR),
3743 +                       blk, chunk));
3744 +               YBUG();
3745         }
3746  }
3747
3748 -static Y_INLINE void yaffs_ClearChunkBits(yaffs_Device * dev, int blk)
3749 +static Y_INLINE void yaffs_ClearChunkBits(yaffs_Device *dev, int blk)
3750  {
3751         __u8 *blkBits = yaffs_BlockBits(dev, blk);
3752
3753         memset(blkBits, 0, dev->chunkBitmapStride);
3754  }
3755
3756 -static Y_INLINE void yaffs_ClearChunkBit(yaffs_Device * dev, int blk, int chunk)
3757 +static Y_INLINE void yaffs_ClearChunkBit(yaffs_Device *dev, int blk, int chunk)
3758  {
3759         __u8 *blkBits = yaffs_BlockBits(dev, blk);
3760
3761 -       yaffs_VerifyChunkBitId(dev,blk,chunk);
3762 +       yaffs_VerifyChunkBitId(dev, blk, chunk);
3763
3764         blkBits[chunk / 8] &= ~(1 << (chunk & 7));
3765  }
3766
3767 -static Y_INLINE void yaffs_SetChunkBit(yaffs_Device * dev, int blk, int chunk)
3768 +static Y_INLINE void yaffs_SetChunkBit(yaffs_Device *dev, int blk, int chunk)
3769  {
3770         __u8 *blkBits = yaffs_BlockBits(dev, blk);
3771
3772 -       yaffs_VerifyChunkBitId(dev,blk,chunk);
3773 +       yaffs_VerifyChunkBitId(dev, blk, chunk);
3774
3775         blkBits[chunk / 8] |= (1 << (chunk & 7));
3776  }
3777
3778 -static Y_INLINE int yaffs_CheckChunkBit(yaffs_Device * dev, int blk, int chunk)
3779 +static Y_INLINE int yaffs_CheckChunkBit(yaffs_Device *dev, int blk, int chunk)
3780  {
3781         __u8 *blkBits = yaffs_BlockBits(dev, blk);
3782 -       yaffs_VerifyChunkBitId(dev,blk,chunk);
3783 +       yaffs_VerifyChunkBitId(dev, blk, chunk);
3784
3785         return (blkBits[chunk / 8] & (1 << (chunk & 7))) ? 1 : 0;
3786  }
3787
3788 -static Y_INLINE int yaffs_StillSomeChunkBits(yaffs_Device * dev, int blk)
3789 +static Y_INLINE int yaffs_StillSomeChunkBits(yaffs_Device *dev, int blk)
3790  {
3791         __u8 *blkBits = yaffs_BlockBits(dev, blk);
3792         int i;
3793 @@ -363,17 +373,17 @@ static Y_INLINE int yaffs_StillSomeChunk
3794         return 0;
3795  }
3796
3797 -static int yaffs_CountChunkBits(yaffs_Device * dev, int blk)
3798 +static int yaffs_CountChunkBits(yaffs_Device *dev, int blk)
3799  {
3800         __u8 *blkBits = yaffs_BlockBits(dev, blk);
3801         int i;
3802         int n = 0;
3803         for (i = 0; i < dev->chunkBitmapStride; i++) {
3804                 __u8 x = *blkBits;
3805 -               while(x){
3806 -                       if(x & 1)
3807 +               while (x) {
3808 +                       if (x & 1)
3809                                 n++;
3810 -                       x >>=1;
3811 +                       x >>= 1;
3812                 }
3813
3814                 blkBits++;
3815 @@ -400,7 +410,7 @@ static int yaffs_SkipNANDVerification(ya
3816         return !(yaffs_traceMask & (YAFFS_TRACE_VERIFY_NAND));
3817  }
3818
3819 -static const char * blockStateName[] = {
3820 +static const char *blockStateName[] = {
3821  "Unknown",
3822  "Needs scanning",
3823  "Scanning",
3824 @@ -413,64 +423,65 @@ static const char * blockStateName[] = {
3825  "Dead"
3826  };
3827
3828 -static void yaffs_VerifyBlock(yaffs_Device *dev,yaffs_BlockInfo *bi,int n)
3829 +static void yaffs_VerifyBlock(yaffs_Device *dev, yaffs_BlockInfo *bi, int n)
3830  {
3831         int actuallyUsed;
3832         int inUse;
3833
3834 -       if(yaffs_SkipVerification(dev))
3835 +       if (yaffs_SkipVerification(dev))
3836                 return;
3837
3838         /* Report illegal runtime states */
3839 -       if(bi->blockState <0 || bi->blockState >= YAFFS_NUMBER_OF_BLOCK_STATES)
3840 -               T(YAFFS_TRACE_VERIFY,(TSTR("Block %d has undefined state %d"TENDSTR),n,bi->blockState));
3841 +       if (bi->blockState >= YAFFS_NUMBER_OF_BLOCK_STATES)
3842 +               T(YAFFS_TRACE_VERIFY, (TSTR("Block %d has undefined state %d"TENDSTR), n, bi->blockState));
3843
3844 -       switch(bi->blockState){
3845 -        case YAFFS_BLOCK_STATE_UNKNOWN:
3846 -        case YAFFS_BLOCK_STATE_SCANNING:
3847 -        case YAFFS_BLOCK_STATE_NEEDS_SCANNING:
3848 -               T(YAFFS_TRACE_VERIFY,(TSTR("Block %d has bad run-state %s"TENDSTR),
3849 -               n,blockStateName[bi->blockState]));
3850 +       switch (bi->blockState) {
3851 +       case YAFFS_BLOCK_STATE_UNKNOWN:
3852 +       case YAFFS_BLOCK_STATE_SCANNING:
3853 +       case YAFFS_BLOCK_STATE_NEEDS_SCANNING:
3854 +               T(YAFFS_TRACE_VERIFY, (TSTR("Block %d has bad run-state %s"TENDSTR),
3855 +               n, blockStateName[bi->blockState]));
3856         }
3857
3858         /* Check pages in use and soft deletions are legal */
3859
3860         actuallyUsed = bi->pagesInUse - bi->softDeletions;
3861
3862 -       if(bi->pagesInUse < 0 || bi->pagesInUse > dev->nChunksPerBlock ||
3863 +       if (bi->pagesInUse < 0 || bi->pagesInUse > dev->nChunksPerBlock ||
3864            bi->softDeletions < 0 || bi->softDeletions > dev->nChunksPerBlock ||
3865            actuallyUsed < 0 || actuallyUsed > dev->nChunksPerBlock)
3866 -               T(YAFFS_TRACE_VERIFY,(TSTR("Block %d has illegal values pagesInUsed %d softDeletions %d"TENDSTR),
3867 -               n,bi->pagesInUse,bi->softDeletions));
3868 +               T(YAFFS_TRACE_VERIFY, (TSTR("Block %d has illegal values pagesInUsed %d softDeletions %d"TENDSTR),
3869 +               n, bi->pagesInUse, bi->softDeletions));
3870
3871
3872         /* Check chunk bitmap legal */
3873 -       inUse = yaffs_CountChunkBits(dev,n);
3874 -       if(inUse != bi->pagesInUse)
3875 -               T(YAFFS_TRACE_VERIFY,(TSTR("Block %d has inconsistent values pagesInUse %d counted chunk bits %d"TENDSTR),
3876 -                       n,bi->pagesInUse,inUse));
3877 +       inUse = yaffs_CountChunkBits(dev, n);
3878 +       if (inUse != bi->pagesInUse)
3879 +               T(YAFFS_TRACE_VERIFY, (TSTR("Block %d has inconsistent values pagesInUse %d counted chunk bits %d"TENDSTR),
3880 +                       n, bi->pagesInUse, inUse));
3881
3882         /* Check that the sequence number is valid.
3883          * Ten million is legal, but is very unlikely
3884          */
3885 -       if(dev->isYaffs2 &&
3886 +       if (dev->isYaffs2 &&
3887            (bi->blockState == YAFFS_BLOCK_STATE_ALLOCATING || bi->blockState == YAFFS_BLOCK_STATE_FULL) &&
3888 -          (bi->sequenceNumber < YAFFS_LOWEST_SEQUENCE_NUMBER || bi->sequenceNumber > 10000000 ))
3889 -               T(YAFFS_TRACE_VERIFY,(TSTR("Block %d has suspect sequence number of %d"TENDSTR),
3890 -               n,bi->sequenceNumber));
3891 -
3892 +          (bi->sequenceNumber < YAFFS_LOWEST_SEQUENCE_NUMBER || bi->sequenceNumber > 10000000))
3893 +               T(YAFFS_TRACE_VERIFY, (TSTR("Block %d has suspect sequence number of %d"TENDSTR),
3894 +               n, bi->sequenceNumber));
3895  }
3896
3897 -static void yaffs_VerifyCollectedBlock(yaffs_Device *dev,yaffs_BlockInfo *bi,int n)
3898 +static void yaffs_VerifyCollectedBlock(yaffs_Device *dev, yaffs_BlockInfo *bi,
3899 +               int n)
3900  {
3901 -       yaffs_VerifyBlock(dev,bi,n);
3902 +       yaffs_VerifyBlock(dev, bi, n);
3903
3904         /* After collection the block should be in the erased state */
3905 -       /* TODO: This will need to change if we do partial gc */
3906 +       /* This will need to change if we do partial gc */
3907
3908 -       if(bi->blockState != YAFFS_BLOCK_STATE_EMPTY){
3909 -               T(YAFFS_TRACE_ERROR,(TSTR("Block %d is in state %d after gc, should be erased"TENDSTR),
3910 -                       n,bi->blockState));
3911 +       if (bi->blockState != YAFFS_BLOCK_STATE_COLLECTING &&
3912 +                       bi->blockState != YAFFS_BLOCK_STATE_EMPTY) {
3913 +               T(YAFFS_TRACE_ERROR, (TSTR("Block %d is in state %d after gc, should be erased"TENDSTR),
3914 +                       n, bi->blockState));
3915         }
3916  }
3917
3918 @@ -480,52 +491,49 @@ static void yaffs_VerifyBlocks(yaffs_Dev
3919         int nBlocksPerState[YAFFS_NUMBER_OF_BLOCK_STATES];
3920         int nIllegalBlockStates = 0;
3921
3922 -
3923 -       if(yaffs_SkipVerification(dev))
3924 +       if (yaffs_SkipVerification(dev))
3925                 return;
3926
3927 -       memset(nBlocksPerState,0,sizeof(nBlocksPerState));
3928 -
3929 +       memset(nBlocksPerState, 0, sizeof(nBlocksPerState));
3930
3931 -       for(i = dev->internalStartBlock; i <= dev->internalEndBlock; i++){
3932 -               yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev,i);
3933 -               yaffs_VerifyBlock(dev,bi,i);
3934 +       for (i = dev->internalStartBlock; i <= dev->internalEndBlock; i++) {
3935 +               yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, i);
3936 +               yaffs_VerifyBlock(dev, bi, i);
3937
3938 -               if(bi->blockState >=0 && bi->blockState < YAFFS_NUMBER_OF_BLOCK_STATES)
3939 +               if (bi->blockState < YAFFS_NUMBER_OF_BLOCK_STATES)
3940                         nBlocksPerState[bi->blockState]++;
3941                 else
3942                         nIllegalBlockStates++;
3943 -
3944         }
3945
3946 -       T(YAFFS_TRACE_VERIFY,(TSTR(""TENDSTR)));
3947 -       T(YAFFS_TRACE_VERIFY,(TSTR("Block summary"TENDSTR)));
3948 +       T(YAFFS_TRACE_VERIFY, (TSTR(""TENDSTR)));
3949 +       T(YAFFS_TRACE_VERIFY, (TSTR("Block summary"TENDSTR)));
3950
3951 -       T(YAFFS_TRACE_VERIFY,(TSTR("%d blocks have illegal states"TENDSTR),nIllegalBlockStates));
3952 -       if(nBlocksPerState[YAFFS_BLOCK_STATE_ALLOCATING] > 1)
3953 -               T(YAFFS_TRACE_VERIFY,(TSTR("Too many allocating blocks"TENDSTR)));
3954 +       T(YAFFS_TRACE_VERIFY, (TSTR("%d blocks have illegal states"TENDSTR), nIllegalBlockStates));
3955 +       if (nBlocksPerState[YAFFS_BLOCK_STATE_ALLOCATING] > 1)
3956 +               T(YAFFS_TRACE_VERIFY, (TSTR("Too many allocating blocks"TENDSTR)));
3957
3958 -       for(i = 0; i < YAFFS_NUMBER_OF_BLOCK_STATES; i++)
3959 +       for (i = 0; i < YAFFS_NUMBER_OF_BLOCK_STATES; i++)
3960                 T(YAFFS_TRACE_VERIFY,
3961                   (TSTR("%s %d blocks"TENDSTR),
3962 -                 blockStateName[i],nBlocksPerState[i]));
3963 +                 blockStateName[i], nBlocksPerState[i]));
3964
3965 -       if(dev->blocksInCheckpoint != nBlocksPerState[YAFFS_BLOCK_STATE_CHECKPOINT])
3966 +       if (dev->blocksInCheckpoint != nBlocksPerState[YAFFS_BLOCK_STATE_CHECKPOINT])
3967                 T(YAFFS_TRACE_VERIFY,
3968                  (TSTR("Checkpoint block count wrong dev %d count %d"TENDSTR),
3969                  dev->blocksInCheckpoint, nBlocksPerState[YAFFS_BLOCK_STATE_CHECKPOINT]));
3970
3971 -       if(dev->nErasedBlocks != nBlocksPerState[YAFFS_BLOCK_STATE_EMPTY])
3972 +       if (dev->nErasedBlocks != nBlocksPerState[YAFFS_BLOCK_STATE_EMPTY])
3973                 T(YAFFS_TRACE_VERIFY,
3974                  (TSTR("Erased block count wrong dev %d count %d"TENDSTR),
3975                  dev->nErasedBlocks, nBlocksPerState[YAFFS_BLOCK_STATE_EMPTY]));
3976
3977 -       if(nBlocksPerState[YAFFS_BLOCK_STATE_COLLECTING] > 1)
3978 +       if (nBlocksPerState[YAFFS_BLOCK_STATE_COLLECTING] > 1)
3979                 T(YAFFS_TRACE_VERIFY,
3980                  (TSTR("Too many collecting blocks %d (max is 1)"TENDSTR),
3981                  nBlocksPerState[YAFFS_BLOCK_STATE_COLLECTING]));
3982
3983 -       T(YAFFS_TRACE_VERIFY,(TSTR(""TENDSTR)));
3984 +       T(YAFFS_TRACE_VERIFY, (TSTR(""TENDSTR)));
3985
3986  }
3987
3988 @@ -535,26 +543,26 @@ static void yaffs_VerifyBlocks(yaffs_Dev
3989   */
3990  static void yaffs_VerifyObjectHeader(yaffs_Object *obj, yaffs_ObjectHeader *oh, yaffs_ExtendedTags *tags, int parentCheck)
3991  {
3992 -       if(yaffs_SkipVerification(obj->myDev))
3993 +       if (obj && yaffs_SkipVerification(obj->myDev))
3994                 return;
3995
3996 -       if(!(tags && obj && oh)){
3997 -               T(YAFFS_TRACE_VERIFY,
3998 -                               (TSTR("Verifying object header tags %x obj %x oh %x"TENDSTR),
3999 -                               (__u32)tags,(__u32)obj,(__u32)oh));
4000 +       if (!(tags && obj && oh)) {
4001 +               T(YAFFS_TRACE_VERIFY,
4002 +                               (TSTR("Verifying object header tags %x obj %x oh %x"TENDSTR),
4003 +                               (__u32)tags, (__u32)obj, (__u32)oh));
4004                 return;
4005         }
4006
4007 -       if(oh->type <= YAFFS_OBJECT_TYPE_UNKNOWN ||
4008 -          oh->type > YAFFS_OBJECT_TYPE_MAX)
4009 -               T(YAFFS_TRACE_VERIFY,
4010 -                (TSTR("Obj %d header type is illegal value 0x%x"TENDSTR),
4011 -                tags->objectId, oh->type));
4012 -
4013 -       if(tags->objectId != obj->objectId)
4014 -               T(YAFFS_TRACE_VERIFY,
4015 -                (TSTR("Obj %d header mismatch objectId %d"TENDSTR),
4016 -                tags->objectId, obj->objectId));
4017 +       if (oh->type <= YAFFS_OBJECT_TYPE_UNKNOWN ||
4018 +                       oh->type > YAFFS_OBJECT_TYPE_MAX)
4019 +               T(YAFFS_TRACE_VERIFY,
4020 +                       (TSTR("Obj %d header type is illegal value 0x%x"TENDSTR),
4021 +                       tags->objectId, oh->type));
4022 +
4023 +       if (tags->objectId != obj->objectId)
4024 +               T(YAFFS_TRACE_VERIFY,
4025 +                       (TSTR("Obj %d header mismatch objectId %d"TENDSTR),
4026 +                       tags->objectId, obj->objectId));
4027
4028
4029         /*
4030 @@ -563,46 +571,43 @@ static void yaffs_VerifyObjectHeader(yaf
4031          * Tests do not apply to the root object.
4032          */
4033
4034 -       if(parentCheck && tags->objectId > 1 && !obj->parent)
4035 -               T(YAFFS_TRACE_VERIFY,
4036 -                (TSTR("Obj %d header mismatch parentId %d obj->parent is NULL"TENDSTR),
4037 -                tags->objectId, oh->parentObjectId));
4038 -
4039 -
4040 -       if(parentCheck && obj->parent &&
4041 -          oh->parentObjectId != obj->parent->objectId &&
4042 -          (oh->parentObjectId != YAFFS_OBJECTID_UNLINKED ||
4043 -           obj->parent->objectId != YAFFS_OBJECTID_DELETED))
4044 -               T(YAFFS_TRACE_VERIFY,
4045 -                (TSTR("Obj %d header mismatch parentId %d parentObjectId %d"TENDSTR),
4046 -                tags->objectId, oh->parentObjectId, obj->parent->objectId));
4047 +       if (parentCheck && tags->objectId > 1 && !obj->parent)
4048 +               T(YAFFS_TRACE_VERIFY,
4049 +                       (TSTR("Obj %d header mismatch parentId %d obj->parent is NULL"TENDSTR),
4050 +                       tags->objectId, oh->parentObjectId));
4051
4052 +       if (parentCheck && obj->parent &&
4053 +                       oh->parentObjectId != obj->parent->objectId &&
4054 +                       (oh->parentObjectId != YAFFS_OBJECTID_UNLINKED ||
4055 +                       obj->parent->objectId != YAFFS_OBJECTID_DELETED))
4056 +               T(YAFFS_TRACE_VERIFY,
4057 +                       (TSTR("Obj %d header mismatch parentId %d parentObjectId %d"TENDSTR),
4058 +                       tags->objectId, oh->parentObjectId, obj->parent->objectId));
4059
4060 -       if(tags->objectId > 1 && oh->name[0] == 0) /* Null name */
4061 +       if (tags->objectId > 1 && oh->name[0] == 0) /* Null name */
4062                 T(YAFFS_TRACE_VERIFY,
4063 -               (TSTR("Obj %d header name is NULL"TENDSTR),
4064 -                obj->objectId));
4065 +                       (TSTR("Obj %d header name is NULL"TENDSTR),
4066 +                       obj->objectId));
4067
4068 -       if(tags->objectId > 1 && ((__u8)(oh->name[0])) == 0xff) /* Trashed name */
4069 +       if (tags->objectId > 1 && ((__u8)(oh->name[0])) == 0xff) /* Trashed name */
4070                 T(YAFFS_TRACE_VERIFY,
4071 -               (TSTR("Obj %d header name is 0xFF"TENDSTR),
4072 -                obj->objectId));
4073 +                       (TSTR("Obj %d header name is 0xFF"TENDSTR),
4074 +                       obj->objectId));
4075  }
4076
4077
4078
4079 -static int yaffs_VerifyTnodeWorker(yaffs_Object * obj, yaffs_Tnode * tn,
4080 -                                       __u32 level, int chunkOffset)
4081 +static int yaffs_VerifyTnodeWorker(yaffs_Object *obj, yaffs_Tnode *tn,
4082 +                                       __u32 level, int chunkOffset)
4083  {
4084         int i;
4085         yaffs_Device *dev = obj->myDev;
4086         int ok = 1;
4087 -       int nTnodeBytes = (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8;
4088
4089         if (tn) {
4090                 if (level > 0) {
4091
4092 -                       for (i = 0; i < YAFFS_NTNODES_INTERNAL && ok; i++){
4093 +                       for (i = 0; i < YAFFS_NTNODES_INTERNAL && ok; i++) {
4094                                 if (tn->internal[i]) {
4095                                         ok = yaffs_VerifyTnodeWorker(obj,
4096                                                         tn->internal[i],
4097 @@ -611,20 +616,19 @@ static int yaffs_VerifyTnodeWorker(yaffs
4098                                 }
4099                         }
4100                 } else if (level == 0) {
4101 -                       int i;
4102                         yaffs_ExtendedTags tags;
4103                         __u32 objectId = obj->objectId;
4104
4105                         chunkOffset <<=  YAFFS_TNODES_LEVEL0_BITS;
4106
4107 -                       for(i = 0; i < YAFFS_NTNODES_LEVEL0; i++){
4108 -                               __u32 theChunk = yaffs_GetChunkGroupBase(dev,tn,i);
4109 +                       for (i = 0; i < YAFFS_NTNODES_LEVEL0; i++) {
4110 +                               __u32 theChunk = yaffs_GetChunkGroupBase(dev, tn, i);
4111
4112 -                               if(theChunk > 0){
4113 +                               if (theChunk > 0) {
4114                                         /* T(~0,(TSTR("verifying (%d:%d) %d"TENDSTR),tags.objectId,tags.chunkId,theChunk)); */
4115 -                                       yaffs_ReadChunkWithTagsFromNAND(dev,theChunk,NULL, &tags);
4116 -                                       if(tags.objectId != objectId || tags.chunkId != chunkOffset){
4117 -                                               T(~0,(TSTR("Object %d chunkId %d NAND mismatch chunk %d tags (%d:%d)"TENDSTR),
4118 +                                       yaffs_ReadChunkWithTagsFromNAND(dev, theChunk, NULL, &tags);
4119 +                                       if (tags.objectId != objectId || tags.chunkId != chunkOffset) {
4120 +                                               T(~0, (TSTR("Object %d chunkId %d NAND mismatch chunk %d tags (%d:%d)"TENDSTR),
4121                                                         objectId, chunkOffset, theChunk,
4122                                                         tags.objectId, tags.chunkId));
4123                                         }
4124 @@ -646,13 +650,15 @@ static void yaffs_VerifyFile(yaffs_Objec
4125         __u32 lastChunk;
4126         __u32 x;
4127         __u32 i;
4128 -       int ok;
4129         yaffs_Device *dev;
4130         yaffs_ExtendedTags tags;
4131         yaffs_Tnode *tn;
4132         __u32 objectId;
4133
4134 -       if(obj && yaffs_SkipVerification(obj->myDev))
4135 +       if (!obj)
4136 +               return;
4137 +
4138 +       if (yaffs_SkipVerification(obj->myDev))
4139                 return;
4140
4141         dev = obj->myDev;
4142 @@ -662,17 +668,17 @@ static void yaffs_VerifyFile(yaffs_Objec
4143         lastChunk =  obj->variant.fileVariant.fileSize / dev->nDataBytesPerChunk + 1;
4144         x = lastChunk >> YAFFS_TNODES_LEVEL0_BITS;
4145         requiredTallness = 0;
4146 -       while (x> 0) {
4147 +       while (x > 0) {
4148                 x >>= YAFFS_TNODES_INTERNAL_BITS;
4149                 requiredTallness++;
4150         }
4151
4152         actualTallness = obj->variant.fileVariant.topLevel;
4153
4154 -       if(requiredTallness > actualTallness )
4155 +       if (requiredTallness > actualTallness)
4156                 T(YAFFS_TRACE_VERIFY,
4157                 (TSTR("Obj %d had tnode tallness %d, needs to be %d"TENDSTR),
4158 -                obj->objectId,actualTallness, requiredTallness));
4159 +                obj->objectId, actualTallness, requiredTallness));
4160
4161
4162         /* Check that the chunks in the tnode tree are all correct.
4163 @@ -680,39 +686,31 @@ static void yaffs_VerifyFile(yaffs_Objec
4164          * checking the tags for every chunk match.
4165          */
4166
4167 -       if(yaffs_SkipNANDVerification(dev))
4168 +       if (yaffs_SkipNANDVerification(dev))
4169                 return;
4170
4171 -       for(i = 1; i <= lastChunk; i++){
4172 -               tn = yaffs_FindLevel0Tnode(dev, &obj->variant.fileVariant,i);
4173 +       for (i = 1; i <= lastChunk; i++) {
4174 +               tn = yaffs_FindLevel0Tnode(dev, &obj->variant.fileVariant, i);
4175
4176                 if (tn) {
4177 -                       __u32 theChunk = yaffs_GetChunkGroupBase(dev,tn,i);
4178 -                       if(theChunk > 0){
4179 +                       __u32 theChunk = yaffs_GetChunkGroupBase(dev, tn, i);
4180 +                       if (theChunk > 0) {
4181                                 /* T(~0,(TSTR("verifying (%d:%d) %d"TENDSTR),objectId,i,theChunk)); */
4182 -                               yaffs_ReadChunkWithTagsFromNAND(dev,theChunk,NULL, &tags);
4183 -                               if(tags.objectId != objectId || tags.chunkId != i){
4184 -                                       T(~0,(TSTR("Object %d chunkId %d NAND mismatch chunk %d tags (%d:%d)"TENDSTR),
4185 +                               yaffs_ReadChunkWithTagsFromNAND(dev, theChunk, NULL, &tags);
4186 +                               if (tags.objectId != objectId || tags.chunkId != i) {
4187 +                                       T(~0, (TSTR("Object %d chunkId %d NAND mismatch chunk %d tags (%d:%d)"TENDSTR),
4188                                                 objectId, i, theChunk,
4189                                                 tags.objectId, tags.chunkId));
4190                                 }
4191                         }
4192                 }
4193 -
4194         }
4195 -
4196  }
4197
4198 -static void yaffs_VerifyDirectory(yaffs_Object *obj)
4199 -{
4200 -       if(obj && yaffs_SkipVerification(obj->myDev))
4201 -               return;
4202 -
4203 -}
4204
4205  static void yaffs_VerifyHardLink(yaffs_Object *obj)
4206  {
4207 -       if(obj && yaffs_SkipVerification(obj->myDev))
4208 +       if (obj && yaffs_SkipVerification(obj->myDev))
4209                 return;
4210
4211         /* Verify sane equivalent object */
4212 @@ -720,7 +718,7 @@ static void yaffs_VerifyHardLink(yaffs_O
4213
4214  static void yaffs_VerifySymlink(yaffs_Object *obj)
4215  {
4216 -       if(obj && yaffs_SkipVerification(obj->myDev))
4217 +       if (obj && yaffs_SkipVerification(obj->myDev))
4218                 return;
4219
4220         /* Verify symlink string */
4221 @@ -728,7 +726,7 @@ static void yaffs_VerifySymlink(yaffs_Ob
4222
4223  static void yaffs_VerifySpecial(yaffs_Object *obj)
4224  {
4225 -       if(obj && yaffs_SkipVerification(obj->myDev))
4226 +       if (obj && yaffs_SkipVerification(obj->myDev))
4227                 return;
4228  }
4229
4230 @@ -740,14 +738,19 @@ static void yaffs_VerifyObject(yaffs_Obj
4231         __u32 chunkMax;
4232
4233         __u32 chunkIdOk;
4234 -       __u32 chunkIsLive;
4235 +       __u32 chunkInRange;
4236 +       __u32 chunkShouldNotBeDeleted;
4237 +       __u32 chunkValid;
4238 +
4239 +       if (!obj)
4240 +               return;
4241
4242 -       if(!obj)
4243 +       if (obj->beingCreated)
4244                 return;
4245
4246         dev = obj->myDev;
4247
4248 -       if(yaffs_SkipVerification(dev))
4249 +       if (yaffs_SkipVerification(dev))
4250                 return;
4251
4252         /* Check sane object header chunk */
4253 @@ -755,50 +758,54 @@ static void yaffs_VerifyObject(yaffs_Obj
4254         chunkMin = dev->internalStartBlock * dev->nChunksPerBlock;
4255         chunkMax = (dev->internalEndBlock+1) * dev->nChunksPerBlock - 1;
4256
4257 -       chunkIdOk = (obj->chunkId >= chunkMin && obj->chunkId <= chunkMax);
4258 -       chunkIsLive = chunkIdOk &&
4259 +       chunkInRange = (((unsigned)(obj->hdrChunk)) >= chunkMin && ((unsigned)(obj->hdrChunk)) <= chunkMax);
4260 +       chunkIdOk = chunkInRange || obj->hdrChunk == 0;
4261 +       chunkValid = chunkInRange &&
4262                         yaffs_CheckChunkBit(dev,
4263 -                                           obj->chunkId / dev->nChunksPerBlock,
4264 -                                           obj->chunkId % dev->nChunksPerBlock);
4265 -       if(!obj->fake &&
4266 -           (!chunkIdOk || !chunkIsLive)) {
4267 -          T(YAFFS_TRACE_VERIFY,
4268 -          (TSTR("Obj %d has chunkId %d %s %s"TENDSTR),
4269 -          obj->objectId,obj->chunkId,
4270 -          chunkIdOk ? "" : ",out of range",
4271 -          chunkIsLive || !chunkIdOk ? "" : ",marked as deleted"));
4272 +                                       obj->hdrChunk / dev->nChunksPerBlock,
4273 +                                       obj->hdrChunk % dev->nChunksPerBlock);
4274 +       chunkShouldNotBeDeleted = chunkInRange && !chunkValid;
4275 +
4276 +       if (!obj->fake &&
4277 +                       (!chunkIdOk || chunkShouldNotBeDeleted)) {
4278 +               T(YAFFS_TRACE_VERIFY,
4279 +                       (TSTR("Obj %d has chunkId %d %s %s"TENDSTR),
4280 +                       obj->objectId, obj->hdrChunk,
4281 +                       chunkIdOk ? "" : ",out of range",
4282 +                       chunkShouldNotBeDeleted ? ",marked as deleted" : ""));
4283         }
4284
4285 -       if(chunkIdOk && chunkIsLive &&!yaffs_SkipNANDVerification(dev)) {
4286 +       if (chunkValid && !yaffs_SkipNANDVerification(dev)) {
4287                 yaffs_ExtendedTags tags;
4288                 yaffs_ObjectHeader *oh;
4289 -               __u8 *buffer = yaffs_GetTempBuffer(dev,__LINE__);
4290 +               __u8 *buffer = yaffs_GetTempBuffer(dev, __LINE__);
4291
4292                 oh = (yaffs_ObjectHeader *)buffer;
4293
4294 -               yaffs_ReadChunkWithTagsFromNAND(dev, obj->chunkId,buffer, &tags);
4295 +               yaffs_ReadChunkWithTagsFromNAND(dev, obj->hdrChunk, buffer,
4296 +                               &tags);
4297
4298 -               yaffs_VerifyObjectHeader(obj,oh,&tags,1);
4299 +               yaffs_VerifyObjectHeader(obj, oh, &tags, 1);
4300
4301 -               yaffs_ReleaseTempBuffer(dev,buffer,__LINE__);
4302 +               yaffs_ReleaseTempBuffer(dev, buffer, __LINE__);
4303         }
4304
4305         /* Verify it has a parent */
4306 -       if(obj && !obj->fake &&
4307 -          (!obj->parent || obj->parent->myDev != dev)){
4308 -          T(YAFFS_TRACE_VERIFY,
4309 -          (TSTR("Obj %d has parent pointer %p which does not look like an object"TENDSTR),
4310 -          obj->objectId,obj->parent));
4311 +       if (obj && !obj->fake &&
4312 +                       (!obj->parent || obj->parent->myDev != dev)) {
4313 +               T(YAFFS_TRACE_VERIFY,
4314 +                       (TSTR("Obj %d has parent pointer %p which does not look like an object"TENDSTR),
4315 +                       obj->objectId, obj->parent));
4316         }
4317
4318         /* Verify parent is a directory */
4319 -       if(obj->parent && obj->parent->variantType != YAFFS_OBJECT_TYPE_DIRECTORY){
4320 -          T(YAFFS_TRACE_VERIFY,
4321 -          (TSTR("Obj %d's parent is not a directory (type %d)"TENDSTR),
4322 -          obj->objectId,obj->parent->variantType));
4323 +       if (obj->parent && obj->parent->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) {
4324 +               T(YAFFS_TRACE_VERIFY,
4325 +                       (TSTR("Obj %d's parent is not a directory (type %d)"TENDSTR),
4326 +                       obj->objectId, obj->parent->variantType));
4327         }
4328
4329 -       switch(obj->variantType){
4330 +       switch (obj->variantType) {
4331         case YAFFS_OBJECT_TYPE_FILE:
4332                 yaffs_VerifyFile(obj);
4333                 break;
4334 @@ -818,33 +825,30 @@ static void yaffs_VerifyObject(yaffs_Obj
4335         default:
4336                 T(YAFFS_TRACE_VERIFY,
4337                 (TSTR("Obj %d has illegaltype %d"TENDSTR),
4338 -               obj->objectId,obj->variantType));
4339 +               obj->objectId, obj->variantType));
4340                 break;
4341         }
4342 -
4343 -
4344  }
4345
4346  static void yaffs_VerifyObjects(yaffs_Device *dev)
4347  {
4348         yaffs_Object *obj;
4349         int i;
4350 -       struct list_head *lh;
4351 +       struct ylist_head *lh;
4352
4353 -       if(yaffs_SkipVerification(dev))
4354 +       if (yaffs_SkipVerification(dev))
4355                 return;
4356
4357         /* Iterate through the objects in each hash entry */
4358
4359 -        for(i = 0; i <  YAFFS_NOBJECT_BUCKETS; i++){
4360 -               list_for_each(lh, &dev->objectBucket[i].list) {
4361 +       for (i = 0; i <  YAFFS_NOBJECT_BUCKETS; i++) {
4362 +               ylist_for_each(lh, &dev->objectBucket[i].list) {
4363                         if (lh) {
4364 -                               obj = list_entry(lh, yaffs_Object, hashLink);
4365 +                               obj = ylist_entry(lh, yaffs_Object, hashLink);
4366                                 yaffs_VerifyObject(obj);
4367                         }
4368                 }
4369 -        }
4370 -
4371 +       }
4372  }
4373
4374
4375 @@ -855,19 +859,20 @@ static void yaffs_VerifyObjects(yaffs_De
4376  static Y_INLINE int yaffs_HashFunction(int n)
4377  {
4378         n = abs(n);
4379 -       return (n % YAFFS_NOBJECT_BUCKETS);
4380 +       return n % YAFFS_NOBJECT_BUCKETS;
4381  }
4382
4383  /*
4384 - * Access functions to useful fake objects
4385 + * Access functions to useful fake objects.
4386 + * Note that root might have a presence in NAND if permissions are set.
4387   */
4388
4389 -yaffs_Object *yaffs_Root(yaffs_Device * dev)
4390 +yaffs_Object *yaffs_Root(yaffs_Device *dev)
4391  {
4392         return dev->rootDir;
4393  }
4394
4395 -yaffs_Object *yaffs_LostNFound(yaffs_Device * dev)
4396 +yaffs_Object *yaffs_LostNFound(yaffs_Device *dev)
4397  {
4398         return dev->lostNFoundDir;
4399  }
4400 @@ -877,7 +882,7 @@ yaffs_Object *yaffs_LostNFound(yaffs_Dev
4401   *  Erased NAND checking functions
4402   */
4403
4404 -int yaffs_CheckFF(__u8 * buffer, int nBytes)
4405 +int yaffs_CheckFF(__u8 *buffer, int nBytes)
4406  {
4407         /* Horrible, slow implementation */
4408         while (nBytes--) {
4409 @@ -889,9 +894,8 @@ int yaffs_CheckFF(__u8 * buffer, int nBy
4410  }
4411
4412  static int yaffs_CheckChunkErased(struct yaffs_DeviceStruct *dev,
4413 -                                 int chunkInNAND)
4414 +                               int chunkInNAND)
4415  {
4416 -
4417         int retval = YAFFS_OK;
4418         __u8 *data = yaffs_GetTempBuffer(dev, __LINE__);
4419         yaffs_ExtendedTags tags;
4420 @@ -899,10 +903,9 @@ static int yaffs_CheckChunkErased(struct
4421
4422         result = yaffs_ReadChunkWithTagsFromNAND(dev, chunkInNAND, data, &tags);
4423
4424 -       if(tags.eccResult > YAFFS_ECC_RESULT_NO_ERROR)
4425 +       if (tags.eccResult > YAFFS_ECC_RESULT_NO_ERROR)
4426                 retval = YAFFS_FAIL;
4427
4428 -
4429         if (!yaffs_CheckFF(data, dev->nDataBytesPerChunk) || tags.chunkUsed) {
4430                 T(YAFFS_TRACE_NANDACCESS,
4431                   (TSTR("Chunk %d not erased" TENDSTR), chunkInNAND));
4432 @@ -915,11 +918,10 @@ static int yaffs_CheckChunkErased(struct
4433
4434  }
4435
4436 -
4437  static int yaffs_WriteNewChunkWithTagsToNAND(struct yaffs_DeviceStruct *dev,
4438 -                                            const __u8 * data,
4439 -                                            yaffs_ExtendedTags * tags,
4440 -                                            int useReserve)
4441 +                                       const __u8 *data,
4442 +                                       yaffs_ExtendedTags *tags,
4443 +                                       int useReserve)
4444  {
4445         int attempts = 0;
4446         int writeOk = 0;
4447 @@ -972,7 +974,7 @@ static int yaffs_WriteNewChunkWithTagsTo
4448                         erasedOk = yaffs_CheckChunkErased(dev, chunk);
4449                         if (erasedOk != YAFFS_OK) {
4450                                 T(YAFFS_TRACE_ERROR,
4451 -                               (TSTR ("**>> yaffs chunk %d was not erased"
4452 +                               (TSTR("**>> yaffs chunk %d was not erased"
4453                                 TENDSTR), chunk));
4454
4455                                 /* try another chunk */
4456 @@ -992,7 +994,11 @@ static int yaffs_WriteNewChunkWithTagsTo
4457                 /* Copy the data into the robustification buffer */
4458                 yaffs_HandleWriteChunkOk(dev, chunk, data, tags);
4459
4460 -       } while (writeOk != YAFFS_OK && attempts < yaffs_wr_attempts);
4461 +       } while (writeOk != YAFFS_OK &&
4462 +               (yaffs_wr_attempts <= 0 || attempts <= yaffs_wr_attempts));
4463 +
4464 +       if (!writeOk)
4465 +               chunk = -1;
4466
4467         if (attempts > 1) {
4468                 T(YAFFS_TRACE_ERROR,
4469 @@ -1009,13 +1015,35 @@ static int yaffs_WriteNewChunkWithTagsTo
4470   * Block retiring for handling a broken block.
4471   */
4472
4473 -static void yaffs_RetireBlock(yaffs_Device * dev, int blockInNAND)
4474 +static void yaffs_RetireBlock(yaffs_Device *dev, int blockInNAND)
4475  {
4476         yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, blockInNAND);
4477
4478         yaffs_InvalidateCheckpoint(dev);
4479
4480 -       yaffs_MarkBlockBad(dev, blockInNAND);
4481 +       if (yaffs_MarkBlockBad(dev, blockInNAND) != YAFFS_OK) {
4482 +               if (yaffs_EraseBlockInNAND(dev, blockInNAND) != YAFFS_OK) {
4483 +                       T(YAFFS_TRACE_ALWAYS, (TSTR(
4484 +                               "yaffs: Failed to mark bad and erase block %d"
4485 +                               TENDSTR), blockInNAND));
4486 +               } else {
4487 +                       yaffs_ExtendedTags tags;
4488 +                       int chunkId = blockInNAND * dev->nChunksPerBlock;
4489 +
4490 +                       __u8 *buffer = yaffs_GetTempBuffer(dev, __LINE__);
4491 +
4492 +                       memset(buffer, 0xff, dev->nDataBytesPerChunk);
4493 +                       yaffs_InitialiseTags(&tags);
4494 +                       tags.sequenceNumber = YAFFS_SEQUENCE_BAD_BLOCK;
4495 +                       if (dev->writeChunkWithTagsToNAND(dev, chunkId -
4496 +                               dev->chunkOffset, buffer, &tags) != YAFFS_OK)
4497 +                               T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: Failed to "
4498 +                                       TCONT("write bad block marker to block %d")
4499 +                                       TENDSTR), blockInNAND));
4500 +
4501 +                       yaffs_ReleaseTempBuffer(dev, buffer, __LINE__);
4502 +               }
4503 +       }
4504
4505         bi->blockState = YAFFS_BLOCK_STATE_DEAD;
4506         bi->gcPrioritise = 0;
4507 @@ -1029,49 +1057,45 @@ static void yaffs_RetireBlock(yaffs_Devi
4508   *
4509   */
4510
4511 -static void yaffs_HandleWriteChunkOk(yaffs_Device * dev, int chunkInNAND,
4512 -                                    const __u8 * data,
4513 -                                    const yaffs_ExtendedTags * tags)
4514 +static void yaffs_HandleWriteChunkOk(yaffs_Device *dev, int chunkInNAND,
4515 +                               const __u8 *data,
4516 +                               const yaffs_ExtendedTags *tags)
4517  {
4518  }
4519
4520 -static void yaffs_HandleUpdateChunk(yaffs_Device * dev, int chunkInNAND,
4521 -                                   const yaffs_ExtendedTags * tags)
4522 +static void yaffs_HandleUpdateChunk(yaffs_Device *dev, int chunkInNAND,
4523 +                               const yaffs_ExtendedTags *tags)
4524  {
4525  }
4526
4527  void yaffs_HandleChunkError(yaffs_Device *dev, yaffs_BlockInfo *bi)
4528  {
4529 -       if(!bi->gcPrioritise){
4530 +       if (!bi->gcPrioritise) {
4531                 bi->gcPrioritise = 1;
4532                 dev->hasPendingPrioritisedGCs = 1;
4533 -               bi->chunkErrorStrikes ++;
4534 +               bi->chunkErrorStrikes++;
4535
4536 -               if(bi->chunkErrorStrikes > 3){
4537 +               if (bi->chunkErrorStrikes > 3) {
4538                         bi->needsRetiring = 1; /* Too many stikes, so retire this */
4539                         T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: Block struck out" TENDSTR)));
4540
4541                 }
4542 -
4543         }
4544  }
4545
4546 -static void yaffs_HandleWriteChunkError(yaffs_Device * dev, int chunkInNAND, int erasedOk)
4547 +static void yaffs_HandleWriteChunkError(yaffs_Device *dev, int chunkInNAND,
4548 +               int erasedOk)
4549  {
4550 -
4551         int blockInNAND = chunkInNAND / dev->nChunksPerBlock;
4552         yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, blockInNAND);
4553
4554 -       yaffs_HandleChunkError(dev,bi);
4555 +       yaffs_HandleChunkError(dev, bi);
4556
4557 -
4558 -       if(erasedOk ) {
4559 +       if (erasedOk) {
4560                 /* Was an actual write failure, so mark the block for retirement  */
4561                 bi->needsRetiring = 1;
4562                 T(YAFFS_TRACE_ERROR | YAFFS_TRACE_BAD_BLOCKS,
4563                   (TSTR("**>> Block %d needs retiring" TENDSTR), blockInNAND));
4564 -
4565 -
4566         }
4567
4568         /* Delete the chunk */
4569 @@ -1081,12 +1105,12 @@ static void yaffs_HandleWriteChunkError(
4570
4571  /*---------------- Name handling functions ------------*/
4572
4573 -static __u16 yaffs_CalcNameSum(const YCHAR * name)
4574 +static __u16 yaffs_CalcNameSum(const YCHAR *name)
4575  {
4576         __u16 sum = 0;
4577         __u16 i = 1;
4578
4579 -       YUCHAR *bname = (YUCHAR *) name;
4580 +       const YUCHAR *bname = (const YUCHAR *) name;
4581         if (bname) {
4582                 while ((*bname) && (i < (YAFFS_MAX_NAME_LENGTH/2))) {
4583
4584 @@ -1102,14 +1126,14 @@ static __u16 yaffs_CalcNameSum(const YCH
4585         return sum;
4586  }
4587
4588 -static void yaffs_SetObjectName(yaffs_Object * obj, const YCHAR * name)
4589 +static void yaffs_SetObjectName(yaffs_Object *obj, const YCHAR *name)
4590  {
4591  #ifdef CONFIG_YAFFS_SHORT_NAMES_IN_RAM
4592 -       if (name && yaffs_strlen(name) <= YAFFS_SHORT_NAME_LENGTH) {
4593 +       memset(obj->shortName, 0, sizeof(YCHAR) * (YAFFS_SHORT_NAME_LENGTH+1));
4594 +       if (name && yaffs_strlen(name) <= YAFFS_SHORT_NAME_LENGTH)
4595                 yaffs_strcpy(obj->shortName, name);
4596 -       } else {
4597 +       else
4598                 obj->shortName[0] = _Y('\0');
4599 -       }
4600  #endif
4601         obj->sum = yaffs_CalcNameSum(name);
4602  }
4603 @@ -1126,7 +1150,7 @@ static void yaffs_SetObjectName(yaffs_Ob
4604   * Don't use this function directly
4605   */
4606
4607 -static int yaffs_CreateTnodes(yaffs_Device * dev, int nTnodes)
4608 +static int yaffs_CreateTnodes(yaffs_Device *dev, int nTnodes)
4609  {
4610         int i;
4611         int tnodeSize;
4612 @@ -1143,6 +1167,9 @@ static int yaffs_CreateTnodes(yaffs_Devi
4613          * Must be a multiple of 32-bits  */
4614         tnodeSize = (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8;
4615
4616 +       if (tnodeSize < sizeof(yaffs_Tnode))
4617 +               tnodeSize = sizeof(yaffs_Tnode);
4618 +
4619         /* make these things */
4620
4621         newTnodes = YMALLOC(nTnodes * tnodeSize);
4622 @@ -1150,7 +1177,7 @@ static int yaffs_CreateTnodes(yaffs_Devi
4623
4624         if (!newTnodes) {
4625                 T(YAFFS_TRACE_ERROR,
4626 -                 (TSTR("yaffs: Could not allocate Tnodes" TENDSTR)));
4627 +                       (TSTR("yaffs: Could not allocate Tnodes" TENDSTR)));
4628                 return YAFFS_FAIL;
4629         }
4630
4631 @@ -1170,7 +1197,7 @@ static int yaffs_CreateTnodes(yaffs_Devi
4632         dev->freeTnodes = newTnodes;
4633  #else
4634         /* New hookup for wide tnodes */
4635 -       for(i = 0; i < nTnodes -1; i++) {
4636 +       for (i = 0; i < nTnodes - 1; i++) {
4637                 curr = (yaffs_Tnode *) &mem[i * tnodeSize];
4638                 next = (yaffs_Tnode *) &mem[(i+1) * tnodeSize];
4639                 curr->internal[0] = next;
4640 @@ -1197,7 +1224,6 @@ static int yaffs_CreateTnodes(yaffs_Devi
4641                   (TSTR
4642                    ("yaffs: Could not add tnodes to management list" TENDSTR)));
4643                    return YAFFS_FAIL;
4644 -
4645         } else {
4646                 tnl->tnodes = newTnodes;
4647                 tnl->next = dev->allocatedTnodeList;
4648 @@ -1211,14 +1237,13 @@ static int yaffs_CreateTnodes(yaffs_Devi
4649
4650  /* GetTnode gets us a clean tnode. Tries to make allocate more if we run out */
4651
4652 -static yaffs_Tnode *yaffs_GetTnodeRaw(yaffs_Device * dev)
4653 +static yaffs_Tnode *yaffs_GetTnodeRaw(yaffs_Device *dev)
4654  {
4655         yaffs_Tnode *tn = NULL;
4656
4657         /* If there are none left make more */
4658 -       if (!dev->freeTnodes) {
4659 +       if (!dev->freeTnodes)
4660                 yaffs_CreateTnodes(dev, YAFFS_ALLOCATION_NTNODES);
4661 -       }
4662
4663         if (dev->freeTnodes) {
4664                 tn = dev->freeTnodes;
4665 @@ -1233,21 +1258,27 @@ static yaffs_Tnode *yaffs_GetTnodeRaw(ya
4666                 dev->nFreeTnodes--;
4667         }
4668
4669 +       dev->nCheckpointBlocksRequired = 0; /* force recalculation*/
4670 +
4671         return tn;
4672  }
4673
4674 -static yaffs_Tnode *yaffs_GetTnode(yaffs_Device * dev)
4675 +static yaffs_Tnode *yaffs_GetTnode(yaffs_Device *dev)
4676  {
4677         yaffs_Tnode *tn = yaffs_GetTnodeRaw(dev);
4678 +       int tnodeSize = (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8;
4679
4680 -       if(tn)
4681 -               memset(tn, 0, (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8);
4682 +       if (tnodeSize < sizeof(yaffs_Tnode))
4683 +               tnodeSize = sizeof(yaffs_Tnode);
4684 +
4685 +       if (tn)
4686 +               memset(tn, 0, tnodeSize);
4687
4688         return tn;
4689  }
4690
4691  /* FreeTnode frees up a tnode and puts it back on the free list */
4692 -static void yaffs_FreeTnode(yaffs_Device * dev, yaffs_Tnode * tn)
4693 +static void yaffs_FreeTnode(yaffs_Device *dev, yaffs_Tnode *tn)
4694  {
4695         if (tn) {
4696  #ifdef CONFIG_YAFFS_TNODE_LIST_DEBUG
4697 @@ -1262,9 +1293,10 @@ static void yaffs_FreeTnode(yaffs_Device
4698                 dev->freeTnodes = tn;
4699                 dev->nFreeTnodes++;
4700         }
4701 +       dev->nCheckpointBlocksRequired = 0; /* force recalculation*/
4702  }
4703
4704 -static void yaffs_DeinitialiseTnodes(yaffs_Device * dev)
4705 +static void yaffs_DeinitialiseTnodes(yaffs_Device *dev)
4706  {
4707         /* Free the list of allocated tnodes */
4708         yaffs_TnodeList *tmp;
4709 @@ -1282,71 +1314,72 @@ static void yaffs_DeinitialiseTnodes(yaf
4710         dev->nFreeTnodes = 0;
4711  }
4712
4713 -static void yaffs_InitialiseTnodes(yaffs_Device * dev)
4714 +static void yaffs_InitialiseTnodes(yaffs_Device *dev)
4715  {
4716         dev->allocatedTnodeList = NULL;
4717         dev->freeTnodes = NULL;
4718         dev->nFreeTnodes = 0;
4719         dev->nTnodesCreated = 0;
4720 -
4721  }
4722
4723
4724 -void yaffs_PutLevel0Tnode(yaffs_Device *dev, yaffs_Tnode *tn, unsigned pos, unsigned val)
4725 +void yaffs_PutLevel0Tnode(yaffs_Device *dev, yaffs_Tnode *tn, unsigned pos,
4726 +               unsigned val)
4727  {
4728 -  __u32 *map = (__u32 *)tn;
4729 -  __u32 bitInMap;
4730 -  __u32 bitInWord;
4731 -  __u32 wordInMap;
4732 -  __u32 mask;
4733 +       __u32 *map = (__u32 *)tn;
4734 +       __u32 bitInMap;
4735 +       __u32 bitInWord;
4736 +       __u32 wordInMap;
4737 +       __u32 mask;
4738
4739 -  pos &= YAFFS_TNODES_LEVEL0_MASK;
4740 -  val >>= dev->chunkGroupBits;
4741 +       pos &= YAFFS_TNODES_LEVEL0_MASK;
4742 +       val >>= dev->chunkGroupBits;
4743
4744 -  bitInMap = pos * dev->tnodeWidth;
4745 -  wordInMap = bitInMap /32;
4746 -  bitInWord = bitInMap & (32 -1);
4747 +       bitInMap = pos * dev->tnodeWidth;
4748 +       wordInMap = bitInMap / 32;
4749 +       bitInWord = bitInMap & (32 - 1);
4750
4751 -  mask = dev->tnodeMask << bitInWord;
4752 +       mask = dev->tnodeMask << bitInWord;
4753
4754 -  map[wordInMap] &= ~mask;
4755 -  map[wordInMap] |= (mask & (val << bitInWord));
4756 +       map[wordInMap] &= ~mask;
4757 +       map[wordInMap] |= (mask & (val << bitInWord));
4758
4759 -  if(dev->tnodeWidth > (32-bitInWord)) {
4760 -    bitInWord = (32 - bitInWord);
4761 -    wordInMap++;;
4762 -    mask = dev->tnodeMask >> (/*dev->tnodeWidth -*/ bitInWord);
4763 -    map[wordInMap] &= ~mask;
4764 -    map[wordInMap] |= (mask & (val >> bitInWord));
4765 -  }
4766 +       if (dev->tnodeWidth > (32 - bitInWord)) {
4767 +               bitInWord = (32 - bitInWord);
4768 +               wordInMap++;;
4769 +               mask = dev->tnodeMask >> (/*dev->tnodeWidth -*/ bitInWord);
4770 +               map[wordInMap] &= ~mask;
4771 +               map[wordInMap] |= (mask & (val >> bitInWord));
4772 +       }
4773  }
4774
4775 -static __u32 yaffs_GetChunkGroupBase(yaffs_Device *dev, yaffs_Tnode *tn, unsigned pos)
4776 +static __u32 yaffs_GetChunkGroupBase(yaffs_Device *dev, yaffs_Tnode *tn,
4777 +               unsigned pos)
4778  {
4779 -  __u32 *map = (__u32 *)tn;
4780 -  __u32 bitInMap;
4781 -  __u32 bitInWord;
4782 -  __u32 wordInMap;
4783 -  __u32 val;
4784 +       __u32 *map = (__u32 *)tn;
4785 +       __u32 bitInMap;
4786 +       __u32 bitInWord;
4787 +       __u32 wordInMap;
4788 +       __u32 val;
4789
4790 -  pos &= YAFFS_TNODES_LEVEL0_MASK;
4791 +       pos &= YAFFS_TNODES_LEVEL0_MASK;
4792
4793 -  bitInMap = pos * dev->tnodeWidth;
4794 -  wordInMap = bitInMap /32;
4795 -  bitInWord = bitInMap & (32 -1);
4796 +       bitInMap = pos * dev->tnodeWidth;
4797 +       wordInMap = bitInMap / 32;
4798 +       bitInWord = bitInMap & (32 - 1);
4799
4800 -  val = map[wordInMap] >> bitInWord;
4801 +       val = map[wordInMap] >> bitInWord;
4802
4803 -  if(dev->tnodeWidth > (32-bitInWord)) {
4804 -    bitInWord = (32 - bitInWord);
4805 -    wordInMap++;;
4806 -    val |= (map[wordInMap] << bitInWord);
4807 -  }
4808 +       if      (dev->tnodeWidth > (32 - bitInWord)) {
4809 +               bitInWord = (32 - bitInWord);
4810 +               wordInMap++;;
4811 +               val |= (map[wordInMap] << bitInWord);
4812 +       }
4813
4814 -  val &= dev->tnodeMask;
4815 -  val <<= dev->chunkGroupBits;
4816 +       val &= dev->tnodeMask;
4817 +       val <<= dev->chunkGroupBits;
4818
4819 -  return val;
4820 +       return val;
4821  }
4822
4823  /* ------------------- End of individual tnode manipulation -----------------*/
4824 @@ -1357,24 +1390,21 @@ static __u32 yaffs_GetChunkGroupBase(yaf
4825   */
4826
4827  /* FindLevel0Tnode finds the level 0 tnode, if one exists. */
4828 -static yaffs_Tnode *yaffs_FindLevel0Tnode(yaffs_Device * dev,
4829 -                                         yaffs_FileStructure * fStruct,
4830 -                                         __u32 chunkId)
4831 +static yaffs_Tnode *yaffs_FindLevel0Tnode(yaffs_Device *dev,
4832 +                                       yaffs_FileStructure *fStruct,
4833 +                                       __u32 chunkId)
4834  {
4835 -
4836         yaffs_Tnode *tn = fStruct->top;
4837         __u32 i;
4838         int requiredTallness;
4839         int level = fStruct->topLevel;
4840
4841         /* Check sane level and chunk Id */
4842 -       if (level < 0 || level > YAFFS_TNODES_MAX_LEVEL) {
4843 +       if (level < 0 || level > YAFFS_TNODES_MAX_LEVEL)
4844                 return NULL;
4845 -       }
4846
4847 -       if (chunkId > YAFFS_MAX_CHUNK_ID) {
4848 +       if (chunkId > YAFFS_MAX_CHUNK_ID)
4849                 return NULL;
4850 -       }
4851
4852         /* First check we're tall enough (ie enough topLevel) */
4853
4854 @@ -1385,22 +1415,17 @@ static yaffs_Tnode *yaffs_FindLevel0Tnod
4855                 requiredTallness++;
4856         }
4857
4858 -       if (requiredTallness > fStruct->topLevel) {
4859 -               /* Not tall enough, so we can't find it, return NULL. */
4860 -               return NULL;
4861 -       }
4862 +       if (requiredTallness > fStruct->topLevel)
4863 +               return NULL; /* Not tall enough, so we can't find it */
4864
4865         /* Traverse down to level 0 */
4866         while (level > 0 && tn) {
4867 -               tn = tn->
4868 -                   internal[(chunkId >>
4869 -                              ( YAFFS_TNODES_LEVEL0_BITS +
4870 -                                (level - 1) *
4871 -                                YAFFS_TNODES_INTERNAL_BITS)
4872 -                             ) &
4873 -                            YAFFS_TNODES_INTERNAL_MASK];
4874 +               tn = tn->internal[(chunkId >>
4875 +                       (YAFFS_TNODES_LEVEL0_BITS +
4876 +                               (level - 1) *
4877 +                               YAFFS_TNODES_INTERNAL_BITS)) &
4878 +                       YAFFS_TNODES_INTERNAL_MASK];
4879                 level--;
4880 -
4881         }
4882
4883         return tn;
4884 @@ -1417,12 +1442,11 @@ static yaffs_Tnode *yaffs_FindLevel0Tnod
4885   *  be plugged into the ttree.
4886   */
4887
4888 -static yaffs_Tnode *yaffs_AddOrFindLevel0Tnode(yaffs_Device * dev,
4889 -                                              yaffs_FileStructure * fStruct,
4890 -                                              __u32 chunkId,
4891 -                                              yaffs_Tnode *passedTn)
4892 +static yaffs_Tnode *yaffs_AddOrFindLevel0Tnode(yaffs_Device *dev,
4893 +                                       yaffs_FileStructure *fStruct,
4894 +                                       __u32 chunkId,
4895 +                                       yaffs_Tnode *passedTn)
4896  {
4897 -
4898         int requiredTallness;
4899         int i;
4900         int l;
4901 @@ -1432,13 +1456,11 @@ static yaffs_Tnode *yaffs_AddOrFindLevel
4902
4903
4904         /* Check sane level and page Id */
4905 -       if (fStruct->topLevel < 0 || fStruct->topLevel > YAFFS_TNODES_MAX_LEVEL) {
4906 +       if (fStruct->topLevel < 0 || fStruct->topLevel > YAFFS_TNODES_MAX_LEVEL)
4907                 return NULL;
4908 -       }
4909
4910 -       if (chunkId > YAFFS_MAX_CHUNK_ID) {
4911 +       if (chunkId > YAFFS_MAX_CHUNK_ID)
4912                 return NULL;
4913 -       }
4914
4915         /* First check we're tall enough (ie enough topLevel) */
4916
4917 @@ -1451,7 +1473,7 @@ static yaffs_Tnode *yaffs_AddOrFindLevel
4918
4919
4920         if (requiredTallness > fStruct->topLevel) {
4921 -               /* Not tall enough,gotta make the tree taller */
4922 +               /* Not tall enough, gotta make the tree taller */
4923                 for (i = fStruct->topLevel; i < requiredTallness; i++) {
4924
4925                         tn = yaffs_GetTnode(dev);
4926 @@ -1473,27 +1495,27 @@ static yaffs_Tnode *yaffs_AddOrFindLevel
4927         l = fStruct->topLevel;
4928         tn = fStruct->top;
4929
4930 -       if(l > 0) {
4931 +       if (l > 0) {
4932                 while (l > 0 && tn) {
4933                         x = (chunkId >>
4934 -                            ( YAFFS_TNODES_LEVEL0_BITS +
4935 +                            (YAFFS_TNODES_LEVEL0_BITS +
4936                               (l - 1) * YAFFS_TNODES_INTERNAL_BITS)) &
4937                             YAFFS_TNODES_INTERNAL_MASK;
4938
4939
4940 -                       if((l>1) && !tn->internal[x]){
4941 +                       if ((l > 1) && !tn->internal[x]) {
4942                                 /* Add missing non-level-zero tnode */
4943                                 tn->internal[x] = yaffs_GetTnode(dev);
4944
4945 -                       } else if(l == 1) {
4946 +                       } else if (l == 1) {
4947                                 /* Looking from level 1 at level 0 */
4948 -                               if (passedTn) {
4949 +                               if (passedTn) {
4950                                         /* If we already have one, then release it.*/
4951 -                                       if(tn->internal[x])
4952 -                                               yaffs_FreeTnode(dev,tn->internal[x]);
4953 +                                       if (tn->internal[x])
4954 +                                               yaffs_FreeTnode(dev, tn->internal[x]);
4955                                         tn->internal[x] = passedTn;
4956
4957 -                               } else if(!tn->internal[x]) {
4958 +                               } else if (!tn->internal[x]) {
4959                                         /* Don't have one, none passed in */
4960                                         tn->internal[x] = yaffs_GetTnode(dev);
4961                                 }
4962 @@ -1504,31 +1526,29 @@ static yaffs_Tnode *yaffs_AddOrFindLevel
4963                 }
4964         } else {
4965                 /* top is level 0 */
4966 -               if(passedTn) {
4967 -                       memcpy(tn,passedTn,(dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8);
4968 -                       yaffs_FreeTnode(dev,passedTn);
4969 +               if (passedTn) {
4970 +                       memcpy(tn, passedTn, (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8);
4971 +                       yaffs_FreeTnode(dev, passedTn);
4972                 }
4973         }
4974
4975         return tn;
4976  }
4977
4978 -static int yaffs_FindChunkInGroup(yaffs_Device * dev, int theChunk,
4979 -                                 yaffs_ExtendedTags * tags, int objectId,
4980 -                                 int chunkInInode)
4981 +static int yaffs_FindChunkInGroup(yaffs_Device *dev, int theChunk,
4982 +                               yaffs_ExtendedTags *tags, int objectId,
4983 +                               int chunkInInode)
4984  {
4985         int j;
4986
4987         for (j = 0; theChunk && j < dev->chunkGroupSize; j++) {
4988 -               if (yaffs_CheckChunkBit
4989 -                   (dev, theChunk / dev->nChunksPerBlock,
4990 -                    theChunk % dev->nChunksPerBlock)) {
4991 +               if (yaffs_CheckChunkBit(dev, theChunk / dev->nChunksPerBlock,
4992 +                               theChunk % dev->nChunksPerBlock)) {
4993                         yaffs_ReadChunkWithTagsFromNAND(dev, theChunk, NULL,
4994                                                         tags);
4995                         if (yaffs_TagsMatch(tags, objectId, chunkInInode)) {
4996                                 /* found it; */
4997                                 return theChunk;
4998 -
4999                         }
5000                 }
5001                 theChunk++;
5002 @@ -1543,7 +1563,7 @@ static int yaffs_FindChunkInGroup(yaffs_
5003   * Returns 0 if it stopped early due to hitting the limit and the delete is incomplete.
5004   */
5005
5006 -static int yaffs_DeleteWorker(yaffs_Object * in, yaffs_Tnode * tn, __u32 level,
5007 +static int yaffs_DeleteWorker(yaffs_Object *in, yaffs_Tnode *tn, __u32 level,
5008                               int chunkOffset, int *limit)
5009  {
5010         int i;
5011 @@ -1557,7 +1577,6 @@ static int yaffs_DeleteWorker(yaffs_Obje
5012
5013         if (tn) {
5014                 if (level > 0) {
5015 -
5016                         for (i = YAFFS_NTNODES_INTERNAL - 1; allDone && i >= 0;
5017                              i--) {
5018                                 if (tn->internal[i]) {
5019 @@ -1565,17 +1584,17 @@ static int yaffs_DeleteWorker(yaffs_Obje
5020                                                 allDone = 0;
5021                                         } else {
5022                                                 allDone =
5023 -                                                   yaffs_DeleteWorker(in,
5024 -                                                                      tn->
5025 -                                                                      internal
5026 -                                                                      [i],
5027 -                                                                      level -
5028 -                                                                      1,
5029 -                                                                      (chunkOffset
5030 +                                                       yaffs_DeleteWorker(in,
5031 +                                                               tn->
5032 +                                                               internal
5033 +                                                               [i],
5034 +                                                               level -
5035 +                                                               1,
5036 +                                                               (chunkOffset
5037                                                                         <<
5038                                                                         YAFFS_TNODES_INTERNAL_BITS)
5039 -                                                                      + i,
5040 -                                                                      limit);
5041 +                                                               + i,
5042 +                                                               limit);
5043                                         }
5044                                         if (allDone) {
5045                                                 yaffs_FreeTnode(dev,
5046 @@ -1584,27 +1603,25 @@ static int yaffs_DeleteWorker(yaffs_Obje
5047                                                 tn->internal[i] = NULL;
5048                                         }
5049                                 }
5050 -
5051                         }
5052                         return (allDone) ? 1 : 0;
5053                 } else if (level == 0) {
5054                         int hitLimit = 0;
5055
5056                         for (i = YAFFS_NTNODES_LEVEL0 - 1; i >= 0 && !hitLimit;
5057 -                            i--) {
5058 -                               theChunk = yaffs_GetChunkGroupBase(dev,tn,i);
5059 +                                       i--) {
5060 +                               theChunk = yaffs_GetChunkGroupBase(dev, tn, i);
5061                                 if (theChunk) {
5062
5063 -                                       chunkInInode =
5064 -                                           (chunkOffset <<
5065 -                                            YAFFS_TNODES_LEVEL0_BITS) + i;
5066 +                                       chunkInInode = (chunkOffset <<
5067 +                                               YAFFS_TNODES_LEVEL0_BITS) + i;
5068
5069                                         foundChunk =
5070 -                                           yaffs_FindChunkInGroup(dev,
5071 -                                                                  theChunk,
5072 -                                                                  &tags,
5073 -                                                                  in->objectId,
5074 -                                                                  chunkInInode);
5075 +                                               yaffs_FindChunkInGroup(dev,
5076 +                                                               theChunk,
5077 +                                                               &tags,
5078 +                                                               in->objectId,
5079 +                                                               chunkInInode);
5080
5081                                         if (foundChunk > 0) {
5082                                                 yaffs_DeleteChunk(dev,
5083 @@ -1613,14 +1630,13 @@ static int yaffs_DeleteWorker(yaffs_Obje
5084                                                 in->nDataChunks--;
5085                                                 if (limit) {
5086                                                         *limit = *limit - 1;
5087 -                                                       if (*limit <= 0) {
5088 +                                                       if (*limit <= 0)
5089                                                                 hitLimit = 1;
5090 -                                                       }
5091                                                 }
5092
5093                                         }
5094
5095 -                                       yaffs_PutLevel0Tnode(dev,tn,i,0);
5096 +                                       yaffs_PutLevel0Tnode(dev, tn, i, 0);
5097                                 }
5098
5099                         }
5100 @@ -1634,9 +1650,8 @@ static int yaffs_DeleteWorker(yaffs_Obje
5101
5102  }
5103
5104 -static void yaffs_SoftDeleteChunk(yaffs_Device * dev, int chunk)
5105 +static void yaffs_SoftDeleteChunk(yaffs_Device *dev, int chunk)
5106  {
5107 -
5108         yaffs_BlockInfo *theBlock;
5109
5110         T(YAFFS_TRACE_DELETION, (TSTR("soft delete chunk %d" TENDSTR), chunk));
5111 @@ -1654,7 +1669,7 @@ static void yaffs_SoftDeleteChunk(yaffs_
5112   * Thus, essentially this is the same as DeleteWorker except that the chunks are soft deleted.
5113   */
5114
5115 -static int yaffs_SoftDeleteWorker(yaffs_Object * in, yaffs_Tnode * tn,
5116 +static int yaffs_SoftDeleteWorker(yaffs_Object *in, yaffs_Tnode *tn,
5117                                   __u32 level, int chunkOffset)
5118  {
5119         int i;
5120 @@ -1691,14 +1706,14 @@ static int yaffs_SoftDeleteWorker(yaffs_
5121                 } else if (level == 0) {
5122
5123                         for (i = YAFFS_NTNODES_LEVEL0 - 1; i >= 0; i--) {
5124 -                               theChunk = yaffs_GetChunkGroupBase(dev,tn,i);
5125 +                               theChunk = yaffs_GetChunkGroupBase(dev, tn, i);
5126                                 if (theChunk) {
5127                                         /* Note this does not find the real chunk, only the chunk group.
5128                                          * We make an assumption that a chunk group is not larger than
5129                                          * a block.
5130                                          */
5131                                         yaffs_SoftDeleteChunk(dev, theChunk);
5132 -                                       yaffs_PutLevel0Tnode(dev,tn,i,0);
5133 +                                       yaffs_PutLevel0Tnode(dev, tn, i, 0);
5134                                 }
5135
5136                         }
5137 @@ -1712,7 +1727,7 @@ static int yaffs_SoftDeleteWorker(yaffs_
5138
5139  }
5140
5141 -static void yaffs_SoftDeleteFile(yaffs_Object * obj)
5142 +static void yaffs_SoftDeleteFile(yaffs_Object *obj)
5143  {
5144         if (obj->deleted &&
5145             obj->variantType == YAFFS_OBJECT_TYPE_FILE && !obj->softDeleted) {
5146 @@ -1746,8 +1761,8 @@ static void yaffs_SoftDeleteFile(yaffs_O
5147   * by a special case.
5148   */
5149
5150 -static yaffs_Tnode *yaffs_PruneWorker(yaffs_Device * dev, yaffs_Tnode * tn,
5151 -                                     __u32 level, int del0)
5152 +static yaffs_Tnode *yaffs_PruneWorker(yaffs_Device *dev, yaffs_Tnode *tn,
5153 +                               __u32 level, int del0)
5154  {
5155         int i;
5156         int hasData;
5157 @@ -1763,9 +1778,8 @@ static yaffs_Tnode *yaffs_PruneWorker(ya
5158                                                       (i == 0) ? del0 : 1);
5159                         }
5160
5161 -                       if (tn->internal[i]) {
5162 +                       if (tn->internal[i])
5163                                 hasData++;
5164 -                       }
5165                 }
5166
5167                 if (hasData == 0 && del0) {
5168 @@ -1781,8 +1795,8 @@ static yaffs_Tnode *yaffs_PruneWorker(ya
5169
5170  }
5171
5172 -static int yaffs_PruneFileStructure(yaffs_Device * dev,
5173 -                                   yaffs_FileStructure * fStruct)
5174 +static int yaffs_PruneFileStructure(yaffs_Device *dev,
5175 +                               yaffs_FileStructure *fStruct)
5176  {
5177         int i;
5178         int hasData;
5179 @@ -1805,9 +1819,8 @@ static int yaffs_PruneFileStructure(yaff
5180
5181                         hasData = 0;
5182                         for (i = 1; i < YAFFS_NTNODES_INTERNAL; i++) {
5183 -                               if (tn->internal[i]) {
5184 +                               if (tn->internal[i])
5185                                         hasData++;
5186 -                               }
5187                         }
5188
5189                         if (!hasData) {
5190 @@ -1828,7 +1841,7 @@ static int yaffs_PruneFileStructure(yaff
5191  /* yaffs_CreateFreeObjects creates a bunch more objects and
5192   * adds them to the object free list.
5193   */
5194 -static int yaffs_CreateFreeObjects(yaffs_Device * dev, int nObjects)
5195 +static int yaffs_CreateFreeObjects(yaffs_Device *dev, int nObjects)
5196  {
5197         int i;
5198         yaffs_Object *newObjects;
5199 @@ -1842,9 +1855,9 @@ static int yaffs_CreateFreeObjects(yaffs
5200         list = YMALLOC(sizeof(yaffs_ObjectList));
5201
5202         if (!newObjects || !list) {
5203 -               if(newObjects)
5204 +               if (newObjects)
5205                         YFREE(newObjects);
5206 -               if(list)
5207 +               if (list)
5208                         YFREE(list);
5209                 T(YAFFS_TRACE_ALLOCATE,
5210                   (TSTR("yaffs: Could not allocate more objects" TENDSTR)));
5211 @@ -1854,7 +1867,7 @@ static int yaffs_CreateFreeObjects(yaffs
5212         /* Hook them into the free list */
5213         for (i = 0; i < nObjects - 1; i++) {
5214                 newObjects[i].siblings.next =
5215 -                   (struct list_head *)(&newObjects[i + 1]);
5216 +                               (struct ylist_head *)(&newObjects[i + 1]);
5217         }
5218
5219         newObjects[nObjects - 1].siblings.next = (void *)dev->freeObjects;
5220 @@ -1873,85 +1886,109 @@ static int yaffs_CreateFreeObjects(yaffs
5221
5222
5223  /* AllocateEmptyObject gets us a clean Object. Tries to make allocate more if we run out */
5224 -static yaffs_Object *yaffs_AllocateEmptyObject(yaffs_Device * dev)
5225 +static yaffs_Object *yaffs_AllocateEmptyObject(yaffs_Device *dev)
5226  {
5227         yaffs_Object *tn = NULL;
5228
5229 +#ifdef VALGRIND_TEST
5230 +       tn = YMALLOC(sizeof(yaffs_Object));
5231 +#else
5232         /* If there are none left make more */
5233 -       if (!dev->freeObjects) {
5234 +       if (!dev->freeObjects)
5235                 yaffs_CreateFreeObjects(dev, YAFFS_ALLOCATION_NOBJECTS);
5236 -       }
5237
5238         if (dev->freeObjects) {
5239                 tn = dev->freeObjects;
5240                 dev->freeObjects =
5241 -                   (yaffs_Object *) (dev->freeObjects->siblings.next);
5242 +                       (yaffs_Object *) (dev->freeObjects->siblings.next);
5243                 dev->nFreeObjects--;
5244 -
5245 +       }
5246 +#endif
5247 +       if (tn) {
5248                 /* Now sweeten it up... */
5249
5250                 memset(tn, 0, sizeof(yaffs_Object));
5251 +               tn->beingCreated = 1;
5252 +
5253                 tn->myDev = dev;
5254 -               tn->chunkId = -1;
5255 +               tn->hdrChunk = 0;
5256                 tn->variantType = YAFFS_OBJECT_TYPE_UNKNOWN;
5257 -               INIT_LIST_HEAD(&(tn->hardLinks));
5258 -               INIT_LIST_HEAD(&(tn->hashLink));
5259 -               INIT_LIST_HEAD(&tn->siblings);
5260 +               YINIT_LIST_HEAD(&(tn->hardLinks));
5261 +               YINIT_LIST_HEAD(&(tn->hashLink));
5262 +               YINIT_LIST_HEAD(&tn->siblings);
5263 +
5264 +
5265 +               /* Now make the directory sane */
5266 +               if (dev->rootDir) {
5267 +                       tn->parent = dev->rootDir;
5268 +                       ylist_add(&(tn->siblings), &dev->rootDir->variant.directoryVariant.children);
5269 +               }
5270
5271                 /* Add it to the lost and found directory.
5272                  * NB Can't put root or lostNFound in lostNFound so
5273                  * check if lostNFound exists first
5274                  */
5275 -               if (dev->lostNFoundDir) {
5276 +               if (dev->lostNFoundDir)
5277                         yaffs_AddObjectToDirectory(dev->lostNFoundDir, tn);
5278 -               }
5279 +
5280 +               tn->beingCreated = 0;
5281         }
5282
5283 +       dev->nCheckpointBlocksRequired = 0; /* force recalculation*/
5284 +
5285         return tn;
5286  }
5287
5288 -static yaffs_Object *yaffs_CreateFakeDirectory(yaffs_Device * dev, int number,
5289 +static yaffs_Object *yaffs_CreateFakeDirectory(yaffs_Device *dev, int number,
5290                                                __u32 mode)
5291  {
5292
5293         yaffs_Object *obj =
5294             yaffs_CreateNewObject(dev, number, YAFFS_OBJECT_TYPE_DIRECTORY);
5295         if (obj) {
5296 -               obj->fake = 1;          /* it is fake so it has no NAND presence... */
5297 +               obj->fake = 1;          /* it is fake so it might have no NAND presence... */
5298                 obj->renameAllowed = 0; /* ... and we're not allowed to rename it... */
5299                 obj->unlinkAllowed = 0; /* ... or unlink it */
5300                 obj->deleted = 0;
5301                 obj->unlinked = 0;
5302                 obj->yst_mode = mode;
5303                 obj->myDev = dev;
5304 -               obj->chunkId = 0;       /* Not a valid chunk. */
5305 +               obj->hdrChunk = 0;      /* Not a valid chunk. */
5306         }
5307
5308         return obj;
5309
5310  }
5311
5312 -static void yaffs_UnhashObject(yaffs_Object * tn)
5313 +static void yaffs_UnhashObject(yaffs_Object *tn)
5314  {
5315         int bucket;
5316         yaffs_Device *dev = tn->myDev;
5317
5318         /* If it is still linked into the bucket list, free from the list */
5319 -       if (!list_empty(&tn->hashLink)) {
5320 -               list_del_init(&tn->hashLink);
5321 +       if (!ylist_empty(&tn->hashLink)) {
5322 +               ylist_del_init(&tn->hashLink);
5323                 bucket = yaffs_HashFunction(tn->objectId);
5324                 dev->objectBucket[bucket].count--;
5325         }
5326 -
5327  }
5328
5329  /*  FreeObject frees up a Object and puts it back on the free list */
5330 -static void yaffs_FreeObject(yaffs_Object * tn)
5331 +static void yaffs_FreeObject(yaffs_Object *tn)
5332  {
5333 -
5334         yaffs_Device *dev = tn->myDev;
5335
5336 -#ifdef  __KERNEL__
5337 +#ifdef __KERNEL__
5338 +       T(YAFFS_TRACE_OS, (TSTR("FreeObject %p inode %p"TENDSTR), tn, tn->myInode));
5339 +#endif
5340 +
5341 +       if (tn->parent)
5342 +               YBUG();
5343 +       if (!ylist_empty(&tn->siblings))
5344 +               YBUG();
5345 +
5346 +
5347 +#ifdef __KERNEL__
5348         if (tn->myInode) {
5349                 /* We're still hooked up to a cached inode.
5350                  * Don't delete now, but mark for later deletion
5351 @@ -1963,24 +2000,28 @@ static void yaffs_FreeObject(yaffs_Objec
5352
5353         yaffs_UnhashObject(tn);
5354
5355 +#ifdef VALGRIND_TEST
5356 +       YFREE(tn);
5357 +#else
5358         /* Link into the free list. */
5359 -       tn->siblings.next = (struct list_head *)(dev->freeObjects);
5360 +       tn->siblings.next = (struct ylist_head *)(dev->freeObjects);
5361         dev->freeObjects = tn;
5362         dev->nFreeObjects++;
5363 +#endif
5364 +       dev->nCheckpointBlocksRequired = 0; /* force recalculation*/
5365  }
5366
5367  #ifdef __KERNEL__
5368
5369 -void yaffs_HandleDeferedFree(yaffs_Object * obj)
5370 +void yaffs_HandleDeferedFree(yaffs_Object *obj)
5371  {
5372 -       if (obj->deferedFree) {
5373 +       if (obj->deferedFree)
5374                 yaffs_FreeObject(obj);
5375 -       }
5376  }
5377
5378  #endif
5379
5380 -static void yaffs_DeinitialiseObjects(yaffs_Device * dev)
5381 +static void yaffs_DeinitialiseObjects(yaffs_Device *dev)
5382  {
5383         /* Free the list of allocated Objects */
5384
5385 @@ -1998,7 +2039,7 @@ static void yaffs_DeinitialiseObjects(ya
5386         dev->nFreeObjects = 0;
5387  }
5388
5389 -static void yaffs_InitialiseObjects(yaffs_Device * dev)
5390 +static void yaffs_InitialiseObjects(yaffs_Device *dev)
5391  {
5392         int i;
5393
5394 @@ -2007,15 +2048,14 @@ static void yaffs_InitialiseObjects(yaff
5395         dev->nFreeObjects = 0;
5396
5397         for (i = 0; i < YAFFS_NOBJECT_BUCKETS; i++) {
5398 -               INIT_LIST_HEAD(&dev->objectBucket[i].list);
5399 +               YINIT_LIST_HEAD(&dev->objectBucket[i].list);
5400                 dev->objectBucket[i].count = 0;
5401         }
5402 -
5403  }
5404
5405 -static int yaffs_FindNiceObjectBucket(yaffs_Device * dev)
5406 +static int yaffs_FindNiceObjectBucket(yaffs_Device *dev)
5407  {
5408 -       static int x = 0;
5409 +       static int x;
5410         int i;
5411         int l = 999;
5412         int lowest = 999999;
5413 @@ -2049,7 +2089,7 @@ static int yaffs_FindNiceObjectBucket(ya
5414         return l;
5415  }
5416
5417 -static int yaffs_CreateNewObjectNumber(yaffs_Device * dev)
5418 +static int yaffs_CreateNewObjectNumber(yaffs_Device *dev)
5419  {
5420         int bucket = yaffs_FindNiceObjectBucket(dev);
5421
5422 @@ -2058,7 +2098,7 @@ static int yaffs_CreateNewObjectNumber(y
5423          */
5424
5425         int found = 0;
5426 -       struct list_head *i;
5427 +       struct ylist_head *i;
5428
5429         __u32 n = (__u32) bucket;
5430
5431 @@ -2068,41 +2108,38 @@ static int yaffs_CreateNewObjectNumber(y
5432                 found = 1;
5433                 n += YAFFS_NOBJECT_BUCKETS;
5434                 if (1 || dev->objectBucket[bucket].count > 0) {
5435 -                       list_for_each(i, &dev->objectBucket[bucket].list) {
5436 +                       ylist_for_each(i, &dev->objectBucket[bucket].list) {
5437                                 /* If there is already one in the list */
5438 -                               if (i
5439 -                                   && list_entry(i, yaffs_Object,
5440 -                                                 hashLink)->objectId == n) {
5441 +                               if (i && ylist_entry(i, yaffs_Object,
5442 +                                               hashLink)->objectId == n) {
5443                                         found = 0;
5444                                 }
5445                         }
5446                 }
5447         }
5448
5449 -
5450         return n;
5451  }
5452
5453 -static void yaffs_HashObject(yaffs_Object * in)
5454 +static void yaffs_HashObject(yaffs_Object *in)
5455  {
5456         int bucket = yaffs_HashFunction(in->objectId);
5457         yaffs_Device *dev = in->myDev;
5458
5459 -       list_add(&in->hashLink, &dev->objectBucket[bucket].list);
5460 +       ylist_add(&in->hashLink, &dev->objectBucket[bucket].list);
5461         dev->objectBucket[bucket].count++;
5462 -
5463  }
5464
5465 -yaffs_Object *yaffs_FindObjectByNumber(yaffs_Device * dev, __u32 number)
5466 +yaffs_Object *yaffs_FindObjectByNumber(yaffs_Device *dev, __u32 number)
5467  {
5468         int bucket = yaffs_HashFunction(number);
5469 -       struct list_head *i;
5470 +       struct ylist_head *i;
5471         yaffs_Object *in;
5472
5473 -       list_for_each(i, &dev->objectBucket[bucket].list) {
5474 +       ylist_for_each(i, &dev->objectBucket[bucket].list) {
5475                 /* Look if it is in the list */
5476                 if (i) {
5477 -                       in = list_entry(i, yaffs_Object, hashLink);
5478 +                       in = ylist_entry(i, yaffs_Object, hashLink);
5479                         if (in->objectId == number) {
5480  #ifdef __KERNEL__
5481                                 /* Don't tell the VFS about this one if it is defered free */
5482 @@ -2118,31 +2155,27 @@ yaffs_Object *yaffs_FindObjectByNumber(y
5483         return NULL;
5484  }
5485
5486 -yaffs_Object *yaffs_CreateNewObject(yaffs_Device * dev, int number,
5487 +yaffs_Object *yaffs_CreateNewObject(yaffs_Device *dev, int number,
5488                                     yaffs_ObjectType type)
5489  {
5490 -
5491         yaffs_Object *theObject;
5492 -       yaffs_Tnode *tn;
5493 +       yaffs_Tnode *tn = NULL;
5494
5495 -       if (number < 0) {
5496 +       if (number < 0)
5497                 number = yaffs_CreateNewObjectNumber(dev);
5498 -       }
5499
5500         theObject = yaffs_AllocateEmptyObject(dev);
5501 -       if(!theObject)
5502 +       if (!theObject)
5503                 return NULL;
5504
5505 -       if(type == YAFFS_OBJECT_TYPE_FILE){
5506 +       if (type == YAFFS_OBJECT_TYPE_FILE) {
5507                 tn = yaffs_GetTnode(dev);
5508 -               if(!tn){
5509 +               if (!tn) {
5510                         yaffs_FreeObject(theObject);
5511                         return NULL;
5512                 }
5513         }
5514
5515 -
5516 -
5517         if (theObject) {
5518                 theObject->fake = 0;
5519                 theObject->renameAllowed = 1;
5520 @@ -2171,8 +2204,8 @@ yaffs_Object *yaffs_CreateNewObject(yaff
5521                         theObject->variant.fileVariant.top = tn;
5522                         break;
5523                 case YAFFS_OBJECT_TYPE_DIRECTORY:
5524 -                       INIT_LIST_HEAD(&theObject->variant.directoryVariant.
5525 -                                      children);
5526 +                       YINIT_LIST_HEAD(&theObject->variant.directoryVariant.
5527 +                                       children);
5528                         break;
5529                 case YAFFS_OBJECT_TYPE_SYMLINK:
5530                 case YAFFS_OBJECT_TYPE_HARDLINK:
5531 @@ -2188,32 +2221,30 @@ yaffs_Object *yaffs_CreateNewObject(yaff
5532         return theObject;
5533  }
5534
5535 -static yaffs_Object *yaffs_FindOrCreateObjectByNumber(yaffs_Device * dev,
5536 +static yaffs_Object *yaffs_FindOrCreateObjectByNumber(yaffs_Device *dev,
5537                                                       int number,
5538                                                       yaffs_ObjectType type)
5539  {
5540         yaffs_Object *theObject = NULL;
5541
5542 -       if (number > 0) {
5543 +       if (number > 0)
5544                 theObject = yaffs_FindObjectByNumber(dev, number);
5545 -       }
5546
5547 -       if (!theObject) {
5548 +       if (!theObject)
5549                 theObject = yaffs_CreateNewObject(dev, number, type);
5550 -       }
5551
5552         return theObject;
5553
5554  }
5555
5556
5557 -static YCHAR *yaffs_CloneString(const YCHAR * str)
5558 +static YCHAR *yaffs_CloneString(const YCHAR *str)
5559  {
5560         YCHAR *newStr = NULL;
5561
5562         if (str && *str) {
5563                 newStr = YMALLOC((yaffs_strlen(str) + 1) * sizeof(YCHAR));
5564 -               if(newStr)
5565 +               if (newStr)
5566                         yaffs_strcpy(newStr, str);
5567         }
5568
5569 @@ -2229,29 +2260,31 @@ static YCHAR *yaffs_CloneString(const YC
5570   */
5571
5572  static yaffs_Object *yaffs_MknodObject(yaffs_ObjectType type,
5573 -                                      yaffs_Object * parent,
5574 -                                      const YCHAR * name,
5575 +                                      yaffs_Object *parent,
5576 +                                      const YCHAR *name,
5577                                        __u32 mode,
5578                                        __u32 uid,
5579                                        __u32 gid,
5580 -                                      yaffs_Object * equivalentObject,
5581 -                                      const YCHAR * aliasString, __u32 rdev)
5582 +                                      yaffs_Object *equivalentObject,
5583 +                                      const YCHAR *aliasString, __u32 rdev)
5584  {
5585         yaffs_Object *in;
5586 -       YCHAR *str;
5587 +       YCHAR *str = NULL;
5588
5589         yaffs_Device *dev = parent->myDev;
5590
5591         /* Check if the entry exists. If it does then fail the call since we don't want a dup.*/
5592 -       if (yaffs_FindObjectByName(parent, name)) {
5593 +       if (yaffs_FindObjectByName(parent, name))
5594                 return NULL;
5595 -       }
5596
5597         in = yaffs_CreateNewObject(dev, -1, type);
5598
5599 -       if(type == YAFFS_OBJECT_TYPE_SYMLINK){
5600 +       if (!in)
5601 +               return YAFFS_FAIL;
5602 +
5603 +       if (type == YAFFS_OBJECT_TYPE_SYMLINK) {
5604                 str = yaffs_CloneString(aliasString);
5605 -               if(!str){
5606 +               if (!str) {
5607                         yaffs_FreeObject(in);
5608                         return NULL;
5609                 }
5610 @@ -2260,7 +2293,7 @@ static yaffs_Object *yaffs_MknodObject(y
5611
5612
5613         if (in) {
5614 -               in->chunkId = -1;
5615 +               in->hdrChunk = 0;
5616                 in->valid = 1;
5617                 in->variantType = type;
5618
5619 @@ -2293,10 +2326,10 @@ static yaffs_Object *yaffs_MknodObject(y
5620                         break;
5621                 case YAFFS_OBJECT_TYPE_HARDLINK:
5622                         in->variant.hardLinkVariant.equivalentObject =
5623 -                           equivalentObject;
5624 +                               equivalentObject;
5625                         in->variant.hardLinkVariant.equivalentObjectId =
5626 -                           equivalentObject->objectId;
5627 -                       list_add(&in->hardLinks, &equivalentObject->hardLinks);
5628 +                               equivalentObject->objectId;
5629 +                       ylist_add(&in->hardLinks, &equivalentObject->hardLinks);
5630                         break;
5631                 case YAFFS_OBJECT_TYPE_FILE:
5632                 case YAFFS_OBJECT_TYPE_DIRECTORY:
5633 @@ -2308,7 +2341,7 @@ static yaffs_Object *yaffs_MknodObject(y
5634
5635                 if (yaffs_UpdateObjectHeader(in, name, 0, 0, 0) < 0) {
5636                         /* Could not create the object header, fail the creation */
5637 -                       yaffs_DestroyObject(in);
5638 +                       yaffs_DeleteObject(in);
5639                         in = NULL;
5640                 }
5641
5642 @@ -2317,38 +2350,38 @@ static yaffs_Object *yaffs_MknodObject(y
5643         return in;
5644  }
5645
5646 -yaffs_Object *yaffs_MknodFile(yaffs_Object * parent, const YCHAR * name,
5647 -                             __u32 mode, __u32 uid, __u32 gid)
5648 +yaffs_Object *yaffs_MknodFile(yaffs_Object *parent, const YCHAR *name,
5649 +                       __u32 mode, __u32 uid, __u32 gid)
5650  {
5651         return yaffs_MknodObject(YAFFS_OBJECT_TYPE_FILE, parent, name, mode,
5652 -                                uid, gid, NULL, NULL, 0);
5653 +                               uid, gid, NULL, NULL, 0);
5654  }
5655
5656 -yaffs_Object *yaffs_MknodDirectory(yaffs_Object * parent, const YCHAR * name,
5657 -                                  __u32 mode, __u32 uid, __u32 gid)
5658 +yaffs_Object *yaffs_MknodDirectory(yaffs_Object *parent, const YCHAR *name,
5659 +                               __u32 mode, __u32 uid, __u32 gid)
5660  {
5661         return yaffs_MknodObject(YAFFS_OBJECT_TYPE_DIRECTORY, parent, name,
5662                                  mode, uid, gid, NULL, NULL, 0);
5663  }
5664
5665 -yaffs_Object *yaffs_MknodSpecial(yaffs_Object * parent, const YCHAR * name,
5666 -                                __u32 mode, __u32 uid, __u32 gid, __u32 rdev)
5667 +yaffs_Object *yaffs_MknodSpecial(yaffs_Object *parent, const YCHAR *name,
5668 +                               __u32 mode, __u32 uid, __u32 gid, __u32 rdev)
5669  {
5670         return yaffs_MknodObject(YAFFS_OBJECT_TYPE_SPECIAL, parent, name, mode,
5671                                  uid, gid, NULL, NULL, rdev);
5672  }
5673
5674 -yaffs_Object *yaffs_MknodSymLink(yaffs_Object * parent, const YCHAR * name,
5675 -                                __u32 mode, __u32 uid, __u32 gid,
5676 -                                const YCHAR * alias)
5677 +yaffs_Object *yaffs_MknodSymLink(yaffs_Object *parent, const YCHAR *name,
5678 +                               __u32 mode, __u32 uid, __u32 gid,
5679 +                               const YCHAR *alias)
5680  {
5681         return yaffs_MknodObject(YAFFS_OBJECT_TYPE_SYMLINK, parent, name, mode,
5682 -                                uid, gid, NULL, alias, 0);
5683 +                               uid, gid, NULL, alias, 0);
5684  }
5685
5686  /* yaffs_Link returns the object id of the equivalent object.*/
5687 -yaffs_Object *yaffs_Link(yaffs_Object * parent, const YCHAR * name,
5688 -                        yaffs_Object * equivalentObject)
5689 +yaffs_Object *yaffs_Link(yaffs_Object *parent, const YCHAR *name,
5690 +                       yaffs_Object *equivalentObject)
5691  {
5692         /* Get the real object in case we were fed a hard link as an equivalent object */
5693         equivalentObject = yaffs_GetEquivalentObject(equivalentObject);
5694 @@ -2363,33 +2396,31 @@ yaffs_Object *yaffs_Link(yaffs_Object *
5695
5696  }
5697
5698 -static int yaffs_ChangeObjectName(yaffs_Object * obj, yaffs_Object * newDir,
5699 -                                 const YCHAR * newName, int force, int shadows)
5700 +static int yaffs_ChangeObjectName(yaffs_Object *obj, yaffs_Object *newDir,
5701 +                               const YCHAR *newName, int force, int shadows)
5702  {
5703         int unlinkOp;
5704         int deleteOp;
5705
5706         yaffs_Object *existingTarget;
5707
5708 -       if (newDir == NULL) {
5709 +       if (newDir == NULL)
5710                 newDir = obj->parent;   /* use the old directory */
5711 -       }
5712
5713         if (newDir->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) {
5714                 T(YAFFS_TRACE_ALWAYS,
5715                   (TSTR
5716 -                  ("tragendy: yaffs_ChangeObjectName: newDir is not a directory"
5717 +                  ("tragedy: yaffs_ChangeObjectName: newDir is not a directory"
5718                     TENDSTR)));
5719                 YBUG();
5720         }
5721
5722         /* TODO: Do we need this different handling for YAFFS2 and YAFFS1?? */
5723 -       if (obj->myDev->isYaffs2) {
5724 +       if (obj->myDev->isYaffs2)
5725                 unlinkOp = (newDir == obj->myDev->unlinkedDir);
5726 -       } else {
5727 +       else
5728                 unlinkOp = (newDir == obj->myDev->unlinkedDir
5729                             && obj->variantType == YAFFS_OBJECT_TYPE_FILE);
5730 -       }
5731
5732         deleteOp = (newDir == obj->myDev->deletedDir);
5733
5734 @@ -2415,40 +2446,40 @@ static int yaffs_ChangeObjectName(yaffs_
5735                         obj->unlinked = 1;
5736
5737                 /* If it is a deletion then we mark it as a shrink for gc purposes. */
5738 -               if (yaffs_UpdateObjectHeader(obj, newName, 0, deleteOp, shadows)>= 0)
5739 +               if (yaffs_UpdateObjectHeader(obj, newName, 0, deleteOp, shadows) >= 0)
5740                         return YAFFS_OK;
5741         }
5742
5743         return YAFFS_FAIL;
5744  }
5745
5746 -int yaffs_RenameObject(yaffs_Object * oldDir, const YCHAR * oldName,
5747 -                      yaffs_Object * newDir, const YCHAR * newName)
5748 +int yaffs_RenameObject(yaffs_Object *oldDir, const YCHAR *oldName,
5749 +               yaffs_Object *newDir, const YCHAR *newName)
5750  {
5751 -       yaffs_Object *obj;
5752 -       yaffs_Object *existingTarget;
5753 +       yaffs_Object *obj = NULL;
5754 +       yaffs_Object *existingTarget = NULL;
5755         int force = 0;
5756
5757 +
5758 +       if (!oldDir || oldDir->variantType != YAFFS_OBJECT_TYPE_DIRECTORY)
5759 +               YBUG();
5760 +       if (!newDir || newDir->variantType != YAFFS_OBJECT_TYPE_DIRECTORY)
5761 +               YBUG();
5762 +
5763  #ifdef CONFIG_YAFFS_CASE_INSENSITIVE
5764         /* Special case for case insemsitive systems (eg. WinCE).
5765          * While look-up is case insensitive, the name isn't.
5766          * Therefore we might want to change x.txt to X.txt
5767         */
5768 -       if (oldDir == newDir && yaffs_strcmp(oldName, newName) == 0) {
5769 +       if (oldDir == newDir && yaffs_strcmp(oldName, newName) == 0)
5770                 force = 1;
5771 -       }
5772  #endif
5773
5774 +       else if (yaffs_strlen(newName) > YAFFS_MAX_NAME_LENGTH)
5775 +               /* ENAMETOOLONG */
5776 +               return YAFFS_FAIL;
5777 +
5778         obj = yaffs_FindObjectByName(oldDir, oldName);
5779 -       /* Check new name to long. */
5780 -       if (obj->variantType == YAFFS_OBJECT_TYPE_SYMLINK &&
5781 -           yaffs_strlen(newName) > YAFFS_MAX_ALIAS_LENGTH)
5782 -         /* ENAMETOOLONG */
5783 -         return YAFFS_FAIL;
5784 -       else if (obj->variantType != YAFFS_OBJECT_TYPE_SYMLINK &&
5785 -                yaffs_strlen(newName) > YAFFS_MAX_NAME_LENGTH)
5786 -         /* ENAMETOOLONG */
5787 -         return YAFFS_FAIL;
5788
5789         if (obj && obj->renameAllowed) {
5790
5791 @@ -2456,8 +2487,8 @@ int yaffs_RenameObject(yaffs_Object * ol
5792
5793                 existingTarget = yaffs_FindObjectByName(newDir, newName);
5794                 if (existingTarget &&
5795 -                   existingTarget->variantType == YAFFS_OBJECT_TYPE_DIRECTORY &&
5796 -                   !list_empty(&existingTarget->variant.directoryVariant.children)) {
5797 +                       existingTarget->variantType == YAFFS_OBJECT_TYPE_DIRECTORY &&
5798 +                       !ylist_empty(&existingTarget->variant.directoryVariant.children)) {
5799                         /* There is a target that is a non-empty directory, so we fail */
5800                         return YAFFS_FAIL;      /* EEXIST or ENOTEMPTY */
5801                 } else if (existingTarget && existingTarget != obj) {
5802 @@ -2465,7 +2496,7 @@ int yaffs_RenameObject(yaffs_Object * ol
5803                          * but only if it isn't the same object
5804                          */
5805                         yaffs_ChangeObjectName(obj, newDir, newName, force,
5806 -                                              existingTarget->objectId);
5807 +                                               existingTarget->objectId);
5808                         yaffs_UnlinkObject(existingTarget);
5809                 }
5810
5811 @@ -2476,7 +2507,7 @@ int yaffs_RenameObject(yaffs_Object * ol
5812
5813  /*------------------------- Block Management and Page Allocation ----------------*/
5814
5815 -static int yaffs_InitialiseBlocks(yaffs_Device * dev)
5816 +static int yaffs_InitialiseBlocks(yaffs_Device *dev)
5817  {
5818         int nBlocks = dev->internalEndBlock - dev->internalStartBlock + 1;
5819
5820 @@ -2487,23 +2518,20 @@ static int yaffs_InitialiseBlocks(yaffs_
5821
5822         /* If the first allocation strategy fails, thry the alternate one */
5823         dev->blockInfo = YMALLOC(nBlocks * sizeof(yaffs_BlockInfo));
5824 -       if(!dev->blockInfo){
5825 +       if (!dev->blockInfo) {
5826                 dev->blockInfo = YMALLOC_ALT(nBlocks * sizeof(yaffs_BlockInfo));
5827                 dev->blockInfoAlt = 1;
5828 -       }
5829 -       else
5830 +       } else
5831                 dev->blockInfoAlt = 0;
5832
5833 -       if(dev->blockInfo){
5834 -
5835 +       if (dev->blockInfo) {
5836                 /* Set up dynamic blockinfo stuff. */
5837                 dev->chunkBitmapStride = (dev->nChunksPerBlock + 7) / 8; /* round up bytes */
5838                 dev->chunkBits = YMALLOC(dev->chunkBitmapStride * nBlocks);
5839 -               if(!dev->chunkBits){
5840 +               if (!dev->chunkBits) {
5841                         dev->chunkBits = YMALLOC_ALT(dev->chunkBitmapStride * nBlocks);
5842                         dev->chunkBitsAlt = 1;
5843 -               }
5844 -               else
5845 +               } else
5846                         dev->chunkBitsAlt = 0;
5847         }
5848
5849 @@ -2514,30 +2542,29 @@ static int yaffs_InitialiseBlocks(yaffs_
5850         }
5851
5852         return YAFFS_FAIL;
5853 -
5854  }
5855
5856 -static void yaffs_DeinitialiseBlocks(yaffs_Device * dev)
5857 +static void yaffs_DeinitialiseBlocks(yaffs_Device *dev)
5858  {
5859 -       if(dev->blockInfoAlt && dev->blockInfo)
5860 +       if (dev->blockInfoAlt && dev->blockInfo)
5861                 YFREE_ALT(dev->blockInfo);
5862 -       else if(dev->blockInfo)
5863 +       else if (dev->blockInfo)
5864                 YFREE(dev->blockInfo);
5865
5866         dev->blockInfoAlt = 0;
5867
5868         dev->blockInfo = NULL;
5869
5870 -       if(dev->chunkBitsAlt && dev->chunkBits)
5871 +       if (dev->chunkBitsAlt && dev->chunkBits)
5872                 YFREE_ALT(dev->chunkBits);
5873 -       else if(dev->chunkBits)
5874 +       else if (dev->chunkBits)
5875                 YFREE(dev->chunkBits);
5876         dev->chunkBitsAlt = 0;
5877         dev->chunkBits = NULL;
5878  }
5879
5880 -static int yaffs_BlockNotDisqualifiedFromGC(yaffs_Device * dev,
5881 -                                           yaffs_BlockInfo * bi)
5882 +static int yaffs_BlockNotDisqualifiedFromGC(yaffs_Device *dev,
5883 +                                       yaffs_BlockInfo *bi)
5884  {
5885         int i;
5886         __u32 seq;
5887 @@ -2556,7 +2583,7 @@ static int yaffs_BlockNotDisqualifiedFro
5888                 seq = dev->sequenceNumber;
5889
5890                 for (i = dev->internalStartBlock; i <= dev->internalEndBlock;
5891 -                    i++) {
5892 +                               i++) {
5893                         b = yaffs_GetBlockInfo(dev, i);
5894                         if (b->blockState == YAFFS_BLOCK_STATE_FULL &&
5895                             (b->pagesInUse - b->softDeletions) <
5896 @@ -2571,38 +2598,36 @@ static int yaffs_BlockNotDisqualifiedFro
5897          * discarded pages.
5898          */
5899         return (bi->sequenceNumber <= dev->oldestDirtySequence);
5900 -
5901  }
5902
5903  /* FindDiretiestBlock is used to select the dirtiest block (or close enough)
5904   * for garbage collection.
5905   */
5906
5907 -static int yaffs_FindBlockForGarbageCollection(yaffs_Device * dev,
5908 -                                              int aggressive)
5909 +static int yaffs_FindBlockForGarbageCollection(yaffs_Device *dev,
5910 +                                       int aggressive)
5911  {
5912 -
5913         int b = dev->currentDirtyChecker;
5914
5915         int i;
5916         int iterations;
5917         int dirtiest = -1;
5918         int pagesInUse = 0;
5919 -       int prioritised=0;
5920 +       int prioritised = 0;
5921         yaffs_BlockInfo *bi;
5922         int pendingPrioritisedExist = 0;
5923
5924         /* First let's see if we need to grab a prioritised block */
5925 -       if(dev->hasPendingPrioritisedGCs){
5926 -               for(i = dev->internalStartBlock; i < dev->internalEndBlock && !prioritised; i++){
5927 +       if (dev->hasPendingPrioritisedGCs) {
5928 +               for (i = dev->internalStartBlock; i < dev->internalEndBlock && !prioritised; i++) {
5929
5930                         bi = yaffs_GetBlockInfo(dev, i);
5931 -                       //yaffs_VerifyBlock(dev,bi,i);
5932 +                       /* yaffs_VerifyBlock(dev,bi,i); */
5933
5934 -                       if(bi->gcPrioritise) {
5935 +                       if (bi->gcPrioritise) {
5936                                 pendingPrioritisedExist = 1;
5937 -                               if(bi->blockState == YAFFS_BLOCK_STATE_FULL &&
5938 -                                  yaffs_BlockNotDisqualifiedFromGC(dev, bi)){
5939 +                               if (bi->blockState == YAFFS_BLOCK_STATE_FULL &&
5940 +                                  yaffs_BlockNotDisqualifiedFromGC(dev, bi)) {
5941                                         pagesInUse = (bi->pagesInUse - bi->softDeletions);
5942                                         dirtiest = i;
5943                                         prioritised = 1;
5944 @@ -2611,7 +2636,7 @@ static int yaffs_FindBlockForGarbageColl
5945                         }
5946                 }
5947
5948 -               if(!pendingPrioritisedExist) /* None found, so we can clear this */
5949 +               if (!pendingPrioritisedExist) /* None found, so we can clear this */
5950                         dev->hasPendingPrioritisedGCs = 0;
5951         }
5952
5953 @@ -2623,31 +2648,28 @@ static int yaffs_FindBlockForGarbageColl
5954
5955         dev->nonAggressiveSkip--;
5956
5957 -       if (!aggressive && (dev->nonAggressiveSkip > 0)) {
5958 +       if (!aggressive && (dev->nonAggressiveSkip > 0))
5959                 return -1;
5960 -       }
5961
5962 -       if(!prioritised)
5963 +       if (!prioritised)
5964                 pagesInUse =
5965 -                       (aggressive) ? dev->nChunksPerBlock : YAFFS_PASSIVE_GC_CHUNKS + 1;
5966 +                       (aggressive) ? dev->nChunksPerBlock : YAFFS_PASSIVE_GC_CHUNKS + 1;
5967
5968 -       if (aggressive) {
5969 +       if (aggressive)
5970                 iterations =
5971                     dev->internalEndBlock - dev->internalStartBlock + 1;
5972 -       } else {
5973 +       else {
5974                 iterations =
5975                     dev->internalEndBlock - dev->internalStartBlock + 1;
5976                 iterations = iterations / 16;
5977 -               if (iterations > 200) {
5978 +               if (iterations > 200)
5979                         iterations = 200;
5980 -               }
5981         }
5982
5983         for (i = 0; i <= iterations && pagesInUse > 0 && !prioritised; i++) {
5984                 b++;
5985 -               if (b < dev->internalStartBlock || b > dev->internalEndBlock) {
5986 +               if (b < dev->internalStartBlock || b > dev->internalEndBlock)
5987                         b = dev->internalStartBlock;
5988 -               }
5989
5990                 if (b < dev->internalStartBlock || b > dev->internalEndBlock) {
5991                         T(YAFFS_TRACE_ERROR,
5992 @@ -2657,17 +2679,9 @@ static int yaffs_FindBlockForGarbageColl
5993
5994                 bi = yaffs_GetBlockInfo(dev, b);
5995
5996 -#if 0
5997 -               if (bi->blockState == YAFFS_BLOCK_STATE_CHECKPOINT) {
5998 -                       dirtiest = b;
5999 -                       pagesInUse = 0;
6000 -               }
6001 -               else
6002 -#endif
6003 -
6004                 if (bi->blockState == YAFFS_BLOCK_STATE_FULL &&
6005 -                      (bi->pagesInUse - bi->softDeletions) < pagesInUse &&
6006 -                       yaffs_BlockNotDisqualifiedFromGC(dev, bi)) {
6007 +                       (bi->pagesInUse - bi->softDeletions) < pagesInUse &&
6008 +                               yaffs_BlockNotDisqualifiedFromGC(dev, bi)) {
6009                         dirtiest = b;
6010                         pagesInUse = (bi->pagesInUse - bi->softDeletions);
6011                 }
6012 @@ -2678,19 +2692,18 @@ static int yaffs_FindBlockForGarbageColl
6013         if (dirtiest > 0) {
6014                 T(YAFFS_TRACE_GC,
6015                   (TSTR("GC Selected block %d with %d free, prioritised:%d" TENDSTR), dirtiest,
6016 -                  dev->nChunksPerBlock - pagesInUse,prioritised));
6017 +                  dev->nChunksPerBlock - pagesInUse, prioritised));
6018         }
6019
6020         dev->oldestDirtySequence = 0;
6021
6022 -       if (dirtiest > 0) {
6023 +       if (dirtiest > 0)
6024                 dev->nonAggressiveSkip = 4;
6025 -       }
6026
6027         return dirtiest;
6028  }
6029
6030 -static void yaffs_BlockBecameDirty(yaffs_Device * dev, int blockNo)
6031 +static void yaffs_BlockBecameDirty(yaffs_Device *dev, int blockNo)
6032  {
6033         yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, blockNo);
6034
6035 @@ -2752,7 +2765,7 @@ static void yaffs_BlockBecameDirty(yaffs
6036         }
6037  }
6038
6039 -static int yaffs_FindBlockForAllocation(yaffs_Device * dev)
6040 +static int yaffs_FindBlockForAllocation(yaffs_Device *dev)
6041  {
6042         int i;
6043
6044 @@ -2763,7 +2776,7 @@ static int yaffs_FindBlockForAllocation(
6045                  * Can't get space to gc
6046                  */
6047                 T(YAFFS_TRACE_ERROR,
6048 -                 (TSTR("yaffs tragedy: no more eraased blocks" TENDSTR)));
6049 +                 (TSTR("yaffs tragedy: no more erased blocks" TENDSTR)));
6050
6051                 return -1;
6052         }
6053 @@ -2794,31 +2807,74 @@ static int yaffs_FindBlockForAllocation(
6054
6055         T(YAFFS_TRACE_ALWAYS,
6056           (TSTR
6057 -          ("yaffs tragedy: no more eraased blocks, but there should have been %d"
6058 +          ("yaffs tragedy: no more erased blocks, but there should have been %d"
6059             TENDSTR), dev->nErasedBlocks));
6060
6061         return -1;
6062  }
6063
6064
6065 -// Check if there's space to allocate...
6066 -// Thinks.... do we need top make this ths same as yaffs_GetFreeChunks()?
6067 -static int yaffs_CheckSpaceForAllocation(yaffs_Device * dev)
6068 +
6069 +static int yaffs_CalcCheckpointBlocksRequired(yaffs_Device *dev)
6070 +{
6071 +       if (!dev->nCheckpointBlocksRequired &&
6072 +          dev->isYaffs2) {
6073 +               /* Not a valid value so recalculate */
6074 +               int nBytes = 0;
6075 +               int nBlocks;
6076 +               int devBlocks = (dev->endBlock - dev->startBlock + 1);
6077 +               int tnodeSize;
6078 +
6079 +               tnodeSize = (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8;
6080 +
6081 +               if (tnodeSize < sizeof(yaffs_Tnode))
6082 +                       tnodeSize = sizeof(yaffs_Tnode);
6083 +
6084 +               nBytes += sizeof(yaffs_CheckpointValidity);
6085 +               nBytes += sizeof(yaffs_CheckpointDevice);
6086 +               nBytes += devBlocks * sizeof(yaffs_BlockInfo);
6087 +               nBytes += devBlocks * dev->chunkBitmapStride;
6088 +               nBytes += (sizeof(yaffs_CheckpointObject) + sizeof(__u32)) * (dev->nObjectsCreated - dev->nFreeObjects);
6089 +               nBytes += (tnodeSize + sizeof(__u32)) * (dev->nTnodesCreated - dev->nFreeTnodes);
6090 +               nBytes += sizeof(yaffs_CheckpointValidity);
6091 +               nBytes += sizeof(__u32); /* checksum*/
6092 +
6093 +               /* Round up and add 2 blocks to allow for some bad blocks, so add 3 */
6094 +
6095 +               nBlocks = (nBytes/(dev->nDataBytesPerChunk * dev->nChunksPerBlock)) + 3;
6096 +
6097 +               dev->nCheckpointBlocksRequired = nBlocks;
6098 +       }
6099 +
6100 +       return dev->nCheckpointBlocksRequired;
6101 +}
6102 +
6103 +/*
6104 + * Check if there's space to allocate...
6105 + * Thinks.... do we need top make this ths same as yaffs_GetFreeChunks()?
6106 + */
6107 +static int yaffs_CheckSpaceForAllocation(yaffs_Device *dev)
6108  {
6109         int reservedChunks;
6110         int reservedBlocks = dev->nReservedBlocks;
6111         int checkpointBlocks;
6112
6113 -       checkpointBlocks =  dev->nCheckpointReservedBlocks - dev->blocksInCheckpoint;
6114 -       if(checkpointBlocks < 0)
6115 +       if (dev->isYaffs2) {
6116 +               checkpointBlocks =  yaffs_CalcCheckpointBlocksRequired(dev) -
6117 +                                   dev->blocksInCheckpoint;
6118 +               if (checkpointBlocks < 0)
6119 +                       checkpointBlocks = 0;
6120 +       } else {
6121                 checkpointBlocks = 0;
6122 +       }
6123
6124         reservedChunks = ((reservedBlocks + checkpointBlocks) * dev->nChunksPerBlock);
6125
6126         return (dev->nFreeChunks > reservedChunks);
6127  }
6128
6129 -static int yaffs_AllocateChunk(yaffs_Device * dev, int useReserve, yaffs_BlockInfo **blockUsedPtr)
6130 +static int yaffs_AllocateChunk(yaffs_Device *dev, int useReserve,
6131 +               yaffs_BlockInfo **blockUsedPtr)
6132  {
6133         int retVal;
6134         yaffs_BlockInfo *bi;
6135 @@ -2835,7 +2891,7 @@ static int yaffs_AllocateChunk(yaffs_Dev
6136         }
6137
6138         if (dev->nErasedBlocks < dev->nReservedBlocks
6139 -           && dev->allocationPage == 0) {
6140 +                       && dev->allocationPage == 0) {
6141                 T(YAFFS_TRACE_ALLOCATE, (TSTR("Allocating reserve" TENDSTR)));
6142         }
6143
6144 @@ -2844,10 +2900,10 @@ static int yaffs_AllocateChunk(yaffs_Dev
6145                 bi = yaffs_GetBlockInfo(dev, dev->allocationBlock);
6146
6147                 retVal = (dev->allocationBlock * dev->nChunksPerBlock) +
6148 -                   dev->allocationPage;
6149 +                       dev->allocationPage;
6150                 bi->pagesInUse++;
6151                 yaffs_SetChunkBit(dev, dev->allocationBlock,
6152 -                                 dev->allocationPage);
6153 +                               dev->allocationPage);
6154
6155                 dev->allocationPage++;
6156
6157 @@ -2859,43 +2915,43 @@ static int yaffs_AllocateChunk(yaffs_Dev
6158                         dev->allocationBlock = -1;
6159                 }
6160
6161 -               if(blockUsedPtr)
6162 +               if (blockUsedPtr)
6163                         *blockUsedPtr = bi;
6164
6165                 return retVal;
6166         }
6167
6168         T(YAFFS_TRACE_ERROR,
6169 -         (TSTR("!!!!!!!!! Allocator out !!!!!!!!!!!!!!!!!" TENDSTR)));
6170 +                       (TSTR("!!!!!!!!! Allocator out !!!!!!!!!!!!!!!!!" TENDSTR)));
6171
6172         return -1;
6173  }
6174
6175 -static int yaffs_GetErasedChunks(yaffs_Device * dev)
6176 +static int yaffs_GetErasedChunks(yaffs_Device *dev)
6177  {
6178         int n;
6179
6180         n = dev->nErasedBlocks * dev->nChunksPerBlock;
6181
6182 -       if (dev->allocationBlock > 0) {
6183 +       if (dev->allocationBlock > 0)
6184                 n += (dev->nChunksPerBlock - dev->allocationPage);
6185 -       }
6186
6187         return n;
6188
6189  }
6190
6191 -static int yaffs_GarbageCollectBlock(yaffs_Device * dev, int block)
6192 +static int yaffs_GarbageCollectBlock(yaffs_Device *dev, int block,
6193 +               int wholeBlock)
6194  {
6195         int oldChunk;
6196         int newChunk;
6197 -       int chunkInBlock;
6198         int markNAND;
6199         int retVal = YAFFS_OK;
6200         int cleanups = 0;
6201         int i;
6202         int isCheckpointBlock;
6203         int matchingChunk;
6204 +       int maxCopies;
6205
6206         int chunksBefore = yaffs_GetErasedChunks(dev);
6207         int chunksAfter;
6208 @@ -2911,8 +2967,11 @@ static int yaffs_GarbageCollectBlock(yaf
6209         bi->blockState = YAFFS_BLOCK_STATE_COLLECTING;
6210
6211         T(YAFFS_TRACE_TRACING,
6212 -         (TSTR("Collecting block %d, in use %d, shrink %d, " TENDSTR), block,
6213 -          bi->pagesInUse, bi->hasShrinkHeader));
6214 +                       (TSTR("Collecting block %d, in use %d, shrink %d, wholeBlock %d" TENDSTR),
6215 +                        block,
6216 +                        bi->pagesInUse,
6217 +                        bi->hasShrinkHeader,
6218 +                        wholeBlock));
6219
6220         /*yaffs_VerifyFreeChunks(dev); */
6221
6222 @@ -2926,26 +2985,33 @@ static int yaffs_GarbageCollectBlock(yaf
6223         dev->isDoingGC = 1;
6224
6225         if (isCheckpointBlock ||
6226 -           !yaffs_StillSomeChunkBits(dev, block)) {
6227 +                       !yaffs_StillSomeChunkBits(dev, block)) {
6228                 T(YAFFS_TRACE_TRACING,
6229 -                 (TSTR
6230 -                  ("Collecting block %d that has no chunks in use" TENDSTR),
6231 -                  block));
6232 +                               (TSTR
6233 +                                ("Collecting block %d that has no chunks in use" TENDSTR),
6234 +                                block));
6235                 yaffs_BlockBecameDirty(dev, block);
6236         } else {
6237
6238                 __u8 *buffer = yaffs_GetTempBuffer(dev, __LINE__);
6239
6240 -               yaffs_VerifyBlock(dev,bi,block);
6241 +               yaffs_VerifyBlock(dev, bi, block);
6242
6243 -               for (chunkInBlock = 0, oldChunk = block * dev->nChunksPerBlock;
6244 -                    chunkInBlock < dev->nChunksPerBlock
6245 -                    && yaffs_StillSomeChunkBits(dev, block);
6246 -                    chunkInBlock++, oldChunk++) {
6247 -                       if (yaffs_CheckChunkBit(dev, block, chunkInBlock)) {
6248 +               maxCopies = (wholeBlock) ? dev->nChunksPerBlock : 10;
6249 +               oldChunk = block * dev->nChunksPerBlock + dev->gcChunk;
6250 +
6251 +               for (/* init already done */;
6252 +                    retVal == YAFFS_OK &&
6253 +                    dev->gcChunk < dev->nChunksPerBlock &&
6254 +                    (bi->blockState == YAFFS_BLOCK_STATE_COLLECTING) &&
6255 +                    maxCopies > 0;
6256 +                    dev->gcChunk++, oldChunk++) {
6257 +                       if (yaffs_CheckChunkBit(dev, block, dev->gcChunk)) {
6258
6259                                 /* This page is in use and might need to be copied off */
6260
6261 +                               maxCopies--;
6262 +
6263                                 markNAND = 1;
6264
6265                                 yaffs_InitialiseTags(&tags);
6266 @@ -2959,22 +3025,22 @@ static int yaffs_GarbageCollectBlock(yaf
6267
6268                                 T(YAFFS_TRACE_GC_DETAIL,
6269                                   (TSTR
6270 -                                  ("Collecting page %d, %d %d %d " TENDSTR),
6271 -                                  chunkInBlock, tags.objectId, tags.chunkId,
6272 +                                  ("Collecting chunk in block %d, %d %d %d " TENDSTR),
6273 +                                  dev->gcChunk, tags.objectId, tags.chunkId,
6274                                    tags.byteCount));
6275
6276 -                               if(object && !yaffs_SkipVerification(dev)){
6277 -                                       if(tags.chunkId == 0)
6278 -                                               matchingChunk = object->chunkId;
6279 -                                       else if(object->softDeleted)
6280 +                               if (object && !yaffs_SkipVerification(dev)) {
6281 +                                       if (tags.chunkId == 0)
6282 +                                               matchingChunk = object->hdrChunk;
6283 +                                       else if (object->softDeleted)
6284                                                 matchingChunk = oldChunk; /* Defeat the test */
6285                                         else
6286 -                                               matchingChunk = yaffs_FindChunkInFile(object,tags.chunkId,NULL);
6287 +                                               matchingChunk = yaffs_FindChunkInFile(object, tags.chunkId, NULL);
6288
6289 -                                       if(oldChunk != matchingChunk)
6290 +                                       if (oldChunk != matchingChunk)
6291                                                 T(YAFFS_TRACE_ERROR,
6292                                                   (TSTR("gc: page in gc mismatch: %d %d %d %d"TENDSTR),
6293 -                                                 oldChunk,matchingChunk,tags.objectId, tags.chunkId));
6294 +                                                 oldChunk, matchingChunk, tags.objectId, tags.chunkId));
6295
6296                                 }
6297
6298 @@ -2986,9 +3052,11 @@ static int yaffs_GarbageCollectBlock(yaf
6299                                             tags.objectId, tags.chunkId, tags.byteCount));
6300                                 }
6301
6302 -                               if (object && object->deleted
6303 -                                   && tags.chunkId != 0) {
6304 -                                       /* Data chunk in a deleted file, throw it away
6305 +                               if (object &&
6306 +                                   object->deleted &&
6307 +                                   object->softDeleted &&
6308 +                                   tags.chunkId != 0) {
6309 +                                       /* Data chunk in a soft deleted file, throw it away
6310                                          * It's a soft deleted data chunk,
6311                                          * No need to copy this, just forget about it and
6312                                          * fix up the object.
6313 @@ -3003,13 +3071,12 @@ static int yaffs_GarbageCollectBlock(yaf
6314                                                 cleanups++;
6315                                         }
6316                                         markNAND = 0;
6317 -                               } else if (0
6318 -                                          /* Todo object && object->deleted && object->nDataChunks == 0 */
6319 -                                          ) {
6320 +                               } else if (0) {
6321 +                                       /* Todo object && object->deleted && object->nDataChunks == 0 */
6322                                         /* Deleted object header with no data chunks.
6323                                          * Can be discarded and the file deleted.
6324                                          */
6325 -                                       object->chunkId = 0;
6326 +                                       object->hdrChunk = 0;
6327                                         yaffs_FreeTnode(object->myDev,
6328                                                         object->variant.
6329                                                         fileVariant.top);
6330 @@ -3031,17 +3098,14 @@ static int yaffs_GarbageCollectBlock(yaf
6331                                                  * We need to nuke the shrinkheader flags first
6332                                                  * We no longer want the shrinkHeader flag since its work is done
6333                                                  * and if it is left in place it will mess up scanning.
6334 -                                                * Also, clear out any shadowing stuff
6335                                                  */
6336
6337                                                 yaffs_ObjectHeader *oh;
6338                                                 oh = (yaffs_ObjectHeader *)buffer;
6339                                                 oh->isShrink = 0;
6340 -                                               oh->shadowsObject = -1;
6341 -                                               tags.extraShadows = 0;
6342                                                 tags.extraIsShrinkHeader = 0;
6343
6344 -                                               yaffs_VerifyObjectHeader(object,oh,&tags,1);
6345 +                                               yaffs_VerifyObjectHeader(object, oh, &tags, 1);
6346                                         }
6347
6348                                         newChunk =
6349 @@ -3055,7 +3119,7 @@ static int yaffs_GarbageCollectBlock(yaf
6350
6351                                                 if (tags.chunkId == 0) {
6352                                                         /* It's a header */
6353 -                                                       object->chunkId =  newChunk;
6354 +                                                       object->hdrChunk =  newChunk;
6355                                                         object->serial =   tags.serialNumber;
6356                                                 } else {
6357                                                         /* It's a data chunk */
6358 @@ -3067,7 +3131,8 @@ static int yaffs_GarbageCollectBlock(yaf
6359                                         }
6360                                 }
6361
6362 -                               yaffs_DeleteChunk(dev, oldChunk, markNAND, __LINE__);
6363 +                               if (retVal == YAFFS_OK)
6364 +                                       yaffs_DeleteChunk(dev, oldChunk, markNAND, __LINE__);
6365
6366                         }
6367                 }
6368 @@ -3098,18 +3163,25 @@ static int yaffs_GarbageCollectBlock(yaf
6369
6370         }
6371
6372 -       yaffs_VerifyCollectedBlock(dev,bi,block);
6373 +       yaffs_VerifyCollectedBlock(dev, bi, block);
6374
6375 -       if (chunksBefore >= (chunksAfter = yaffs_GetErasedChunks(dev))) {
6376 +       chunksAfter = yaffs_GetErasedChunks(dev);
6377 +       if (chunksBefore >= chunksAfter) {
6378                 T(YAFFS_TRACE_GC,
6379                   (TSTR
6380                    ("gc did not increase free chunks before %d after %d"
6381                     TENDSTR), chunksBefore, chunksAfter));
6382         }
6383
6384 +       /* If the gc completed then clear the current gcBlock so that we find another. */
6385 +       if (bi->blockState != YAFFS_BLOCK_STATE_COLLECTING) {
6386 +               dev->gcBlock = -1;
6387 +               dev->gcChunk = 0;
6388 +       }
6389 +
6390         dev->isDoingGC = 0;
6391
6392 -       return YAFFS_OK;
6393 +       return retVal;
6394  }
6395
6396  /* New garbage collector
6397 @@ -3121,7 +3193,7 @@ static int yaffs_GarbageCollectBlock(yaf
6398   * The idea is to help clear out space in a more spread-out manner.
6399   * Dunno if it really does anything useful.
6400   */
6401 -static int yaffs_CheckGarbageCollection(yaffs_Device * dev)
6402 +static int yaffs_CheckGarbageCollection(yaffs_Device *dev)
6403  {
6404         int block;
6405         int aggressive;
6406 @@ -3142,8 +3214,8 @@ static int yaffs_CheckGarbageCollection(
6407         do {
6408                 maxTries++;
6409
6410 -               checkpointBlockAdjust = (dev->nCheckpointReservedBlocks - dev->blocksInCheckpoint);
6411 -               if(checkpointBlockAdjust < 0)
6412 +               checkpointBlockAdjust = yaffs_CalcCheckpointBlocksRequired(dev) - dev->blocksInCheckpoint;
6413 +               if (checkpointBlockAdjust < 0)
6414                         checkpointBlockAdjust = 0;
6415
6416                 if (dev->nErasedBlocks < (dev->nReservedBlocks + checkpointBlockAdjust + 2)) {
6417 @@ -3154,20 +3226,24 @@ static int yaffs_CheckGarbageCollection(
6418                         aggressive = 0;
6419                 }
6420
6421 -               block = yaffs_FindBlockForGarbageCollection(dev, aggressive);
6422 +               if (dev->gcBlock <= 0) {
6423 +                       dev->gcBlock = yaffs_FindBlockForGarbageCollection(dev, aggressive);
6424 +                       dev->gcChunk = 0;
6425 +               }
6426 +
6427 +               block = dev->gcBlock;
6428
6429                 if (block > 0) {
6430                         dev->garbageCollections++;
6431 -                       if (!aggressive) {
6432 +                       if (!aggressive)
6433                                 dev->passiveGarbageCollections++;
6434 -                       }
6435
6436                         T(YAFFS_TRACE_GC,
6437                           (TSTR
6438                            ("yaffs: GC erasedBlocks %d aggressive %d" TENDSTR),
6439                            dev->nErasedBlocks, aggressive));
6440
6441 -                       gcOk = yaffs_GarbageCollectBlock(dev, block);
6442 +                       gcOk = yaffs_GarbageCollectBlock(dev, block, aggressive);
6443                 }
6444
6445                 if (dev->nErasedBlocks < (dev->nReservedBlocks) && block > 0) {
6446 @@ -3176,15 +3252,16 @@ static int yaffs_CheckGarbageCollection(
6447                            ("yaffs: GC !!!no reclaim!!! erasedBlocks %d after try %d block %d"
6448                             TENDSTR), dev->nErasedBlocks, maxTries, block));
6449                 }
6450 -       } while ((dev->nErasedBlocks < dev->nReservedBlocks) && (block > 0)
6451 -                && (maxTries < 2));
6452 +       } while ((dev->nErasedBlocks < dev->nReservedBlocks) &&
6453 +                (block > 0) &&
6454 +                (maxTries < 2));
6455
6456         return aggressive ? gcOk : YAFFS_OK;
6457  }
6458
6459  /*-------------------------  TAGS --------------------------------*/
6460
6461 -static int yaffs_TagsMatch(const yaffs_ExtendedTags * tags, int objectId,
6462 +static int yaffs_TagsMatch(const yaffs_ExtendedTags *tags, int objectId,
6463                            int chunkInObject)
6464  {
6465         return (tags->chunkId == chunkInObject &&
6466 @@ -3195,8 +3272,8 @@ static int yaffs_TagsMatch(const yaffs_E
6467
6468  /*-------------------- Data file manipulation -----------------*/
6469
6470 -static int yaffs_FindChunkInFile(yaffs_Object * in, int chunkInInode,
6471 -                                yaffs_ExtendedTags * tags)
6472 +static int yaffs_FindChunkInFile(yaffs_Object *in, int chunkInInode,
6473 +                                yaffs_ExtendedTags *tags)
6474  {
6475         /*Get the Tnode, then get the level 0 offset chunk offset */
6476         yaffs_Tnode *tn;
6477 @@ -3214,7 +3291,7 @@ static int yaffs_FindChunkInFile(yaffs_O
6478         tn = yaffs_FindLevel0Tnode(dev, &in->variant.fileVariant, chunkInInode);
6479
6480         if (tn) {
6481 -               theChunk = yaffs_GetChunkGroupBase(dev,tn,chunkInInode);
6482 +               theChunk = yaffs_GetChunkGroupBase(dev, tn, chunkInInode);
6483
6484                 retVal =
6485                     yaffs_FindChunkInGroup(dev, theChunk, tags, in->objectId,
6486 @@ -3223,8 +3300,8 @@ static int yaffs_FindChunkInFile(yaffs_O
6487         return retVal;
6488  }
6489
6490 -static int yaffs_FindAndDeleteChunkInFile(yaffs_Object * in, int chunkInInode,
6491 -                                         yaffs_ExtendedTags * tags)
6492 +static int yaffs_FindAndDeleteChunkInFile(yaffs_Object *in, int chunkInInode,
6493 +                                         yaffs_ExtendedTags *tags)
6494  {
6495         /* Get the Tnode, then get the level 0 offset chunk offset */
6496         yaffs_Tnode *tn;
6497 @@ -3243,29 +3320,23 @@ static int yaffs_FindAndDeleteChunkInFil
6498
6499         if (tn) {
6500
6501 -               theChunk = yaffs_GetChunkGroupBase(dev,tn,chunkInInode);
6502 +               theChunk = yaffs_GetChunkGroupBase(dev, tn, chunkInInode);
6503
6504                 retVal =
6505                     yaffs_FindChunkInGroup(dev, theChunk, tags, in->objectId,
6506                                            chunkInInode);
6507
6508                 /* Delete the entry in the filestructure (if found) */
6509 -               if (retVal != -1) {
6510 -                       yaffs_PutLevel0Tnode(dev,tn,chunkInInode,0);
6511 -               }
6512 -       } else {
6513 -               /*T(("No level 0 found for %d\n", chunkInInode)); */
6514 +               if (retVal != -1)
6515 +                       yaffs_PutLevel0Tnode(dev, tn, chunkInInode, 0);
6516         }
6517
6518 -       if (retVal == -1) {
6519 -               /* T(("Could not find %d to delete\n",chunkInInode)); */
6520 -       }
6521         return retVal;
6522  }
6523
6524  #ifdef YAFFS_PARANOID
6525
6526 -static int yaffs_CheckFileSanity(yaffs_Object * in)
6527 +static int yaffs_CheckFileSanity(yaffs_Object *in)
6528  {
6529         int chunk;
6530         int nChunks;
6531 @@ -3278,10 +3349,8 @@ static int yaffs_CheckFileSanity(yaffs_O
6532         int theChunk;
6533         int chunkDeleted;
6534
6535 -       if (in->variantType != YAFFS_OBJECT_TYPE_FILE) {
6536 -               /* T(("Object not a file\n")); */
6537 +       if (in->variantType != YAFFS_OBJECT_TYPE_FILE)
6538                 return YAFFS_FAIL;
6539 -       }
6540
6541         objId = in->objectId;
6542         fSize = in->variant.fileVariant.fileSize;
6543 @@ -3294,7 +3363,7 @@ static int yaffs_CheckFileSanity(yaffs_O
6544
6545                 if (tn) {
6546
6547 -                       theChunk = yaffs_GetChunkGroupBase(dev,tn,chunk);
6548 +                       theChunk = yaffs_GetChunkGroupBase(dev, tn, chunk);
6549
6550                         if (yaffs_CheckChunkBits
6551                             (dev, theChunk / dev->nChunksPerBlock,
6552 @@ -3323,7 +3392,7 @@ static int yaffs_CheckFileSanity(yaffs_O
6553
6554  #endif
6555
6556 -static int yaffs_PutChunkIntoFile(yaffs_Object * in, int chunkInInode,
6557 +static int yaffs_PutChunkIntoFile(yaffs_Object *in, int chunkInInode,
6558                                   int chunkInNAND, int inScan)
6559  {
6560         /* NB inScan is zero unless scanning.
6561 @@ -3358,11 +3427,10 @@ static int yaffs_PutChunkIntoFile(yaffs_
6562                                         &in->variant.fileVariant,
6563                                         chunkInInode,
6564                                         NULL);
6565 -       if (!tn) {
6566 +       if (!tn)
6567                 return YAFFS_FAIL;
6568 -       }
6569
6570 -       existingChunk = yaffs_GetChunkGroupBase(dev,tn,chunkInInode);
6571 +       existingChunk = yaffs_GetChunkGroupBase(dev, tn, chunkInInode);
6572
6573         if (inScan != 0) {
6574                 /* If we're scanning then we need to test for duplicates
6575 @@ -3374,7 +3442,7 @@ static int yaffs_PutChunkIntoFile(yaffs_
6576                  * Update: For backward scanning we don't need to re-read tags so this is quite cheap.
6577                  */
6578
6579 -               if (existingChunk != 0) {
6580 +               if (existingChunk > 0) {
6581                         /* NB Right now existing chunk will not be real chunkId if the device >= 32MB
6582                          *    thus we have to do a FindChunkInFile to get the real chunk id.
6583                          *
6584 @@ -3411,8 +3479,10 @@ static int yaffs_PutChunkIntoFile(yaffs_
6585                          * not be loaded during a scan
6586                          */
6587
6588 -                       newSerial = newTags.serialNumber;
6589 -                       existingSerial = existingTags.serialNumber;
6590 +                       if (inScan > 0) {
6591 +                               newSerial = newTags.serialNumber;
6592 +                               existingSerial = existingTags.serialNumber;
6593 +                       }
6594
6595                         if ((inScan > 0) &&
6596                             (in->myDev->isYaffs2 ||
6597 @@ -3437,24 +3507,23 @@ static int yaffs_PutChunkIntoFile(yaffs_
6598
6599         }
6600
6601 -       if (existingChunk == 0) {
6602 +       if (existingChunk == 0)
6603                 in->nDataChunks++;
6604 -       }
6605
6606 -       yaffs_PutLevel0Tnode(dev,tn,chunkInInode,chunkInNAND);
6607 +       yaffs_PutLevel0Tnode(dev, tn, chunkInInode, chunkInNAND);
6608
6609         return YAFFS_OK;
6610  }
6611
6612 -static int yaffs_ReadChunkDataFromObject(yaffs_Object * in, int chunkInInode,
6613 -                                        __u8 * buffer)
6614 +static int yaffs_ReadChunkDataFromObject(yaffs_Object *in, int chunkInInode,
6615 +                                       __u8 *buffer)
6616  {
6617         int chunkInNAND = yaffs_FindChunkInFile(in, chunkInInode, NULL);
6618
6619 -       if (chunkInNAND >= 0) {
6620 +       if (chunkInNAND >= 0)
6621                 return yaffs_ReadChunkWithTagsFromNAND(in->myDev, chunkInNAND,
6622 -                                                      buffer,NULL);
6623 -       } else {
6624 +                                               buffer, NULL);
6625 +       else {
6626                 T(YAFFS_TRACE_NANDACCESS,
6627                   (TSTR("Chunk %d not found zero instead" TENDSTR),
6628                    chunkInNAND));
6629 @@ -3465,7 +3534,7 @@ static int yaffs_ReadChunkDataFromObject
6630
6631  }
6632
6633 -void yaffs_DeleteChunk(yaffs_Device * dev, int chunkId, int markNAND, int lyn)
6634 +void yaffs_DeleteChunk(yaffs_Device *dev, int chunkId, int markNAND, int lyn)
6635  {
6636         int block;
6637         int page;
6638 @@ -3475,16 +3544,15 @@ void yaffs_DeleteChunk(yaffs_Device * de
6639         if (chunkId <= 0)
6640                 return;
6641
6642 -
6643         dev->nDeletions++;
6644         block = chunkId / dev->nChunksPerBlock;
6645         page = chunkId % dev->nChunksPerBlock;
6646
6647
6648 -       if(!yaffs_CheckChunkBit(dev,block,page))
6649 +       if (!yaffs_CheckChunkBit(dev, block, page))
6650                 T(YAFFS_TRACE_VERIFY,
6651 -                       (TSTR("Deleting invalid chunk %d"TENDSTR),
6652 -                        chunkId));
6653 +                       (TSTR("Deleting invalid chunk %d"TENDSTR),
6654 +                        chunkId));
6655
6656         bi = yaffs_GetBlockInfo(dev, block);
6657
6658 @@ -3524,14 +3592,12 @@ void yaffs_DeleteChunk(yaffs_Device * de
6659                         yaffs_BlockBecameDirty(dev, block);
6660                 }
6661
6662 -       } else {
6663 -               /* T(("Bad news deleting chunk %d\n",chunkId)); */
6664         }
6665
6666  }
6667
6668 -static int yaffs_WriteChunkDataToObject(yaffs_Object * in, int chunkInInode,
6669 -                                       const __u8 * buffer, int nBytes,
6670 +static int yaffs_WriteChunkDataToObject(yaffs_Object *in, int chunkInInode,
6671 +                                       const __u8 *buffer, int nBytes,
6672                                         int useReserve)
6673  {
6674         /* Find old chunk Need to do this to get serial number
6675 @@ -3561,6 +3627,12 @@ static int yaffs_WriteChunkDataToObject(
6676             (prevChunkId >= 0) ? prevTags.serialNumber + 1 : 1;
6677         newTags.byteCount = nBytes;
6678
6679 +       if (nBytes < 1 || nBytes > dev->totalBytesPerChunk) {
6680 +               T(YAFFS_TRACE_ERROR,
6681 +               (TSTR("Writing %d bytes to chunk!!!!!!!!!" TENDSTR), nBytes));
6682 +               YBUG();
6683 +       }
6684 +
6685         newChunkId =
6686             yaffs_WriteNewChunkWithTagsToNAND(dev, buffer, &newTags,
6687                                               useReserve);
6688 @@ -3568,11 +3640,9 @@ static int yaffs_WriteChunkDataToObject(
6689         if (newChunkId >= 0) {
6690                 yaffs_PutChunkIntoFile(in, chunkInInode, newChunkId, 0);
6691
6692 -               if (prevChunkId >= 0) {
6693 +               if (prevChunkId >= 0)
6694                         yaffs_DeleteChunk(dev, prevChunkId, 1, __LINE__);
6695
6696 -               }
6697 -
6698                 yaffs_CheckFileSanity(in);
6699         }
6700         return newChunkId;
6701 @@ -3582,7 +3652,7 @@ static int yaffs_WriteChunkDataToObject(
6702  /* UpdateObjectHeader updates the header on NAND for an object.
6703   * If name is not NULL, then that new name is used.
6704   */
6705 -int yaffs_UpdateObjectHeader(yaffs_Object * in, const YCHAR * name, int force,
6706 +int yaffs_UpdateObjectHeader(yaffs_Object *in, const YCHAR *name, int force,
6707                              int isShrink, int shadows)
6708  {
6709
6710 @@ -3603,9 +3673,12 @@ int yaffs_UpdateObjectHeader(yaffs_Objec
6711
6712         yaffs_ObjectHeader *oh = NULL;
6713
6714 -       yaffs_strcpy(oldName,"silly old name");
6715 +       yaffs_strcpy(oldName, _Y("silly old name"));
6716
6717 -       if (!in->fake || force) {
6718 +
6719 +       if (!in->fake ||
6720 +               in == dev->rootDir || /* The rootDir should also be saved */
6721 +               force) {
6722
6723                 yaffs_CheckGarbageCollection(dev);
6724                 yaffs_CheckObjectDetailsLoaded(in);
6725 @@ -3613,13 +3686,13 @@ int yaffs_UpdateObjectHeader(yaffs_Objec
6726                 buffer = yaffs_GetTempBuffer(in->myDev, __LINE__);
6727                 oh = (yaffs_ObjectHeader *) buffer;
6728
6729 -               prevChunkId = in->chunkId;
6730 +               prevChunkId = in->hdrChunk;
6731
6732 -               if (prevChunkId >= 0) {
6733 +               if (prevChunkId > 0) {
6734                         result = yaffs_ReadChunkWithTagsFromNAND(dev, prevChunkId,
6735                                                         buffer, &oldTags);
6736
6737 -                       yaffs_VerifyObjectHeader(in,oh,&oldTags,0);
6738 +                       yaffs_VerifyObjectHeader(in, oh, &oldTags, 0);
6739
6740                         memcpy(oldName, oh->name, sizeof(oh->name));
6741                 }
6742 @@ -3628,7 +3701,7 @@ int yaffs_UpdateObjectHeader(yaffs_Objec
6743
6744                 oh->type = in->variantType;
6745                 oh->yst_mode = in->yst_mode;
6746 -               oh->shadowsObject = shadows;
6747 +               oh->shadowsObject = oh->inbandShadowsObject = shadows;
6748
6749  #ifdef CONFIG_YAFFS_WINCE
6750                 oh->win_atime[0] = in->win_atime[0];
6751 @@ -3645,20 +3718,18 @@ int yaffs_UpdateObjectHeader(yaffs_Objec
6752                 oh->yst_ctime = in->yst_ctime;
6753                 oh->yst_rdev = in->yst_rdev;
6754  #endif
6755 -               if (in->parent) {
6756 +               if (in->parent)
6757                         oh->parentObjectId = in->parent->objectId;
6758 -               } else {
6759 +               else
6760                         oh->parentObjectId = 0;
6761 -               }
6762
6763                 if (name && *name) {
6764                         memset(oh->name, 0, sizeof(oh->name));
6765                         yaffs_strncpy(oh->name, name, YAFFS_MAX_NAME_LENGTH);
6766 -               } else if (prevChunkId>=0) {
6767 +               } else if (prevChunkId >= 0)
6768                         memcpy(oh->name, oldName, sizeof(oh->name));
6769 -               } else {
6770 +               else
6771                         memset(oh->name, 0, sizeof(oh->name));
6772 -               }
6773
6774                 oh->isShrink = isShrink;
6775
6776 @@ -3708,7 +3779,7 @@ int yaffs_UpdateObjectHeader(yaffs_Objec
6777                 newTags.extraShadows = (oh->shadowsObject > 0) ? 1 : 0;
6778                 newTags.extraObjectType = in->variantType;
6779
6780 -               yaffs_VerifyObjectHeader(in,oh,&newTags,1);
6781 +               yaffs_VerifyObjectHeader(in, oh, &newTags, 1);
6782
6783                 /* Create new chunk in NAND */
6784                 newChunkId =
6785 @@ -3717,20 +3788,20 @@ int yaffs_UpdateObjectHeader(yaffs_Objec
6786
6787                 if (newChunkId >= 0) {
6788
6789 -                       in->chunkId = newChunkId;
6790 +                       in->hdrChunk = newChunkId;
6791
6792                         if (prevChunkId >= 0) {
6793                                 yaffs_DeleteChunk(dev, prevChunkId, 1,
6794                                                   __LINE__);
6795                         }
6796
6797 -                       if(!yaffs_ObjectHasCachedWriteData(in))
6798 +                       if (!yaffs_ObjectHasCachedWriteData(in))
6799                                 in->dirty = 0;
6800
6801                         /* If this was a shrink, then mark the block that the chunk lives on */
6802                         if (isShrink) {
6803                                 bi = yaffs_GetBlockInfo(in->myDev,
6804 -                                                       newChunkId /in->myDev-> nChunksPerBlock);
6805 +                                       newChunkId / in->myDev->nChunksPerBlock);
6806                                 bi->hasShrinkHeader = 1;
6807                         }
6808
6809 @@ -3766,7 +3837,7 @@ static int yaffs_ObjectHasCachedWriteDat
6810         yaffs_ChunkCache *cache;
6811         int nCaches = obj->myDev->nShortOpCaches;
6812
6813 -       for(i = 0; i < nCaches; i++){
6814 +       for (i = 0; i < nCaches; i++) {
6815                 cache = &dev->srCache[i];
6816                 if (cache->object == obj &&
6817                     cache->dirty)
6818 @@ -3777,7 +3848,7 @@ static int yaffs_ObjectHasCachedWriteDat
6819  }
6820
6821
6822 -static void yaffs_FlushFilesChunkCache(yaffs_Object * obj)
6823 +static void yaffs_FlushFilesChunkCache(yaffs_Object *obj)
6824  {
6825         yaffs_Device *dev = obj->myDev;
6826         int lowest = -99;       /* Stop compiler whining. */
6827 @@ -3844,16 +3915,16 @@ void yaffs_FlushEntireDeviceCache(yaffs_
6828          */
6829         do {
6830                 obj = NULL;
6831 -               for( i = 0; i < nCaches && !obj; i++) {
6832 +               for (i = 0; i < nCaches && !obj; i++) {
6833                         if (dev->srCache[i].object &&
6834                             dev->srCache[i].dirty)
6835                                 obj = dev->srCache[i].object;
6836
6837                 }
6838 -               if(obj)
6839 +               if (obj)
6840                         yaffs_FlushFilesChunkCache(obj);
6841
6842 -       } while(obj);
6843 +       } while (obj);
6844
6845  }
6846
6847 @@ -3863,41 +3934,21 @@ void yaffs_FlushEntireDeviceCache(yaffs_
6848   * Then look for the least recently used non-dirty one.
6849   * Then look for the least recently used dirty one...., flush and look again.
6850   */
6851 -static yaffs_ChunkCache *yaffs_GrabChunkCacheWorker(yaffs_Device * dev)
6852 +static yaffs_ChunkCache *yaffs_GrabChunkCacheWorker(yaffs_Device *dev)
6853  {
6854         int i;
6855 -       int usage;
6856 -       int theOne;
6857
6858         if (dev->nShortOpCaches > 0) {
6859                 for (i = 0; i < dev->nShortOpCaches; i++) {
6860                         if (!dev->srCache[i].object)
6861                                 return &dev->srCache[i];
6862                 }
6863 +       }
6864
6865 -               return NULL;
6866 +       return NULL;
6867 +}
6868
6869 -               theOne = -1;
6870 -               usage = 0;      /* just to stop the compiler grizzling */
6871 -
6872 -               for (i = 0; i < dev->nShortOpCaches; i++) {
6873 -                       if (!dev->srCache[i].dirty &&
6874 -                           ((dev->srCache[i].lastUse < usage && theOne >= 0) ||
6875 -                            theOne < 0)) {
6876 -                               usage = dev->srCache[i].lastUse;
6877 -                               theOne = i;
6878 -                       }
6879 -               }
6880 -
6881 -
6882 -               return theOne >= 0 ? &dev->srCache[theOne] : NULL;
6883 -       } else {
6884 -               return NULL;
6885 -       }
6886 -
6887 -}
6888 -
6889 -static yaffs_ChunkCache *yaffs_GrabChunkCache(yaffs_Device * dev)
6890 +static yaffs_ChunkCache *yaffs_GrabChunkCache(yaffs_Device *dev)
6891  {
6892         yaffs_ChunkCache *cache;
6893         yaffs_Object *theObj;
6894 @@ -3927,8 +3978,7 @@ static yaffs_ChunkCache *yaffs_GrabChunk
6895                         for (i = 0; i < dev->nShortOpCaches; i++) {
6896                                 if (dev->srCache[i].object &&
6897                                     !dev->srCache[i].locked &&
6898 -                                   (dev->srCache[i].lastUse < usage || !cache))
6899 -                               {
6900 +                                   (dev->srCache[i].lastUse < usage || !cache)) {
6901                                         usage = dev->srCache[i].lastUse;
6902                                         theObj = dev->srCache[i].object;
6903                                         cache = &dev->srCache[i];
6904 @@ -3950,7 +4000,7 @@ static yaffs_ChunkCache *yaffs_GrabChunk
6905  }
6906
6907  /* Find a cached chunk */
6908 -static yaffs_ChunkCache *yaffs_FindChunkCache(const yaffs_Object * obj,
6909 +static yaffs_ChunkCache *yaffs_FindChunkCache(const yaffs_Object *obj,
6910                                               int chunkId)
6911  {
6912         yaffs_Device *dev = obj->myDev;
6913 @@ -3969,7 +4019,7 @@ static yaffs_ChunkCache *yaffs_FindChunk
6914  }
6915
6916  /* Mark the chunk for the least recently used algorithym */
6917 -static void yaffs_UseChunkCache(yaffs_Device * dev, yaffs_ChunkCache * cache,
6918 +static void yaffs_UseChunkCache(yaffs_Device *dev, yaffs_ChunkCache *cache,
6919                                 int isAWrite)
6920  {
6921
6922 @@ -3977,9 +4027,9 @@ static void yaffs_UseChunkCache(yaffs_De
6923                 if (dev->srLastUse < 0 || dev->srLastUse > 100000000) {
6924                         /* Reset the cache usages */
6925                         int i;
6926 -                       for (i = 1; i < dev->nShortOpCaches; i++) {
6927 +                       for (i = 1; i < dev->nShortOpCaches; i++)
6928                                 dev->srCache[i].lastUse = 0;
6929 -                       }
6930 +
6931                         dev->srLastUse = 0;
6932                 }
6933
6934 @@ -3987,9 +4037,8 @@ static void yaffs_UseChunkCache(yaffs_De
6935
6936                 cache->lastUse = dev->srLastUse;
6937
6938 -               if (isAWrite) {
6939 +               if (isAWrite)
6940                         cache->dirty = 1;
6941 -               }
6942         }
6943  }
6944
6945 @@ -3997,21 +4046,20 @@ static void yaffs_UseChunkCache(yaffs_De
6946   * Do this when a whole page gets written,
6947   * ie the short cache for this page is no longer valid.
6948   */
6949 -static void yaffs_InvalidateChunkCache(yaffs_Object * object, int chunkId)
6950 +static void yaffs_InvalidateChunkCache(yaffs_Object *object, int chunkId)
6951  {
6952         if (object->myDev->nShortOpCaches > 0) {
6953                 yaffs_ChunkCache *cache = yaffs_FindChunkCache(object, chunkId);
6954
6955 -               if (cache) {
6956 +               if (cache)
6957                         cache->object = NULL;
6958 -               }
6959         }
6960  }
6961
6962  /* Invalidate all the cache pages associated with this object
6963   * Do this whenever ther file is deleted or resized.
6964   */
6965 -static void yaffs_InvalidateWholeChunkCache(yaffs_Object * in)
6966 +static void yaffs_InvalidateWholeChunkCache(yaffs_Object *in)
6967  {
6968         int i;
6969         yaffs_Device *dev = in->myDev;
6970 @@ -4019,9 +4067,8 @@ static void yaffs_InvalidateWholeChunkCa
6971         if (dev->nShortOpCaches > 0) {
6972                 /* Invalidate it. */
6973                 for (i = 0; i < dev->nShortOpCaches; i++) {
6974 -                       if (dev->srCache[i].object == in) {
6975 +                       if (dev->srCache[i].object == in)
6976                                 dev->srCache[i].object = NULL;
6977 -                       }
6978                 }
6979         }
6980  }
6981 @@ -4029,18 +4076,18 @@ static void yaffs_InvalidateWholeChunkCa
6982  /*--------------------- Checkpointing --------------------*/
6983
6984
6985 -static int yaffs_WriteCheckpointValidityMarker(yaffs_Device *dev,int head)
6986 +static int yaffs_WriteCheckpointValidityMarker(yaffs_Device *dev, int head)
6987  {
6988         yaffs_CheckpointValidity cp;
6989
6990 -       memset(&cp,0,sizeof(cp));
6991 +       memset(&cp, 0, sizeof(cp));
6992
6993         cp.structType = sizeof(cp);
6994         cp.magic = YAFFS_MAGIC;
6995         cp.version = YAFFS_CHECKPOINT_VERSION;
6996         cp.head = (head) ? 1 : 0;
6997
6998 -       return (yaffs_CheckpointWrite(dev,&cp,sizeof(cp)) == sizeof(cp))?
6999 +       return (yaffs_CheckpointWrite(dev, &cp, sizeof(cp)) == sizeof(cp)) ?
7000                 1 : 0;
7001  }
7002
7003 @@ -4049,9 +4096,9 @@ static int yaffs_ReadCheckpointValidityM
7004         yaffs_CheckpointValidity cp;
7005         int ok;
7006
7007 -       ok = (yaffs_CheckpointRead(dev,&cp,sizeof(cp)) == sizeof(cp));
7008 +       ok = (yaffs_CheckpointRead(dev, &cp, sizeof(cp)) == sizeof(cp));
7009
7010 -       if(ok)
7011 +       if (ok)
7012                 ok = (cp.structType == sizeof(cp)) &&
7013                      (cp.magic == YAFFS_MAGIC) &&
7014                      (cp.version == YAFFS_CHECKPOINT_VERSION) &&
7015 @@ -4100,21 +4147,21 @@ static int yaffs_WriteCheckpointDevice(y
7016         int ok;
7017
7018         /* Write device runtime values*/
7019 -       yaffs_DeviceToCheckpointDevice(&cp,dev);
7020 +       yaffs_DeviceToCheckpointDevice(&cp, dev);
7021         cp.structType = sizeof(cp);
7022
7023 -       ok = (yaffs_CheckpointWrite(dev,&cp,sizeof(cp)) == sizeof(cp));
7024 +       ok = (yaffs_CheckpointWrite(dev, &cp, sizeof(cp)) == sizeof(cp));
7025
7026         /* Write block info */
7027 -       if(ok) {
7028 +       if (ok) {
7029                 nBytes = nBlocks * sizeof(yaffs_BlockInfo);
7030 -               ok = (yaffs_CheckpointWrite(dev,dev->blockInfo,nBytes) == nBytes);
7031 +               ok = (yaffs_CheckpointWrite(dev, dev->blockInfo, nBytes) == nBytes);
7032         }
7033
7034         /* Write chunk bits */
7035 -       if(ok) {
7036 +       if (ok) {
7037                 nBytes = nBlocks * dev->chunkBitmapStride;
7038 -               ok = (yaffs_CheckpointWrite(dev,dev->chunkBits,nBytes) == nBytes);
7039 +               ok = (yaffs_CheckpointWrite(dev, dev->chunkBits, nBytes) == nBytes);
7040         }
7041         return   ok ? 1 : 0;
7042
7043 @@ -4128,25 +4175,25 @@ static int yaffs_ReadCheckpointDevice(ya
7044
7045         int ok;
7046
7047 -       ok = (yaffs_CheckpointRead(dev,&cp,sizeof(cp)) == sizeof(cp));
7048 -       if(!ok)
7049 +       ok = (yaffs_CheckpointRead(dev, &cp, sizeof(cp)) == sizeof(cp));
7050 +       if (!ok)
7051                 return 0;
7052
7053 -       if(cp.structType != sizeof(cp))
7054 +       if (cp.structType != sizeof(cp))
7055                 return 0;
7056
7057
7058 -       yaffs_CheckpointDeviceToDevice(dev,&cp);
7059 +       yaffs_CheckpointDeviceToDevice(dev, &cp);
7060
7061         nBytes = nBlocks * sizeof(yaffs_BlockInfo);
7062
7063 -       ok = (yaffs_CheckpointRead(dev,dev->blockInfo,nBytes) == nBytes);
7064 +       ok = (yaffs_CheckpointRead(dev, dev->blockInfo, nBytes) == nBytes);
7065
7066 -       if(!ok)
7067 +       if (!ok)
7068                 return 0;
7069         nBytes = nBlocks * dev->chunkBitmapStride;
7070
7071 -       ok = (yaffs_CheckpointRead(dev,dev->chunkBits,nBytes) == nBytes);
7072 +       ok = (yaffs_CheckpointRead(dev, dev->chunkBits, nBytes) == nBytes);
7073
7074         return ok ? 1 : 0;
7075  }
7076 @@ -4157,7 +4204,7 @@ static void yaffs_ObjectToCheckpointObje
7077
7078         cp->objectId = obj->objectId;
7079         cp->parentId = (obj->parent) ? obj->parent->objectId : 0;
7080 -       cp->chunkId = obj->chunkId;
7081 +       cp->hdrChunk = obj->hdrChunk;
7082         cp->variantType = obj->variantType;
7083         cp->deleted = obj->deleted;
7084         cp->softDeleted = obj->softDeleted;
7085 @@ -4168,20 +4215,28 @@ static void yaffs_ObjectToCheckpointObje
7086         cp->serial = obj->serial;
7087         cp->nDataChunks = obj->nDataChunks;
7088
7089 -       if(obj->variantType == YAFFS_OBJECT_TYPE_FILE)
7090 +       if (obj->variantType == YAFFS_OBJECT_TYPE_FILE)
7091                 cp->fileSizeOrEquivalentObjectId = obj->variant.fileVariant.fileSize;
7092 -       else if(obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK)
7093 +       else if (obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK)
7094                 cp->fileSizeOrEquivalentObjectId = obj->variant.hardLinkVariant.equivalentObjectId;
7095  }
7096
7097 -static void yaffs_CheckpointObjectToObject( yaffs_Object *obj,yaffs_CheckpointObject *cp)
7098 +static int yaffs_CheckpointObjectToObject(yaffs_Object *obj, yaffs_CheckpointObject *cp)
7099  {
7100
7101         yaffs_Object *parent;
7102
7103 +       if (obj->variantType != cp->variantType) {
7104 +               T(YAFFS_TRACE_ERROR, (TSTR("Checkpoint read object %d type %d "
7105 +                       TCONT("chunk %d does not match existing object type %d")
7106 +                       TENDSTR), cp->objectId, cp->variantType, cp->hdrChunk,
7107 +                       obj->variantType));
7108 +               return 0;
7109 +       }
7110 +
7111         obj->objectId = cp->objectId;
7112
7113 -       if(cp->parentId)
7114 +       if (cp->parentId)
7115                 parent = yaffs_FindOrCreateObjectByNumber(
7116                                         obj->myDev,
7117                                         cp->parentId,
7118 @@ -4189,10 +4244,19 @@ static void yaffs_CheckpointObjectToObje
7119         else
7120                 parent = NULL;
7121
7122 -       if(parent)
7123 +       if (parent) {
7124 +               if (parent->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) {
7125 +                       T(YAFFS_TRACE_ALWAYS, (TSTR("Checkpoint read object %d parent %d type %d"
7126 +                               TCONT(" chunk %d Parent type, %d, not directory")
7127 +                               TENDSTR),
7128 +                               cp->objectId, cp->parentId, cp->variantType,
7129 +                               cp->hdrChunk, parent->variantType));
7130 +                       return 0;
7131 +               }
7132                 yaffs_AddObjectToDirectory(parent, obj);
7133 +       }
7134
7135 -       obj->chunkId = cp->chunkId;
7136 +       obj->hdrChunk = cp->hdrChunk;
7137         obj->variantType = cp->variantType;
7138         obj->deleted = cp->deleted;
7139         obj->softDeleted = cp->softDeleted;
7140 @@ -4203,29 +4267,34 @@ static void yaffs_CheckpointObjectToObje
7141         obj->serial = cp->serial;
7142         obj->nDataChunks = cp->nDataChunks;
7143
7144 -       if(obj->variantType == YAFFS_OBJECT_TYPE_FILE)
7145 +       if (obj->variantType == YAFFS_OBJECT_TYPE_FILE)
7146                 obj->variant.fileVariant.fileSize = cp->fileSizeOrEquivalentObjectId;
7147 -       else if(obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK)
7148 +       else if (obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK)
7149                 obj->variant.hardLinkVariant.equivalentObjectId = cp->fileSizeOrEquivalentObjectId;
7150
7151 -       if(obj->objectId >= YAFFS_NOBJECT_BUCKETS)
7152 +       if (obj->hdrChunk > 0)
7153                 obj->lazyLoaded = 1;
7154 +       return 1;
7155  }
7156
7157
7158
7159 -static int yaffs_CheckpointTnodeWorker(yaffs_Object * in, yaffs_Tnode * tn,
7160 -                                       __u32 level, int chunkOffset)
7161 +static int yaffs_CheckpointTnodeWorker(yaffs_Object *in, yaffs_Tnode *tn,
7162 +                                       __u32 level, int chunkOffset)
7163  {
7164         int i;
7165         yaffs_Device *dev = in->myDev;
7166         int ok = 1;
7167 -       int nTnodeBytes = (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8;
7168 +       int tnodeSize = (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8;
7169 +
7170 +       if (tnodeSize < sizeof(yaffs_Tnode))
7171 +               tnodeSize = sizeof(yaffs_Tnode);
7172 +
7173
7174         if (tn) {
7175                 if (level > 0) {
7176
7177 -                       for (i = 0; i < YAFFS_NTNODES_INTERNAL && ok; i++){
7178 +                       for (i = 0; i < YAFFS_NTNODES_INTERNAL && ok; i++) {
7179                                 if (tn->internal[i]) {
7180                                         ok = yaffs_CheckpointTnodeWorker(in,
7181                                                         tn->internal[i],
7182 @@ -4235,10 +4304,9 @@ static int yaffs_CheckpointTnodeWorker(y
7183                         }
7184                 } else if (level == 0) {
7185                         __u32 baseOffset = chunkOffset <<  YAFFS_TNODES_LEVEL0_BITS;
7186 -                       /* printf("write tnode at %d\n",baseOffset); */
7187 -                       ok = (yaffs_CheckpointWrite(dev,&baseOffset,sizeof(baseOffset)) == sizeof(baseOffset));
7188 -                       if(ok)
7189 -                               ok = (yaffs_CheckpointWrite(dev,tn,nTnodeBytes) == nTnodeBytes);
7190 +                       ok = (yaffs_CheckpointWrite(dev, &baseOffset, sizeof(baseOffset)) == sizeof(baseOffset));
7191 +                       if (ok)
7192 +                               ok = (yaffs_CheckpointWrite(dev, tn, tnodeSize) == tnodeSize);
7193                 }
7194         }
7195
7196 @@ -4251,13 +4319,13 @@ static int yaffs_WriteCheckpointTnodes(y
7197         __u32 endMarker = ~0;
7198         int ok = 1;
7199
7200 -       if(obj->variantType == YAFFS_OBJECT_TYPE_FILE){
7201 +       if (obj->variantType == YAFFS_OBJECT_TYPE_FILE) {
7202                 ok = yaffs_CheckpointTnodeWorker(obj,
7203                                             obj->variant.fileVariant.top,
7204                                             obj->variant.fileVariant.topLevel,
7205                                             0);
7206 -               if(ok)
7207 -                       ok = (yaffs_CheckpointWrite(obj->myDev,&endMarker,sizeof(endMarker)) ==
7208 +               if (ok)
7209 +                       ok = (yaffs_CheckpointWrite(obj->myDev, &endMarker, sizeof(endMarker)) ==
7210                                 sizeof(endMarker));
7211         }
7212
7213 @@ -4272,38 +4340,38 @@ static int yaffs_ReadCheckpointTnodes(ya
7214         yaffs_FileStructure *fileStructPtr = &obj->variant.fileVariant;
7215         yaffs_Tnode *tn;
7216         int nread = 0;
7217 +       int tnodeSize = (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8;
7218
7219 -       ok = (yaffs_CheckpointRead(dev,&baseChunk,sizeof(baseChunk)) == sizeof(baseChunk));
7220 +       if (tnodeSize < sizeof(yaffs_Tnode))
7221 +               tnodeSize = sizeof(yaffs_Tnode);
7222
7223 -       while(ok && (~baseChunk)){
7224 +       ok = (yaffs_CheckpointRead(dev, &baseChunk, sizeof(baseChunk)) == sizeof(baseChunk));
7225 +
7226 +       while (ok && (~baseChunk)) {
7227                 nread++;
7228                 /* Read level 0 tnode */
7229
7230
7231 -               /* printf("read  tnode at %d\n",baseChunk); */
7232                 tn = yaffs_GetTnodeRaw(dev);
7233 -               if(tn)
7234 -                       ok = (yaffs_CheckpointRead(dev,tn,(dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8) ==
7235 -                             (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8);
7236 +               if (tn)
7237 +                       ok = (yaffs_CheckpointRead(dev, tn, tnodeSize) == tnodeSize);
7238                 else
7239                         ok = 0;
7240
7241 -               if(tn && ok){
7242 +               if (tn && ok)
7243                         ok = yaffs_AddOrFindLevel0Tnode(dev,
7244 -                                                       fileStructPtr,
7245 -                                                       baseChunk,
7246 -                                                       tn) ? 1 : 0;
7247 +                                                       fileStructPtr,
7248 +                                                       baseChunk,
7249 +                                                       tn) ? 1 : 0;
7250
7251 -               }
7252 -
7253 -               if(ok)
7254 -                       ok = (yaffs_CheckpointRead(dev,&baseChunk,sizeof(baseChunk)) == sizeof(baseChunk));
7255 +               if (ok)
7256 +                       ok = (yaffs_CheckpointRead(dev, &baseChunk, sizeof(baseChunk)) == sizeof(baseChunk));
7257
7258         }
7259
7260 -       T(YAFFS_TRACE_CHECKPOINT,(
7261 +       T(YAFFS_TRACE_CHECKPOINT, (
7262                 TSTR("Checkpoint read tnodes %d records, last %d. ok %d" TENDSTR),
7263 -               nread,baseChunk,ok));
7264 +               nread, baseChunk, ok));
7265
7266         return ok ? 1 : 0;
7267  }
7268 @@ -4315,41 +4383,40 @@ static int yaffs_WriteCheckpointObjects(
7269         yaffs_CheckpointObject cp;
7270         int i;
7271         int ok = 1;
7272 -       struct list_head *lh;
7273 +       struct ylist_head *lh;
7274
7275
7276         /* Iterate through the objects in each hash entry,
7277          * dumping them to the checkpointing stream.
7278          */
7279
7280 -        for(i = 0; ok &&  i <  YAFFS_NOBJECT_BUCKETS; i++){
7281 -               list_for_each(lh, &dev->objectBucket[i].list) {
7282 +       for (i = 0; ok &&  i <  YAFFS_NOBJECT_BUCKETS; i++) {
7283 +               ylist_for_each(lh, &dev->objectBucket[i].list) {
7284                         if (lh) {
7285 -                               obj = list_entry(lh, yaffs_Object, hashLink);
7286 +                               obj = ylist_entry(lh, yaffs_Object, hashLink);
7287                                 if (!obj->deferedFree) {
7288 -                                       yaffs_ObjectToCheckpointObject(&cp,obj);
7289 +                                       yaffs_ObjectToCheckpointObject(&cp, obj);
7290                                         cp.structType = sizeof(cp);
7291
7292 -                                       T(YAFFS_TRACE_CHECKPOINT,(
7293 +                                       T(YAFFS_TRACE_CHECKPOINT, (
7294                                                 TSTR("Checkpoint write object %d parent %d type %d chunk %d obj addr %x" TENDSTR),
7295 -                                               cp.objectId,cp.parentId,cp.variantType,cp.chunkId,(unsigned) obj));
7296 +                                               cp.objectId, cp.parentId, cp.variantType, cp.hdrChunk, (unsigned) obj));
7297
7298 -                                       ok = (yaffs_CheckpointWrite(dev,&cp,sizeof(cp)) == sizeof(cp));
7299 +                                       ok = (yaffs_CheckpointWrite(dev, &cp, sizeof(cp)) == sizeof(cp));
7300
7301 -                                       if(ok && obj->variantType == YAFFS_OBJECT_TYPE_FILE){
7302 +                                       if (ok && obj->variantType == YAFFS_OBJECT_TYPE_FILE)
7303                                                 ok = yaffs_WriteCheckpointTnodes(obj);
7304 -                                       }
7305                                 }
7306                         }
7307                 }
7308 -        }
7309 +       }
7310
7311 -        /* Dump end of list */
7312 -       memset(&cp,0xFF,sizeof(yaffs_CheckpointObject));
7313 +       /* Dump end of list */
7314 +       memset(&cp, 0xFF, sizeof(yaffs_CheckpointObject));
7315         cp.structType = sizeof(cp);
7316
7317 -       if(ok)
7318 -               ok = (yaffs_CheckpointWrite(dev,&cp,sizeof(cp)) == sizeof(cp));
7319 +       if (ok)
7320 +               ok = (yaffs_CheckpointWrite(dev, &cp, sizeof(cp)) == sizeof(cp));
7321
7322         return ok ? 1 : 0;
7323  }
7324 @@ -4362,38 +4429,39 @@ static int yaffs_ReadCheckpointObjects(y
7325         int done = 0;
7326         yaffs_Object *hardList = NULL;
7327
7328 -       while(ok && !done) {
7329 -               ok = (yaffs_CheckpointRead(dev,&cp,sizeof(cp)) == sizeof(cp));
7330 -               if(cp.structType != sizeof(cp)) {
7331 -                       T(YAFFS_TRACE_CHECKPOINT,(TSTR("struct size %d instead of %d ok %d"TENDSTR),
7332 -                               cp.structType,sizeof(cp),ok));
7333 +       while (ok && !done) {
7334 +               ok = (yaffs_CheckpointRead(dev, &cp, sizeof(cp)) == sizeof(cp));
7335 +               if (cp.structType != sizeof(cp)) {
7336 +                       T(YAFFS_TRACE_CHECKPOINT, (TSTR("struct size %d instead of %d ok %d"TENDSTR),
7337 +                               cp.structType, sizeof(cp), ok));
7338                         ok = 0;
7339                 }
7340
7341 -               T(YAFFS_TRACE_CHECKPOINT,(TSTR("Checkpoint read object %d parent %d type %d chunk %d " TENDSTR),
7342 -                       cp.objectId,cp.parentId,cp.variantType,cp.chunkId));
7343 +               T(YAFFS_TRACE_CHECKPOINT, (TSTR("Checkpoint read object %d parent %d type %d chunk %d " TENDSTR),
7344 +                       cp.objectId, cp.parentId, cp.variantType, cp.hdrChunk));
7345
7346 -               if(ok && cp.objectId == ~0)
7347 +               if (ok && cp.objectId == ~0)
7348                         done = 1;
7349 -               else if(ok){
7350 -                       obj = yaffs_FindOrCreateObjectByNumber(dev,cp.objectId, cp.variantType);
7351 -                       if(obj) {
7352 -                               yaffs_CheckpointObjectToObject(obj,&cp);
7353 -                               if(obj->variantType == YAFFS_OBJECT_TYPE_FILE) {
7354 +               else if (ok) {
7355 +                       obj = yaffs_FindOrCreateObjectByNumber(dev, cp.objectId, cp.variantType);
7356 +                       if (obj) {
7357 +                               ok = yaffs_CheckpointObjectToObject(obj, &cp);
7358 +                               if (!ok)
7359 +                                       break;
7360 +                               if (obj->variantType == YAFFS_OBJECT_TYPE_FILE) {
7361                                         ok = yaffs_ReadCheckpointTnodes(obj);
7362 -                               } else if(obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK) {
7363 +                               } else if (obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK) {
7364                                         obj->hardLinks.next =
7365 -                                                   (struct list_head *)
7366 -                                                   hardList;
7367 +                                               (struct ylist_head *) hardList;
7368                                         hardList = obj;
7369                                 }
7370 -
7371 -                       }
7372 +                       } else
7373 +                               ok = 0;
7374                 }
7375         }
7376
7377 -       if(ok)
7378 -               yaffs_HardlinkFixup(dev,hardList);
7379 +       if (ok)
7380 +               yaffs_HardlinkFixup(dev, hardList);
7381
7382         return ok ? 1 : 0;
7383  }
7384 @@ -4403,11 +4471,11 @@ static int yaffs_WriteCheckpointSum(yaff
7385         __u32 checkpointSum;
7386         int ok;
7387
7388 -       yaffs_GetCheckpointSum(dev,&checkpointSum);
7389 +       yaffs_GetCheckpointSum(dev, &checkpointSum);
7390
7391 -       ok = (yaffs_CheckpointWrite(dev,&checkpointSum,sizeof(checkpointSum)) == sizeof(checkpointSum));
7392 +       ok = (yaffs_CheckpointWrite(dev, &checkpointSum, sizeof(checkpointSum)) == sizeof(checkpointSum));
7393
7394 -       if(!ok)
7395 +       if (!ok)
7396                 return 0;
7397
7398         return 1;
7399 @@ -4419,14 +4487,14 @@ static int yaffs_ReadCheckpointSum(yaffs
7400         __u32 checkpointSum1;
7401         int ok;
7402
7403 -       yaffs_GetCheckpointSum(dev,&checkpointSum0);
7404 +       yaffs_GetCheckpointSum(dev, &checkpointSum0);
7405
7406 -       ok = (yaffs_CheckpointRead(dev,&checkpointSum1,sizeof(checkpointSum1)) == sizeof(checkpointSum1));
7407 +       ok = (yaffs_CheckpointRead(dev, &checkpointSum1, sizeof(checkpointSum1)) == sizeof(checkpointSum1));
7408
7409 -       if(!ok)
7410 +       if (!ok)
7411                 return 0;
7412
7413 -       if(checkpointSum0 != checkpointSum1)
7414 +       if (checkpointSum0 != checkpointSum1)
7415                 return 0;
7416
7417         return 1;
7418 @@ -4435,46 +4503,43 @@ static int yaffs_ReadCheckpointSum(yaffs
7419
7420  static int yaffs_WriteCheckpointData(yaffs_Device *dev)
7421  {
7422 -
7423         int ok = 1;
7424
7425 -       if(dev->skipCheckpointWrite || !dev->isYaffs2){
7426 -               T(YAFFS_TRACE_CHECKPOINT,(TSTR("skipping checkpoint write" TENDSTR)));
7427 +       if (dev->skipCheckpointWrite || !dev->isYaffs2) {
7428 +               T(YAFFS_TRACE_CHECKPOINT, (TSTR("skipping checkpoint write" TENDSTR)));
7429                 ok = 0;
7430         }
7431
7432 -       if(ok)
7433 -               ok = yaffs_CheckpointOpen(dev,1);
7434 +       if (ok)
7435 +               ok = yaffs_CheckpointOpen(dev, 1);
7436
7437 -       if(ok){
7438 -               T(YAFFS_TRACE_CHECKPOINT,(TSTR("write checkpoint validity" TENDSTR)));
7439 -               ok = yaffs_WriteCheckpointValidityMarker(dev,1);
7440 +       if (ok) {
7441 +               T(YAFFS_TRACE_CHECKPOINT, (TSTR("write checkpoint validity" TENDSTR)));
7442 +               ok = yaffs_WriteCheckpointValidityMarker(dev, 1);
7443         }
7444 -       if(ok){
7445 -               T(YAFFS_TRACE_CHECKPOINT,(TSTR("write checkpoint device" TENDSTR)));
7446 +       if (ok) {
7447 +               T(YAFFS_TRACE_CHECKPOINT, (TSTR("write checkpoint device" TENDSTR)));
7448                 ok = yaffs_WriteCheckpointDevice(dev);
7449         }
7450 -       if(ok){
7451 -               T(YAFFS_TRACE_CHECKPOINT,(TSTR("write checkpoint objects" TENDSTR)));
7452 +       if (ok) {
7453 +               T(YAFFS_TRACE_CHECKPOINT, (TSTR("write checkpoint objects" TENDSTR)));
7454                 ok = yaffs_WriteCheckpointObjects(dev);
7455         }
7456 -       if(ok){
7457 -               T(YAFFS_TRACE_CHECKPOINT,(TSTR("write checkpoint validity" TENDSTR)));
7458 -               ok = yaffs_WriteCheckpointValidityMarker(dev,0);
7459 +       if (ok) {
7460 +               T(YAFFS_TRACE_CHECKPOINT, (TSTR("write checkpoint validity" TENDSTR)));
7461 +               ok = yaffs_WriteCheckpointValidityMarker(dev, 0);
7462         }
7463
7464 -       if(ok){
7465 +       if (ok)
7466                 ok = yaffs_WriteCheckpointSum(dev);
7467 -       }
7468 -
7469
7470 -       if(!yaffs_CheckpointClose(dev))
7471 -                ok = 0;
7472 +       if (!yaffs_CheckpointClose(dev))
7473 +               ok = 0;
7474
7475 -       if(ok)
7476 -               dev->isCheckpointed = 1;
7477 -        else
7478 -               dev->isCheckpointed = 0;
7479 +       if (ok)
7480 +               dev->isCheckpointed = 1;
7481 +       else
7482 +               dev->isCheckpointed = 0;
7483
7484         return dev->isCheckpointed;
7485  }
7486 @@ -4483,43 +4548,43 @@ static int yaffs_ReadCheckpointData(yaff
7487  {
7488         int ok = 1;
7489
7490 -       if(dev->skipCheckpointRead || !dev->isYaffs2){
7491 -               T(YAFFS_TRACE_CHECKPOINT,(TSTR("skipping checkpoint read" TENDSTR)));
7492 +       if (dev->skipCheckpointRead || !dev->isYaffs2) {
7493 +               T(YAFFS_TRACE_CHECKPOINT, (TSTR("skipping checkpoint read" TENDSTR)));
7494                 ok = 0;
7495         }
7496
7497 -       if(ok)
7498 -               ok = yaffs_CheckpointOpen(dev,0); /* open for read */
7499 +       if (ok)
7500 +               ok = yaffs_CheckpointOpen(dev, 0); /* open for read */
7501
7502 -       if(ok){
7503 -               T(YAFFS_TRACE_CHECKPOINT,(TSTR("read checkpoint validity" TENDSTR)));
7504 -               ok = yaffs_ReadCheckpointValidityMarker(dev,1);
7505 +       if (ok) {
7506 +               T(YAFFS_TRACE_CHECKPOINT, (TSTR("read checkpoint validity" TENDSTR)));
7507 +               ok = yaffs_ReadCheckpointValidityMarker(dev, 1);
7508         }
7509 -       if(ok){
7510 -               T(YAFFS_TRACE_CHECKPOINT,(TSTR("read checkpoint device" TENDSTR)));
7511 +       if (ok) {
7512 +               T(YAFFS_TRACE_CHECKPOINT, (TSTR("read checkpoint device" TENDSTR)));
7513                 ok = yaffs_ReadCheckpointDevice(dev);
7514         }
7515 -       if(ok){
7516 -               T(YAFFS_TRACE_CHECKPOINT,(TSTR("read checkpoint objects" TENDSTR)));
7517 +       if (ok) {
7518 +               T(YAFFS_TRACE_CHECKPOINT, (TSTR("read checkpoint objects" TENDSTR)));
7519                 ok = yaffs_ReadCheckpointObjects(dev);
7520         }
7521 -       if(ok){
7522 -               T(YAFFS_TRACE_CHECKPOINT,(TSTR("read checkpoint validity" TENDSTR)));
7523 -               ok = yaffs_ReadCheckpointValidityMarker(dev,0);
7524 +       if (ok) {
7525 +               T(YAFFS_TRACE_CHECKPOINT, (TSTR("read checkpoint validity" TENDSTR)));
7526 +               ok = yaffs_ReadCheckpointValidityMarker(dev, 0);
7527         }
7528
7529 -       if(ok){
7530 +       if (ok) {
7531                 ok = yaffs_ReadCheckpointSum(dev);
7532 -               T(YAFFS_TRACE_CHECKPOINT,(TSTR("read checkpoint checksum %d" TENDSTR),ok));
7533 +               T(YAFFS_TRACE_CHECKPOINT, (TSTR("read checkpoint checksum %d" TENDSTR), ok));
7534         }
7535
7536 -       if(!yaffs_CheckpointClose(dev))
7537 +       if (!yaffs_CheckpointClose(dev))
7538                 ok = 0;
7539
7540 -       if(ok)
7541 -               dev->isCheckpointed = 1;
7542 -        else
7543 -               dev->isCheckpointed = 0;
7544 +       if (ok)
7545 +               dev->isCheckpointed = 1;
7546 +       else
7547 +               dev->isCheckpointed = 0;
7548
7549         return ok ? 1 : 0;
7550
7551 @@ -4527,11 +4592,11 @@ static int yaffs_ReadCheckpointData(yaff
7552
7553  static void yaffs_InvalidateCheckpoint(yaffs_Device *dev)
7554  {
7555 -       if(dev->isCheckpointed ||
7556 -          dev->blocksInCheckpoint > 0){
7557 +       if (dev->isCheckpointed ||
7558 +                       dev->blocksInCheckpoint > 0) {
7559                 dev->isCheckpointed = 0;
7560                 yaffs_CheckpointInvalidateStream(dev);
7561 -               if(dev->superBlock && dev->markSuperBlockDirty)
7562 +               if (dev->superBlock && dev->markSuperBlockDirty)
7563                         dev->markSuperBlockDirty(dev->superBlock);
7564         }
7565  }
7566 @@ -4540,18 +4605,18 @@ static void yaffs_InvalidateCheckpoint(y
7567  int yaffs_CheckpointSave(yaffs_Device *dev)
7568  {
7569
7570 -       T(YAFFS_TRACE_CHECKPOINT,(TSTR("save entry: isCheckpointed %d"TENDSTR),dev->isCheckpointed));
7571 +       T(YAFFS_TRACE_CHECKPOINT, (TSTR("save entry: isCheckpointed %d"TENDSTR), dev->isCheckpointed));
7572
7573         yaffs_VerifyObjects(dev);
7574         yaffs_VerifyBlocks(dev);
7575         yaffs_VerifyFreeChunks(dev);
7576
7577 -       if(!dev->isCheckpointed) {
7578 +       if (!dev->isCheckpointed) {
7579                 yaffs_InvalidateCheckpoint(dev);
7580                 yaffs_WriteCheckpointData(dev);
7581         }
7582
7583 -       T(YAFFS_TRACE_ALWAYS,(TSTR("save exit: isCheckpointed %d"TENDSTR),dev->isCheckpointed));
7584 +       T(YAFFS_TRACE_ALWAYS, (TSTR("save exit: isCheckpointed %d"TENDSTR), dev->isCheckpointed));
7585
7586         return dev->isCheckpointed;
7587  }
7588 @@ -4559,17 +4624,17 @@ int yaffs_CheckpointSave(yaffs_Device *d
7589  int yaffs_CheckpointRestore(yaffs_Device *dev)
7590  {
7591         int retval;
7592 -       T(YAFFS_TRACE_CHECKPOINT,(TSTR("restore entry: isCheckpointed %d"TENDSTR),dev->isCheckpointed));
7593 +       T(YAFFS_TRACE_CHECKPOINT, (TSTR("restore entry: isCheckpointed %d"TENDSTR), dev->isCheckpointed));
7594
7595         retval = yaffs_ReadCheckpointData(dev);
7596
7597 -       if(dev->isCheckpointed){
7598 +       if (dev->isCheckpointed) {
7599                 yaffs_VerifyObjects(dev);
7600                 yaffs_VerifyBlocks(dev);
7601                 yaffs_VerifyFreeChunks(dev);
7602         }
7603
7604 -       T(YAFFS_TRACE_CHECKPOINT,(TSTR("restore exit: isCheckpointed %d"TENDSTR),dev->isCheckpointed));
7605 +       T(YAFFS_TRACE_CHECKPOINT, (TSTR("restore exit: isCheckpointed %d"TENDSTR), dev->isCheckpointed));
7606
7607         return retval;
7608  }
7609 @@ -4584,12 +4649,12 @@ int yaffs_CheckpointRestore(yaffs_Device
7610   * Curve-balls: the first chunk might also be the last chunk.
7611   */
7612
7613 -int yaffs_ReadDataFromFile(yaffs_Object * in, __u8 * buffer, loff_t offset,
7614 -                          int nBytes)
7615 +int yaffs_ReadDataFromFile(yaffs_Object *in, __u8 *buffer, loff_t offset,
7616 +                       int nBytes)
7617  {
7618
7619         int chunk;
7620 -       int start;
7621 +       __u32 start;
7622         int nToCopy;
7623         int n = nBytes;
7624         int nDone = 0;
7625 @@ -4600,27 +4665,26 @@ int yaffs_ReadDataFromFile(yaffs_Object
7626         dev = in->myDev;
7627
7628         while (n > 0) {
7629 -               //chunk = offset / dev->nDataBytesPerChunk + 1;
7630 -               //start = offset % dev->nDataBytesPerChunk;
7631 -               yaffs_AddrToChunk(dev,offset,&chunk,&start);
7632 +               /* chunk = offset / dev->nDataBytesPerChunk + 1; */
7633 +               /* start = offset % dev->nDataBytesPerChunk; */
7634 +               yaffs_AddrToChunk(dev, offset, &chunk, &start);
7635                 chunk++;
7636
7637                 /* OK now check for the curveball where the start and end are in
7638                  * the same chunk.
7639                  */
7640 -               if ((start + n) < dev->nDataBytesPerChunk) {
7641 +               if ((start + n) < dev->nDataBytesPerChunk)
7642                         nToCopy = n;
7643 -               } else {
7644 +               else
7645                         nToCopy = dev->nDataBytesPerChunk - start;
7646 -               }
7647
7648                 cache = yaffs_FindChunkCache(in, chunk);
7649
7650                 /* If the chunk is already in the cache or it is less than a whole chunk
7651 -                * then use the cache (if there is caching)
7652 +                * or we're using inband tags then use the cache (if there is caching)
7653                  * else bypass the cache.
7654                  */
7655 -               if (cache || nToCopy != dev->nDataBytesPerChunk) {
7656 +               if (cache || nToCopy != dev->nDataBytesPerChunk || dev->inbandTags) {
7657                         if (dev->nShortOpCaches > 0) {
7658
7659                                 /* If we can't find the data in the cache, then load it up. */
7660 @@ -4641,14 +4705,9 @@ int yaffs_ReadDataFromFile(yaffs_Object
7661
7662                                 cache->locked = 1;
7663
7664 -#ifdef CONFIG_YAFFS_WINCE
7665 -                               yfsd_UnlockYAFFS(TRUE);
7666 -#endif
7667 +
7668                                 memcpy(buffer, &cache->data[start], nToCopy);
7669
7670 -#ifdef CONFIG_YAFFS_WINCE
7671 -                               yfsd_LockYAFFS(TRUE);
7672 -#endif
7673                                 cache->locked = 0;
7674                         } else {
7675                                 /* Read into the local buffer then copy..*/
7676 @@ -4657,41 +4716,19 @@ int yaffs_ReadDataFromFile(yaffs_Object
7677                                     yaffs_GetTempBuffer(dev, __LINE__);
7678                                 yaffs_ReadChunkDataFromObject(in, chunk,
7679                                                               localBuffer);
7680 -#ifdef CONFIG_YAFFS_WINCE
7681 -                               yfsd_UnlockYAFFS(TRUE);
7682 -#endif
7683 +
7684                                 memcpy(buffer, &localBuffer[start], nToCopy);
7685
7686 -#ifdef CONFIG_YAFFS_WINCE
7687 -                               yfsd_LockYAFFS(TRUE);
7688 -#endif
7689 +
7690                                 yaffs_ReleaseTempBuffer(dev, localBuffer,
7691                                                         __LINE__);
7692                         }
7693
7694                 } else {
7695 -#ifdef CONFIG_YAFFS_WINCE
7696 -                       __u8 *localBuffer = yaffs_GetTempBuffer(dev, __LINE__);
7697 -
7698 -                       /* Under WinCE can't do direct transfer. Need to use a local buffer.
7699 -                        * This is because we otherwise screw up WinCE's memory mapper
7700 -                        */
7701 -                       yaffs_ReadChunkDataFromObject(in, chunk, localBuffer);
7702 -
7703 -#ifdef CONFIG_YAFFS_WINCE
7704 -                       yfsd_UnlockYAFFS(TRUE);
7705 -#endif
7706 -                       memcpy(buffer, localBuffer, dev->nDataBytesPerChunk);
7707
7708 -#ifdef CONFIG_YAFFS_WINCE
7709 -                       yfsd_LockYAFFS(TRUE);
7710 -                       yaffs_ReleaseTempBuffer(dev, localBuffer, __LINE__);
7711 -#endif
7712 -
7713 -#else
7714                         /* A full chunk. Read directly into the supplied buffer. */
7715                         yaffs_ReadChunkDataFromObject(in, chunk, buffer);
7716 -#endif
7717 +
7718                 }
7719
7720                 n -= nToCopy;
7721 @@ -4704,28 +4741,37 @@ int yaffs_ReadDataFromFile(yaffs_Object
7722         return nDone;
7723  }
7724
7725 -int yaffs_WriteDataToFile(yaffs_Object * in, const __u8 * buffer, loff_t offset,
7726 -                         int nBytes, int writeThrough)
7727 +int yaffs_WriteDataToFile(yaffs_Object *in, const __u8 *buffer, loff_t offset,
7728 +                       int nBytes, int writeThrough)
7729  {
7730
7731         int chunk;
7732 -       int start;
7733 +       __u32 start;
7734         int nToCopy;
7735         int n = nBytes;
7736         int nDone = 0;
7737         int nToWriteBack;
7738         int startOfWrite = offset;
7739         int chunkWritten = 0;
7740 -       int nBytesRead;
7741 +       __u32 nBytesRead;
7742 +       __u32 chunkStart;
7743
7744         yaffs_Device *dev;
7745
7746         dev = in->myDev;
7747
7748         while (n > 0 && chunkWritten >= 0) {
7749 -               //chunk = offset / dev->nDataBytesPerChunk + 1;
7750 -               //start = offset % dev->nDataBytesPerChunk;
7751 -               yaffs_AddrToChunk(dev,offset,&chunk,&start);
7752 +               /* chunk = offset / dev->nDataBytesPerChunk + 1; */
7753 +               /* start = offset % dev->nDataBytesPerChunk; */
7754 +               yaffs_AddrToChunk(dev, offset, &chunk, &start);
7755 +
7756 +               if (chunk * dev->nDataBytesPerChunk + start != offset ||
7757 +                               start >= dev->nDataBytesPerChunk) {
7758 +                       T(YAFFS_TRACE_ERROR, (
7759 +                          TSTR("AddrToChunk of offset %d gives chunk %d start %d"
7760 +                          TENDSTR),
7761 +                          (int)offset, chunk, start));
7762 +               }
7763                 chunk++;
7764
7765                 /* OK now check for the curveball where the start and end are in
7766 @@ -4740,25 +4786,32 @@ int yaffs_WriteDataToFile(yaffs_Object *
7767                          * we need to write back as much as was there before.
7768                          */
7769
7770 -                       nBytesRead =
7771 -                           in->variant.fileVariant.fileSize -
7772 -                           ((chunk - 1) * dev->nDataBytesPerChunk);
7773 +                       chunkStart = ((chunk - 1) * dev->nDataBytesPerChunk);
7774 +
7775 +                       if (chunkStart > in->variant.fileVariant.fileSize)
7776 +                               nBytesRead = 0; /* Past end of file */
7777 +                       else
7778 +                               nBytesRead = in->variant.fileVariant.fileSize - chunkStart;
7779
7780 -                       if (nBytesRead > dev->nDataBytesPerChunk) {
7781 +                       if (nBytesRead > dev->nDataBytesPerChunk)
7782                                 nBytesRead = dev->nDataBytesPerChunk;
7783 -                       }
7784
7785                         nToWriteBack =
7786                             (nBytesRead >
7787                              (start + n)) ? nBytesRead : (start + n);
7788
7789 +                       if (nToWriteBack < 0 || nToWriteBack > dev->nDataBytesPerChunk)
7790 +                               YBUG();
7791 +
7792                 } else {
7793                         nToCopy = dev->nDataBytesPerChunk - start;
7794                         nToWriteBack = dev->nDataBytesPerChunk;
7795                 }
7796
7797 -               if (nToCopy != dev->nDataBytesPerChunk) {
7798 -                       /* An incomplete start or end chunk (or maybe both start and end chunk) */
7799 +               if (nToCopy != dev->nDataBytesPerChunk || dev->inbandTags) {
7800 +                       /* An incomplete start or end chunk (or maybe both start and end chunk),
7801 +                        * or we're using inband tags, so we want to use the cache buffers.
7802 +                        */
7803                         if (dev->nShortOpCaches > 0) {
7804                                 yaffs_ChunkCache *cache;
7805                                 /* If we can't find the data in the cache, then load the cache */
7806 @@ -4775,10 +4828,9 @@ int yaffs_WriteDataToFile(yaffs_Object *
7807                                         yaffs_ReadChunkDataFromObject(in, chunk,
7808                                                                       cache->
7809                                                                       data);
7810 -                               }
7811 -                               else if(cache &&
7812 -                                       !cache->dirty &&
7813 -                                       !yaffs_CheckSpaceForAllocation(in->myDev)){
7814 +                               } else if (cache &&
7815 +                                       !cache->dirty &&
7816 +                                       !yaffs_CheckSpaceForAllocation(in->myDev)) {
7817                                         /* Drop the cache if it was a read cache item and
7818                                          * no space check has been made for it.
7819                                          */
7820 @@ -4788,16 +4840,12 @@ int yaffs_WriteDataToFile(yaffs_Object *
7821                                 if (cache) {
7822                                         yaffs_UseChunkCache(dev, cache, 1);
7823                                         cache->locked = 1;
7824 -#ifdef CONFIG_YAFFS_WINCE
7825 -                                       yfsd_UnlockYAFFS(TRUE);
7826 -#endif
7827 +
7828
7829                                         memcpy(&cache->data[start], buffer,
7830                                                nToCopy);
7831
7832 -#ifdef CONFIG_YAFFS_WINCE
7833 -                                       yfsd_LockYAFFS(TRUE);
7834 -#endif
7835 +
7836                                         cache->locked = 0;
7837                                         cache->nBytes = nToWriteBack;
7838
7839 @@ -4825,15 +4873,10 @@ int yaffs_WriteDataToFile(yaffs_Object *
7840                                 yaffs_ReadChunkDataFromObject(in, chunk,
7841                                                               localBuffer);
7842
7843 -#ifdef CONFIG_YAFFS_WINCE
7844 -                               yfsd_UnlockYAFFS(TRUE);
7845 -#endif
7846 +
7847
7848                                 memcpy(&localBuffer[start], buffer, nToCopy);
7849
7850 -#ifdef CONFIG_YAFFS_WINCE
7851 -                               yfsd_LockYAFFS(TRUE);
7852 -#endif
7853                                 chunkWritten =
7854                                     yaffs_WriteChunkDataToObject(in, chunk,
7855                                                                  localBuffer,
7856 @@ -4846,31 +4889,15 @@ int yaffs_WriteDataToFile(yaffs_Object *
7857                         }
7858
7859                 } else {
7860 -
7861 -#ifdef CONFIG_YAFFS_WINCE
7862 -                       /* Under WinCE can't do direct transfer. Need to use a local buffer.
7863 -                        * This is because we otherwise screw up WinCE's memory mapper
7864 -                        */
7865 -                       __u8 *localBuffer = yaffs_GetTempBuffer(dev, __LINE__);
7866 -#ifdef CONFIG_YAFFS_WINCE
7867 -                       yfsd_UnlockYAFFS(TRUE);
7868 -#endif
7869 -                       memcpy(localBuffer, buffer, dev->nDataBytesPerChunk);
7870 -#ifdef CONFIG_YAFFS_WINCE
7871 -                       yfsd_LockYAFFS(TRUE);
7872 -#endif
7873 -                       chunkWritten =
7874 -                           yaffs_WriteChunkDataToObject(in, chunk, localBuffer,
7875 -                                                        dev->nDataBytesPerChunk,
7876 -                                                        0);
7877 -                       yaffs_ReleaseTempBuffer(dev, localBuffer, __LINE__);
7878 -#else
7879                         /* A full chunk. Write directly from the supplied buffer. */
7880 +
7881 +
7882 +
7883                         chunkWritten =
7884                             yaffs_WriteChunkDataToObject(in, chunk, buffer,
7885                                                          dev->nDataBytesPerChunk,
7886                                                          0);
7887 -#endif
7888 +
7889                         /* Since we've overwritten the cached data, we better invalidate it. */
7890                         yaffs_InvalidateChunkCache(in, chunk);
7891                 }
7892 @@ -4886,9 +4913,8 @@ int yaffs_WriteDataToFile(yaffs_Object *
7893
7894         /* Update file object */
7895
7896 -       if ((startOfWrite + nDone) > in->variant.fileVariant.fileSize) {
7897 +       if ((startOfWrite + nDone) > in->variant.fileVariant.fileSize)
7898                 in->variant.fileVariant.fileSize = (startOfWrite + nDone);
7899 -       }
7900
7901         in->dirty = 1;
7902
7903 @@ -4898,7 +4924,7 @@ int yaffs_WriteDataToFile(yaffs_Object *
7904
7905  /* ---------------------- File resizing stuff ------------------ */
7906
7907 -static void yaffs_PruneResizedChunks(yaffs_Object * in, int newSize)
7908 +static void yaffs_PruneResizedChunks(yaffs_Object *in, int newSize)
7909  {
7910
7911         yaffs_Device *dev = in->myDev;
7912 @@ -4939,11 +4965,11 @@ static void yaffs_PruneResizedChunks(yaf
7913
7914  }
7915
7916 -int yaffs_ResizeFile(yaffs_Object * in, loff_t newSize)
7917 +int yaffs_ResizeFile(yaffs_Object *in, loff_t newSize)
7918  {
7919
7920         int oldFileSize = in->variant.fileVariant.fileSize;
7921 -       int newSizeOfPartialChunk;
7922 +       __u32 newSizeOfPartialChunk;
7923         int newFullChunks;
7924
7925         yaffs_Device *dev = in->myDev;
7926 @@ -4955,13 +4981,11 @@ int yaffs_ResizeFile(yaffs_Object * in,
7927
7928         yaffs_CheckGarbageCollection(dev);
7929
7930 -       if (in->variantType != YAFFS_OBJECT_TYPE_FILE) {
7931 -               return yaffs_GetFileSize(in);
7932 -       }
7933 +       if (in->variantType != YAFFS_OBJECT_TYPE_FILE)
7934 +               return YAFFS_FAIL;
7935
7936 -       if (newSize == oldFileSize) {
7937 -               return oldFileSize;
7938 -       }
7939 +       if (newSize == oldFileSize)
7940 +               return YAFFS_OK;
7941
7942         if (newSize < oldFileSize) {
7943
7944 @@ -4994,21 +5018,20 @@ int yaffs_ResizeFile(yaffs_Object * in,
7945         }
7946
7947
7948 -
7949         /* Write a new object header.
7950          * show we've shrunk the file, if need be
7951          * Do this only if the file is not in the deleted directories.
7952          */
7953 -       if (in->parent->objectId != YAFFS_OBJECTID_UNLINKED &&
7954 -           in->parent->objectId != YAFFS_OBJECTID_DELETED) {
7955 +       if (in->parent &&
7956 +           in->parent->objectId != YAFFS_OBJECTID_UNLINKED &&
7957 +           in->parent->objectId != YAFFS_OBJECTID_DELETED)
7958                 yaffs_UpdateObjectHeader(in, NULL, 0,
7959                                          (newSize < oldFileSize) ? 1 : 0, 0);
7960 -       }
7961
7962 -       return newSize;
7963 +       return YAFFS_OK;
7964  }
7965
7966 -loff_t yaffs_GetFileSize(yaffs_Object * obj)
7967 +loff_t yaffs_GetFileSize(yaffs_Object *obj)
7968  {
7969         obj = yaffs_GetEquivalentObject(obj);
7970
7971 @@ -5024,7 +5047,7 @@ loff_t yaffs_GetFileSize(yaffs_Object *
7972
7973
7974
7975 -int yaffs_FlushFile(yaffs_Object * in, int updateTime)
7976 +int yaffs_FlushFile(yaffs_Object *in, int updateTime)
7977  {
7978         int retVal;
7979         if (in->dirty) {
7980 @@ -5039,9 +5062,8 @@ int yaffs_FlushFile(yaffs_Object * in, i
7981  #endif
7982                 }
7983
7984 -               retVal =
7985 -                   (yaffs_UpdateObjectHeader(in, NULL, 0, 0, 0) >=
7986 -                    0) ? YAFFS_OK : YAFFS_FAIL;
7987 +               retVal = (yaffs_UpdateObjectHeader(in, NULL, 0, 0, 0) >=
7988 +                       0) ? YAFFS_OK : YAFFS_FAIL;
7989         } else {
7990                 retVal = YAFFS_OK;
7991         }
7992 @@ -5050,7 +5072,7 @@ int yaffs_FlushFile(yaffs_Object * in, i
7993
7994  }
7995
7996 -static int yaffs_DoGenericObjectDeletion(yaffs_Object * in)
7997 +static int yaffs_DoGenericObjectDeletion(yaffs_Object *in)
7998  {
7999
8000         /* First off, invalidate the file's data in the cache, without flushing. */
8001 @@ -5058,13 +5080,13 @@ static int yaffs_DoGenericObjectDeletion
8002
8003         if (in->myDev->isYaffs2 && (in->parent != in->myDev->deletedDir)) {
8004                 /* Move to the unlinked directory so we have a record that it was deleted. */
8005 -               yaffs_ChangeObjectName(in, in->myDev->deletedDir,"deleted", 0, 0);
8006 +               yaffs_ChangeObjectName(in, in->myDev->deletedDir, _Y("deleted"), 0, 0);
8007
8008         }
8009
8010         yaffs_RemoveObjectFromDirectory(in);
8011 -       yaffs_DeleteChunk(in->myDev, in->chunkId, 1, __LINE__);
8012 -       in->chunkId = -1;
8013 +       yaffs_DeleteChunk(in->myDev, in->hdrChunk, 1, __LINE__);
8014 +       in->hdrChunk = 0;
8015
8016         yaffs_FreeObject(in);
8017         return YAFFS_OK;
8018 @@ -5075,62 +5097,63 @@ static int yaffs_DoGenericObjectDeletion
8019   * and the inode associated with the file.
8020   * It does not delete the links associated with the file.
8021   */
8022 -static int yaffs_UnlinkFile(yaffs_Object * in)
8023 +static int yaffs_UnlinkFileIfNeeded(yaffs_Object *in)
8024  {
8025
8026         int retVal;
8027         int immediateDeletion = 0;
8028
8029 -       if (1) {
8030  #ifdef __KERNEL__
8031 -               if (!in->myInode) {
8032 -                       immediateDeletion = 1;
8033 -
8034 -               }
8035 +       if (!in->myInode)
8036 +               immediateDeletion = 1;
8037  #else
8038 -               if (in->inUse <= 0) {
8039 -                       immediateDeletion = 1;
8040 -
8041 -               }
8042 +       if (in->inUse <= 0)
8043 +               immediateDeletion = 1;
8044  #endif
8045 -               if (immediateDeletion) {
8046 -                       retVal =
8047 -                           yaffs_ChangeObjectName(in, in->myDev->deletedDir,
8048 -                                                  "deleted", 0, 0);
8049 -                       T(YAFFS_TRACE_TRACING,
8050 -                         (TSTR("yaffs: immediate deletion of file %d" TENDSTR),
8051 -                          in->objectId));
8052 -                       in->deleted = 1;
8053 -                       in->myDev->nDeletedFiles++;
8054 -                       if (0 && in->myDev->isYaffs2) {
8055 -                               yaffs_ResizeFile(in, 0);
8056 -                       }
8057 -                       yaffs_SoftDeleteFile(in);
8058 -               } else {
8059 -                       retVal =
8060 -                           yaffs_ChangeObjectName(in, in->myDev->unlinkedDir,
8061 -                                                  "unlinked", 0, 0);
8062 -               }
8063
8064 +       if (immediateDeletion) {
8065 +               retVal =
8066 +                   yaffs_ChangeObjectName(in, in->myDev->deletedDir,
8067 +                                          _Y("deleted"), 0, 0);
8068 +               T(YAFFS_TRACE_TRACING,
8069 +                 (TSTR("yaffs: immediate deletion of file %d" TENDSTR),
8070 +                  in->objectId));
8071 +               in->deleted = 1;
8072 +               in->myDev->nDeletedFiles++;
8073 +               if (1 || in->myDev->isYaffs2)
8074 +                       yaffs_ResizeFile(in, 0);
8075 +               yaffs_SoftDeleteFile(in);
8076 +       } else {
8077 +               retVal =
8078 +                   yaffs_ChangeObjectName(in, in->myDev->unlinkedDir,
8079 +                                          _Y("unlinked"), 0, 0);
8080         }
8081 +
8082 +
8083         return retVal;
8084  }
8085
8086 -int yaffs_DeleteFile(yaffs_Object * in)
8087 +int yaffs_DeleteFile(yaffs_Object *in)
8088  {
8089         int retVal = YAFFS_OK;
8090 +       int deleted = in->deleted;
8091 +
8092 +       yaffs_ResizeFile(in, 0);
8093
8094         if (in->nDataChunks > 0) {
8095 -               /* Use soft deletion if there is data in the file */
8096 -               if (!in->unlinked) {
8097 -                       retVal = yaffs_UnlinkFile(in);
8098 -               }
8099 +               /* Use soft deletion if there is data in the file.
8100 +                * That won't be the case if it has been resized to zero.
8101 +                */
8102 +               if (!in->unlinked)
8103 +                       retVal = yaffs_UnlinkFileIfNeeded(in);
8104 +
8105                 if (retVal == YAFFS_OK && in->unlinked && !in->deleted) {
8106                         in->deleted = 1;
8107 +                       deleted = 1;
8108                         in->myDev->nDeletedFiles++;
8109                         yaffs_SoftDeleteFile(in);
8110                 }
8111 -               return in->deleted ? YAFFS_OK : YAFFS_FAIL;
8112 +               return deleted ? YAFFS_OK : YAFFS_FAIL;
8113         } else {
8114                 /* The file has no data chunks so we toss it immediately */
8115                 yaffs_FreeTnode(in->myDev, in->variant.fileVariant.top);
8116 @@ -5141,62 +5164,75 @@ int yaffs_DeleteFile(yaffs_Object * in)
8117         }
8118  }
8119
8120 -static int yaffs_DeleteDirectory(yaffs_Object * in)
8121 +static int yaffs_DeleteDirectory(yaffs_Object *in)
8122  {
8123         /* First check that the directory is empty. */
8124 -       if (list_empty(&in->variant.directoryVariant.children)) {
8125 +       if (ylist_empty(&in->variant.directoryVariant.children))
8126                 return yaffs_DoGenericObjectDeletion(in);
8127 -       }
8128
8129         return YAFFS_FAIL;
8130
8131  }
8132
8133 -static int yaffs_DeleteSymLink(yaffs_Object * in)
8134 +static int yaffs_DeleteSymLink(yaffs_Object *in)
8135  {
8136         YFREE(in->variant.symLinkVariant.alias);
8137
8138         return yaffs_DoGenericObjectDeletion(in);
8139  }
8140
8141 -static int yaffs_DeleteHardLink(yaffs_Object * in)
8142 +static int yaffs_DeleteHardLink(yaffs_Object *in)
8143  {
8144         /* remove this hardlink from the list assocaited with the equivalent
8145          * object
8146          */
8147 -       list_del(&in->hardLinks);
8148 +       ylist_del_init(&in->hardLinks);
8149         return yaffs_DoGenericObjectDeletion(in);
8150  }
8151
8152 -static void yaffs_DestroyObject(yaffs_Object * obj)
8153 +int yaffs_DeleteObject(yaffs_Object *obj)
8154  {
8155 +int retVal = -1;
8156         switch (obj->variantType) {
8157         case YAFFS_OBJECT_TYPE_FILE:
8158 -               yaffs_DeleteFile(obj);
8159 +               retVal = yaffs_DeleteFile(obj);
8160                 break;
8161         case YAFFS_OBJECT_TYPE_DIRECTORY:
8162 -               yaffs_DeleteDirectory(obj);
8163 +               return yaffs_DeleteDirectory(obj);
8164                 break;
8165         case YAFFS_OBJECT_TYPE_SYMLINK:
8166 -               yaffs_DeleteSymLink(obj);
8167 +               retVal = yaffs_DeleteSymLink(obj);
8168                 break;
8169         case YAFFS_OBJECT_TYPE_HARDLINK:
8170 -               yaffs_DeleteHardLink(obj);
8171 +               retVal = yaffs_DeleteHardLink(obj);
8172                 break;
8173         case YAFFS_OBJECT_TYPE_SPECIAL:
8174 -               yaffs_DoGenericObjectDeletion(obj);
8175 +               retVal = yaffs_DoGenericObjectDeletion(obj);
8176                 break;
8177         case YAFFS_OBJECT_TYPE_UNKNOWN:
8178 +               retVal = 0;
8179                 break;          /* should not happen. */
8180         }
8181 +
8182 +       return retVal;
8183  }
8184
8185 -static int yaffs_UnlinkWorker(yaffs_Object * obj)
8186 +static int yaffs_UnlinkWorker(yaffs_Object *obj)
8187  {
8188
8189 +       int immediateDeletion = 0;
8190 +
8191 +#ifdef __KERNEL__
8192 +       if (!obj->myInode)
8193 +               immediateDeletion = 1;
8194 +#else
8195 +       if (obj->inUse <= 0)
8196 +               immediateDeletion = 1;
8197 +#endif
8198 +
8199         if (obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK) {
8200                 return yaffs_DeleteHardLink(obj);
8201 -       } else if (!list_empty(&obj->hardLinks)) {
8202 +       } else if (!ylist_empty(&obj->hardLinks)) {
8203                 /* Curve ball: We're unlinking an object that has a hardlink.
8204                  *
8205                  * This problem arises because we are not strictly following
8206 @@ -5215,24 +5251,24 @@ static int yaffs_UnlinkWorker(yaffs_Obje
8207                 int retVal;
8208                 YCHAR name[YAFFS_MAX_NAME_LENGTH + 1];
8209
8210 -               hl = list_entry(obj->hardLinks.next, yaffs_Object, hardLinks);
8211 +               hl = ylist_entry(obj->hardLinks.next, yaffs_Object, hardLinks);
8212
8213 -               list_del_init(&hl->hardLinks);
8214 -               list_del_init(&hl->siblings);
8215 +               ylist_del_init(&hl->hardLinks);
8216 +               ylist_del_init(&hl->siblings);
8217
8218                 yaffs_GetObjectName(hl, name, YAFFS_MAX_NAME_LENGTH + 1);
8219
8220                 retVal = yaffs_ChangeObjectName(obj, hl->parent, name, 0, 0);
8221
8222 -               if (retVal == YAFFS_OK) {
8223 +               if (retVal == YAFFS_OK)
8224                         retVal = yaffs_DoGenericObjectDeletion(hl);
8225 -               }
8226 +
8227                 return retVal;
8228
8229 -       } else {
8230 +       } else if (immediateDeletion) {
8231                 switch (obj->variantType) {
8232                 case YAFFS_OBJECT_TYPE_FILE:
8233 -                       return yaffs_UnlinkFile(obj);
8234 +                       return yaffs_DeleteFile(obj);
8235                         break;
8236                 case YAFFS_OBJECT_TYPE_DIRECTORY:
8237                         return yaffs_DeleteDirectory(obj);
8238 @@ -5248,21 +5284,22 @@ static int yaffs_UnlinkWorker(yaffs_Obje
8239                 default:
8240                         return YAFFS_FAIL;
8241                 }
8242 -       }
8243 +       } else
8244 +               return yaffs_ChangeObjectName(obj, obj->myDev->unlinkedDir,
8245 +                                          _Y("unlinked"), 0, 0);
8246  }
8247
8248
8249 -static int yaffs_UnlinkObject( yaffs_Object *obj)
8250 +static int yaffs_UnlinkObject(yaffs_Object *obj)
8251  {
8252
8253 -       if (obj && obj->unlinkAllowed) {
8254 +       if (obj && obj->unlinkAllowed)
8255                 return yaffs_UnlinkWorker(obj);
8256 -       }
8257
8258         return YAFFS_FAIL;
8259
8260  }
8261 -int yaffs_Unlink(yaffs_Object * dir, const YCHAR * name)
8262 +int yaffs_Unlink(yaffs_Object *dir, const YCHAR *name)
8263  {
8264         yaffs_Object *obj;
8265
8266 @@ -5272,8 +5309,8 @@ int yaffs_Unlink(yaffs_Object * dir, con
8267
8268  /*----------------------- Initialisation Scanning ---------------------- */
8269
8270 -static void yaffs_HandleShadowedObject(yaffs_Device * dev, int objId,
8271 -                                      int backwardScanning)
8272 +static void yaffs_HandleShadowedObject(yaffs_Device *dev, int objId,
8273 +                               int backwardScanning)
8274  {
8275         yaffs_Object *obj;
8276
8277 @@ -5286,9 +5323,8 @@ static void yaffs_HandleShadowedObject(y
8278                 /* Handle YAFFS2 case (backward scanning)
8279                  * If the shadowed object exists then ignore.
8280                  */
8281 -               if (yaffs_FindObjectByNumber(dev, objId)) {
8282 +               if (yaffs_FindObjectByNumber(dev, objId))
8283                         return;
8284 -               }
8285         }
8286
8287         /* Let's create it (if it does not exist) assuming it is a file so that it can do shrinking etc.
8288 @@ -5297,6 +5333,8 @@ static void yaffs_HandleShadowedObject(y
8289         obj =
8290             yaffs_FindOrCreateObjectByNumber(dev, objId,
8291                                              YAFFS_OBJECT_TYPE_FILE);
8292 +       if (!obj)
8293 +               return;
8294         yaffs_AddObjectToDirectory(dev->unlinkedDir, obj);
8295         obj->variant.fileVariant.shrinkSize = 0;
8296         obj->valid = 1;         /* So that we don't read any other info for this file */
8297 @@ -5325,44 +5363,77 @@ static void yaffs_HardlinkFixup(yaffs_De
8298                 if (in) {
8299                         /* Add the hardlink pointers */
8300                         hl->variant.hardLinkVariant.equivalentObject = in;
8301 -                       list_add(&hl->hardLinks, &in->hardLinks);
8302 +                       ylist_add(&hl->hardLinks, &in->hardLinks);
8303                 } else {
8304                         /* Todo Need to report/handle this better.
8305                          * Got a problem... hardlink to a non-existant object
8306                          */
8307                         hl->variant.hardLinkVariant.equivalentObject = NULL;
8308 -                       INIT_LIST_HEAD(&hl->hardLinks);
8309 +                       YINIT_LIST_HEAD(&hl->hardLinks);
8310
8311                 }
8312 -
8313         }
8314 +}
8315 +
8316 +
8317
8318 +
8319 +
8320 +static int ybicmp(const void *a, const void *b)
8321 +{
8322 +       register int aseq = ((yaffs_BlockIndex *)a)->seq;
8323 +       register int bseq = ((yaffs_BlockIndex *)b)->seq;
8324 +       register int ablock = ((yaffs_BlockIndex *)a)->block;
8325 +       register int bblock = ((yaffs_BlockIndex *)b)->block;
8326 +       if (aseq == bseq)
8327 +               return ablock - bblock;
8328 +       else
8329 +               return aseq - bseq;
8330  }
8331
8332
8333 +struct yaffs_ShadowFixerStruct {
8334 +       int objectId;
8335 +       int shadowedId;
8336 +       struct yaffs_ShadowFixerStruct *next;
8337 +};
8338 +
8339
8340 +static void yaffs_StripDeletedObjects(yaffs_Device *dev)
8341 +{
8342 +       /*
8343 +       *  Sort out state of unlinked and deleted objects after scanning.
8344 +       */
8345 +       struct ylist_head *i;
8346 +       struct ylist_head *n;
8347 +       yaffs_Object *l;
8348
8349 +       /* Soft delete all the unlinked files */
8350 +       ylist_for_each_safe(i, n,
8351 +               &dev->unlinkedDir->variant.directoryVariant.children) {
8352 +               if (i) {
8353 +                       l = ylist_entry(i, yaffs_Object, siblings);
8354 +                       yaffs_DeleteObject(l);
8355 +               }
8356 +       }
8357
8358 -static int ybicmp(const void *a, const void *b){
8359 -    register int aseq = ((yaffs_BlockIndex *)a)->seq;
8360 -    register int bseq = ((yaffs_BlockIndex *)b)->seq;
8361 -    register int ablock = ((yaffs_BlockIndex *)a)->block;
8362 -    register int bblock = ((yaffs_BlockIndex *)b)->block;
8363 -    if( aseq == bseq )
8364 -        return ablock - bblock;
8365 -    else
8366 -        return aseq - bseq;
8367 +       ylist_for_each_safe(i, n,
8368 +               &dev->deletedDir->variant.directoryVariant.children) {
8369 +               if (i) {
8370 +                       l = ylist_entry(i, yaffs_Object, siblings);
8371 +                       yaffs_DeleteObject(l);
8372 +               }
8373 +       }
8374
8375  }
8376
8377 -static int yaffs_Scan(yaffs_Device * dev)
8378 +static int yaffs_Scan(yaffs_Device *dev)
8379  {
8380         yaffs_ExtendedTags tags;
8381         int blk;
8382         int blockIterator;
8383         int startIterator;
8384         int endIterator;
8385 -       int nBlocksToScan = 0;
8386         int result;
8387
8388         int chunk;
8389 @@ -5371,26 +5442,19 @@ static int yaffs_Scan(yaffs_Device * dev
8390         yaffs_BlockState state;
8391         yaffs_Object *hardList = NULL;
8392         yaffs_BlockInfo *bi;
8393 -       int sequenceNumber;
8394 +       __u32 sequenceNumber;
8395         yaffs_ObjectHeader *oh;
8396         yaffs_Object *in;
8397         yaffs_Object *parent;
8398 -       int nBlocks = dev->internalEndBlock - dev->internalStartBlock + 1;
8399
8400         int alloc_failed = 0;
8401
8402 +       struct yaffs_ShadowFixerStruct *shadowFixerList = NULL;
8403 +
8404
8405         __u8 *chunkData;
8406
8407 -       yaffs_BlockIndex *blockIndex = NULL;
8408
8409 -       if (dev->isYaffs2) {
8410 -               T(YAFFS_TRACE_SCAN,
8411 -                 (TSTR("yaffs_Scan is not for YAFFS2!" TENDSTR)));
8412 -               return YAFFS_FAIL;
8413 -       }
8414 -
8415 -       //TODO  Throw all the yaffs2 stuuf out of yaffs_Scan since it is only for yaffs1 format.
8416
8417         T(YAFFS_TRACE_SCAN,
8418           (TSTR("yaffs_Scan starts  intstartblk %d intendblk %d..." TENDSTR),
8419 @@ -5400,12 +5464,6 @@ static int yaffs_Scan(yaffs_Device * dev
8420
8421         dev->sequenceNumber = YAFFS_LOWEST_SEQUENCE_NUMBER;
8422
8423 -       if (dev->isYaffs2) {
8424 -               blockIndex = YMALLOC(nBlocks * sizeof(yaffs_BlockIndex));
8425 -               if(!blockIndex)
8426 -                       return YAFFS_FAIL;
8427 -       }
8428 -
8429         /* Scan all the blocks to determine their state */
8430         for (blk = dev->internalStartBlock; blk <= dev->internalEndBlock; blk++) {
8431                 bi = yaffs_GetBlockInfo(dev, blk);
8432 @@ -5418,6 +5476,9 @@ static int yaffs_Scan(yaffs_Device * dev
8433                 bi->blockState = state;
8434                 bi->sequenceNumber = sequenceNumber;
8435
8436 +               if (bi->sequenceNumber == YAFFS_SEQUENCE_BAD_BLOCK)
8437 +                       bi->blockState = state = YAFFS_BLOCK_STATE_DEAD;
8438 +
8439                 T(YAFFS_TRACE_SCAN_DEBUG,
8440                   (TSTR("Block scanning block %d state %d seq %d" TENDSTR), blk,
8441                    state, sequenceNumber));
8442 @@ -5430,70 +5491,21 @@ static int yaffs_Scan(yaffs_Device * dev
8443                           (TSTR("Block empty " TENDSTR)));
8444                         dev->nErasedBlocks++;
8445                         dev->nFreeChunks += dev->nChunksPerBlock;
8446 -               } else if (state == YAFFS_BLOCK_STATE_NEEDS_SCANNING) {
8447 -
8448 -                       /* Determine the highest sequence number */
8449 -                       if (dev->isYaffs2 &&
8450 -                           sequenceNumber >= YAFFS_LOWEST_SEQUENCE_NUMBER &&
8451 -                           sequenceNumber < YAFFS_HIGHEST_SEQUENCE_NUMBER) {
8452 -
8453 -                               blockIndex[nBlocksToScan].seq = sequenceNumber;
8454 -                               blockIndex[nBlocksToScan].block = blk;
8455 -
8456 -                               nBlocksToScan++;
8457 -
8458 -                               if (sequenceNumber >= dev->sequenceNumber) {
8459 -                                       dev->sequenceNumber = sequenceNumber;
8460 -                               }
8461 -                       } else if (dev->isYaffs2) {
8462 -                               /* TODO: Nasty sequence number! */
8463 -                               T(YAFFS_TRACE_SCAN,
8464 -                                 (TSTR
8465 -                                  ("Block scanning block %d has bad sequence number %d"
8466 -                                   TENDSTR), blk, sequenceNumber));
8467 -
8468 -                       }
8469                 }
8470         }
8471
8472 -       /* Sort the blocks
8473 -        * Dungy old bubble sort for now...
8474 -        */
8475 -       if (dev->isYaffs2) {
8476 -               yaffs_BlockIndex temp;
8477 -               int i;
8478 -               int j;
8479 -
8480 -               for (i = 0; i < nBlocksToScan; i++)
8481 -                       for (j = i + 1; j < nBlocksToScan; j++)
8482 -                               if (blockIndex[i].seq > blockIndex[j].seq) {
8483 -                                       temp = blockIndex[j];
8484 -                                       blockIndex[j] = blockIndex[i];
8485 -                                       blockIndex[i] = temp;
8486 -                               }
8487 -       }
8488 -
8489 -       /* Now scan the blocks looking at the data. */
8490 -       if (dev->isYaffs2) {
8491 -               startIterator = 0;
8492 -               endIterator = nBlocksToScan - 1;
8493 -               T(YAFFS_TRACE_SCAN_DEBUG,
8494 -                 (TSTR("%d blocks to be scanned" TENDSTR), nBlocksToScan));
8495 -       } else {
8496 -               startIterator = dev->internalStartBlock;
8497 -               endIterator = dev->internalEndBlock;
8498 -       }
8499 +       startIterator = dev->internalStartBlock;
8500 +       endIterator = dev->internalEndBlock;
8501
8502         /* For each block.... */
8503         for (blockIterator = startIterator; !alloc_failed && blockIterator <= endIterator;
8504              blockIterator++) {
8505
8506 -               if (dev->isYaffs2) {
8507 -                       /* get the block to scan in the correct order */
8508 -                       blk = blockIndex[blockIterator].block;
8509 -               } else {
8510 -                       blk = blockIterator;
8511 -               }
8512 +               YYIELD();
8513 +
8514 +               YYIELD();
8515 +
8516 +               blk = blockIterator;
8517
8518                 bi = yaffs_GetBlockInfo(dev, blk);
8519                 state = bi->blockState;
8520 @@ -5511,7 +5523,7 @@ static int yaffs_Scan(yaffs_Device * dev
8521
8522                         /* Let's have a good look at this chunk... */
8523
8524 -                       if (!dev->isYaffs2 && tags.chunkDeleted) {
8525 +                       if (tags.eccResult == YAFFS_ECC_RESULT_UNFIXED || tags.chunkDeleted) {
8526                                 /* YAFFS1 only...
8527                                  * A deleted chunk
8528                                  */
8529 @@ -5540,18 +5552,6 @@ static int yaffs_Scan(yaffs_Device * dev
8530                                         dev->allocationBlockFinder = blk;
8531                                         /* Set it to here to encourage the allocator to go forth from here. */
8532
8533 -                                       /* Yaffs2 sanity check:
8534 -                                        * This should be the one with the highest sequence number
8535 -                                        */
8536 -                                       if (dev->isYaffs2
8537 -                                           && (dev->sequenceNumber !=
8538 -                                               bi->sequenceNumber)) {
8539 -                                               T(YAFFS_TRACE_ALWAYS,
8540 -                                                 (TSTR
8541 -                                                  ("yaffs: Allocation block %d was not highest sequence id:"
8542 -                                                   " block seq = %d, dev seq = %d"
8543 -                                                   TENDSTR), blk,bi->sequenceNumber,dev->sequenceNumber));
8544 -                                       }
8545                                 }
8546
8547                                 dev->nFreeChunks += (dev->nChunksPerBlock - c);
8548 @@ -5570,11 +5570,11 @@ static int yaffs_Scan(yaffs_Device * dev
8549                                  * the same chunkId).
8550                                  */
8551
8552 -                               if(!in)
8553 +                               if (!in)
8554                                         alloc_failed = 1;
8555
8556 -                               if(in){
8557 -                                       if(!yaffs_PutChunkIntoFile(in, tags.chunkId, chunk,1))
8558 +                               if (in) {
8559 +                                       if (!yaffs_PutChunkIntoFile(in, tags.chunkId, chunk, 1))
8560                                                 alloc_failed = 1;
8561                                 }
8562
8563 @@ -5617,7 +5617,7 @@ static int yaffs_Scan(yaffs_Device * dev
8564                                          * deleted, and worse still it has changed type. Delete the old object.
8565                                          */
8566
8567 -                                       yaffs_DestroyObject(in);
8568 +                                       yaffs_DeleteObject(in);
8569
8570                                         in = 0;
8571                                 }
8572 @@ -5627,14 +5627,20 @@ static int yaffs_Scan(yaffs_Device * dev
8573                                                                       objectId,
8574                                                                       oh->type);
8575
8576 -                               if(!in)
8577 +                               if (!in)
8578                                         alloc_failed = 1;
8579
8580                                 if (in && oh->shadowsObject > 0) {
8581 -                                       yaffs_HandleShadowedObject(dev,
8582 -                                                                  oh->
8583 -                                                                  shadowsObject,
8584 -                                                                  0);
8585 +
8586 +                                       struct yaffs_ShadowFixerStruct *fixer;
8587 +                                       fixer = YMALLOC(sizeof(struct yaffs_ShadowFixerStruct));
8588 +                                       if (fixer) {
8589 +                                               fixer->next = shadowFixerList;
8590 +                                               shadowFixerList = fixer;
8591 +                                               fixer->objectId = tags.objectId;
8592 +                                               fixer->shadowedId = oh->shadowsObject;
8593 +                                       }
8594 +
8595                                 }
8596
8597                                 if (in && in->valid) {
8598 @@ -5643,12 +5649,10 @@ static int yaffs_Scan(yaffs_Device * dev
8599                                         unsigned existingSerial = in->serial;
8600                                         unsigned newSerial = tags.serialNumber;
8601
8602 -                                       if (dev->isYaffs2 ||
8603 -                                           ((existingSerial + 1) & 3) ==
8604 -                                           newSerial) {
8605 +                                       if (((existingSerial + 1) & 3) == newSerial) {
8606                                                 /* Use new one - destroy the exisiting one */
8607                                                 yaffs_DeleteChunk(dev,
8608 -                                                                 in->chunkId,
8609 +                                                                 in->hdrChunk,
8610                                                                   1, __LINE__);
8611                                                 in->valid = 0;
8612                                         } else {
8613 @@ -5681,7 +5685,8 @@ static int yaffs_Scan(yaffs_Device * dev
8614                                         in->yst_ctime = oh->yst_ctime;
8615                                         in->yst_rdev = oh->yst_rdev;
8616  #endif
8617 -                                       in->chunkId = chunk;
8618 +                                       in->hdrChunk = chunk;
8619 +                                       in->serial = tags.serialNumber;
8620
8621                                 } else if (in && !in->valid) {
8622                                         /* we need to load this info */
8623 @@ -5705,7 +5710,8 @@ static int yaffs_Scan(yaffs_Device * dev
8624                                         in->yst_ctime = oh->yst_ctime;
8625                                         in->yst_rdev = oh->yst_rdev;
8626  #endif
8627 -                                       in->chunkId = chunk;
8628 +                                       in->hdrChunk = chunk;
8629 +                                       in->serial = tags.serialNumber;
8630
8631                                         yaffs_SetObjectName(in, oh->name);
8632                                         in->dirty = 0;
8633 @@ -5718,25 +5724,25 @@ static int yaffs_Scan(yaffs_Device * dev
8634                                             yaffs_FindOrCreateObjectByNumber
8635                                             (dev, oh->parentObjectId,
8636                                              YAFFS_OBJECT_TYPE_DIRECTORY);
8637 -                                       if (parent->variantType ==
8638 +                                       if (!parent)
8639 +                                               alloc_failed = 1;
8640 +                                       if (parent && parent->variantType ==
8641                                             YAFFS_OBJECT_TYPE_UNKNOWN) {
8642                                                 /* Set up as a directory */
8643                                                 parent->variantType =
8644 -                                                   YAFFS_OBJECT_TYPE_DIRECTORY;
8645 -                                               INIT_LIST_HEAD(&parent->variant.
8646 -                                                              directoryVariant.
8647 -                                                              children);
8648 -                                       } else if (parent->variantType !=
8649 -                                                  YAFFS_OBJECT_TYPE_DIRECTORY)
8650 -                                       {
8651 +                                                       YAFFS_OBJECT_TYPE_DIRECTORY;
8652 +                                               YINIT_LIST_HEAD(&parent->variant.
8653 +                                                               directoryVariant.
8654 +                                                               children);
8655 +                                       } else if (!parent || parent->variantType !=
8656 +                                                  YAFFS_OBJECT_TYPE_DIRECTORY) {
8657                                                 /* Hoosterman, another problem....
8658                                                  * We're trying to use a non-directory as a directory
8659                                                  */
8660
8661                                                 T(YAFFS_TRACE_ERROR,
8662                                                   (TSTR
8663 -                                                  ("yaffs tragedy: attempting to use non-directory as"
8664 -                                                   " a directory in scan. Put in lost+found."
8665 +                                                  ("yaffs tragedy: attempting to use non-directory as a directory in scan. Put in lost+found."
8666                                                     TENDSTR)));
8667                                                 parent = dev->lostNFoundDir;
8668                                         }
8669 @@ -5760,15 +5766,6 @@ static int yaffs_Scan(yaffs_Device * dev
8670                                                 /* Todo got a problem */
8671                                                 break;
8672                                         case YAFFS_OBJECT_TYPE_FILE:
8673 -                                               if (dev->isYaffs2
8674 -                                                   && oh->isShrink) {
8675 -                                                       /* Prune back the shrunken chunks */
8676 -                                                       yaffs_PruneResizedChunks
8677 -                                                           (in, oh->fileSize);
8678 -                                                       /* Mark the block as having a shrinkHeader */
8679 -                                                       bi->hasShrinkHeader = 1;
8680 -                                               }
8681 -
8682                                                 if (dev->useHeaderFileSize)
8683
8684                                                         in->variant.fileVariant.
8685 @@ -5778,11 +5775,11 @@ static int yaffs_Scan(yaffs_Device * dev
8686                                                 break;
8687                                         case YAFFS_OBJECT_TYPE_HARDLINK:
8688                                                 in->variant.hardLinkVariant.
8689 -                                                   equivalentObjectId =
8690 -                                                   oh->equivalentObjectId;
8691 +                                                       equivalentObjectId =
8692 +                                                       oh->equivalentObjectId;
8693                                                 in->hardLinks.next =
8694 -                                                   (struct list_head *)
8695 -                                                   hardList;
8696 +                                                       (struct ylist_head *)
8697 +                                                       hardList;
8698                                                 hardList = in;
8699                                                 break;
8700                                         case YAFFS_OBJECT_TYPE_DIRECTORY:
8701 @@ -5794,15 +5791,17 @@ static int yaffs_Scan(yaffs_Device * dev
8702                                         case YAFFS_OBJECT_TYPE_SYMLINK:
8703                                                 in->variant.symLinkVariant.alias =
8704                                                     yaffs_CloneString(oh->alias);
8705 -                                               if(!in->variant.symLinkVariant.alias)
8706 +                                               if (!in->variant.symLinkVariant.alias)
8707                                                         alloc_failed = 1;
8708                                                 break;
8709                                         }
8710
8711 +/*
8712                                         if (parent == dev->deletedDir) {
8713                                                 yaffs_DestroyObject(in);
8714                                                 bi->hasShrinkHeader = 1;
8715                                         }
8716 +*/
8717                                 }
8718                         }
8719                 }
8720 @@ -5823,10 +5822,6 @@ static int yaffs_Scan(yaffs_Device * dev
8721
8722         }
8723
8724 -       if (blockIndex) {
8725 -               YFREE(blockIndex);
8726 -       }
8727 -
8728
8729         /* Ok, we've done all the scanning.
8730          * Fix up the hard link chains.
8731 @@ -5834,32 +5829,36 @@ static int yaffs_Scan(yaffs_Device * dev
8732          * hardlinks.
8733          */
8734
8735 -       yaffs_HardlinkFixup(dev,hardList);
8736 +       yaffs_HardlinkFixup(dev, hardList);
8737
8738 -       /* Handle the unlinked files. Since they were left in an unlinked state we should
8739 -        * just delete them.
8740 -        */
8741 +       /* Fix up any shadowed objects */
8742         {
8743 -               struct list_head *i;
8744 -               struct list_head *n;
8745 +               struct yaffs_ShadowFixerStruct *fixer;
8746 +               yaffs_Object *obj;
8747
8748 -               yaffs_Object *l;
8749 -               /* Soft delete all the unlinked files */
8750 -               list_for_each_safe(i, n,
8751 -                                  &dev->unlinkedDir->variant.directoryVariant.
8752 -                                  children) {
8753 -                       if (i) {
8754 -                               l = list_entry(i, yaffs_Object, siblings);
8755 -                               yaffs_DestroyObject(l);
8756 -                       }
8757 +               while (shadowFixerList) {
8758 +                       fixer = shadowFixerList;
8759 +                       shadowFixerList = fixer->next;
8760 +                       /* Complete the rename transaction by deleting the shadowed object
8761 +                        * then setting the object header to unshadowed.
8762 +                        */
8763 +                       obj = yaffs_FindObjectByNumber(dev, fixer->shadowedId);
8764 +                       if (obj)
8765 +                               yaffs_DeleteObject(obj);
8766 +
8767 +                       obj = yaffs_FindObjectByNumber(dev, fixer->objectId);
8768 +
8769 +                       if (obj)
8770 +                               yaffs_UpdateObjectHeader(obj, NULL, 1, 0, 0);
8771 +
8772 +                       YFREE(fixer);
8773                 }
8774         }
8775
8776         yaffs_ReleaseTempBuffer(dev, chunkData, __LINE__);
8777
8778 -       if(alloc_failed){
8779 +       if (alloc_failed)
8780                 return YAFFS_FAIL;
8781 -       }
8782
8783         T(YAFFS_TRACE_SCAN, (TSTR("yaffs_Scan ends" TENDSTR)));
8784
8785 @@ -5871,25 +5870,27 @@ static void yaffs_CheckObjectDetailsLoad
8786  {
8787         __u8 *chunkData;
8788         yaffs_ObjectHeader *oh;
8789 -       yaffs_Device *dev = in->myDev;
8790 +       yaffs_Device *dev;
8791         yaffs_ExtendedTags tags;
8792         int result;
8793         int alloc_failed = 0;
8794
8795 -       if(!in)
8796 +       if (!in)
8797                 return;
8798
8799 +       dev = in->myDev;
8800 +
8801  #if 0
8802 -       T(YAFFS_TRACE_SCAN,(TSTR("details for object %d %s loaded" TENDSTR),
8803 +       T(YAFFS_TRACE_SCAN, (TSTR("details for object %d %s loaded" TENDSTR),
8804                 in->objectId,
8805                 in->lazyLoaded ? "not yet" : "already"));
8806  #endif
8807
8808 -       if(in->lazyLoaded){
8809 +       if (in->lazyLoaded && in->hdrChunk > 0) {
8810                 in->lazyLoaded = 0;
8811                 chunkData = yaffs_GetTempBuffer(dev, __LINE__);
8812
8813 -               result = yaffs_ReadChunkWithTagsFromNAND(dev,in->chunkId,chunkData,&tags);
8814 +               result = yaffs_ReadChunkWithTagsFromNAND(dev, in->hdrChunk, chunkData, &tags);
8815                 oh = (yaffs_ObjectHeader *) chunkData;
8816
8817                 in->yst_mode = oh->yst_mode;
8818 @@ -5911,18 +5912,18 @@ static void yaffs_CheckObjectDetailsLoad
8819  #endif
8820                 yaffs_SetObjectName(in, oh->name);
8821
8822 -               if(in->variantType == YAFFS_OBJECT_TYPE_SYMLINK){
8823 -                        in->variant.symLinkVariant.alias =
8824 +               if (in->variantType == YAFFS_OBJECT_TYPE_SYMLINK) {
8825 +                       in->variant.symLinkVariant.alias =
8826                                                     yaffs_CloneString(oh->alias);
8827 -                       if(!in->variant.symLinkVariant.alias)
8828 +                       if (!in->variant.symLinkVariant.alias)
8829                                 alloc_failed = 1; /* Not returned to caller */
8830                 }
8831
8832 -               yaffs_ReleaseTempBuffer(dev,chunkData, __LINE__);
8833 +               yaffs_ReleaseTempBuffer(dev, chunkData, __LINE__);
8834         }
8835  }
8836
8837 -static int yaffs_ScanBackwards(yaffs_Device * dev)
8838 +static int yaffs_ScanBackwards(yaffs_Device *dev)
8839  {
8840         yaffs_ExtendedTags tags;
8841         int blk;
8842 @@ -5938,7 +5939,7 @@ static int yaffs_ScanBackwards(yaffs_Dev
8843         yaffs_BlockState state;
8844         yaffs_Object *hardList = NULL;
8845         yaffs_BlockInfo *bi;
8846 -       int sequenceNumber;
8847 +       __u32 sequenceNumber;
8848         yaffs_ObjectHeader *oh;
8849         yaffs_Object *in;
8850         yaffs_Object *parent;
8851 @@ -5972,12 +5973,12 @@ static int yaffs_ScanBackwards(yaffs_Dev
8852
8853         blockIndex = YMALLOC(nBlocks * sizeof(yaffs_BlockIndex));
8854
8855 -       if(!blockIndex) {
8856 +       if (!blockIndex) {
8857                 blockIndex = YMALLOC_ALT(nBlocks * sizeof(yaffs_BlockIndex));
8858                 altBlockIndex = 1;
8859         }
8860
8861 -       if(!blockIndex) {
8862 +       if (!blockIndex) {
8863                 T(YAFFS_TRACE_SCAN,
8864                   (TSTR("yaffs_Scan() could not allocate block index!" TENDSTR)));
8865                 return YAFFS_FAIL;
8866 @@ -5999,15 +6000,17 @@ static int yaffs_ScanBackwards(yaffs_Dev
8867                 bi->blockState = state;
8868                 bi->sequenceNumber = sequenceNumber;
8869
8870 -               if(bi->sequenceNumber == YAFFS_SEQUENCE_CHECKPOINT_DATA)
8871 +               if (bi->sequenceNumber == YAFFS_SEQUENCE_CHECKPOINT_DATA)
8872                         bi->blockState = state = YAFFS_BLOCK_STATE_CHECKPOINT;
8873 +               if (bi->sequenceNumber == YAFFS_SEQUENCE_BAD_BLOCK)
8874 +                       bi->blockState = state = YAFFS_BLOCK_STATE_DEAD;
8875
8876                 T(YAFFS_TRACE_SCAN_DEBUG,
8877                   (TSTR("Block scanning block %d state %d seq %d" TENDSTR), blk,
8878                    state, sequenceNumber));
8879
8880
8881 -               if(state == YAFFS_BLOCK_STATE_CHECKPOINT){
8882 +               if (state == YAFFS_BLOCK_STATE_CHECKPOINT) {
8883                         dev->blocksInCheckpoint++;
8884
8885                 } else if (state == YAFFS_BLOCK_STATE_DEAD) {
8886 @@ -6021,8 +6024,7 @@ static int yaffs_ScanBackwards(yaffs_Dev
8887                 } else if (state == YAFFS_BLOCK_STATE_NEEDS_SCANNING) {
8888
8889                         /* Determine the highest sequence number */
8890 -                       if (dev->isYaffs2 &&
8891 -                           sequenceNumber >= YAFFS_LOWEST_SEQUENCE_NUMBER &&
8892 +                       if (sequenceNumber >= YAFFS_LOWEST_SEQUENCE_NUMBER &&
8893                             sequenceNumber < YAFFS_HIGHEST_SEQUENCE_NUMBER) {
8894
8895                                 blockIndex[nBlocksToScan].seq = sequenceNumber;
8896 @@ -6030,10 +6032,9 @@ static int yaffs_ScanBackwards(yaffs_Dev
8897
8898                                 nBlocksToScan++;
8899
8900 -                               if (sequenceNumber >= dev->sequenceNumber) {
8901 +                               if (sequenceNumber >= dev->sequenceNumber)
8902                                         dev->sequenceNumber = sequenceNumber;
8903 -                               }
8904 -                       } else if (dev->isYaffs2) {
8905 +                       } else {
8906                                 /* TODO: Nasty sequence number! */
8907                                 T(YAFFS_TRACE_SCAN,
8908                                   (TSTR
8909 @@ -6053,11 +6054,13 @@ static int yaffs_ScanBackwards(yaffs_Dev
8910
8911         /* Sort the blocks */
8912  #ifndef CONFIG_YAFFS_USE_OWN_SORT
8913 -       yaffs_qsort(blockIndex, nBlocksToScan,
8914 -               sizeof(yaffs_BlockIndex), ybicmp);
8915 +       {
8916 +               /* Use qsort now. */
8917 +               yaffs_qsort(blockIndex, nBlocksToScan, sizeof(yaffs_BlockIndex), ybicmp);
8918 +       }
8919  #else
8920         {
8921 -               /* Dungy old bubble sort... */
8922 +               /* Dungy old bubble sort... */
8923
8924                 yaffs_BlockIndex temp;
8925                 int i;
8926 @@ -6075,7 +6078,7 @@ static int yaffs_ScanBackwards(yaffs_Dev
8927
8928         YYIELD();
8929
8930 -       T(YAFFS_TRACE_SCAN, (TSTR("...done" TENDSTR)));
8931 +       T(YAFFS_TRACE_SCAN, (TSTR("...done" TENDSTR)));
8932
8933         /* Now scan the blocks looking at the data. */
8934         startIterator = 0;
8935 @@ -6085,10 +6088,10 @@ static int yaffs_ScanBackwards(yaffs_Dev
8936
8937         /* For each block.... backwards */
8938         for (blockIterator = endIterator; !alloc_failed && blockIterator >= startIterator;
8939 -            blockIterator--) {
8940 -               /* Cooperative multitasking! This loop can run for so
8941 +                       blockIterator--) {
8942 +               /* Cooperative multitasking! This loop can run for so
8943                    long that watchdog timers expire. */
8944 -               YYIELD();
8945 +               YYIELD();
8946
8947                 /* get the block to scan in the correct order */
8948                 blk = blockIndex[blockIterator].block;
8949 @@ -6127,10 +6130,8 @@ static int yaffs_ScanBackwards(yaffs_Dev
8950                                  * this is the one being allocated from
8951                                  */
8952
8953 -                               if(foundChunksInBlock)
8954 -                               {
8955 +                               if (foundChunksInBlock) {
8956                                         /* This is a chunk that was skipped due to failing the erased check */
8957 -
8958                                 } else if (c == 0) {
8959                                         /* We're looking at the first chunk in the block so the block is unused */
8960                                         state = YAFFS_BLOCK_STATE_EMPTY;
8961 @@ -6138,7 +6139,7 @@ static int yaffs_ScanBackwards(yaffs_Dev
8962                                 } else {
8963                                         if (state == YAFFS_BLOCK_STATE_NEEDS_SCANNING ||
8964                                             state == YAFFS_BLOCK_STATE_ALLOCATING) {
8965 -                                               if(dev->sequenceNumber == bi->sequenceNumber) {
8966 +                                               if (dev->sequenceNumber == bi->sequenceNumber) {
8967                                                         /* this is the block being allocated from */
8968
8969                                                         T(YAFFS_TRACE_SCAN,
8970 @@ -6150,27 +6151,31 @@ static int yaffs_ScanBackwards(yaffs_Dev
8971                                                         dev->allocationBlock = blk;
8972                                                         dev->allocationPage = c;
8973                                                         dev->allocationBlockFinder = blk;
8974 -                                               }
8975 -                                               else {
8976 +                                               } else {
8977                                                         /* This is a partially written block that is not
8978                                                          * the current allocation block. This block must have
8979                                                          * had a write failure, so set up for retirement.
8980                                                          */
8981
8982 -                                                        bi->needsRetiring = 1;
8983 +                                                        /* bi->needsRetiring = 1; ??? TODO */
8984                                                          bi->gcPrioritise = 1;
8985
8986                                                          T(YAFFS_TRACE_ALWAYS,
8987 -                                                        (TSTR("Partially written block %d being set for retirement" TENDSTR),
8988 +                                                        (TSTR("Partially written block %d detected" TENDSTR),
8989                                                          blk));
8990                                                 }
8991 -
8992                                         }
8993 -
8994                                 }
8995
8996                                 dev->nFreeChunks++;
8997
8998 +                       } else if (tags.eccResult == YAFFS_ECC_RESULT_UNFIXED) {
8999 +                               T(YAFFS_TRACE_SCAN,
9000 +                                 (TSTR(" Unfixed ECC in chunk(%d:%d), chunk ignored"TENDSTR),
9001 +                                 blk, c));
9002 +
9003 +                                 dev->nFreeChunks++;
9004 +
9005                         } else if (tags.chunkId > 0) {
9006                                 /* chunkId > 0 so it is a data chunk... */
9007                                 unsigned int endpos;
9008 @@ -6187,7 +6192,7 @@ static int yaffs_ScanBackwards(yaffs_Dev
9009                                                                       tags.
9010                                                                       objectId,
9011                                                                       YAFFS_OBJECT_TYPE_FILE);
9012 -                               if(!in){
9013 +                               if (!in) {
9014                                         /* Out of memory */
9015                                         alloc_failed = 1;
9016                                 }
9017 @@ -6197,8 +6202,8 @@ static int yaffs_ScanBackwards(yaffs_Dev
9018                                     && chunkBase <
9019                                     in->variant.fileVariant.shrinkSize) {
9020                                         /* This has not been invalidated by a resize */
9021 -                                       if(!yaffs_PutChunkIntoFile(in, tags.chunkId,
9022 -                                                              chunk, -1)){
9023 +                                       if (!yaffs_PutChunkIntoFile(in, tags.chunkId,
9024 +                                                              chunk, -1)) {
9025                                                 alloc_failed = 1;
9026                                         }
9027
9028 @@ -6221,7 +6226,7 @@ static int yaffs_ScanBackwards(yaffs_Dev
9029                                                     scannedFileSize;
9030                                         }
9031
9032 -                               } else if(in) {
9033 +                               } else if (in) {
9034                                         /* This chunk has been invalidated by a resize, so delete */
9035                                         yaffs_DeleteChunk(dev, chunk, 1, __LINE__);
9036
9037 @@ -6242,6 +6247,8 @@ static int yaffs_ScanBackwards(yaffs_Dev
9038                                         in = yaffs_FindOrCreateObjectByNumber
9039                                             (dev, tags.objectId,
9040                                              tags.extraObjectType);
9041 +                                       if (!in)
9042 +                                               alloc_failed = 1;
9043                                 }
9044
9045                                 if (!in ||
9046 @@ -6251,8 +6258,7 @@ static int yaffs_ScanBackwards(yaffs_Dev
9047                                     tags.extraShadows ||
9048                                     (!in->valid &&
9049                                     (tags.objectId == YAFFS_OBJECTID_ROOT ||
9050 -                                    tags.objectId == YAFFS_OBJECTID_LOSTNFOUND))
9051 -                                   ) {
9052 +                                    tags.objectId == YAFFS_OBJECTID_LOSTNFOUND))) {
9053
9054                                         /* If we don't have  valid info then we need to read the chunk
9055                                          * TODO In future we can probably defer reading the chunk and
9056 @@ -6266,8 +6272,17 @@ static int yaffs_ScanBackwards(yaffs_Dev
9057
9058                                         oh = (yaffs_ObjectHeader *) chunkData;
9059
9060 -                                       if (!in)
9061 +                                       if (dev->inbandTags) {
9062 +                                               /* Fix up the header if they got corrupted by inband tags */
9063 +                                               oh->shadowsObject = oh->inbandShadowsObject;
9064 +                                               oh->isShrink = oh->inbandIsShrink;
9065 +                                       }
9066 +
9067 +                                       if (!in) {
9068                                                 in = yaffs_FindOrCreateObjectByNumber(dev, tags.objectId, oh->type);
9069 +                                               if (!in)
9070 +                                                       alloc_failed = 1;
9071 +                                       }
9072
9073                                 }
9074
9075 @@ -6275,10 +6290,9 @@ static int yaffs_ScanBackwards(yaffs_Dev
9076                                         /* TODO Hoosterman we have a problem! */
9077                                         T(YAFFS_TRACE_ERROR,
9078                                           (TSTR
9079 -                                          ("yaffs tragedy: Could not make object for object  %d  "
9080 -                                           "at chunk %d during scan"
9081 +                                          ("yaffs tragedy: Could not make object for object  %d at chunk %d during scan"
9082                                             TENDSTR), tags.objectId, chunk));
9083 -
9084 +                                       continue;
9085                                 }
9086
9087                                 if (in->valid) {
9088 @@ -6289,10 +6303,9 @@ static int yaffs_ScanBackwards(yaffs_Dev
9089
9090                                         if ((in->variantType == YAFFS_OBJECT_TYPE_FILE) &&
9091                                              ((oh &&
9092 -                                              oh-> type == YAFFS_OBJECT_TYPE_FILE)||
9093 +                                              oh->type == YAFFS_OBJECT_TYPE_FILE) ||
9094                                               (tags.extraHeaderInfoAvailable  &&
9095 -                                              tags.extraObjectType == YAFFS_OBJECT_TYPE_FILE))
9096 -                                           ) {
9097 +                                              tags.extraObjectType == YAFFS_OBJECT_TYPE_FILE))) {
9098                                                 __u32 thisSize =
9099                                                     (oh) ? oh->fileSize : tags.
9100                                                     extraFileLength;
9101 @@ -6300,7 +6313,9 @@ static int yaffs_ScanBackwards(yaffs_Dev
9102                                                     (oh) ? oh->
9103                                                     parentObjectId : tags.
9104                                                     extraParentObjectId;
9105 -                                               unsigned isShrink =
9106 +
9107 +
9108 +                                               isShrink =
9109                                                     (oh) ? oh->isShrink : tags.
9110                                                     extraIsShrinkHeader;
9111
9112 @@ -6323,9 +6338,8 @@ static int yaffs_ScanBackwards(yaffs_Dev
9113                                                             thisSize;
9114                                                 }
9115
9116 -                                               if (isShrink) {
9117 +                                               if (isShrink)
9118                                                         bi->hasShrinkHeader = 1;
9119 -                                               }
9120
9121                                         }
9122                                         /* Use existing - destroy this one. */
9123 @@ -6333,6 +6347,17 @@ static int yaffs_ScanBackwards(yaffs_Dev
9124
9125                                 }
9126
9127 +                               if (!in->valid && in->variantType !=
9128 +                                   (oh ? oh->type : tags.extraObjectType))
9129 +                                       T(YAFFS_TRACE_ERROR, (
9130 +                                               TSTR("yaffs tragedy: Bad object type, "
9131 +                                           TCONT("%d != %d, for object %d at chunk ")
9132 +                                           TCONT("%d during scan")
9133 +                                               TENDSTR), oh ?
9134 +                                           oh->type : tags.extraObjectType,
9135 +                                           in->variantType, tags.objectId,
9136 +                                           chunk));
9137 +
9138                                 if (!in->valid &&
9139                                     (tags.objectId == YAFFS_OBJECTID_ROOT ||
9140                                      tags.objectId ==
9141 @@ -6340,7 +6365,7 @@ static int yaffs_ScanBackwards(yaffs_Dev
9142                                         /* We only load some info, don't fiddle with directory structure */
9143                                         in->valid = 1;
9144
9145 -                                       if(oh) {
9146 +                                       if (oh) {
9147                                                 in->variantType = oh->type;
9148
9149                                                 in->yst_mode = oh->yst_mode;
9150 @@ -6365,15 +6390,15 @@ static int yaffs_ScanBackwards(yaffs_Dev
9151                                                 in->lazyLoaded = 1;
9152                                         }
9153
9154 -                                       in->chunkId = chunk;
9155 +                                       in->hdrChunk = chunk;
9156
9157                                 } else if (!in->valid) {
9158                                         /* we need to load this info */
9159
9160                                         in->valid = 1;
9161 -                                       in->chunkId = chunk;
9162 +                                       in->hdrChunk = chunk;
9163
9164 -                                       if(oh) {
9165 +                                       if (oh) {
9166                                                 in->variantType = oh->type;
9167
9168                                                 in->yst_mode = oh->yst_mode;
9169 @@ -6403,20 +6428,19 @@ static int yaffs_ScanBackwards(yaffs_Dev
9170                                                 yaffs_SetObjectName(in, oh->name);
9171                                                 parent =
9172                                                     yaffs_FindOrCreateObjectByNumber
9173 -                                                       (dev, oh->parentObjectId,
9174 -                                                        YAFFS_OBJECT_TYPE_DIRECTORY);
9175 +                                                       (dev, oh->parentObjectId,
9176 +                                                        YAFFS_OBJECT_TYPE_DIRECTORY);
9177
9178                                                  fileSize = oh->fileSize;
9179 -                                                isShrink = oh->isShrink;
9180 +                                                isShrink = oh->isShrink;
9181                                                  equivalentObjectId = oh->equivalentObjectId;
9182
9183 -                                       }
9184 -                                       else {
9185 +                                       } else {
9186                                                 in->variantType = tags.extraObjectType;
9187                                                 parent =
9188                                                     yaffs_FindOrCreateObjectByNumber
9189 -                                                       (dev, tags.extraParentObjectId,
9190 -                                                        YAFFS_OBJECT_TYPE_DIRECTORY);
9191 +                                                       (dev, tags.extraParentObjectId,
9192 +                                                        YAFFS_OBJECT_TYPE_DIRECTORY);
9193                                                  fileSize = tags.extraFileLength;
9194                                                  isShrink = tags.extraIsShrinkHeader;
9195                                                  equivalentObjectId = tags.extraEquivalentObjectId;
9196 @@ -6425,29 +6449,30 @@ static int yaffs_ScanBackwards(yaffs_Dev
9197                                         }
9198                                         in->dirty = 0;
9199
9200 +                                       if (!parent)
9201 +                                               alloc_failed = 1;
9202 +
9203                                         /* directory stuff...
9204                                          * hook up to parent
9205                                          */
9206
9207 -                                       if (parent->variantType ==
9208 +                                       if (parent && parent->variantType ==
9209                                             YAFFS_OBJECT_TYPE_UNKNOWN) {
9210                                                 /* Set up as a directory */
9211                                                 parent->variantType =
9212 -                                                   YAFFS_OBJECT_TYPE_DIRECTORY;
9213 -                                               INIT_LIST_HEAD(&parent->variant.
9214 -                                                              directoryVariant.
9215 -                                                              children);
9216 -                                       } else if (parent->variantType !=
9217 -                                                  YAFFS_OBJECT_TYPE_DIRECTORY)
9218 -                                       {
9219 +                                                       YAFFS_OBJECT_TYPE_DIRECTORY;
9220 +                                               YINIT_LIST_HEAD(&parent->variant.
9221 +                                                       directoryVariant.
9222 +                                                       children);
9223 +                                       } else if (!parent || parent->variantType !=
9224 +                                                  YAFFS_OBJECT_TYPE_DIRECTORY) {
9225                                                 /* Hoosterman, another problem....
9226                                                  * We're trying to use a non-directory as a directory
9227                                                  */
9228
9229                                                 T(YAFFS_TRACE_ERROR,
9230                                                   (TSTR
9231 -                                                  ("yaffs tragedy: attempting to use non-directory as"
9232 -                                                   " a directory in scan. Put in lost+found."
9233 +                                                  ("yaffs tragedy: attempting to use non-directory as a directory in scan. Put in lost+found."
9234                                                     TENDSTR)));
9235                                                 parent = dev->lostNFoundDir;
9236                                         }
9237 @@ -6494,12 +6519,12 @@ static int yaffs_ScanBackwards(yaffs_Dev
9238
9239                                                 break;
9240                                         case YAFFS_OBJECT_TYPE_HARDLINK:
9241 -                                               if(!itsUnlinked) {
9242 -                                                 in->variant.hardLinkVariant.equivalentObjectId =
9243 -                                                   equivalentObjectId;
9244 -                                                 in->hardLinks.next =
9245 -                                                   (struct list_head *) hardList;
9246 -                                                 hardList = in;
9247 +                                               if (!itsUnlinked) {
9248 +                                                       in->variant.hardLinkVariant.equivalentObjectId =
9249 +                                                               equivalentObjectId;
9250 +                                                       in->hardLinks.next =
9251 +                                                               (struct ylist_head *) hardList;
9252 +                                                       hardList = in;
9253                                                 }
9254                                                 break;
9255                                         case YAFFS_OBJECT_TYPE_DIRECTORY:
9256 @@ -6509,12 +6534,11 @@ static int yaffs_ScanBackwards(yaffs_Dev
9257                                                 /* Do nothing */
9258                                                 break;
9259                                         case YAFFS_OBJECT_TYPE_SYMLINK:
9260 -                                               if(oh){
9261 -                                                  in->variant.symLinkVariant.alias =
9262 -                                                   yaffs_CloneString(oh->
9263 -                                                                     alias);
9264 -                                                  if(!in->variant.symLinkVariant.alias)
9265 -                                                       alloc_failed = 1;
9266 +                                               if (oh) {
9267 +                                                       in->variant.symLinkVariant.alias =
9268 +                                                               yaffs_CloneString(oh->alias);
9269 +                                                       if (!in->variant.symLinkVariant.alias)
9270 +                                                               alloc_failed = 1;
9271                                                 }
9272                                                 break;
9273                                         }
9274 @@ -6551,75 +6575,129 @@ static int yaffs_ScanBackwards(yaffs_Dev
9275          * We should now have scanned all the objects, now it's time to add these
9276          * hardlinks.
9277          */
9278 -       yaffs_HardlinkFixup(dev,hardList);
9279 +       yaffs_HardlinkFixup(dev, hardList);
9280
9281
9282 -       /*
9283 -       *  Sort out state of unlinked and deleted objects.
9284 -       */
9285 -       {
9286 -               struct list_head *i;
9287 -               struct list_head *n;
9288 +       yaffs_ReleaseTempBuffer(dev, chunkData, __LINE__);
9289
9290 -               yaffs_Object *l;
9291 +       if (alloc_failed)
9292 +               return YAFFS_FAIL;
9293
9294 -               /* Soft delete all the unlinked files */
9295 -               list_for_each_safe(i, n,
9296 -                                  &dev->unlinkedDir->variant.directoryVariant.
9297 -                                  children) {
9298 -                       if (i) {
9299 -                               l = list_entry(i, yaffs_Object, siblings);
9300 -                               yaffs_DestroyObject(l);
9301 -                       }
9302 -               }
9303 +       T(YAFFS_TRACE_SCAN, (TSTR("yaffs_ScanBackwards ends" TENDSTR)));
9304
9305 -               /* Soft delete all the deletedDir files */
9306 -               list_for_each_safe(i, n,
9307 -                                  &dev->deletedDir->variant.directoryVariant.
9308 -                                  children) {
9309 -                       if (i) {
9310 -                               l = list_entry(i, yaffs_Object, siblings);
9311 -                               yaffs_DestroyObject(l);
9312 +       return YAFFS_OK;
9313 +}
9314
9315 -                       }
9316 +/*------------------------------  Directory Functions ----------------------------- */
9317 +
9318 +static void yaffs_VerifyObjectInDirectory(yaffs_Object *obj)
9319 +{
9320 +       struct ylist_head *lh;
9321 +       yaffs_Object *listObj;
9322 +
9323 +       int count = 0;
9324 +
9325 +       if (!obj) {
9326 +               T(YAFFS_TRACE_ALWAYS, (TSTR("No object to verify" TENDSTR)));
9327 +               YBUG();
9328 +               return;
9329 +       }
9330 +
9331 +       if (yaffs_SkipVerification(obj->myDev))
9332 +               return;
9333 +
9334 +       if (!obj->parent) {
9335 +               T(YAFFS_TRACE_ALWAYS, (TSTR("Object does not have parent" TENDSTR)));
9336 +               YBUG();
9337 +               return;
9338 +       }
9339 +
9340 +       if (obj->parent->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) {
9341 +               T(YAFFS_TRACE_ALWAYS, (TSTR("Parent is not directory" TENDSTR)));
9342 +               YBUG();
9343 +       }
9344 +
9345 +       /* Iterate through the objects in each hash entry */
9346 +
9347 +       ylist_for_each(lh, &obj->parent->variant.directoryVariant.children) {
9348 +               if (lh) {
9349 +                       listObj = ylist_entry(lh, yaffs_Object, siblings);
9350 +                       yaffs_VerifyObject(listObj);
9351 +                       if (obj == listObj)
9352 +                               count++;
9353                 }
9354 +        }
9355 +
9356 +       if (count != 1) {
9357 +               T(YAFFS_TRACE_ALWAYS, (TSTR("Object in directory %d times" TENDSTR), count));
9358 +               YBUG();
9359         }
9360 +}
9361
9362 -       yaffs_ReleaseTempBuffer(dev, chunkData, __LINE__);
9363 +static void yaffs_VerifyDirectory(yaffs_Object *directory)
9364 +{
9365 +       struct ylist_head *lh;
9366 +       yaffs_Object *listObj;
9367
9368 -       if(alloc_failed){
9369 -               return YAFFS_FAIL;
9370 +       if (!directory) {
9371 +               YBUG();
9372 +               return;
9373         }
9374
9375 -       T(YAFFS_TRACE_SCAN, (TSTR("yaffs_ScanBackwards ends" TENDSTR)));
9376 +       if (yaffs_SkipFullVerification(directory->myDev))
9377 +               return;
9378
9379 -       return YAFFS_OK;
9380 +       if (directory->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) {
9381 +               T(YAFFS_TRACE_ALWAYS, (TSTR("Directory has wrong type: %d" TENDSTR), directory->variantType));
9382 +               YBUG();
9383 +       }
9384 +
9385 +       /* Iterate through the objects in each hash entry */
9386 +
9387 +       ylist_for_each(lh, &directory->variant.directoryVariant.children) {
9388 +               if (lh) {
9389 +                       listObj = ylist_entry(lh, yaffs_Object, siblings);
9390 +                       if (listObj->parent != directory) {
9391 +                               T(YAFFS_TRACE_ALWAYS, (TSTR("Object in directory list has wrong parent %p" TENDSTR), listObj->parent));
9392 +                               YBUG();
9393 +                       }
9394 +                       yaffs_VerifyObjectInDirectory(listObj);
9395 +               }
9396 +       }
9397  }
9398
9399 -/*------------------------------  Directory Functions ----------------------------- */
9400
9401 -static void yaffs_RemoveObjectFromDirectory(yaffs_Object * obj)
9402 +static void yaffs_RemoveObjectFromDirectory(yaffs_Object *obj)
9403  {
9404         yaffs_Device *dev = obj->myDev;
9405 +       yaffs_Object *parent;
9406 +
9407 +       yaffs_VerifyObjectInDirectory(obj);
9408 +       parent = obj->parent;
9409 +
9410 +       yaffs_VerifyDirectory(parent);
9411
9412 -       if(dev && dev->removeObjectCallback)
9413 +       if (dev && dev->removeObjectCallback)
9414                 dev->removeObjectCallback(obj);
9415
9416 -       list_del_init(&obj->siblings);
9417 +
9418 +       ylist_del_init(&obj->siblings);
9419         obj->parent = NULL;
9420 +
9421 +       yaffs_VerifyDirectory(parent);
9422  }
9423
9424
9425 -static void yaffs_AddObjectToDirectory(yaffs_Object * directory,
9426 -                                      yaffs_Object * obj)
9427 +static void yaffs_AddObjectToDirectory(yaffs_Object *directory,
9428 +                                       yaffs_Object *obj)
9429  {
9430 -
9431         if (!directory) {
9432                 T(YAFFS_TRACE_ALWAYS,
9433                   (TSTR
9434                    ("tragedy: Trying to add an object to a null pointer directory"
9435                     TENDSTR)));
9436                 YBUG();
9437 +               return;
9438         }
9439         if (directory->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) {
9440                 T(YAFFS_TRACE_ALWAYS,
9441 @@ -6631,37 +6709,42 @@ static void yaffs_AddObjectToDirectory(y
9442
9443         if (obj->siblings.prev == NULL) {
9444                 /* Not initialised */
9445 -               INIT_LIST_HEAD(&obj->siblings);
9446 -
9447 -       } else if (!list_empty(&obj->siblings)) {
9448 -               /* If it is holed up somewhere else, un hook it */
9449 -               yaffs_RemoveObjectFromDirectory(obj);
9450 +               YBUG();
9451         }
9452 +
9453 +
9454 +       yaffs_VerifyDirectory(directory);
9455 +
9456 +       yaffs_RemoveObjectFromDirectory(obj);
9457 +
9458 +
9459         /* Now add it */
9460 -       list_add(&obj->siblings, &directory->variant.directoryVariant.children);
9461 +       ylist_add(&obj->siblings, &directory->variant.directoryVariant.children);
9462         obj->parent = directory;
9463
9464         if (directory == obj->myDev->unlinkedDir
9465 -           || directory == obj->myDev->deletedDir) {
9466 +                       || directory == obj->myDev->deletedDir) {
9467                 obj->unlinked = 1;
9468                 obj->myDev->nUnlinkedFiles++;
9469                 obj->renameAllowed = 0;
9470         }
9471 +
9472 +       yaffs_VerifyDirectory(directory);
9473 +       yaffs_VerifyObjectInDirectory(obj);
9474  }
9475
9476 -yaffs_Object *yaffs_FindObjectByName(yaffs_Object * directory,
9477 -                                    const YCHAR * name)
9478 +yaffs_Object *yaffs_FindObjectByName(yaffs_Object *directory,
9479 +                                    const YCHAR *name)
9480  {
9481         int sum;
9482
9483 -       struct list_head *i;
9484 +       struct ylist_head *i;
9485         YCHAR buffer[YAFFS_MAX_NAME_LENGTH + 1];
9486
9487         yaffs_Object *l;
9488
9489 -       if (!name) {
9490 +       if (!name)
9491                 return NULL;
9492 -       }
9493
9494         if (!directory) {
9495                 T(YAFFS_TRACE_ALWAYS,
9496 @@ -6669,6 +6752,7 @@ yaffs_Object *yaffs_FindObjectByName(yaf
9497                    ("tragedy: yaffs_FindObjectByName: null pointer directory"
9498                     TENDSTR)));
9499                 YBUG();
9500 +               return NULL;
9501         }
9502         if (directory->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) {
9503                 T(YAFFS_TRACE_ALWAYS,
9504 @@ -6679,28 +6763,27 @@ yaffs_Object *yaffs_FindObjectByName(yaf
9505
9506         sum = yaffs_CalcNameSum(name);
9507
9508 -       list_for_each(i, &directory->variant.directoryVariant.children) {
9509 +       ylist_for_each(i, &directory->variant.directoryVariant.children) {
9510                 if (i) {
9511 -                       l = list_entry(i, yaffs_Object, siblings);
9512 +                       l = ylist_entry(i, yaffs_Object, siblings);
9513 +
9514 +                       if (l->parent != directory)
9515 +                               YBUG();
9516
9517                         yaffs_CheckObjectDetailsLoaded(l);
9518
9519                         /* Special case for lost-n-found */
9520                         if (l->objectId == YAFFS_OBJECTID_LOSTNFOUND) {
9521 -                               if (yaffs_strcmp(name, YAFFS_LOSTNFOUND_NAME) == 0) {
9522 +                               if (yaffs_strcmp(name, YAFFS_LOSTNFOUND_NAME) == 0)
9523                                         return l;
9524 -                               }
9525 -                       } else if (yaffs_SumCompare(l->sum, sum) || l->chunkId <= 0)
9526 -                       {
9527 -                               /* LostnFound cunk called Objxxx
9528 +                       } else if (yaffs_SumCompare(l->sum, sum) || l->hdrChunk <= 0) {
9529 +                               /* LostnFound chunk called Objxxx
9530                                  * Do a real check
9531                                  */
9532                                 yaffs_GetObjectName(l, buffer,
9533                                                     YAFFS_MAX_NAME_LENGTH);
9534 -                               if (yaffs_strncmp(name, buffer,YAFFS_MAX_NAME_LENGTH) == 0) {
9535 +                               if (yaffs_strncmp(name, buffer, YAFFS_MAX_NAME_LENGTH) == 0)
9536                                         return l;
9537 -                               }
9538 -
9539                         }
9540                 }
9541         }
9542 @@ -6710,10 +6793,10 @@ yaffs_Object *yaffs_FindObjectByName(yaf
9543
9544
9545  #if 0
9546 -int yaffs_ApplyToDirectoryChildren(yaffs_Object * theDir,
9547 -                                  int (*fn) (yaffs_Object *))
9548 +int yaffs_ApplyToDirectoryChildren(yaffs_Object *theDir,
9549 +                                       int (*fn) (yaffs_Object *))
9550  {
9551 -       struct list_head *i;
9552 +       struct ylist_head *i;
9553         yaffs_Object *l;
9554
9555         if (!theDir) {
9556 @@ -6722,20 +6805,21 @@ int yaffs_ApplyToDirectoryChildren(yaffs
9557                    ("tragedy: yaffs_FindObjectByName: null pointer directory"
9558                     TENDSTR)));
9559                 YBUG();
9560 +               return YAFFS_FAIL;
9561         }
9562         if (theDir->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) {
9563                 T(YAFFS_TRACE_ALWAYS,
9564                   (TSTR
9565                    ("tragedy: yaffs_FindObjectByName: non-directory" TENDSTR)));
9566                 YBUG();
9567 +               return YAFFS_FAIL;
9568         }
9569
9570 -       list_for_each(i, &theDir->variant.directoryVariant.children) {
9571 +       ylist_for_each(i, &theDir->variant.directoryVariant.children) {
9572                 if (i) {
9573 -                       l = list_entry(i, yaffs_Object, siblings);
9574 -                       if (l && !fn(l)) {
9575 +                       l = ylist_entry(i, yaffs_Object, siblings);
9576 +                       if (l && !fn(l))
9577                                 return YAFFS_FAIL;
9578 -                       }
9579                 }
9580         }
9581
9582 @@ -6748,7 +6832,7 @@ int yaffs_ApplyToDirectoryChildren(yaffs
9583   * actual object.
9584   */
9585
9586 -yaffs_Object *yaffs_GetEquivalentObject(yaffs_Object * obj)
9587 +yaffs_Object *yaffs_GetEquivalentObject(yaffs_Object *obj)
9588  {
9589         if (obj && obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK) {
9590                 /* We want the object id of the equivalent object, not this one */
9591 @@ -6756,10 +6840,9 @@ yaffs_Object *yaffs_GetEquivalentObject(
9592                 yaffs_CheckObjectDetailsLoaded(obj);
9593         }
9594         return obj;
9595 -
9596  }
9597
9598 -int yaffs_GetObjectName(yaffs_Object * obj, YCHAR * name, int buffSize)
9599 +int yaffs_GetObjectName(yaffs_Object *obj, YCHAR *name, int buffSize)
9600  {
9601         memset(name, 0, buffSize * sizeof(YCHAR));
9602
9603 @@ -6767,18 +6850,26 @@ int yaffs_GetObjectName(yaffs_Object * o
9604
9605         if (obj->objectId == YAFFS_OBJECTID_LOSTNFOUND) {
9606                 yaffs_strncpy(name, YAFFS_LOSTNFOUND_NAME, buffSize - 1);
9607 -       } else if (obj->chunkId <= 0) {
9608 +       } else if (obj->hdrChunk <= 0) {
9609                 YCHAR locName[20];
9610 +               YCHAR numString[20];
9611 +               YCHAR *x = &numString[19];
9612 +               unsigned v = obj->objectId;
9613 +               numString[19] = 0;
9614 +               while (v > 0) {
9615 +                       x--;
9616 +                       *x = '0' + (v % 10);
9617 +                       v /= 10;
9618 +               }
9619                 /* make up a name */
9620 -               yaffs_sprintf(locName, _Y("%s%d"), YAFFS_LOSTNFOUND_PREFIX,
9621 -                             obj->objectId);
9622 +               yaffs_strcpy(locName, YAFFS_LOSTNFOUND_PREFIX);
9623 +               yaffs_strcat(locName, x);
9624                 yaffs_strncpy(name, locName, buffSize - 1);
9625
9626         }
9627  #ifdef CONFIG_YAFFS_SHORT_NAMES_IN_RAM
9628 -       else if (obj->shortName[0]) {
9629 +       else if (obj->shortName[0])
9630                 yaffs_strcpy(name, obj->shortName);
9631 -       }
9632  #endif
9633         else {
9634                 int result;
9635 @@ -6788,9 +6879,9 @@ int yaffs_GetObjectName(yaffs_Object * o
9636
9637                 memset(buffer, 0, obj->myDev->nDataBytesPerChunk);
9638
9639 -               if (obj->chunkId >= 0) {
9640 +               if (obj->hdrChunk > 0) {
9641                         result = yaffs_ReadChunkWithTagsFromNAND(obj->myDev,
9642 -                                                       obj->chunkId, buffer,
9643 +                                                       obj->hdrChunk, buffer,
9644                                                         NULL);
9645                 }
9646                 yaffs_strncpy(name, oh->name, buffSize - 1);
9647 @@ -6801,46 +6892,43 @@ int yaffs_GetObjectName(yaffs_Object * o
9648         return yaffs_strlen(name);
9649  }
9650
9651 -int yaffs_GetObjectFileLength(yaffs_Object * obj)
9652 +int yaffs_GetObjectFileLength(yaffs_Object *obj)
9653  {
9654 -
9655         /* Dereference any hard linking */
9656         obj = yaffs_GetEquivalentObject(obj);
9657
9658 -       if (obj->variantType == YAFFS_OBJECT_TYPE_FILE) {
9659 +       if (obj->variantType == YAFFS_OBJECT_TYPE_FILE)
9660                 return obj->variant.fileVariant.fileSize;
9661 -       }
9662 -       if (obj->variantType == YAFFS_OBJECT_TYPE_SYMLINK) {
9663 +       if (obj->variantType == YAFFS_OBJECT_TYPE_SYMLINK)
9664                 return yaffs_strlen(obj->variant.symLinkVariant.alias);
9665 -       } else {
9666 +       else {
9667                 /* Only a directory should drop through to here */
9668                 return obj->myDev->nDataBytesPerChunk;
9669         }
9670  }
9671
9672 -int yaffs_GetObjectLinkCount(yaffs_Object * obj)
9673 +int yaffs_GetObjectLinkCount(yaffs_Object *obj)
9674  {
9675         int count = 0;
9676 -       struct list_head *i;
9677 +       struct ylist_head *i;
9678
9679 -       if (!obj->unlinked) {
9680 -               count++;        /* the object itself */
9681 -       }
9682 -       list_for_each(i, &obj->hardLinks) {
9683 -               count++;        /* add the hard links; */
9684 -       }
9685 -       return count;
9686 +       if (!obj->unlinked)
9687 +               count++;                /* the object itself */
9688 +
9689 +       ylist_for_each(i, &obj->hardLinks)
9690 +               count++;                /* add the hard links; */
9691
9692 +       return count;
9693  }
9694
9695 -int yaffs_GetObjectInode(yaffs_Object * obj)
9696 +int yaffs_GetObjectInode(yaffs_Object *obj)
9697  {
9698         obj = yaffs_GetEquivalentObject(obj);
9699
9700         return obj->objectId;
9701  }
9702
9703 -unsigned yaffs_GetObjectType(yaffs_Object * obj)
9704 +unsigned yaffs_GetObjectType(yaffs_Object *obj)
9705  {
9706         obj = yaffs_GetEquivalentObject(obj);
9707
9708 @@ -6872,19 +6960,18 @@ unsigned yaffs_GetObjectType(yaffs_Objec
9709         }
9710  }
9711
9712 -YCHAR *yaffs_GetSymlinkAlias(yaffs_Object * obj)
9713 +YCHAR *yaffs_GetSymlinkAlias(yaffs_Object *obj)
9714  {
9715         obj = yaffs_GetEquivalentObject(obj);
9716 -       if (obj->variantType == YAFFS_OBJECT_TYPE_SYMLINK) {
9717 +       if (obj->variantType == YAFFS_OBJECT_TYPE_SYMLINK)
9718                 return yaffs_CloneString(obj->variant.symLinkVariant.alias);
9719 -       } else {
9720 +       else
9721                 return yaffs_CloneString(_Y(""));
9722 -       }
9723  }
9724
9725  #ifndef CONFIG_YAFFS_WINCE
9726
9727 -int yaffs_SetAttributes(yaffs_Object * obj, struct iattr *attr)
9728 +int yaffs_SetAttributes(yaffs_Object *obj, struct iattr *attr)
9729  {
9730         unsigned int valid = attr->ia_valid;
9731
9732 @@ -6910,7 +6997,7 @@ int yaffs_SetAttributes(yaffs_Object * o
9733         return YAFFS_OK;
9734
9735  }
9736 -int yaffs_GetAttributes(yaffs_Object * obj, struct iattr *attr)
9737 +int yaffs_GetAttributes(yaffs_Object *obj, struct iattr *attr)
9738  {
9739         unsigned int valid = 0;
9740
9741 @@ -6934,13 +7021,12 @@ int yaffs_GetAttributes(yaffs_Object * o
9742         attr->ia_valid = valid;
9743
9744         return YAFFS_OK;
9745 -
9746  }
9747
9748  #endif
9749
9750  #if 0
9751 -int yaffs_DumpObject(yaffs_Object * obj)
9752 +int yaffs_DumpObject(yaffs_Object *obj)
9753  {
9754         YCHAR name[257];
9755
9756 @@ -6951,7 +7037,7 @@ int yaffs_DumpObject(yaffs_Object * obj)
9757            ("Object %d, inode %d \"%s\"\n dirty %d valid %d serial %d sum %d"
9758             " chunk %d type %d size %d\n"
9759             TENDSTR), obj->objectId, yaffs_GetObjectInode(obj), name,
9760 -          obj->dirty, obj->valid, obj->serial, obj->sum, obj->chunkId,
9761 +          obj->dirty, obj->valid, obj->serial, obj->sum, obj->hdrChunk,
9762            yaffs_GetObjectType(obj), yaffs_GetObjectFileLength(obj)));
9763
9764         return YAFFS_OK;
9765 @@ -6960,7 +7046,7 @@ int yaffs_DumpObject(yaffs_Object * obj)
9766
9767  /*---------------------------- Initialisation code -------------------------------------- */
9768
9769 -static int yaffs_CheckDevFunctions(const yaffs_Device * dev)
9770 +static int yaffs_CheckDevFunctions(const yaffs_Device *dev)
9771  {
9772
9773         /* Common functions, gotta have */
9774 @@ -7011,7 +7097,7 @@ static int yaffs_CreateInitialDirectorie
9775             yaffs_CreateFakeDirectory(dev, YAFFS_OBJECTID_LOSTNFOUND,
9776                                       YAFFS_LOSTNFOUND_MODE | S_IFDIR);
9777
9778 -       if(dev->lostNFoundDir && dev->rootDir && dev->unlinkedDir && dev->deletedDir){
9779 +       if (dev->lostNFoundDir && dev->rootDir && dev->unlinkedDir && dev->deletedDir) {
9780                 yaffs_AddObjectToDirectory(dev->rootDir, dev->lostNFoundDir);
9781                 return YAFFS_OK;
9782         }
9783 @@ -7019,7 +7105,7 @@ static int yaffs_CreateInitialDirectorie
9784         return YAFFS_FAIL;
9785  }
9786
9787 -int yaffs_GutsInitialise(yaffs_Device * dev)
9788 +int yaffs_GutsInitialise(yaffs_Device *dev)
9789  {
9790         int init_failed = 0;
9791         unsigned x;
9792 @@ -7040,6 +7126,8 @@ int yaffs_GutsInitialise(yaffs_Device *
9793         dev->chunkOffset = 0;
9794         dev->nFreeChunks = 0;
9795
9796 +       dev->gcBlock = -1;
9797 +
9798         if (dev->startBlock == 0) {
9799                 dev->internalStartBlock = dev->startBlock + 1;
9800                 dev->internalEndBlock = dev->endBlock + 1;
9801 @@ -7049,18 +7137,18 @@ int yaffs_GutsInitialise(yaffs_Device *
9802
9803         /* Check geometry parameters. */
9804
9805 -       if ((dev->isYaffs2 && dev->nDataBytesPerChunk < 1024) ||
9806 -           (!dev->isYaffs2 && dev->nDataBytesPerChunk != 512) ||
9807 +       if ((!dev->inbandTags && dev->isYaffs2 && dev->totalBytesPerChunk < 1024) ||
9808 +           (!dev->isYaffs2 && dev->totalBytesPerChunk < 512) ||
9809 +           (dev->inbandTags && !dev->isYaffs2) ||
9810              dev->nChunksPerBlock < 2 ||
9811              dev->nReservedBlocks < 2 ||
9812              dev->internalStartBlock <= 0 ||
9813              dev->internalEndBlock <= 0 ||
9814 -            dev->internalEndBlock <= (dev->internalStartBlock + dev->nReservedBlocks + 2)      // otherwise it is too small
9815 -           ) {
9816 +            dev->internalEndBlock <= (dev->internalStartBlock + dev->nReservedBlocks + 2)) {   /* otherwise it is too small */
9817                 T(YAFFS_TRACE_ALWAYS,
9818                   (TSTR
9819 -                  ("yaffs: NAND geometry problems: chunk size %d, type is yaffs%s "
9820 -                   TENDSTR), dev->nDataBytesPerChunk, dev->isYaffs2 ? "2" : ""));
9821 +                  ("yaffs: NAND geometry problems: chunk size %d, type is yaffs%s, inbandTags %d "
9822 +                   TENDSTR), dev->totalBytesPerChunk, dev->isYaffs2 ? "2" : "", dev->inbandTags));
9823                 return YAFFS_FAIL;
9824         }
9825
9826 @@ -7070,6 +7158,12 @@ int yaffs_GutsInitialise(yaffs_Device *
9827                 return YAFFS_FAIL;
9828         }
9829
9830 +       /* Sort out space for inband tags, if required */
9831 +       if (dev->inbandTags)
9832 +               dev->nDataBytesPerChunk = dev->totalBytesPerChunk - sizeof(yaffs_PackedTags2TagsPart);
9833 +       else
9834 +               dev->nDataBytesPerChunk = dev->totalBytesPerChunk;
9835 +
9836         /* Got the right mix of functions? */
9837         if (!yaffs_CheckDevFunctions(dev)) {
9838                 /* Function missing */
9839 @@ -7097,31 +7191,18 @@ int yaffs_GutsInitialise(yaffs_Device *
9840
9841         dev->isMounted = 1;
9842
9843 -
9844 -
9845         /* OK now calculate a few things for the device */
9846
9847         /*
9848          *  Calculate all the chunk size manipulation numbers:
9849          */
9850 -        /* Start off assuming it is a power of 2 */
9851 -        dev->chunkShift = ShiftDiv(dev->nDataBytesPerChunk);
9852 -        dev->chunkMask = (1<<dev->chunkShift) - 1;
9853 -
9854 -        if(dev->nDataBytesPerChunk == (dev->chunkMask + 1)){
9855 -               /* Yes it is a power of 2, disable crumbs */
9856 -               dev->crumbMask = 0;
9857 -               dev->crumbShift = 0;
9858 -               dev->crumbsPerChunk = 0;
9859 -        } else {
9860 -               /* Not a power of 2, use crumbs instead */
9861 -               dev->crumbShift = ShiftDiv(sizeof(yaffs_PackedTags2TagsPart));
9862 -               dev->crumbMask = (1<<dev->crumbShift)-1;
9863 -               dev->crumbsPerChunk = dev->nDataBytesPerChunk/(1 << dev->crumbShift);
9864 -               dev->chunkShift = 0;
9865 -               dev->chunkMask = 0;
9866 -       }
9867 -
9868 +       x = dev->nDataBytesPerChunk;
9869 +       /* We always use dev->chunkShift and dev->chunkDiv */
9870 +       dev->chunkShift = Shifts(x);
9871 +       x >>= dev->chunkShift;
9872 +       dev->chunkDiv = x;
9873 +       /* We only use chunk mask if chunkDiv is 1 */
9874 +       dev->chunkMask = (1<<dev->chunkShift) - 1;
9875
9876         /*
9877          * Calculate chunkGroupBits.
9878 @@ -7133,16 +7214,15 @@ int yaffs_GutsInitialise(yaffs_Device *
9879         bits = ShiftsGE(x);
9880
9881         /* Set up tnode width if wide tnodes are enabled. */
9882 -       if(!dev->wideTnodesDisabled){
9883 +       if (!dev->wideTnodesDisabled) {
9884                 /* bits must be even so that we end up with 32-bit words */
9885 -               if(bits & 1)
9886 +               if (bits & 1)
9887                         bits++;
9888 -               if(bits < 16)
9889 +               if (bits < 16)
9890                         dev->tnodeWidth = 16;
9891                 else
9892                         dev->tnodeWidth = bits;
9893 -       }
9894 -       else
9895 +       } else
9896                 dev->tnodeWidth = 16;
9897
9898         dev->tnodeMask = (1<<dev->tnodeWidth)-1;
9899 @@ -7193,7 +7273,7 @@ int yaffs_GutsInitialise(yaffs_Device *
9900         dev->hasPendingPrioritisedGCs = 1; /* Assume the worst for now, will get fixed on first GC */
9901
9902         /* Initialise temporary buffers and caches. */
9903 -       if(!yaffs_InitialiseTempBuffers(dev))
9904 +       if (!yaffs_InitialiseTempBuffers(dev))
9905                 init_failed = 1;
9906
9907         dev->srCache = NULL;
9908 @@ -7203,25 +7283,26 @@ int yaffs_GutsInitialise(yaffs_Device *
9909         if (!init_failed &&
9910             dev->nShortOpCaches > 0) {
9911                 int i;
9912 -               __u8 *buf;
9913 +               void *buf;
9914                 int srCacheBytes = dev->nShortOpCaches * sizeof(yaffs_ChunkCache);
9915
9916 -               if (dev->nShortOpCaches > YAFFS_MAX_SHORT_OP_CACHES) {
9917 +               if (dev->nShortOpCaches > YAFFS_MAX_SHORT_OP_CACHES)
9918                         dev->nShortOpCaches = YAFFS_MAX_SHORT_OP_CACHES;
9919 -               }
9920
9921 -               buf = dev->srCache =  YMALLOC(srCacheBytes);
9922 +               dev->srCache =  YMALLOC(srCacheBytes);
9923
9924 -               if(dev->srCache)
9925 -                       memset(dev->srCache,0,srCacheBytes);
9926 +               buf = (__u8 *) dev->srCache;
9927 +
9928 +               if (dev->srCache)
9929 +                       memset(dev->srCache, 0, srCacheBytes);
9930
9931                 for (i = 0; i < dev->nShortOpCaches && buf; i++) {
9932                         dev->srCache[i].object = NULL;
9933                         dev->srCache[i].lastUse = 0;
9934                         dev->srCache[i].dirty = 0;
9935 -                       dev->srCache[i].data = buf = YMALLOC_DMA(dev->nDataBytesPerChunk);
9936 +                       dev->srCache[i].data = buf = YMALLOC_DMA(dev->totalBytesPerChunk);
9937                 }
9938 -               if(!buf)
9939 +               if (!buf)
9940                         init_failed = 1;
9941
9942                 dev->srLastUse = 0;
9943 @@ -7229,29 +7310,30 @@ int yaffs_GutsInitialise(yaffs_Device *
9944
9945         dev->cacheHits = 0;
9946
9947 -       if(!init_failed){
9948 +       if (!init_failed) {
9949                 dev->gcCleanupList = YMALLOC(dev->nChunksPerBlock * sizeof(__u32));
9950 -               if(!dev->gcCleanupList)
9951 +               if (!dev->gcCleanupList)
9952                         init_failed = 1;
9953         }
9954
9955 -       if (dev->isYaffs2) {
9956 +       if (dev->isYaffs2)
9957                 dev->useHeaderFileSize = 1;
9958 -       }
9959 -       if(!init_failed && !yaffs_InitialiseBlocks(dev))
9960 +
9961 +       if (!init_failed && !yaffs_InitialiseBlocks(dev))
9962                 init_failed = 1;
9963
9964         yaffs_InitialiseTnodes(dev);
9965         yaffs_InitialiseObjects(dev);
9966
9967 -       if(!init_failed && !yaffs_CreateInitialDirectories(dev))
9968 +       if (!init_failed && !yaffs_CreateInitialDirectories(dev))
9969                 init_failed = 1;
9970
9971
9972 -       if(!init_failed){
9973 +       if (!init_failed) {
9974                 /* Now scan the flash. */
9975                 if (dev->isYaffs2) {
9976 -                       if(yaffs_CheckpointRestore(dev)) {
9977 +                       if (yaffs_CheckpointRestore(dev)) {
9978 +                               yaffs_CheckObjectDetailsLoaded(dev->rootDir);
9979                                 T(YAFFS_TRACE_ALWAYS,
9980                                   (TSTR("yaffs: restored from checkpoint" TENDSTR)));
9981                         } else {
9982 @@ -7273,24 +7355,25 @@ int yaffs_GutsInitialise(yaffs_Device *
9983                                 dev->nBackgroundDeletions = 0;
9984                                 dev->oldestDirtySequence = 0;
9985
9986 -                               if(!init_failed && !yaffs_InitialiseBlocks(dev))
9987 +                               if (!init_failed && !yaffs_InitialiseBlocks(dev))
9988                                         init_failed = 1;
9989
9990                                 yaffs_InitialiseTnodes(dev);
9991                                 yaffs_InitialiseObjects(dev);
9992
9993 -                               if(!init_failed && !yaffs_CreateInitialDirectories(dev))
9994 +                               if (!init_failed && !yaffs_CreateInitialDirectories(dev))
9995                                         init_failed = 1;
9996
9997 -                               if(!init_failed && !yaffs_ScanBackwards(dev))
9998 +                               if (!init_failed && !yaffs_ScanBackwards(dev))
9999                                         init_failed = 1;
10000                         }
10001 -               }else
10002 -                       if(!yaffs_Scan(dev))
10003 +               } else if (!yaffs_Scan(dev))
10004                                 init_failed = 1;
10005 +
10006 +               yaffs_StripDeletedObjects(dev);
10007         }
10008
10009 -       if(init_failed){
10010 +       if (init_failed) {
10011                 /* Clean up the mess */
10012                 T(YAFFS_TRACE_TRACING,
10013                   (TSTR("yaffs: yaffs_GutsInitialise() aborted.\n" TENDSTR)));
10014 @@ -7318,7 +7401,7 @@ int yaffs_GutsInitialise(yaffs_Device *
10015
10016  }
10017
10018 -void yaffs_Deinitialise(yaffs_Device * dev)
10019 +void yaffs_Deinitialise(yaffs_Device *dev)
10020  {
10021         if (dev->isMounted) {
10022                 int i;
10023 @@ -7330,7 +7413,7 @@ void yaffs_Deinitialise(yaffs_Device * d
10024                     dev->srCache) {
10025
10026                         for (i = 0; i < dev->nShortOpCaches; i++) {
10027 -                               if(dev->srCache[i].data)
10028 +                               if (dev->srCache[i].data)
10029                                         YFREE(dev->srCache[i].data);
10030                                 dev->srCache[i].data = NULL;
10031                         }
10032 @@ -7341,16 +7424,17 @@ void yaffs_Deinitialise(yaffs_Device * d
10033
10034                 YFREE(dev->gcCleanupList);
10035
10036 -               for (i = 0; i < YAFFS_N_TEMP_BUFFERS; i++) {
10037 +               for (i = 0; i < YAFFS_N_TEMP_BUFFERS; i++)
10038                         YFREE(dev->tempBuffer[i].buffer);
10039 -               }
10040
10041                 dev->isMounted = 0;
10042 -       }
10043
10044 +               if (dev->deinitialiseNAND)
10045 +                       dev->deinitialiseNAND(dev);
10046 +       }
10047  }
10048
10049 -static int yaffs_CountFreeChunks(yaffs_Device * dev)
10050 +static int yaffs_CountFreeChunks(yaffs_Device *dev)
10051  {
10052         int nFree;
10053         int b;
10054 @@ -7358,7 +7442,7 @@ static int yaffs_CountFreeChunks(yaffs_D
10055         yaffs_BlockInfo *blk;
10056
10057         for (nFree = 0, b = dev->internalStartBlock; b <= dev->internalEndBlock;
10058 -            b++) {
10059 +                       b++) {
10060                 blk = yaffs_GetBlockInfo(dev, b);
10061
10062                 switch (blk->blockState) {
10063 @@ -7373,19 +7457,19 @@ static int yaffs_CountFreeChunks(yaffs_D
10064                 default:
10065                         break;
10066                 }
10067 -
10068         }
10069
10070         return nFree;
10071  }
10072
10073 -int yaffs_GetNumberOfFreeChunks(yaffs_Device * dev)
10074 +int yaffs_GetNumberOfFreeChunks(yaffs_Device *dev)
10075  {
10076         /* This is what we report to the outside world */
10077
10078         int nFree;
10079         int nDirtyCacheChunks;
10080         int blocksForCheckpoint;
10081 +       int i;
10082
10083  #if 1
10084         nFree = dev->nFreeChunks;
10085 @@ -7397,12 +7481,9 @@ int yaffs_GetNumberOfFreeChunks(yaffs_De
10086
10087         /* Now count the number of dirty chunks in the cache and subtract those */
10088
10089 -       {
10090 -               int i;
10091 -               for (nDirtyCacheChunks = 0, i = 0; i < dev->nShortOpCaches; i++) {
10092 -                       if (dev->srCache[i].dirty)
10093 -                               nDirtyCacheChunks++;
10094 -               }
10095 +       for (nDirtyCacheChunks = 0, i = 0; i < dev->nShortOpCaches; i++) {
10096 +               if (dev->srCache[i].dirty)
10097 +                       nDirtyCacheChunks++;
10098         }
10099
10100         nFree -= nDirtyCacheChunks;
10101 @@ -7410,8 +7491,8 @@ int yaffs_GetNumberOfFreeChunks(yaffs_De
10102         nFree -= ((dev->nReservedBlocks + 1) * dev->nChunksPerBlock);
10103
10104         /* Now we figure out how much to reserve for the checkpoint and report that... */
10105 -       blocksForCheckpoint = dev->nCheckpointReservedBlocks - dev->blocksInCheckpoint;
10106 -       if(blocksForCheckpoint < 0)
10107 +       blocksForCheckpoint = yaffs_CalcCheckpointBlocksRequired(dev) - dev->blocksInCheckpoint;
10108 +       if (blocksForCheckpoint < 0)
10109                 blocksForCheckpoint = 0;
10110
10111         nFree -= (blocksForCheckpoint * dev->nChunksPerBlock);
10112 @@ -7425,12 +7506,12 @@ int yaffs_GetNumberOfFreeChunks(yaffs_De
10113
10114  static int yaffs_freeVerificationFailures;
10115
10116 -static void yaffs_VerifyFreeChunks(yaffs_Device * dev)
10117 +static void yaffs_VerifyFreeChunks(yaffs_Device *dev)
10118  {
10119         int counted;
10120         int difference;
10121
10122 -       if(yaffs_SkipVerification(dev))
10123 +       if (yaffs_SkipVerification(dev))
10124                 return;
10125
10126         counted = yaffs_CountFreeChunks(dev);
10127 @@ -7447,23 +7528,25 @@ static void yaffs_VerifyFreeChunks(yaffs
10128
10129  /*---------------------------------------- YAFFS test code ----------------------*/
10130
10131 -#define yaffs_CheckStruct(structure,syze, name) \
10132 -           if(sizeof(structure) != syze) \
10133 -              { \
10134 -                T(YAFFS_TRACE_ALWAYS,(TSTR("%s should be %d but is %d\n" TENDSTR),\
10135 -                name,syze,sizeof(structure))); \
10136 -                return YAFFS_FAIL; \
10137 -               }
10138 +#define yaffs_CheckStruct(structure, syze, name) \
10139 +       do { \
10140 +               if (sizeof(structure) != syze) { \
10141 +                       T(YAFFS_TRACE_ALWAYS, (TSTR("%s should be %d but is %d\n" TENDSTR),\
10142 +                               name, syze, sizeof(structure))); \
10143 +                       return YAFFS_FAIL; \
10144 +               } \
10145 +       } while (0)
10146
10147  static int yaffs_CheckStructures(void)
10148  {
10149 -/*      yaffs_CheckStruct(yaffs_Tags,8,"yaffs_Tags") */
10150 -/*      yaffs_CheckStruct(yaffs_TagsUnion,8,"yaffs_TagsUnion") */
10151 -/*      yaffs_CheckStruct(yaffs_Spare,16,"yaffs_Spare") */
10152 +/*      yaffs_CheckStruct(yaffs_Tags,8,"yaffs_Tags"); */
10153 +/*      yaffs_CheckStruct(yaffs_TagsUnion,8,"yaffs_TagsUnion"); */
10154 +/*      yaffs_CheckStruct(yaffs_Spare,16,"yaffs_Spare"); */
10155  #ifndef CONFIG_YAFFS_TNODE_LIST_DEBUG
10156 -       yaffs_CheckStruct(yaffs_Tnode, 2 * YAFFS_NTNODES_LEVEL0, "yaffs_Tnode")
10157 +       yaffs_CheckStruct(yaffs_Tnode, 2 * YAFFS_NTNODES_LEVEL0, "yaffs_Tnode");
10158  #endif
10159 -           yaffs_CheckStruct(yaffs_ObjectHeader, 512, "yaffs_ObjectHeader")
10160 -
10161 -           return YAFFS_OK;
10162 +#ifndef CONFIG_YAFFS_WINCE
10163 +       yaffs_CheckStruct(yaffs_ObjectHeader, 512, "yaffs_ObjectHeader");
10164 +#endif
10165 +       return YAFFS_OK;
10166  }
10167 --- a/fs/yaffs2/yaffs_guts.h
10168 +++ b/fs/yaffs2/yaffs_guts.h
10169 @@ -90,7 +90,7 @@
10170
10171  #define YAFFS_MAX_SHORT_OP_CACHES      20
10172
10173 -#define YAFFS_N_TEMP_BUFFERS           4
10174 +#define YAFFS_N_TEMP_BUFFERS           6
10175
10176  /* We limit the number attempts at sucessfully saving a chunk of data.
10177   * Small-page devices have 32 pages per block; large-page devices have 64.
10178 @@ -108,6 +108,9 @@
10179  #define YAFFS_LOWEST_SEQUENCE_NUMBER   0x00001000
10180  #define YAFFS_HIGHEST_SEQUENCE_NUMBER  0xEFFFFF00
10181
10182 +/* Special sequence number for bad block that failed to be marked bad */
10183 +#define YAFFS_SEQUENCE_BAD_BLOCK       0xFFFF0000
10184 +
10185  /* ChunkCache is used for short read/write operations.*/
10186  typedef struct {
10187         struct yaffs_ObjectStruct *object;
10188 @@ -134,11 +137,10 @@ typedef struct {
10189  typedef struct {
10190         unsigned chunkId:20;
10191         unsigned serialNumber:2;
10192 -       unsigned byteCount:10;
10193 +       unsigned byteCountLSB:10;
10194         unsigned objectId:18;
10195         unsigned ecc:12;
10196 -       unsigned unusedStuff:2;
10197 -
10198 +       unsigned byteCountMSB:2;
10199  } yaffs_Tags;
10200
10201  typedef union {
10202 @@ -277,13 +279,13 @@ typedef struct {
10203
10204         int softDeletions:10;   /* number of soft deleted pages */
10205         int pagesInUse:10;      /* number of pages in use */
10206 -       yaffs_BlockState blockState:4;  /* One of the above block states */
10207 +       unsigned blockState:4;  /* One of the above block states. NB use unsigned because enum is sometimes an int */
10208         __u32 needsRetiring:1;  /* Data has failed on this block, need to get valid data off */
10209 -                               /* and retire the block. */
10210 -       __u32 skipErasedCheck: 1; /* If this is set we can skip the erased check on this block */
10211 -       __u32 gcPrioritise: 1;  /* An ECC check or blank check has failed on this block.
10212 +                               /* and retire the block. */
10213 +       __u32 skipErasedCheck:1; /* If this is set we can skip the erased check on this block */
10214 +       __u32 gcPrioritise:1;   /* An ECC check or blank check has failed on this block.
10215                                    It should be prioritised for GC */
10216 -        __u32 chunkErrorStrikes:3; /* How many times we've had ecc etc failures on this block and tried to reuse it */
10217 +       __u32 chunkErrorStrikes:3; /* How many times we've had ecc etc failures on this block and tried to reuse it */
10218
10219  #ifdef CONFIG_YAFFS_YAFFS2
10220         __u32 hasShrinkHeader:1; /* This block has at least one shrink object header */
10221 @@ -300,11 +302,11 @@ typedef struct {
10222
10223         /* Apply to everything  */
10224         int parentObjectId;
10225 -       __u16 sum__NoLongerUsed;        /* checksum of name. No longer used */
10226 +       __u16 sum__NoLongerUsed;        /* checksum of name. No longer used */
10227         YCHAR name[YAFFS_MAX_NAME_LENGTH + 1];
10228
10229 -       /* Thes following apply to directories, files, symlinks - not hard links */
10230 -       __u32 yst_mode;         /* protection */
10231 +       /* The following apply to directories, files, symlinks - not hard links */
10232 +       __u32 yst_mode;         /* protection */
10233
10234  #ifdef CONFIG_YAFFS_WINCE
10235         __u32 notForWinCE[5];
10236 @@ -331,11 +333,14 @@ typedef struct {
10237         __u32 win_ctime[2];
10238         __u32 win_atime[2];
10239         __u32 win_mtime[2];
10240 -       __u32 roomToGrow[4];
10241  #else
10242 -       __u32 roomToGrow[10];
10243 +       __u32 roomToGrow[6];
10244 +
10245  #endif
10246 +       __u32 inbandShadowsObject;
10247 +       __u32 inbandIsShrink;
10248
10249 +       __u32 reservedSpace[2];
10250         int shadowsObject;      /* This object header shadows the specified object if > 0 */
10251
10252         /* isShrink applies to object headers written when we shrink the file (ie resize) */
10253 @@ -381,7 +386,7 @@ typedef struct {
10254  } yaffs_FileStructure;
10255
10256  typedef struct {
10257 -       struct list_head children;      /* list of child links */
10258 +       struct ylist_head children;     /* list of child links */
10259  } yaffs_DirectoryStructure;
10260
10261  typedef struct {
10262 @@ -418,23 +423,24 @@ struct yaffs_ObjectStruct {
10263                                  * still in the inode cache. Free of object is defered.
10264                                  * until the inode is released.
10265                                  */
10266 +       __u8 beingCreated:1;    /* This object is still being created so skip some checks. */
10267
10268         __u8 serial;            /* serial number of chunk in NAND. Cached here */
10269         __u16 sum;              /* sum of the name to speed searching */
10270
10271 -       struct yaffs_DeviceStruct *myDev;       /* The device I'm on */
10272 +       struct yaffs_DeviceStruct *myDev;       /* The device I'm on */
10273
10274 -       struct list_head hashLink;      /* list of objects in this hash bucket */
10275 +       struct ylist_head hashLink;     /* list of objects in this hash bucket */
10276
10277 -       struct list_head hardLinks;     /* all the equivalent hard linked objects */
10278 +       struct ylist_head hardLinks;    /* all the equivalent hard linked objects */
10279
10280         /* directory structure stuff */
10281         /* also used for linking up the free list */
10282         struct yaffs_ObjectStruct *parent;
10283 -       struct list_head siblings;
10284 +       struct ylist_head siblings;
10285
10286         /* Where's my object header in NAND? */
10287 -       int chunkId;
10288 +       int hdrChunk;
10289
10290         int nDataChunks;        /* Number of data chunks attached to the file. */
10291
10292 @@ -485,7 +491,7 @@ struct yaffs_ObjectList_struct {
10293  typedef struct yaffs_ObjectList_struct yaffs_ObjectList;
10294
10295  typedef struct {
10296 -       struct list_head list;
10297 +       struct ylist_head list;
10298         int count;
10299  } yaffs_ObjectBucket;
10300
10301 @@ -495,11 +501,10 @@ typedef struct {
10302   */
10303
10304  typedef struct {
10305 -        int structType;
10306 +       int structType;
10307         __u32 objectId;
10308         __u32 parentId;
10309 -       int chunkId;
10310 -
10311 +       int hdrChunk;
10312         yaffs_ObjectType variantType:3;
10313         __u8 deleted:1;
10314         __u8 softDeleted:1;
10315 @@ -511,8 +516,7 @@ typedef struct {
10316
10317         int nDataChunks;
10318         __u32 fileSizeOrEquivalentObjectId;
10319 -
10320 -}yaffs_CheckpointObject;
10321 +} yaffs_CheckpointObject;
10322
10323  /*--------------------- Temporary buffers ----------------
10324   *
10325 @@ -528,13 +532,13 @@ typedef struct {
10326  /*----------------- Device ---------------------------------*/
10327
10328  struct yaffs_DeviceStruct {
10329 -       struct list_head devList;
10330 +       struct ylist_head devList;
10331         const char *name;
10332
10333         /* Entry parameters set up way early. Yaffs sets up the rest.*/
10334         int nDataBytesPerChunk; /* Should be a power of 2 >= 512 */
10335         int nChunksPerBlock;    /* does not need to be a power of 2 */
10336 -       int nBytesPerSpare;     /* spare area size */
10337 +       int spareBytesPerChunk; /* spare area size */
10338         int startBlock;         /* Start block we're allowed to use */
10339         int endBlock;           /* End block we're allowed to use */
10340         int nReservedBlocks;    /* We want this tuneable so that we can reduce */
10341 @@ -544,9 +548,7 @@ struct yaffs_DeviceStruct {
10342         /* Stuff used by the shared space checkpointing mechanism */
10343         /* If this value is zero, then this mechanism is disabled */
10344
10345 -       int nCheckpointReservedBlocks; /* Blocks to reserve for checkpoint data */
10346 -
10347 -
10348 +/*     int nCheckpointReservedBlocks; */ /* Blocks to reserve for checkpoint data */
10349
10350
10351         int nShortOpCaches;     /* If <= 0, then short op caching is disabled, else
10352 @@ -560,30 +562,31 @@ struct yaffs_DeviceStruct {
10353         void *genericDevice;    /* Pointer to device context
10354                                  * On an mtd this holds the mtd pointer.
10355                                  */
10356 -        void *superBlock;
10357 +       void *superBlock;
10358
10359         /* NAND access functions (Must be set before calling YAFFS)*/
10360
10361 -       int (*writeChunkToNAND) (struct yaffs_DeviceStruct * dev,
10362 -                                int chunkInNAND, const __u8 * data,
10363 -                                const yaffs_Spare * spare);
10364 -       int (*readChunkFromNAND) (struct yaffs_DeviceStruct * dev,
10365 -                                 int chunkInNAND, __u8 * data,
10366 -                                 yaffs_Spare * spare);
10367 -       int (*eraseBlockInNAND) (struct yaffs_DeviceStruct * dev,
10368 -                                int blockInNAND);
10369 -       int (*initialiseNAND) (struct yaffs_DeviceStruct * dev);
10370 +       int (*writeChunkToNAND) (struct yaffs_DeviceStruct *dev,
10371 +                                       int chunkInNAND, const __u8 *data,
10372 +                                       const yaffs_Spare *spare);
10373 +       int (*readChunkFromNAND) (struct yaffs_DeviceStruct *dev,
10374 +                                       int chunkInNAND, __u8 *data,
10375 +                                       yaffs_Spare *spare);
10376 +       int (*eraseBlockInNAND) (struct yaffs_DeviceStruct *dev,
10377 +                                       int blockInNAND);
10378 +       int (*initialiseNAND) (struct yaffs_DeviceStruct *dev);
10379 +       int (*deinitialiseNAND) (struct yaffs_DeviceStruct *dev);
10380
10381  #ifdef CONFIG_YAFFS_YAFFS2
10382 -       int (*writeChunkWithTagsToNAND) (struct yaffs_DeviceStruct * dev,
10383 -                                        int chunkInNAND, const __u8 * data,
10384 -                                        const yaffs_ExtendedTags * tags);
10385 -       int (*readChunkWithTagsFromNAND) (struct yaffs_DeviceStruct * dev,
10386 -                                         int chunkInNAND, __u8 * data,
10387 -                                         yaffs_ExtendedTags * tags);
10388 -       int (*markNANDBlockBad) (struct yaffs_DeviceStruct * dev, int blockNo);
10389 -       int (*queryNANDBlock) (struct yaffs_DeviceStruct * dev, int blockNo,
10390 -                              yaffs_BlockState * state, int *sequenceNumber);
10391 +       int (*writeChunkWithTagsToNAND) (struct yaffs_DeviceStruct *dev,
10392 +                                        int chunkInNAND, const __u8 *data,
10393 +                                        const yaffs_ExtendedTags *tags);
10394 +       int (*readChunkWithTagsFromNAND) (struct yaffs_DeviceStruct *dev,
10395 +                                         int chunkInNAND, __u8 *data,
10396 +                                         yaffs_ExtendedTags *tags);
10397 +       int (*markNANDBlockBad) (struct yaffs_DeviceStruct *dev, int blockNo);
10398 +       int (*queryNANDBlock) (struct yaffs_DeviceStruct *dev, int blockNo,
10399 +                              yaffs_BlockState *state, __u32 *sequenceNumber);
10400  #endif
10401
10402         int isYaffs2;
10403 @@ -595,10 +598,12 @@ struct yaffs_DeviceStruct {
10404         void (*removeObjectCallback)(struct yaffs_ObjectStruct *obj);
10405
10406         /* Callback to mark the superblock dirsty */
10407 -       void (*markSuperBlockDirty)(void * superblock);
10408 +       void (*markSuperBlockDirty)(void *superblock);
10409
10410         int wideTnodesDisabled; /* Set to disable wide tnodes */
10411
10412 +       YCHAR *pathDividers;    /* String of legal path dividers */
10413 +
10414
10415         /* End of stuff that must be set before initialisation. */
10416
10417 @@ -615,16 +620,14 @@ struct yaffs_DeviceStruct {
10418         __u32 tnodeWidth;
10419         __u32 tnodeMask;
10420
10421 -       /* Stuff to support various file offses to chunk/offset translations */
10422 -       /* "Crumbs" for nDataBytesPerChunk not being a power of 2 */
10423 -       __u32 crumbMask;
10424 -       __u32 crumbShift;
10425 -       __u32 crumbsPerChunk;
10426 -
10427 -       /* Straight shifting for nDataBytesPerChunk being a power of 2 */
10428 -       __u32 chunkShift;
10429 -       __u32 chunkMask;
10430 -
10431 +       /* Stuff for figuring out file offset to chunk conversions */
10432 +       __u32 chunkShift; /* Shift value */
10433 +       __u32 chunkDiv;   /* Divisor after shifting: 1 for power-of-2 sizes */
10434 +       __u32 chunkMask;  /* Mask to use for power-of-2 case */
10435 +
10436 +       /* Stuff to handle inband tags */
10437 +       int inbandTags;
10438 +       __u32 totalBytesPerChunk;
10439
10440  #ifdef __KERNEL__
10441
10442 @@ -633,7 +636,7 @@ struct yaffs_DeviceStruct {
10443         __u8 *spareBuffer;      /* For mtdif2 use. Don't know the size of the buffer
10444                                  * at compile time so we have to allocate it.
10445                                  */
10446 -       void (*putSuperFunc) (struct super_block * sb);
10447 +       void (*putSuperFunc) (struct super_block *sb);
10448  #endif
10449
10450         int isMounted;
10451 @@ -663,6 +666,8 @@ struct yaffs_DeviceStruct {
10452         __u32 checkpointSum;
10453         __u32 checkpointXor;
10454
10455 +       int nCheckpointBlocksRequired; /* Number of blocks needed to store current checkpoint set */
10456 +
10457         /* Block Info */
10458         yaffs_BlockInfo *blockInfo;
10459         __u8 *chunkBits;        /* bitmap of chunks in use */
10460 @@ -684,11 +689,15 @@ struct yaffs_DeviceStruct {
10461         yaffs_TnodeList *allocatedTnodeList;
10462
10463         int isDoingGC;
10464 +       int gcBlock;
10465 +       int gcChunk;
10466
10467         int nObjectsCreated;
10468         yaffs_Object *freeObjects;
10469         int nFreeObjects;
10470
10471 +       int nHardLinks;
10472 +
10473         yaffs_ObjectList *allocatedObjectList;
10474
10475         yaffs_ObjectBucket objectBucket[YAFFS_NOBJECT_BUCKETS];
10476 @@ -745,8 +754,10 @@ struct yaffs_DeviceStruct {
10477         int nBackgroundDeletions;       /* Count of background deletions. */
10478
10479
10480 +       /* Temporary buffer management */
10481         yaffs_TempBuffer tempBuffer[YAFFS_N_TEMP_BUFFERS];
10482         int maxTemp;
10483 +       int tempInUse;
10484         int unmanagedTempAllocations;
10485         int unmanagedTempDeallocations;
10486
10487 @@ -758,9 +769,9 @@ struct yaffs_DeviceStruct {
10488
10489  typedef struct yaffs_DeviceStruct yaffs_Device;
10490
10491 -/* The static layout of bllock usage etc is stored in the super block header */
10492 +/* The static layout of block usage etc is stored in the super block header */
10493  typedef struct {
10494 -        int StructType;
10495 +       int StructType;
10496         int version;
10497         int checkpointStartBlock;
10498         int checkpointEndBlock;
10499 @@ -773,7 +784,7 @@ typedef struct {
10500   * must be preserved over unmount/mount cycles.
10501   */
10502  typedef struct {
10503 -        int structType;
10504 +       int structType;
10505         int nErasedBlocks;
10506         int allocationBlock;    /* Current block being allocated off */
10507         __u32 allocationPage;
10508 @@ -791,57 +802,45 @@ typedef struct {
10509
10510
10511  typedef struct {
10512 -    int structType;
10513 -    __u32 magic;
10514 -    __u32 version;
10515 -    __u32 head;
10516 +       int structType;
10517 +       __u32 magic;
10518 +       __u32 version;
10519 +       __u32 head;
10520  } yaffs_CheckpointValidity;
10521
10522 -/* Function to manipulate block info */
10523 -static Y_INLINE yaffs_BlockInfo *yaffs_GetBlockInfo(yaffs_Device * dev, int blk)
10524 -{
10525 -       if (blk < dev->internalStartBlock || blk > dev->internalEndBlock) {
10526 -               T(YAFFS_TRACE_ERROR,
10527 -                 (TSTR
10528 -                  ("**>> yaffs: getBlockInfo block %d is not valid" TENDSTR),
10529 -                  blk));
10530 -               YBUG();
10531 -       }
10532 -       return &dev->blockInfo[blk - dev->internalStartBlock];
10533 -}
10534
10535  /*----------------------- YAFFS Functions -----------------------*/
10536
10537 -int yaffs_GutsInitialise(yaffs_Device * dev);
10538 -void yaffs_Deinitialise(yaffs_Device * dev);
10539 +int yaffs_GutsInitialise(yaffs_Device *dev);
10540 +void yaffs_Deinitialise(yaffs_Device *dev);
10541
10542 -int yaffs_GetNumberOfFreeChunks(yaffs_Device * dev);
10543 +int yaffs_GetNumberOfFreeChunks(yaffs_Device *dev);
10544
10545 -int yaffs_RenameObject(yaffs_Object * oldDir, const YCHAR * oldName,
10546 -                      yaffs_Object * newDir, const YCHAR * newName);
10547 +int yaffs_RenameObject(yaffs_Object *oldDir, const YCHAR *oldName,
10548 +                      yaffs_Object *newDir, const YCHAR *newName);
10549
10550 -int yaffs_Unlink(yaffs_Object * dir, const YCHAR * name);
10551 -int yaffs_DeleteFile(yaffs_Object * obj);
10552 +int yaffs_Unlink(yaffs_Object *dir, const YCHAR *name);
10553 +int yaffs_DeleteObject(yaffs_Object *obj);
10554
10555 -int yaffs_GetObjectName(yaffs_Object * obj, YCHAR * name, int buffSize);
10556 -int yaffs_GetObjectFileLength(yaffs_Object * obj);
10557 -int yaffs_GetObjectInode(yaffs_Object * obj);
10558 -unsigned yaffs_GetObjectType(yaffs_Object * obj);
10559 -int yaffs_GetObjectLinkCount(yaffs_Object * obj);
10560 +int yaffs_GetObjectName(yaffs_Object *obj, YCHAR *name, int buffSize);
10561 +int yaffs_GetObjectFileLength(yaffs_Object *obj);
10562 +int yaffs_GetObjectInode(yaffs_Object *obj);
10563 +unsigned yaffs_GetObjectType(yaffs_Object *obj);
10564 +int yaffs_GetObjectLinkCount(yaffs_Object *obj);
10565
10566 -int yaffs_SetAttributes(yaffs_Object * obj, struct iattr *attr);
10567 -int yaffs_GetAttributes(yaffs_Object * obj, struct iattr *attr);
10568 +int yaffs_SetAttributes(yaffs_Object *obj, struct iattr *attr);
10569 +int yaffs_GetAttributes(yaffs_Object *obj, struct iattr *attr);
10570
10571  /* File operations */
10572 -int yaffs_ReadDataFromFile(yaffs_Object * obj, __u8 * buffer, loff_t offset,
10573 -                          int nBytes);
10574 -int yaffs_WriteDataToFile(yaffs_Object * obj, const __u8 * buffer, loff_t offset,
10575 -                         int nBytes, int writeThrough);
10576 -int yaffs_ResizeFile(yaffs_Object * obj, loff_t newSize);
10577 -
10578 -yaffs_Object *yaffs_MknodFile(yaffs_Object * parent, const YCHAR * name,
10579 -                             __u32 mode, __u32 uid, __u32 gid);
10580 -int yaffs_FlushFile(yaffs_Object * obj, int updateTime);
10581 +int yaffs_ReadDataFromFile(yaffs_Object *obj, __u8 *buffer, loff_t offset,
10582 +                               int nBytes);
10583 +int yaffs_WriteDataToFile(yaffs_Object *obj, const __u8 *buffer, loff_t offset,
10584 +                               int nBytes, int writeThrough);
10585 +int yaffs_ResizeFile(yaffs_Object *obj, loff_t newSize);
10586 +
10587 +yaffs_Object *yaffs_MknodFile(yaffs_Object *parent, const YCHAR *name,
10588 +                               __u32 mode, __u32 uid, __u32 gid);
10589 +int yaffs_FlushFile(yaffs_Object *obj, int updateTime);
10590
10591  /* Flushing and checkpointing */
10592  void yaffs_FlushEntireDeviceCache(yaffs_Device *dev);
10593 @@ -850,33 +849,33 @@ int yaffs_CheckpointSave(yaffs_Device *d
10594  int yaffs_CheckpointRestore(yaffs_Device *dev);
10595
10596  /* Directory operations */
10597 -yaffs_Object *yaffs_MknodDirectory(yaffs_Object * parent, const YCHAR * name,
10598 -                                  __u32 mode, __u32 uid, __u32 gid);
10599 -yaffs_Object *yaffs_FindObjectByName(yaffs_Object * theDir, const YCHAR * name);
10600 -int yaffs_ApplyToDirectoryChildren(yaffs_Object * theDir,
10601 +yaffs_Object *yaffs_MknodDirectory(yaffs_Object *parent, const YCHAR *name,
10602 +                               __u32 mode, __u32 uid, __u32 gid);
10603 +yaffs_Object *yaffs_FindObjectByName(yaffs_Object *theDir, const YCHAR *name);
10604 +int yaffs_ApplyToDirectoryChildren(yaffs_Object *theDir,
10605                                    int (*fn) (yaffs_Object *));
10606
10607 -yaffs_Object *yaffs_FindObjectByNumber(yaffs_Device * dev, __u32 number);
10608 +yaffs_Object *yaffs_FindObjectByNumber(yaffs_Device *dev, __u32 number);
10609
10610  /* Link operations */
10611 -yaffs_Object *yaffs_Link(yaffs_Object * parent, const YCHAR * name,
10612 -                        yaffs_Object * equivalentObject);
10613 +yaffs_Object *yaffs_Link(yaffs_Object *parent, const YCHAR *name,
10614 +                        yaffs_Object *equivalentObject);
10615
10616 -yaffs_Object *yaffs_GetEquivalentObject(yaffs_Object * obj);
10617 +yaffs_Object *yaffs_GetEquivalentObject(yaffs_Object *obj);
10618
10619  /* Symlink operations */
10620 -yaffs_Object *yaffs_MknodSymLink(yaffs_Object * parent, const YCHAR * name,
10621 +yaffs_Object *yaffs_MknodSymLink(yaffs_Object *parent, const YCHAR *name,
10622                                  __u32 mode, __u32 uid, __u32 gid,
10623 -                                const YCHAR * alias);
10624 -YCHAR *yaffs_GetSymlinkAlias(yaffs_Object * obj);
10625 +                                const YCHAR *alias);
10626 +YCHAR *yaffs_GetSymlinkAlias(yaffs_Object *obj);
10627
10628  /* Special inodes (fifos, sockets and devices) */
10629 -yaffs_Object *yaffs_MknodSpecial(yaffs_Object * parent, const YCHAR * name,
10630 +yaffs_Object *yaffs_MknodSpecial(yaffs_Object *parent, const YCHAR *name,
10631                                  __u32 mode, __u32 uid, __u32 gid, __u32 rdev);
10632
10633  /* Special directories */
10634 -yaffs_Object *yaffs_Root(yaffs_Device * dev);
10635 -yaffs_Object *yaffs_LostNFound(yaffs_Device * dev);
10636 +yaffs_Object *yaffs_Root(yaffs_Device *dev);
10637 +yaffs_Object *yaffs_LostNFound(yaffs_Device *dev);
10638
10639  #ifdef CONFIG_YAFFS_WINCE
10640  /* CONFIG_YAFFS_WINCE special stuff */
10641 @@ -885,18 +884,21 @@ void yfsd_WinFileTimeNow(__u32 target[2]
10642
10643  #ifdef __KERNEL__
10644
10645 -void yaffs_HandleDeferedFree(yaffs_Object * obj);
10646 +void yaffs_HandleDeferedFree(yaffs_Object *obj);
10647  #endif
10648
10649  /* Debug dump  */
10650 -int yaffs_DumpObject(yaffs_Object * obj);
10651 +int yaffs_DumpObject(yaffs_Object *obj);
10652
10653 -void yaffs_GutsTest(yaffs_Device * dev);
10654 +void yaffs_GutsTest(yaffs_Device *dev);
10655
10656  /* A few useful functions */
10657 -void yaffs_InitialiseTags(yaffs_ExtendedTags * tags);
10658 -void yaffs_DeleteChunk(yaffs_Device * dev, int chunkId, int markNAND, int lyn);
10659 -int yaffs_CheckFF(__u8 * buffer, int nBytes);
10660 +void yaffs_InitialiseTags(yaffs_ExtendedTags *tags);
10661 +void yaffs_DeleteChunk(yaffs_Device *dev, int chunkId, int markNAND, int lyn);
10662 +int yaffs_CheckFF(__u8 *buffer, int nBytes);
10663  void yaffs_HandleChunkError(yaffs_Device *dev, yaffs_BlockInfo *bi);
10664
10665 +__u8 *yaffs_GetTempBuffer(yaffs_Device *dev, int lineNo);
10666 +void yaffs_ReleaseTempBuffer(yaffs_Device *dev, __u8 *buffer, int lineNo);
10667 +
10668  #endif
10669 --- a/fs/yaffs2/yaffs_mtdif1.c
10670 +++ b/fs/yaffs2/yaffs_mtdif1.c
10671 @@ -26,7 +26,7 @@
10672  #include "yportenv.h"
10673  #include "yaffs_guts.h"
10674  #include "yaffs_packedtags1.h"
10675 -#include "yaffs_tagscompat.h"  // for yaffs_CalcTagsECC
10676 +#include "yaffs_tagscompat.h"  /* for yaffs_CalcTagsECC */
10677
10678  #include "linux/kernel.h"
10679  #include "linux/version.h"
10680 @@ -34,9 +34,9 @@
10681  #include "linux/mtd/mtd.h"
10682
10683  /* Don't compile this module if we don't have MTD's mtd_oob_ops interface */
10684 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
10685 +#if (MTD_VERSION_CODE > MTD_VERSION(2, 6, 17))
10686
10687 -const char *yaffs_mtdif1_c_version = "$Id: yaffs_mtdif1.c,v 1.3 2007/05/15 20:16:11 ian Exp $";
10688 +const char *yaffs_mtdif1_c_version = "$Id: yaffs_mtdif1.c,v 1.10 2009-03-09 07:41:10 charles Exp $";
10689
10690  #ifndef CONFIG_YAFFS_9BYTE_TAGS
10691  # define YTAG1_SIZE 8
10692 @@ -89,9 +89,9 @@ static struct nand_ecclayout nand_oob_16
10693   * Returns YAFFS_OK or YAFFS_FAIL.
10694   */
10695  int nandmtd1_WriteChunkWithTagsToNAND(yaffs_Device *dev,
10696 -       int chunkInNAND, const __u8 * data, const yaffs_ExtendedTags * etags)
10697 +       int chunkInNAND, const __u8 *data, const yaffs_ExtendedTags *etags)
10698  {
10699 -       struct mtd_info * mtd = dev->genericDevice;
10700 +       struct mtd_info *mtd = dev->genericDevice;
10701         int chunkBytes = dev->nDataBytesPerChunk;
10702         loff_t addr = ((loff_t)chunkInNAND) * chunkBytes;
10703         struct mtd_oob_ops ops;
10704 @@ -146,7 +146,7 @@ int nandmtd1_WriteChunkWithTagsToNAND(ya
10705
10706  /* Return with empty ExtendedTags but add eccResult.
10707   */
10708 -static int rettags(yaffs_ExtendedTags * etags, int eccResult, int retval)
10709 +static int rettags(yaffs_ExtendedTags *etags, int eccResult, int retval)
10710  {
10711         if (etags) {
10712                 memset(etags, 0, sizeof(*etags));
10713 @@ -169,9 +169,9 @@ static int rettags(yaffs_ExtendedTags *
10714   * Returns YAFFS_OK or YAFFS_FAIL.
10715   */
10716  int nandmtd1_ReadChunkWithTagsFromNAND(yaffs_Device *dev,
10717 -       int chunkInNAND, __u8 * data, yaffs_ExtendedTags * etags)
10718 +       int chunkInNAND, __u8 *data, yaffs_ExtendedTags *etags)
10719  {
10720 -       struct mtd_info * mtd = dev->genericDevice;
10721 +       struct mtd_info *mtd = dev->genericDevice;
10722         int chunkBytes = dev->nDataBytesPerChunk;
10723         loff_t addr = ((loff_t)chunkInNAND) * chunkBytes;
10724         int eccres = YAFFS_ECC_RESULT_NO_ERROR;
10725 @@ -189,7 +189,7 @@ int nandmtd1_ReadChunkWithTagsFromNAND(y
10726         ops.datbuf = data;
10727         ops.oobbuf = (__u8 *)&pt1;
10728
10729 -#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20))
10730 +#if (MTD_VERSION_CODE < MTD_VERSION(2, 6, 20))
10731         /* In MTD 2.6.18 to 2.6.19 nand_base.c:nand_do_read_oob() has a bug;
10732          * help it out with ops.len = ops.ooblen when ops.datbuf == NULL.
10733          */
10734 @@ -284,11 +284,11 @@ int nandmtd1_ReadChunkWithTagsFromNAND(y
10735   */
10736  int nandmtd1_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo)
10737  {
10738 -       struct mtd_info * mtd = dev->genericDevice;
10739 +       struct mtd_info *mtd = dev->genericDevice;
10740         int blocksize = dev->nChunksPerBlock * dev->nDataBytesPerChunk;
10741         int retval;
10742
10743 -       yaffs_trace(YAFFS_TRACE_BAD_BLOCKS, "marking block %d bad", blockNo);
10744 +       yaffs_trace(YAFFS_TRACE_BAD_BLOCKS, "marking block %d bad\n", blockNo);
10745
10746         retval = mtd->block_markbad(mtd, (loff_t)blocksize * blockNo);
10747         return (retval) ? YAFFS_FAIL : YAFFS_OK;
10748 @@ -298,7 +298,7 @@ int nandmtd1_MarkNANDBlockBad(struct yaf
10749   *
10750   * Returns YAFFS_OK or YAFFS_FAIL.
10751   */
10752 -static int nandmtd1_TestPrerequists(struct mtd_info * mtd)
10753 +static int nandmtd1_TestPrerequists(struct mtd_info *mtd)
10754  {
10755         /* 2.6.18 has mtd->ecclayout->oobavail */
10756         /* 2.6.21 has mtd->ecclayout->oobavail and mtd->oobavail */
10757 @@ -323,10 +323,11 @@ static int nandmtd1_TestPrerequists(stru
10758   * Always returns YAFFS_OK.
10759   */
10760  int nandmtd1_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockNo,
10761 -       yaffs_BlockState * pState, int *pSequenceNumber)
10762 +       yaffs_BlockState *pState, __u32 *pSequenceNumber)
10763  {
10764 -       struct mtd_info * mtd = dev->genericDevice;
10765 +       struct mtd_info *mtd = dev->genericDevice;
10766         int chunkNo = blockNo * dev->nChunksPerBlock;
10767 +       loff_t addr = (loff_t)chunkNo * dev->nDataBytesPerChunk;
10768         yaffs_ExtendedTags etags;
10769         int state = YAFFS_BLOCK_STATE_DEAD;
10770         int seqnum = 0;
10771 @@ -335,21 +336,22 @@ int nandmtd1_QueryNANDBlock(struct yaffs
10772         /* We don't yet have a good place to test for MTD config prerequists.
10773          * Do it here as we are called during the initial scan.
10774          */
10775 -       if (nandmtd1_TestPrerequists(mtd) != YAFFS_OK) {
10776 +       if (nandmtd1_TestPrerequists(mtd) != YAFFS_OK)
10777                 return YAFFS_FAIL;
10778 -       }
10779
10780         retval = nandmtd1_ReadChunkWithTagsFromNAND(dev, chunkNo, NULL, &etags);
10781 +       etags.blockBad = (mtd->block_isbad)(mtd, addr);
10782         if (etags.blockBad) {
10783                 yaffs_trace(YAFFS_TRACE_BAD_BLOCKS,
10784 -                       "block %d is marked bad", blockNo);
10785 +                       "block %d is marked bad\n", blockNo);
10786                 state = YAFFS_BLOCK_STATE_DEAD;
10787 -       }
10788 -       else if (etags.chunkUsed) {
10789 +       } else if (etags.eccResult != YAFFS_ECC_RESULT_NO_ERROR) {
10790 +               /* bad tags, need to look more closely */
10791 +               state = YAFFS_BLOCK_STATE_NEEDS_SCANNING;
10792 +       } else if (etags.chunkUsed) {
10793                 state = YAFFS_BLOCK_STATE_NEEDS_SCANNING;
10794                 seqnum = etags.sequenceNumber;
10795 -       }
10796 -       else {
10797 +       } else {
10798                 state = YAFFS_BLOCK_STATE_EMPTY;
10799         }
10800
10801 @@ -360,4 +362,4 @@ int nandmtd1_QueryNANDBlock(struct yaffs
10802         return YAFFS_OK;
10803  }
10804
10805 -#endif /*KERNEL_VERSION*/
10806 +#endif /*MTD_VERSION*/
10807 --- a/fs/yaffs2/yaffs_mtdif1.h
10808 +++ b/fs/yaffs2/yaffs_mtdif1.h
10809 @@ -14,15 +14,15 @@
10810  #ifndef __YAFFS_MTDIF1_H__
10811  #define __YAFFS_MTDIF1_H__
10812
10813 -int nandmtd1_WriteChunkWithTagsToNAND(yaffs_Device * dev, int chunkInNAND,
10814 -       const __u8 * data, const yaffs_ExtendedTags * tags);
10815 +int nandmtd1_WriteChunkWithTagsToNAND(yaffs_Device *dev, int chunkInNAND,
10816 +       const __u8 *data, const yaffs_ExtendedTags *tags);
10817
10818 -int nandmtd1_ReadChunkWithTagsFromNAND(yaffs_Device * dev, int chunkInNAND,
10819 -       __u8 * data, yaffs_ExtendedTags * tags);
10820 +int nandmtd1_ReadChunkWithTagsFromNAND(yaffs_Device *dev, int chunkInNAND,
10821 +       __u8 *data, yaffs_ExtendedTags *tags);
10822
10823  int nandmtd1_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo);
10824
10825  int nandmtd1_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockNo,
10826 -       yaffs_BlockState * state, int *sequenceNumber);
10827 +       yaffs_BlockState *state, __u32 *sequenceNumber);
10828
10829  #endif
10830 --- a/fs/yaffs2/yaffs_mtdif2.c
10831 +++ b/fs/yaffs2/yaffs_mtdif2.c
10832 @@ -14,7 +14,7 @@
10833  /* mtd interface for YAFFS2 */
10834
10835  const char *yaffs_mtdif2_c_version =
10836 -    "$Id: yaffs_mtdif2.c,v 1.17 2007-02-14 01:09:06 wookey Exp $";
10837 +       "$Id: yaffs_mtdif2.c,v 1.23 2009-03-06 17:20:53 wookey Exp $";
10838
10839  #include "yportenv.h"
10840
10841 @@ -27,19 +27,23 @@ const char *yaffs_mtdif2_c_version =
10842
10843  #include "yaffs_packedtags2.h"
10844
10845 -int nandmtd2_WriteChunkWithTagsToNAND(yaffs_Device * dev, int chunkInNAND,
10846 -                                     const __u8 * data,
10847 -                                     const yaffs_ExtendedTags * tags)
10848 +/* NB For use with inband tags....
10849 + * We assume that the data buffer is of size totalBytersPerChunk so that we can also
10850 + * use it to load the tags.
10851 + */
10852 +int nandmtd2_WriteChunkWithTagsToNAND(yaffs_Device *dev, int chunkInNAND,
10853 +                                     const __u8 *data,
10854 +                                     const yaffs_ExtendedTags *tags)
10855  {
10856         struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice);
10857 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
10858 +#if (MTD_VERSION_CODE > MTD_VERSION(2, 6, 17))
10859         struct mtd_oob_ops ops;
10860  #else
10861         size_t dummy;
10862  #endif
10863         int retval = 0;
10864
10865 -       loff_t addr = ((loff_t) chunkInNAND) * dev->nDataBytesPerChunk;
10866 +       loff_t addr;
10867
10868         yaffs_PackedTags2 pt;
10869
10870 @@ -48,46 +52,40 @@ int nandmtd2_WriteChunkWithTagsToNAND(ya
10871            ("nandmtd2_WriteChunkWithTagsToNAND chunk %d data %p tags %p"
10872             TENDSTR), chunkInNAND, data, tags));
10873
10874 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
10875 -       if (tags)
10876 -               yaffs_PackTags2(&pt, tags);
10877 -       else
10878 -               BUG(); /* both tags and data should always be present */
10879
10880 -       if (data) {
10881 -               ops.mode = MTD_OOB_AUTO;
10882 -               ops.ooblen = sizeof(pt);
10883 -               ops.len = dev->nDataBytesPerChunk;
10884 -               ops.ooboffs = 0;
10885 -               ops.datbuf = (__u8 *)data;
10886 -               ops.oobbuf = (void *)&pt;
10887 -               retval = mtd->write_oob(mtd, addr, &ops);
10888 +       addr  = ((loff_t) chunkInNAND) * dev->totalBytesPerChunk;
10889 +
10890 +       /* For yaffs2 writing there must be both data and tags.
10891 +        * If we're using inband tags, then the tags are stuffed into
10892 +        * the end of the data buffer.
10893 +        */
10894 +       if (!data || !tags)
10895 +               BUG();
10896 +       else if (dev->inbandTags) {
10897 +               yaffs_PackedTags2TagsPart *pt2tp;
10898 +               pt2tp = (yaffs_PackedTags2TagsPart *)(data + dev->nDataBytesPerChunk);
10899 +               yaffs_PackTags2TagsPart(pt2tp, tags);
10900         } else
10901 -               BUG(); /* both tags and data should always be present */
10902 -#else
10903 -       if (tags) {
10904                 yaffs_PackTags2(&pt, tags);
10905 -       }
10906
10907 -       if (data && tags) {
10908 -               if (dev->useNANDECC)
10909 -                       retval =
10910 -                           mtd->write_ecc(mtd, addr, dev->nDataBytesPerChunk,
10911 -                                          &dummy, data, (__u8 *) & pt, NULL);
10912 -               else
10913 -                       retval =
10914 -                           mtd->write_ecc(mtd, addr, dev->nDataBytesPerChunk,
10915 -                                          &dummy, data, (__u8 *) & pt, NULL);
10916 -       } else {
10917 -               if (data)
10918 -                       retval =
10919 -                           mtd->write(mtd, addr, dev->nDataBytesPerChunk, &dummy,
10920 -                                      data);
10921 -               if (tags)
10922 -                       retval =
10923 -                           mtd->write_oob(mtd, addr, mtd->oobsize, &dummy,
10924 -                                          (__u8 *) & pt);
10925 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17))
10926 +       ops.mode = MTD_OOB_AUTO;
10927 +       ops.ooblen = (dev->inbandTags) ? 0 : sizeof(pt);
10928 +       ops.len = dev->totalBytesPerChunk;
10929 +       ops.ooboffs = 0;
10930 +       ops.datbuf = (__u8 *)data;
10931 +       ops.oobbuf = (dev->inbandTags) ? NULL : (void *)&pt;
10932 +       retval = mtd->write_oob(mtd, addr, &ops);
10933
10934 +#else
10935 +       if (!dev->inbandTags) {
10936 +               retval =
10937 +                   mtd->write_ecc(mtd, addr, dev->nDataBytesPerChunk,
10938 +                                  &dummy, data, (__u8 *) &pt, NULL);
10939 +       } else {
10940 +               retval =
10941 +                   mtd->write(mtd, addr, dev->totalBytesPerChunk, &dummy,
10942 +                              data);
10943         }
10944  #endif
10945
10946 @@ -97,17 +95,18 @@ int nandmtd2_WriteChunkWithTagsToNAND(ya
10947                 return YAFFS_FAIL;
10948  }
10949
10950 -int nandmtd2_ReadChunkWithTagsFromNAND(yaffs_Device * dev, int chunkInNAND,
10951 -                                      __u8 * data, yaffs_ExtendedTags * tags)
10952 +int nandmtd2_ReadChunkWithTagsFromNAND(yaffs_Device *dev, int chunkInNAND,
10953 +                                      __u8 *data, yaffs_ExtendedTags *tags)
10954  {
10955         struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice);
10956 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
10957 +#if (MTD_VERSION_CODE > MTD_VERSION(2, 6, 17))
10958         struct mtd_oob_ops ops;
10959  #endif
10960         size_t dummy;
10961         int retval = 0;
10962 +       int localData = 0;
10963
10964 -       loff_t addr = ((loff_t) chunkInNAND) * dev->nDataBytesPerChunk;
10965 +       loff_t addr = ((loff_t) chunkInNAND) * dev->totalBytesPerChunk;
10966
10967         yaffs_PackedTags2 pt;
10968
10969 @@ -116,9 +115,20 @@ int nandmtd2_ReadChunkWithTagsFromNAND(y
10970            ("nandmtd2_ReadChunkWithTagsFromNAND chunk %d data %p tags %p"
10971             TENDSTR), chunkInNAND, data, tags));
10972
10973 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
10974 -       if (data && !tags)
10975 -               retval = mtd->read(mtd, addr, dev->nDataBytesPerChunk,
10976 +       if (dev->inbandTags) {
10977 +
10978 +               if (!data) {
10979 +                       localData = 1;
10980 +                       data = yaffs_GetTempBuffer(dev, __LINE__);
10981 +               }
10982 +
10983 +
10984 +       }
10985 +
10986 +
10987 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17))
10988 +       if (dev->inbandTags || (data && !tags))
10989 +               retval = mtd->read(mtd, addr, dev->totalBytesPerChunk,
10990                                 &dummy, data);
10991         else if (tags) {
10992                 ops.mode = MTD_OOB_AUTO;
10993 @@ -130,38 +140,42 @@ int nandmtd2_ReadChunkWithTagsFromNAND(y
10994                 retval = mtd->read_oob(mtd, addr, &ops);
10995         }
10996  #else
10997 -       if (data && tags) {
10998 -               if (dev->useNANDECC) {
10999 -                       retval =
11000 -                           mtd->read_ecc(mtd, addr, dev->nDataBytesPerChunk,
11001 -                                         &dummy, data, dev->spareBuffer,
11002 -                                         NULL);
11003 -               } else {
11004 -                       retval =
11005 -                           mtd->read_ecc(mtd, addr, dev->nDataBytesPerChunk,
11006 +       if (!dev->inbandTags && data && tags) {
11007 +
11008 +               retval = mtd->read_ecc(mtd, addr, dev->nDataBytesPerChunk,
11009                                           &dummy, data, dev->spareBuffer,
11010                                           NULL);
11011 -               }
11012         } else {
11013                 if (data)
11014                         retval =
11015                             mtd->read(mtd, addr, dev->nDataBytesPerChunk, &dummy,
11016                                       data);
11017 -               if (tags)
11018 +               if (!dev->inbandTags && tags)
11019                         retval =
11020                             mtd->read_oob(mtd, addr, mtd->oobsize, &dummy,
11021                                           dev->spareBuffer);
11022         }
11023  #endif
11024
11025 -       memcpy(&pt, dev->spareBuffer, sizeof(pt));
11026
11027 -       if (tags)
11028 -               yaffs_UnpackTags2(tags, &pt);
11029 +       if (dev->inbandTags) {
11030 +               if (tags) {
11031 +                       yaffs_PackedTags2TagsPart *pt2tp;
11032 +                       pt2tp = (yaffs_PackedTags2TagsPart *)&data[dev->nDataBytesPerChunk];
11033 +                       yaffs_UnpackTags2TagsPart(tags, pt2tp);
11034 +               }
11035 +       } else {
11036 +               if (tags) {
11037 +                       memcpy(&pt, dev->spareBuffer, sizeof(pt));
11038 +                       yaffs_UnpackTags2(tags, &pt);
11039 +               }
11040 +       }
11041 +
11042 +       if (localData)
11043 +               yaffs_ReleaseTempBuffer(dev, data, __LINE__);
11044
11045 -       if(tags && retval == -EBADMSG && tags->eccResult == YAFFS_ECC_RESULT_NO_ERROR)
11046 +       if (tags && retval == -EBADMSG && tags->eccResult == YAFFS_ECC_RESULT_NO_ERROR)
11047                 tags->eccResult = YAFFS_ECC_RESULT_UNFIXED;
11048 -
11049         if (retval == 0)
11050                 return YAFFS_OK;
11051         else
11052 @@ -178,7 +192,7 @@ int nandmtd2_MarkNANDBlockBad(struct yaf
11053         retval =
11054             mtd->block_markbad(mtd,
11055                                blockNo * dev->nChunksPerBlock *
11056 -                              dev->nDataBytesPerChunk);
11057 +                              dev->totalBytesPerChunk);
11058
11059         if (retval == 0)
11060                 return YAFFS_OK;
11061 @@ -188,7 +202,7 @@ int nandmtd2_MarkNANDBlockBad(struct yaf
11062  }
11063
11064  int nandmtd2_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockNo,
11065 -                           yaffs_BlockState * state, int *sequenceNumber)
11066 +                           yaffs_BlockState *state, __u32 *sequenceNumber)
11067  {
11068         struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice);
11069         int retval;
11070 @@ -198,7 +212,7 @@ int nandmtd2_QueryNANDBlock(struct yaffs
11071         retval =
11072             mtd->block_isbad(mtd,
11073                              blockNo * dev->nChunksPerBlock *
11074 -                            dev->nDataBytesPerChunk);
11075 +                            dev->totalBytesPerChunk);
11076
11077         if (retval) {
11078                 T(YAFFS_TRACE_MTD, (TSTR("block is bad" TENDSTR)));
11079 --- a/fs/yaffs2/yaffs_mtdif2.h
11080 +++ b/fs/yaffs2/yaffs_mtdif2.h
11081 @@ -17,13 +17,13 @@
11082  #define __YAFFS_MTDIF2_H__
11083
11084  #include "yaffs_guts.h"
11085 -int nandmtd2_WriteChunkWithTagsToNAND(yaffs_Device * dev, int chunkInNAND,
11086 -                                     const __u8 * data,
11087 -                                     const yaffs_ExtendedTags * tags);
11088 -int nandmtd2_ReadChunkWithTagsFromNAND(yaffs_Device * dev, int chunkInNAND,
11089 -                                      __u8 * data, yaffs_ExtendedTags * tags);
11090 +int nandmtd2_WriteChunkWithTagsToNAND(yaffs_Device *dev, int chunkInNAND,
11091 +                               const __u8 *data,
11092 +                               const yaffs_ExtendedTags *tags);
11093 +int nandmtd2_ReadChunkWithTagsFromNAND(yaffs_Device *dev, int chunkInNAND,
11094 +                               __u8 *data, yaffs_ExtendedTags *tags);
11095  int nandmtd2_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo);
11096  int nandmtd2_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockNo,
11097 -                           yaffs_BlockState * state, int *sequenceNumber);
11098 +                       yaffs_BlockState *state, __u32 *sequenceNumber);
11099
11100  #endif
11101 --- a/fs/yaffs2/yaffs_mtdif.c
11102 +++ b/fs/yaffs2/yaffs_mtdif.c
11103 @@ -12,7 +12,7 @@
11104   */
11105
11106  const char *yaffs_mtdif_c_version =
11107 -    "$Id: yaffs_mtdif.c,v 1.19 2007-02-14 01:09:06 wookey Exp $";
11108 +       "$Id: yaffs_mtdif.c,v 1.22 2009-03-06 17:20:51 wookey Exp $";
11109
11110  #include "yportenv.h"
11111
11112 @@ -24,7 +24,7 @@ const char *yaffs_mtdif_c_version =
11113  #include "linux/time.h"
11114  #include "linux/mtd/nand.h"
11115
11116 -#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,18))
11117 +#if (MTD_VERSION_CODE < MTD_VERSION(2, 6, 18))
11118  static struct nand_oobinfo yaffs_oobinfo = {
11119         .useecc = 1,
11120         .eccbytes = 6,
11121 @@ -36,7 +36,7 @@ static struct nand_oobinfo yaffs_noeccin
11122  };
11123  #endif
11124
11125 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
11126 +#if (MTD_VERSION_CODE > MTD_VERSION(2, 6, 17))
11127  static inline void translate_spare2oob(const yaffs_Spare *spare, __u8 *oob)
11128  {
11129         oob[0] = spare->tagByte0;
11130 @@ -45,8 +45,8 @@ static inline void translate_spare2oob(c
11131         oob[3] = spare->tagByte3;
11132         oob[4] = spare->tagByte4;
11133         oob[5] = spare->tagByte5 & 0x3f;
11134 -       oob[5] |= spare->blockStatus == 'Y' ? 0: 0x80;
11135 -       oob[5] |= spare->pageStatus == 0 ? 0: 0x40;
11136 +       oob[5] |= spare->blockStatus == 'Y' ? 0 : 0x80;
11137 +       oob[5] |= spare->pageStatus == 0 ? 0 : 0x40;
11138         oob[6] = spare->tagByte6;
11139         oob[7] = spare->tagByte7;
11140  }
11141 @@ -71,18 +71,18 @@ static inline void translate_oob2spare(y
11142  }
11143  #endif
11144
11145 -int nandmtd_WriteChunkToNAND(yaffs_Device * dev, int chunkInNAND,
11146 -                            const __u8 * data, const yaffs_Spare * spare)
11147 +int nandmtd_WriteChunkToNAND(yaffs_Device *dev, int chunkInNAND,
11148 +                            const __u8 *data, const yaffs_Spare *spare)
11149  {
11150         struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice);
11151 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
11152 +#if (MTD_VERSION_CODE > MTD_VERSION(2, 6, 17))
11153         struct mtd_oob_ops ops;
11154  #endif
11155         size_t dummy;
11156         int retval = 0;
11157
11158         loff_t addr = ((loff_t) chunkInNAND) * dev->nDataBytesPerChunk;
11159 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
11160 +#if (MTD_VERSION_CODE > MTD_VERSION(2, 6, 17))
11161         __u8 spareAsBytes[8]; /* OOB */
11162
11163         if (data && !spare)
11164 @@ -135,18 +135,18 @@ int nandmtd_WriteChunkToNAND(yaffs_Devic
11165                 return YAFFS_FAIL;
11166  }
11167
11168 -int nandmtd_ReadChunkFromNAND(yaffs_Device * dev, int chunkInNAND, __u8 * data,
11169 -                             yaffs_Spare * spare)
11170 +int nandmtd_ReadChunkFromNAND(yaffs_Device *dev, int chunkInNAND, __u8 *data,
11171 +                             yaffs_Spare *spare)
11172  {
11173         struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice);
11174 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
11175 +#if (MTD_VERSION_CODE > MTD_VERSION(2, 6, 17))
11176         struct mtd_oob_ops ops;
11177  #endif
11178         size_t dummy;
11179         int retval = 0;
11180
11181         loff_t addr = ((loff_t) chunkInNAND) * dev->nDataBytesPerChunk;
11182 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
11183 +#if (MTD_VERSION_CODE > MTD_VERSION(2, 6, 17))
11184         __u8 spareAsBytes[8]; /* OOB */
11185
11186         if (data && !spare)
11187 @@ -205,7 +205,7 @@ int nandmtd_ReadChunkFromNAND(yaffs_Devi
11188                 return YAFFS_FAIL;
11189  }
11190
11191 -int nandmtd_EraseBlockInNAND(yaffs_Device * dev, int blockNumber)
11192 +int nandmtd_EraseBlockInNAND(yaffs_Device *dev, int blockNumber)
11193  {
11194         struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice);
11195         __u32 addr =
11196 @@ -234,7 +234,7 @@ int nandmtd_EraseBlockInNAND(yaffs_Devic
11197                 return YAFFS_FAIL;
11198  }
11199
11200 -int nandmtd_InitialiseNAND(yaffs_Device * dev)
11201 +int nandmtd_InitialiseNAND(yaffs_Device *dev)
11202  {
11203         return YAFFS_OK;
11204  }
11205 --- a/fs/yaffs2/yaffs_mtdif.h
11206 +++ b/fs/yaffs2/yaffs_mtdif.h
11207 @@ -18,10 +18,15 @@
11208
11209  #include "yaffs_guts.h"
11210
11211 -int nandmtd_WriteChunkToNAND(yaffs_Device * dev, int chunkInNAND,
11212 -                            const __u8 * data, const yaffs_Spare * spare);
11213 -int nandmtd_ReadChunkFromNAND(yaffs_Device * dev, int chunkInNAND, __u8 * data,
11214 -                             yaffs_Spare * spare);
11215 -int nandmtd_EraseBlockInNAND(yaffs_Device * dev, int blockNumber);
11216 -int nandmtd_InitialiseNAND(yaffs_Device * dev);
11217 +#if (MTD_VERSION_CODE < MTD_VERSION(2, 6, 18))
11218 +extern struct nand_oobinfo yaffs_oobinfo;
11219 +extern struct nand_oobinfo yaffs_noeccinfo;
11220 +#endif
11221 +
11222 +int nandmtd_WriteChunkToNAND(yaffs_Device *dev, int chunkInNAND,
11223 +                       const __u8 *data, const yaffs_Spare *spare);
11224 +int nandmtd_ReadChunkFromNAND(yaffs_Device *dev, int chunkInNAND, __u8 *data,
11225 +                       yaffs_Spare *spare);
11226 +int nandmtd_EraseBlockInNAND(yaffs_Device *dev, int blockNumber);
11227 +int nandmtd_InitialiseNAND(yaffs_Device *dev);
11228  #endif
11229 --- a/fs/yaffs2/yaffs_nand.c
11230 +++ b/fs/yaffs2/yaffs_nand.c
11231 @@ -12,16 +12,17 @@
11232   */
11233
11234  const char *yaffs_nand_c_version =
11235 -    "$Id: yaffs_nand.c,v 1.7 2007-02-14 01:09:06 wookey Exp $";
11236 +       "$Id: yaffs_nand.c,v 1.10 2009-03-06 17:20:54 wookey Exp $";
11237
11238  #include "yaffs_nand.h"
11239  #include "yaffs_tagscompat.h"
11240  #include "yaffs_tagsvalidity.h"
11241
11242 +#include "yaffs_getblockinfo.h"
11243
11244 -int yaffs_ReadChunkWithTagsFromNAND(yaffs_Device * dev, int chunkInNAND,
11245 -                                          __u8 * buffer,
11246 -                                          yaffs_ExtendedTags * tags)
11247 +int yaffs_ReadChunkWithTagsFromNAND(yaffs_Device *dev, int chunkInNAND,
11248 +                                          __u8 *buffer,
11249 +                                          yaffs_ExtendedTags *tags)
11250  {
11251         int result;
11252         yaffs_ExtendedTags localTags;
11253 @@ -29,7 +30,7 @@ int yaffs_ReadChunkWithTagsFromNAND(yaff
11254         int realignedChunkInNAND = chunkInNAND - dev->chunkOffset;
11255
11256         /* If there are no tags provided, use local tags to get prioritised gc working */
11257 -       if(!tags)
11258 +       if (!tags)
11259                 tags = &localTags;
11260
11261         if (dev->readChunkWithTagsFromNAND)
11262 @@ -40,20 +41,20 @@ int yaffs_ReadChunkWithTagsFromNAND(yaff
11263                                                                         realignedChunkInNAND,
11264                                                                         buffer,
11265                                                                         tags);
11266 -       if(tags &&
11267 -          tags->eccResult > YAFFS_ECC_RESULT_NO_ERROR){
11268 +       if (tags &&
11269 +          tags->eccResult > YAFFS_ECC_RESULT_NO_ERROR) {
11270
11271                 yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, chunkInNAND/dev->nChunksPerBlock);
11272 -                yaffs_HandleChunkError(dev,bi);
11273 +               yaffs_HandleChunkError(dev, bi);
11274         }
11275
11276         return result;
11277  }
11278
11279 -int yaffs_WriteChunkWithTagsToNAND(yaffs_Device * dev,
11280 +int yaffs_WriteChunkWithTagsToNAND(yaffs_Device *dev,
11281                                                    int chunkInNAND,
11282 -                                                  const __u8 * buffer,
11283 -                                                  yaffs_ExtendedTags * tags)
11284 +                                                  const __u8 *buffer,
11285 +                                                  yaffs_ExtendedTags *tags)
11286  {
11287         chunkInNAND -= dev->chunkOffset;
11288
11289 @@ -84,7 +85,7 @@ int yaffs_WriteChunkWithTagsToNAND(yaffs
11290                                                                        tags);
11291  }
11292
11293 -int yaffs_MarkBlockBad(yaffs_Device * dev, int blockNo)
11294 +int yaffs_MarkBlockBad(yaffs_Device *dev, int blockNo)
11295  {
11296         blockNo -= dev->blockOffset;
11297
11298 @@ -95,10 +96,10 @@ int yaffs_MarkBlockBad(yaffs_Device * de
11299                 return yaffs_TagsCompatabilityMarkNANDBlockBad(dev, blockNo);
11300  }
11301
11302 -int yaffs_QueryInitialBlockState(yaffs_Device * dev,
11303 +int yaffs_QueryInitialBlockState(yaffs_Device *dev,
11304                                                  int blockNo,
11305 -                                                yaffs_BlockState * state,
11306 -                                                unsigned *sequenceNumber)
11307 +                                                yaffs_BlockState *state,
11308 +                                                __u32 *sequenceNumber)
11309  {
11310         blockNo -= dev->blockOffset;
11311
11312 --- a/fs/yaffs2/yaffs_nandemul2k.h
11313 +++ b/fs/yaffs2/yaffs_nandemul2k.h
11314 @@ -21,14 +21,14 @@
11315  #include "yaffs_guts.h"
11316
11317  int nandemul2k_WriteChunkWithTagsToNAND(struct yaffs_DeviceStruct *dev,
11318 -                                       int chunkInNAND, const __u8 * data,
11319 -                                       yaffs_ExtendedTags * tags);
11320 +                                       int chunkInNAND, const __u8 *data,
11321 +                                       const yaffs_ExtendedTags *tags);
11322  int nandemul2k_ReadChunkWithTagsFromNAND(struct yaffs_DeviceStruct *dev,
11323 -                                        int chunkInNAND, __u8 * data,
11324 -                                        yaffs_ExtendedTags * tags);
11325 +                                        int chunkInNAND, __u8 *data,
11326 +                                        yaffs_ExtendedTags *tags);
11327  int nandemul2k_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo);
11328  int nandemul2k_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockNo,
11329 -                             yaffs_BlockState * state, int *sequenceNumber);
11330 +                             yaffs_BlockState *state, __u32 *sequenceNumber);
11331  int nandemul2k_EraseBlockInNAND(struct yaffs_DeviceStruct *dev,
11332                                 int blockInNAND);
11333  int nandemul2k_InitialiseNAND(struct yaffs_DeviceStruct *dev);
11334 --- a/fs/yaffs2/yaffs_nand.h
11335 +++ b/fs/yaffs2/yaffs_nand.h
11336 @@ -19,21 +19,21 @@
11337
11338
11339
11340 -int yaffs_ReadChunkWithTagsFromNAND(yaffs_Device * dev, int chunkInNAND,
11341 -                                          __u8 * buffer,
11342 -                                          yaffs_ExtendedTags * tags);
11343 -
11344 -int yaffs_WriteChunkWithTagsToNAND(yaffs_Device * dev,
11345 -                                                  int chunkInNAND,
11346 -                                                  const __u8 * buffer,
11347 -                                                  yaffs_ExtendedTags * tags);
11348 -
11349 -int yaffs_MarkBlockBad(yaffs_Device * dev, int blockNo);
11350 -
11351 -int yaffs_QueryInitialBlockState(yaffs_Device * dev,
11352 -                                                int blockNo,
11353 -                                                yaffs_BlockState * state,
11354 -                                                unsigned *sequenceNumber);
11355 +int yaffs_ReadChunkWithTagsFromNAND(yaffs_Device *dev, int chunkInNAND,
11356 +                                       __u8 *buffer,
11357 +                                       yaffs_ExtendedTags *tags);
11358 +
11359 +int yaffs_WriteChunkWithTagsToNAND(yaffs_Device *dev,
11360 +                                               int chunkInNAND,
11361 +                                               const __u8 *buffer,
11362 +                                               yaffs_ExtendedTags *tags);
11363 +
11364 +int yaffs_MarkBlockBad(yaffs_Device *dev, int blockNo);
11365 +
11366 +int yaffs_QueryInitialBlockState(yaffs_Device *dev,
11367 +                                               int blockNo,
11368 +                                               yaffs_BlockState *state,
11369 +                                               unsigned *sequenceNumber);
11370
11371  int yaffs_EraseBlockInNAND(struct yaffs_DeviceStruct *dev,
11372                                   int blockInNAND);
11373 --- a/fs/yaffs2/yaffs_packedtags1.c
11374 +++ b/fs/yaffs2/yaffs_packedtags1.c
11375 @@ -14,7 +14,7 @@
11376  #include "yaffs_packedtags1.h"
11377  #include "yportenv.h"
11378
11379 -void yaffs_PackTags1(yaffs_PackedTags1 * pt, const yaffs_ExtendedTags * t)
11380 +void yaffs_PackTags1(yaffs_PackedTags1 *pt, const yaffs_ExtendedTags *t)
11381  {
11382         pt->chunkId = t->chunkId;
11383         pt->serialNumber = t->serialNumber;
11384 @@ -27,7 +27,7 @@ void yaffs_PackTags1(yaffs_PackedTags1 *
11385
11386  }
11387
11388 -void yaffs_UnpackTags1(yaffs_ExtendedTags * t, const yaffs_PackedTags1 * pt)
11389 +void yaffs_UnpackTags1(yaffs_ExtendedTags *t, const yaffs_PackedTags1 *pt)
11390  {
11391         static const __u8 allFF[] =
11392             { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
11393 @@ -35,9 +35,8 @@ void yaffs_UnpackTags1(yaffs_ExtendedTag
11394
11395         if (memcmp(allFF, pt, sizeof(yaffs_PackedTags1))) {
11396                 t->blockBad = 0;
11397 -               if (pt->shouldBeFF != 0xFFFFFFFF) {
11398 +               if (pt->shouldBeFF != 0xFFFFFFFF)
11399                         t->blockBad = 1;
11400 -               }
11401                 t->chunkUsed = 1;
11402                 t->objectId = pt->objectId;
11403                 t->chunkId = pt->chunkId;
11404 @@ -47,6 +46,5 @@ void yaffs_UnpackTags1(yaffs_ExtendedTag
11405                 t->serialNumber = pt->serialNumber;
11406         } else {
11407                 memset(t, 0, sizeof(yaffs_ExtendedTags));
11408 -
11409         }
11410  }
11411 --- a/fs/yaffs2/yaffs_packedtags1.h
11412 +++ b/fs/yaffs2/yaffs_packedtags1.h
11413 @@ -32,6 +32,6 @@ typedef struct {
11414
11415  } yaffs_PackedTags1;
11416
11417 -void yaffs_PackTags1(yaffs_PackedTags1 * pt, const yaffs_ExtendedTags * t);
11418 -void yaffs_UnpackTags1(yaffs_ExtendedTags * t, const yaffs_PackedTags1 * pt);
11419 +void yaffs_PackTags1(yaffs_PackedTags1 *pt, const yaffs_ExtendedTags *t);
11420 +void yaffs_UnpackTags1(yaffs_ExtendedTags *t, const yaffs_PackedTags1 *pt);
11421  #endif
11422 --- a/fs/yaffs2/yaffs_packedtags2.c
11423 +++ b/fs/yaffs2/yaffs_packedtags2.c
11424 @@ -37,60 +37,68 @@
11425  #define EXTRA_OBJECT_TYPE_SHIFT (28)
11426  #define EXTRA_OBJECT_TYPE_MASK  ((0x0F) << EXTRA_OBJECT_TYPE_SHIFT)
11427
11428 -static void yaffs_DumpPackedTags2(const yaffs_PackedTags2 * pt)
11429 +
11430 +static void yaffs_DumpPackedTags2TagsPart(const yaffs_PackedTags2TagsPart *ptt)
11431  {
11432         T(YAFFS_TRACE_MTD,
11433           (TSTR("packed tags obj %d chunk %d byte %d seq %d" TENDSTR),
11434 -          pt->t.objectId, pt->t.chunkId, pt->t.byteCount,
11435 -          pt->t.sequenceNumber));
11436 +          ptt->objectId, ptt->chunkId, ptt->byteCount,
11437 +          ptt->sequenceNumber));
11438 +}
11439 +static void yaffs_DumpPackedTags2(const yaffs_PackedTags2 *pt)
11440 +{
11441 +       yaffs_DumpPackedTags2TagsPart(&pt->t);
11442  }
11443
11444 -static void yaffs_DumpTags2(const yaffs_ExtendedTags * t)
11445 +static void yaffs_DumpTags2(const yaffs_ExtendedTags *t)
11446  {
11447         T(YAFFS_TRACE_MTD,
11448           (TSTR
11449 -          ("ext.tags eccres %d blkbad %d chused %d obj %d chunk%d byte "
11450 -           "%d del %d ser %d seq %d"
11451 +          ("ext.tags eccres %d blkbad %d chused %d obj %d chunk%d byte %d del %d ser %d seq %d"
11452             TENDSTR), t->eccResult, t->blockBad, t->chunkUsed, t->objectId,
11453            t->chunkId, t->byteCount, t->chunkDeleted, t->serialNumber,
11454            t->sequenceNumber));
11455
11456  }
11457
11458 -void yaffs_PackTags2(yaffs_PackedTags2 * pt, const yaffs_ExtendedTags * t)
11459 +void yaffs_PackTags2TagsPart(yaffs_PackedTags2TagsPart *ptt,
11460 +               const yaffs_ExtendedTags *t)
11461  {
11462 -       pt->t.chunkId = t->chunkId;
11463 -       pt->t.sequenceNumber = t->sequenceNumber;
11464 -       pt->t.byteCount = t->byteCount;
11465 -       pt->t.objectId = t->objectId;
11466 +       ptt->chunkId = t->chunkId;
11467 +       ptt->sequenceNumber = t->sequenceNumber;
11468 +       ptt->byteCount = t->byteCount;
11469 +       ptt->objectId = t->objectId;
11470
11471         if (t->chunkId == 0 && t->extraHeaderInfoAvailable) {
11472                 /* Store the extra header info instead */
11473                 /* We save the parent object in the chunkId */
11474 -               pt->t.chunkId = EXTRA_HEADER_INFO_FLAG
11475 +               ptt->chunkId = EXTRA_HEADER_INFO_FLAG
11476                         | t->extraParentObjectId;
11477 -               if (t->extraIsShrinkHeader) {
11478 -                       pt->t.chunkId |= EXTRA_SHRINK_FLAG;
11479 -               }
11480 -               if (t->extraShadows) {
11481 -                       pt->t.chunkId |= EXTRA_SHADOWS_FLAG;
11482 -               }
11483 +               if (t->extraIsShrinkHeader)
11484 +                       ptt->chunkId |= EXTRA_SHRINK_FLAG;
11485 +               if (t->extraShadows)
11486 +                       ptt->chunkId |= EXTRA_SHADOWS_FLAG;
11487
11488 -               pt->t.objectId &= ~EXTRA_OBJECT_TYPE_MASK;
11489 -               pt->t.objectId |=
11490 +               ptt->objectId &= ~EXTRA_OBJECT_TYPE_MASK;
11491 +               ptt->objectId |=
11492                     (t->extraObjectType << EXTRA_OBJECT_TYPE_SHIFT);
11493
11494 -               if (t->extraObjectType == YAFFS_OBJECT_TYPE_HARDLINK) {
11495 -                       pt->t.byteCount = t->extraEquivalentObjectId;
11496 -               } else if (t->extraObjectType == YAFFS_OBJECT_TYPE_FILE) {
11497 -                       pt->t.byteCount = t->extraFileLength;
11498 -               } else {
11499 -                       pt->t.byteCount = 0;
11500 -               }
11501 +               if (t->extraObjectType == YAFFS_OBJECT_TYPE_HARDLINK)
11502 +                       ptt->byteCount = t->extraEquivalentObjectId;
11503 +               else if (t->extraObjectType == YAFFS_OBJECT_TYPE_FILE)
11504 +                       ptt->byteCount = t->extraFileLength;
11505 +               else
11506 +                       ptt->byteCount = 0;
11507         }
11508
11509 -       yaffs_DumpPackedTags2(pt);
11510 +       yaffs_DumpPackedTags2TagsPart(ptt);
11511         yaffs_DumpTags2(t);
11512 +}
11513 +
11514 +
11515 +void yaffs_PackTags2(yaffs_PackedTags2 *pt, const yaffs_ExtendedTags *t)
11516 +{
11517 +       yaffs_PackTags2TagsPart(&pt->t, t);
11518
11519  #ifndef YAFFS_IGNORE_TAGS_ECC
11520         {
11521 @@ -101,82 +109,98 @@ void yaffs_PackTags2(yaffs_PackedTags2 *
11522  #endif
11523  }
11524
11525 -void yaffs_UnpackTags2(yaffs_ExtendedTags * t, yaffs_PackedTags2 * pt)
11526 +
11527 +void yaffs_UnpackTags2TagsPart(yaffs_ExtendedTags *t,
11528 +               yaffs_PackedTags2TagsPart *ptt)
11529  {
11530
11531         memset(t, 0, sizeof(yaffs_ExtendedTags));
11532
11533         yaffs_InitialiseTags(t);
11534
11535 -       if (pt->t.sequenceNumber != 0xFFFFFFFF) {
11536 -               /* Page is in use */
11537 -#ifdef YAFFS_IGNORE_TAGS_ECC
11538 -               {
11539 -                       t->eccResult = YAFFS_ECC_RESULT_NO_ERROR;
11540 -               }
11541 -#else
11542 -               {
11543 -                       yaffs_ECCOther ecc;
11544 -                       int result;
11545 -                       yaffs_ECCCalculateOther((unsigned char *)&pt->t,
11546 -                                               sizeof
11547 -                                               (yaffs_PackedTags2TagsPart),
11548 -                                               &ecc);
11549 -                       result =
11550 -                           yaffs_ECCCorrectOther((unsigned char *)&pt->t,
11551 -                                                 sizeof
11552 -                                                 (yaffs_PackedTags2TagsPart),
11553 -                                                 &pt->ecc, &ecc);
11554 -                       switch(result){
11555 -                               case 0:
11556 -                                       t->eccResult = YAFFS_ECC_RESULT_NO_ERROR;
11557 -                                       break;
11558 -                               case 1:
11559 -                                       t->eccResult = YAFFS_ECC_RESULT_FIXED;
11560 -                                       break;
11561 -                               case -1:
11562 -                                       t->eccResult = YAFFS_ECC_RESULT_UNFIXED;
11563 -                                       break;
11564 -                               default:
11565 -                                       t->eccResult = YAFFS_ECC_RESULT_UNKNOWN;
11566 -                       }
11567 -               }
11568 -#endif
11569 +       if (ptt->sequenceNumber != 0xFFFFFFFF) {
11570                 t->blockBad = 0;
11571                 t->chunkUsed = 1;
11572 -               t->objectId = pt->t.objectId;
11573 -               t->chunkId = pt->t.chunkId;
11574 -               t->byteCount = pt->t.byteCount;
11575 +               t->objectId = ptt->objectId;
11576 +               t->chunkId = ptt->chunkId;
11577 +               t->byteCount = ptt->byteCount;
11578                 t->chunkDeleted = 0;
11579                 t->serialNumber = 0;
11580 -               t->sequenceNumber = pt->t.sequenceNumber;
11581 +               t->sequenceNumber = ptt->sequenceNumber;
11582
11583                 /* Do extra header info stuff */
11584
11585 -               if (pt->t.chunkId & EXTRA_HEADER_INFO_FLAG) {
11586 +               if (ptt->chunkId & EXTRA_HEADER_INFO_FLAG) {
11587                         t->chunkId = 0;
11588                         t->byteCount = 0;
11589
11590                         t->extraHeaderInfoAvailable = 1;
11591                         t->extraParentObjectId =
11592 -                           pt->t.chunkId & (~(ALL_EXTRA_FLAGS));
11593 +                           ptt->chunkId & (~(ALL_EXTRA_FLAGS));
11594                         t->extraIsShrinkHeader =
11595 -                           (pt->t.chunkId & EXTRA_SHRINK_FLAG) ? 1 : 0;
11596 +                           (ptt->chunkId & EXTRA_SHRINK_FLAG) ? 1 : 0;
11597                         t->extraShadows =
11598 -                           (pt->t.chunkId & EXTRA_SHADOWS_FLAG) ? 1 : 0;
11599 +                           (ptt->chunkId & EXTRA_SHADOWS_FLAG) ? 1 : 0;
11600                         t->extraObjectType =
11601 -                           pt->t.objectId >> EXTRA_OBJECT_TYPE_SHIFT;
11602 +                           ptt->objectId >> EXTRA_OBJECT_TYPE_SHIFT;
11603                         t->objectId &= ~EXTRA_OBJECT_TYPE_MASK;
11604
11605 -                       if (t->extraObjectType == YAFFS_OBJECT_TYPE_HARDLINK) {
11606 -                               t->extraEquivalentObjectId = pt->t.byteCount;
11607 -                       } else {
11608 -                               t->extraFileLength = pt->t.byteCount;
11609 +                       if (t->extraObjectType == YAFFS_OBJECT_TYPE_HARDLINK)
11610 +                               t->extraEquivalentObjectId = ptt->byteCount;
11611 +                       else
11612 +                               t->extraFileLength = ptt->byteCount;
11613 +               }
11614 +       }
11615 +
11616 +       yaffs_DumpPackedTags2TagsPart(ptt);
11617 +       yaffs_DumpTags2(t);
11618 +
11619 +}
11620 +
11621 +
11622 +void yaffs_UnpackTags2(yaffs_ExtendedTags *t, yaffs_PackedTags2 *pt)
11623 +{
11624 +
11625 +       yaffs_ECCResult eccResult = YAFFS_ECC_RESULT_NO_ERROR;
11626 +
11627 +       if (pt->t.sequenceNumber != 0xFFFFFFFF) {
11628 +               /* Page is in use */
11629 +#ifndef YAFFS_IGNORE_TAGS_ECC
11630 +               {
11631 +                       yaffs_ECCOther ecc;
11632 +                       int result;
11633 +                       yaffs_ECCCalculateOther((unsigned char *)&pt->t,
11634 +                                               sizeof
11635 +                                               (yaffs_PackedTags2TagsPart),
11636 +                                               &ecc);
11637 +                       result =
11638 +                           yaffs_ECCCorrectOther((unsigned char *)&pt->t,
11639 +                                                 sizeof
11640 +                                                 (yaffs_PackedTags2TagsPart),
11641 +                                                 &pt->ecc, &ecc);
11642 +                       switch (result) {
11643 +                       case 0:
11644 +                               eccResult = YAFFS_ECC_RESULT_NO_ERROR;
11645 +                               break;
11646 +                       case 1:
11647 +                               eccResult = YAFFS_ECC_RESULT_FIXED;
11648 +                               break;
11649 +                       case -1:
11650 +                               eccResult = YAFFS_ECC_RESULT_UNFIXED;
11651 +                               break;
11652 +                       default:
11653 +                               eccResult = YAFFS_ECC_RESULT_UNKNOWN;
11654                         }
11655                 }
11656 +#endif
11657         }
11658
11659 +       yaffs_UnpackTags2TagsPart(t, &pt->t);
11660 +
11661 +       t->eccResult = eccResult;
11662 +
11663         yaffs_DumpPackedTags2(pt);
11664         yaffs_DumpTags2(t);
11665
11666  }
11667 +
11668 --- a/fs/yaffs2/yaffs_packedtags2.h
11669 +++ b/fs/yaffs2/yaffs_packedtags2.h
11670 @@ -33,6 +33,11 @@ typedef struct {
11671         yaffs_ECCOther ecc;
11672  } yaffs_PackedTags2;
11673
11674 -void yaffs_PackTags2(yaffs_PackedTags2 * pt, const yaffs_ExtendedTags * t);
11675 -void yaffs_UnpackTags2(yaffs_ExtendedTags * t, yaffs_PackedTags2 * pt);
11676 +/* Full packed tags with ECC, used for oob tags */
11677 +void yaffs_PackTags2(yaffs_PackedTags2 *pt, const yaffs_ExtendedTags *t);
11678 +void yaffs_UnpackTags2(yaffs_ExtendedTags *t, yaffs_PackedTags2 *pt);
11679 +
11680 +/* Only the tags part (no ECC for use with inband tags */
11681 +void yaffs_PackTags2TagsPart(yaffs_PackedTags2TagsPart *pt, const yaffs_ExtendedTags *t);
11682 +void yaffs_UnpackTags2TagsPart(yaffs_ExtendedTags *t, yaffs_PackedTags2TagsPart *pt);
11683  #endif
11684 --- a/fs/yaffs2/yaffs_qsort.c
11685 +++ b/fs/yaffs2/yaffs_qsort.c
11686 @@ -28,12 +28,12 @@
11687   */
11688
11689  #include "yportenv.h"
11690 -//#include <linux/string.h>
11691 +/* #include <linux/string.h> */
11692
11693  /*
11694   * Qsort routine from Bentley & McIlroy's "Engineering a Sort Function".
11695   */
11696 -#define swapcode(TYPE, parmi, parmj, n) {              \
11697 +#define swapcode(TYPE, parmi, parmj, n) do {           \
11698         long i = (n) / sizeof (TYPE);                   \
11699         register TYPE *pi = (TYPE *) (parmi);           \
11700         register TYPE *pj = (TYPE *) (parmj);           \
11701 @@ -41,28 +41,29 @@
11702                 register TYPE   t = *pi;                \
11703                 *pi++ = *pj;                            \
11704                 *pj++ = t;                              \
11705 -        } while (--i > 0);                             \
11706 -}
11707 +       } while (--i > 0);                              \
11708 +} while (0)
11709
11710  #define SWAPINIT(a, es) swaptype = ((char *)a - (char *)0) % sizeof(long) || \
11711 -       es % sizeof(long) ? 2 : es == sizeof(long)? 0 : 1;
11712 +       es % sizeof(long) ? 2 : es == sizeof(long) ? 0 : 1;
11713
11714  static __inline void
11715  swapfunc(char *a, char *b, int n, int swaptype)
11716  {
11717         if (swaptype <= 1)
11718 -               swapcode(long, a, b, n)
11719 +               swapcode(long, a, b, n);
11720         else
11721 -               swapcode(char, a, b, n)
11722 +               swapcode(char, a, b, n);
11723  }
11724
11725 -#define swap(a, b)                                     \
11726 +#define yswap(a, b) do {                                       \
11727         if (swaptype == 0) {                            \
11728                 long t = *(long *)(a);                  \
11729                 *(long *)(a) = *(long *)(b);            \
11730                 *(long *)(b) = t;                       \
11731         } else                                          \
11732 -               swapfunc(a, b, es, swaptype)
11733 +               swapfunc(a, b, es, swaptype);           \
11734 +} while (0)
11735
11736  #define vecswap(a, b, n)       if ((n) > 0) swapfunc(a, b, n, swaptype)
11737
11738 @@ -70,12 +71,12 @@ static __inline char *
11739  med3(char *a, char *b, char *c, int (*cmp)(const void *, const void *))
11740  {
11741         return cmp(a, b) < 0 ?
11742 -              (cmp(b, c) < 0 ? b : (cmp(a, c) < 0 ? c : a ))
11743 -              :(cmp(b, c) > 0 ? b : (cmp(a, c) < 0 ? a : c ));
11744 +               (cmp(b, c) < 0 ? b : (cmp(a, c) < 0 ? c : a))
11745 +               : (cmp(b, c) > 0 ? b : (cmp(a, c) < 0 ? a : c));
11746  }
11747
11748  #ifndef min
11749 -#define min(a,b) (((a) < (b)) ? (a) : (b))
11750 +#define min(a, b) (((a) < (b)) ? (a) : (b))
11751  #endif
11752
11753  void
11754 @@ -92,7 +93,7 @@ loop: SWAPINIT(a, es);
11755                 for (pm = (char *)a + es; pm < (char *) a + n * es; pm += es)
11756                         for (pl = pm; pl > (char *) a && cmp(pl - es, pl) > 0;
11757                              pl -= es)
11758 -                               swap(pl, pl - es);
11759 +                               yswap(pl, pl - es);
11760                 return;
11761         }
11762         pm = (char *)a + (n / 2) * es;
11763 @@ -107,7 +108,7 @@ loop:       SWAPINIT(a, es);
11764                 }
11765                 pm = med3(pl, pm, pn, cmp);
11766         }
11767 -       swap(a, pm);
11768 +       yswap(a, pm);
11769         pa = pb = (char *)a + es;
11770
11771         pc = pd = (char *)a + (n - 1) * es;
11772 @@ -115,7 +116,7 @@ loop:       SWAPINIT(a, es);
11773                 while (pb <= pc && (r = cmp(pb, a)) <= 0) {
11774                         if (r == 0) {
11775                                 swap_cnt = 1;
11776 -                               swap(pa, pb);
11777 +                               yswap(pa, pb);
11778                                 pa += es;
11779                         }
11780                         pb += es;
11781 @@ -123,14 +124,14 @@ loop:     SWAPINIT(a, es);
11782                 while (pb <= pc && (r = cmp(pc, a)) >= 0) {
11783                         if (r == 0) {
11784                                 swap_cnt = 1;
11785 -                               swap(pc, pd);
11786 +                               yswap(pc, pd);
11787                                 pd -= es;
11788                         }
11789                         pc -= es;
11790                 }
11791                 if (pb > pc)
11792                         break;
11793 -               swap(pb, pc);
11794 +               yswap(pb, pc);
11795                 swap_cnt = 1;
11796                 pb += es;
11797                 pc -= es;
11798 @@ -139,7 +140,7 @@ loop:       SWAPINIT(a, es);
11799                 for (pm = (char *) a + es; pm < (char *) a + n * es; pm += es)
11800                         for (pl = pm; pl > (char *) a && cmp(pl - es, pl) > 0;
11801                              pl -= es)
11802 -                               swap(pl, pl - es);
11803 +                               yswap(pl, pl - es);
11804                 return;
11805         }
11806
11807 @@ -148,9 +149,11 @@ loop:      SWAPINIT(a, es);
11808         vecswap(a, pb - r, r);
11809         r = min((long)(pd - pc), (long)(pn - pd - es));
11810         vecswap(pb, pn - r, r);
11811 -       if ((r = pb - pa) > es)
11812 +       r = pb - pa;
11813 +       if (r > es)
11814                 yaffs_qsort(a, r / es, es, cmp);
11815 -       if ((r = pd - pc) > es) {
11816 +       r = pd - pc;
11817 +       if (r > es) {
11818                 /* Iterate rather than recurse to save stack space */
11819                 a = pn - r;
11820                 n = r / es;
11821 --- a/fs/yaffs2/yaffs_qsort.h
11822 +++ b/fs/yaffs2/yaffs_qsort.h
11823 @@ -17,7 +17,7 @@
11824  #ifndef __YAFFS_QSORT_H__
11825  #define __YAFFS_QSORT_H__
11826
11827 -extern void yaffs_qsort (void *const base, size_t total_elems, size_t size,
11828 -                   int (*cmp)(const void *, const void *));
11829 +extern void yaffs_qsort(void *const base, size_t total_elems, size_t size,
11830 +                       int (*cmp)(const void *, const void *));
11831
11832  #endif
11833 --- a/fs/yaffs2/yaffs_tagscompat.c
11834 +++ b/fs/yaffs2/yaffs_tagscompat.c
11835 @@ -14,16 +14,17 @@
11836  #include "yaffs_guts.h"
11837  #include "yaffs_tagscompat.h"
11838  #include "yaffs_ecc.h"
11839 +#include "yaffs_getblockinfo.h"
11840
11841 -static void yaffs_HandleReadDataError(yaffs_Device * dev, int chunkInNAND);
11842 +static void yaffs_HandleReadDataError(yaffs_Device *dev, int chunkInNAND);
11843  #ifdef NOTYET
11844 -static void yaffs_CheckWrittenBlock(yaffs_Device * dev, int chunkInNAND);
11845 -static void yaffs_HandleWriteChunkOk(yaffs_Device * dev, int chunkInNAND,
11846 -                                    const __u8 * data,
11847 -                                    const yaffs_Spare * spare);
11848 -static void yaffs_HandleUpdateChunk(yaffs_Device * dev, int chunkInNAND,
11849 -                                   const yaffs_Spare * spare);
11850 -static void yaffs_HandleWriteChunkError(yaffs_Device * dev, int chunkInNAND);
11851 +static void yaffs_CheckWrittenBlock(yaffs_Device *dev, int chunkInNAND);
11852 +static void yaffs_HandleWriteChunkOk(yaffs_Device *dev, int chunkInNAND,
11853 +                                    const __u8 *data,
11854 +                                    const yaffs_Spare *spare);
11855 +static void yaffs_HandleUpdateChunk(yaffs_Device *dev, int chunkInNAND,
11856 +                                   const yaffs_Spare *spare);
11857 +static void yaffs_HandleWriteChunkError(yaffs_Device *dev, int chunkInNAND);
11858  #endif
11859
11860  static const char yaffs_countBitsTable[256] = {
11861 @@ -54,13 +55,13 @@ int yaffs_CountBits(__u8 x)
11862
11863  /********** Tags ECC calculations  *********/
11864
11865 -void yaffs_CalcECC(const __u8 * data, yaffs_Spare * spare)
11866 +void yaffs_CalcECC(const __u8 *data, yaffs_Spare *spare)
11867  {
11868         yaffs_ECCCalculate(data, spare->ecc1);
11869         yaffs_ECCCalculate(&data[256], spare->ecc2);
11870  }
11871
11872 -void yaffs_CalcTagsECC(yaffs_Tags * tags)
11873 +void yaffs_CalcTagsECC(yaffs_Tags *tags)
11874  {
11875         /* Calculate an ecc */
11876
11877 @@ -74,9 +75,8 @@ void yaffs_CalcTagsECC(yaffs_Tags * tags
11878         for (i = 0; i < 8; i++) {
11879                 for (j = 1; j & 0xff; j <<= 1) {
11880                         bit++;
11881 -                       if (b[i] & j) {
11882 +                       if (b[i] & j)
11883                                 ecc ^= bit;
11884 -                       }
11885                 }
11886         }
11887
11888 @@ -84,7 +84,7 @@ void yaffs_CalcTagsECC(yaffs_Tags * tags
11889
11890  }
11891
11892 -int yaffs_CheckECCOnTags(yaffs_Tags * tags)
11893 +int yaffs_CheckECCOnTags(yaffs_Tags *tags)
11894  {
11895         unsigned ecc = tags->ecc;
11896
11897 @@ -115,8 +115,8 @@ int yaffs_CheckECCOnTags(yaffs_Tags * ta
11898
11899  /********** Tags **********/
11900
11901 -static void yaffs_LoadTagsIntoSpare(yaffs_Spare * sparePtr,
11902 -                                   yaffs_Tags * tagsPtr)
11903 +static void yaffs_LoadTagsIntoSpare(yaffs_Spare *sparePtr,
11904 +                               yaffs_Tags *tagsPtr)
11905  {
11906         yaffs_TagsUnion *tu = (yaffs_TagsUnion *) tagsPtr;
11907
11908 @@ -132,8 +132,8 @@ static void yaffs_LoadTagsIntoSpare(yaff
11909         sparePtr->tagByte7 = tu->asBytes[7];
11910  }
11911
11912 -static void yaffs_GetTagsFromSpare(yaffs_Device * dev, yaffs_Spare * sparePtr,
11913 -                                  yaffs_Tags * tagsPtr)
11914 +static void yaffs_GetTagsFromSpare(yaffs_Device *dev, yaffs_Spare *sparePtr,
11915 +                               yaffs_Tags *tagsPtr)
11916  {
11917         yaffs_TagsUnion *tu = (yaffs_TagsUnion *) tagsPtr;
11918         int result;
11919 @@ -148,21 +148,20 @@ static void yaffs_GetTagsFromSpare(yaffs
11920         tu->asBytes[7] = sparePtr->tagByte7;
11921
11922         result = yaffs_CheckECCOnTags(tagsPtr);
11923 -       if (result > 0) {
11924 +       if (result > 0)
11925                 dev->tagsEccFixed++;
11926 -       } else if (result < 0) {
11927 +       else if (result < 0)
11928                 dev->tagsEccUnfixed++;
11929 -       }
11930  }
11931
11932 -static void yaffs_SpareInitialise(yaffs_Spare * spare)
11933 +static void yaffs_SpareInitialise(yaffs_Spare *spare)
11934  {
11935         memset(spare, 0xFF, sizeof(yaffs_Spare));
11936  }
11937
11938  static int yaffs_WriteChunkToNAND(struct yaffs_DeviceStruct *dev,
11939 -                                 int chunkInNAND, const __u8 * data,
11940 -                                 yaffs_Spare * spare)
11941 +                               int chunkInNAND, const __u8 *data,
11942 +                               yaffs_Spare *spare)
11943  {
11944         if (chunkInNAND < dev->startBlock * dev->nChunksPerBlock) {
11945                 T(YAFFS_TRACE_ERROR,
11946 @@ -177,9 +176,9 @@ static int yaffs_WriteChunkToNAND(struct
11947
11948  static int yaffs_ReadChunkFromNAND(struct yaffs_DeviceStruct *dev,
11949                                    int chunkInNAND,
11950 -                                  __u8 * data,
11951 -                                  yaffs_Spare * spare,
11952 -                                  yaffs_ECCResult * eccResult,
11953 +                                  __u8 *data,
11954 +                                  yaffs_Spare *spare,
11955 +                                  yaffs_ECCResult *eccResult,
11956                                    int doErrorCorrection)
11957  {
11958         int retVal;
11959 @@ -252,9 +251,11 @@ static int yaffs_ReadChunkFromNAND(struc
11960                 /* Must allocate enough memory for spare+2*sizeof(int) */
11961                 /* for ecc results from device. */
11962                 struct yaffs_NANDSpare nspare;
11963 -               retVal =
11964 -                   dev->readChunkFromNAND(dev, chunkInNAND, data,
11965 -                                          (yaffs_Spare *) & nspare);
11966 +
11967 +               memset(&nspare, 0, sizeof(nspare));
11968 +
11969 +               retVal = dev->readChunkFromNAND(dev, chunkInNAND, data,
11970 +                                       (yaffs_Spare *) &nspare);
11971                 memcpy(spare, &nspare, sizeof(yaffs_Spare));
11972                 if (data && doErrorCorrection) {
11973                         if (nspare.eccres1 > 0) {
11974 @@ -302,8 +303,7 @@ static int yaffs_ReadChunkFromNAND(struc
11975  static int yaffs_CheckChunkErased(struct yaffs_DeviceStruct *dev,
11976                                   int chunkInNAND)
11977  {
11978 -
11979 -       static int init = 0;
11980 +       static int init;
11981         static __u8 cmpbuf[YAFFS_BYTES_PER_CHUNK];
11982         static __u8 data[YAFFS_BYTES_PER_CHUNK];
11983         /* Might as well always allocate the larger size for */
11984 @@ -331,12 +331,12 @@ static int yaffs_CheckChunkErased(struct
11985   * Functions for robustisizing
11986   */
11987
11988 -static void yaffs_HandleReadDataError(yaffs_Device * dev, int chunkInNAND)
11989 +static void yaffs_HandleReadDataError(yaffs_Device *dev, int chunkInNAND)
11990  {
11991         int blockInNAND = chunkInNAND / dev->nChunksPerBlock;
11992
11993         /* Mark the block for retirement */
11994 -       yaffs_GetBlockInfo(dev, blockInNAND)->needsRetiring = 1;
11995 +       yaffs_GetBlockInfo(dev, blockInNAND + dev->blockOffset)->needsRetiring = 1;
11996         T(YAFFS_TRACE_ERROR | YAFFS_TRACE_BAD_BLOCKS,
11997           (TSTR("**>>Block %d marked for retirement" TENDSTR), blockInNAND));
11998
11999 @@ -348,22 +348,22 @@ static void yaffs_HandleReadDataError(ya
12000  }
12001
12002  #ifdef NOTYET
12003 -static void yaffs_CheckWrittenBlock(yaffs_Device * dev, int chunkInNAND)
12004 +static void yaffs_CheckWrittenBlock(yaffs_Device *dev, int chunkInNAND)
12005  {
12006  }
12007
12008 -static void yaffs_HandleWriteChunkOk(yaffs_Device * dev, int chunkInNAND,
12009 -                                    const __u8 * data,
12010 -                                    const yaffs_Spare * spare)
12011 +static void yaffs_HandleWriteChunkOk(yaffs_Device *dev, int chunkInNAND,
12012 +                                    const __u8 *data,
12013 +                                    const yaffs_Spare *spare)
12014  {
12015  }
12016
12017 -static void yaffs_HandleUpdateChunk(yaffs_Device * dev, int chunkInNAND,
12018 -                                   const yaffs_Spare * spare)
12019 +static void yaffs_HandleUpdateChunk(yaffs_Device *dev, int chunkInNAND,
12020 +                                   const yaffs_Spare *spare)
12021  {
12022  }
12023
12024 -static void yaffs_HandleWriteChunkError(yaffs_Device * dev, int chunkInNAND)
12025 +static void yaffs_HandleWriteChunkError(yaffs_Device *dev, int chunkInNAND)
12026  {
12027         int blockInNAND = chunkInNAND / dev->nChunksPerBlock;
12028
12029 @@ -373,8 +373,8 @@ static void yaffs_HandleWriteChunkError(
12030         yaffs_DeleteChunk(dev, chunkInNAND, 1, __LINE__);
12031  }
12032
12033 -static int yaffs_VerifyCompare(const __u8 * d0, const __u8 * d1,
12034 -                              const yaffs_Spare * s0, const yaffs_Spare * s1)
12035 +static int yaffs_VerifyCompare(const __u8 *d0, const __u8 *d1,
12036 +                              const yaffs_Spare *s0, const yaffs_Spare *s1)
12037  {
12038
12039         if (memcmp(d0, d1, YAFFS_BYTES_PER_CHUNK) != 0 ||
12040 @@ -398,28 +398,35 @@ static int yaffs_VerifyCompare(const __u
12041  }
12042  #endif                         /* NOTYET */
12043
12044 -int yaffs_TagsCompatabilityWriteChunkWithTagsToNAND(yaffs_Device * dev,
12045 -                                                   int chunkInNAND,
12046 -                                                   const __u8 * data,
12047 -                                                   const yaffs_ExtendedTags *
12048 -                                                   eTags)
12049 +int yaffs_TagsCompatabilityWriteChunkWithTagsToNAND(yaffs_Device *dev,
12050 +                                               int chunkInNAND,
12051 +                                               const __u8 *data,
12052 +                                               const yaffs_ExtendedTags *eTags)
12053  {
12054         yaffs_Spare spare;
12055         yaffs_Tags tags;
12056
12057         yaffs_SpareInitialise(&spare);
12058
12059 -       if (eTags->chunkDeleted) {
12060 +       if (eTags->chunkDeleted)
12061                 spare.pageStatus = 0;
12062 -       } else {
12063 +       else {
12064                 tags.objectId = eTags->objectId;
12065                 tags.chunkId = eTags->chunkId;
12066 -               tags.byteCount = eTags->byteCount;
12067 +
12068 +               tags.byteCountLSB = eTags->byteCount & 0x3ff;
12069 +
12070 +               if (dev->nDataBytesPerChunk >= 1024)
12071 +                       tags.byteCountMSB = (eTags->byteCount >> 10) & 3;
12072 +               else
12073 +                       tags.byteCountMSB = 3;
12074 +
12075 +
12076                 tags.serialNumber = eTags->serialNumber;
12077
12078 -               if (!dev->useNANDECC && data) {
12079 +               if (!dev->useNANDECC && data)
12080                         yaffs_CalcECC(data, &spare);
12081 -               }
12082 +
12083                 yaffs_LoadTagsIntoSpare(&spare, &tags);
12084
12085         }
12086 @@ -427,15 +434,15 @@ int yaffs_TagsCompatabilityWriteChunkWit
12087         return yaffs_WriteChunkToNAND(dev, chunkInNAND, data, &spare);
12088  }
12089
12090 -int yaffs_TagsCompatabilityReadChunkWithTagsFromNAND(yaffs_Device * dev,
12091 +int yaffs_TagsCompatabilityReadChunkWithTagsFromNAND(yaffs_Device *dev,
12092                                                      int chunkInNAND,
12093 -                                                    __u8 * data,
12094 -                                                    yaffs_ExtendedTags * eTags)
12095 +                                                    __u8 *data,
12096 +                                                    yaffs_ExtendedTags *eTags)
12097  {
12098
12099         yaffs_Spare spare;
12100         yaffs_Tags tags;
12101 -       yaffs_ECCResult eccResult;
12102 +       yaffs_ECCResult eccResult = YAFFS_ECC_RESULT_UNKNOWN;
12103
12104         static yaffs_Spare spareFF;
12105         static int init;
12106 @@ -466,7 +473,11 @@ int yaffs_TagsCompatabilityReadChunkWith
12107
12108                                 eTags->objectId = tags.objectId;
12109                                 eTags->chunkId = tags.chunkId;
12110 -                               eTags->byteCount = tags.byteCount;
12111 +                               eTags->byteCount = tags.byteCountLSB;
12112 +
12113 +                               if (dev->nDataBytesPerChunk >= 1024)
12114 +                                       eTags->byteCount |= (((unsigned) tags.byteCountMSB) << 10);
12115 +
12116                                 eTags->serialNumber = tags.serialNumber;
12117                         }
12118                 }
12119 @@ -497,9 +508,9 @@ int yaffs_TagsCompatabilityMarkNANDBlock
12120  }
12121
12122  int yaffs_TagsCompatabilityQueryNANDBlock(struct yaffs_DeviceStruct *dev,
12123 -                                         int blockNo, yaffs_BlockState *
12124 -                                         state,
12125 -                                         int *sequenceNumber)
12126 +                                         int blockNo,
12127 +                                         yaffs_BlockState *state,
12128 +                                         __u32 *sequenceNumber)
12129  {
12130
12131         yaffs_Spare spare0, spare1;
12132 --- a/fs/yaffs2/yaffs_tagscompat.h
12133 +++ b/fs/yaffs2/yaffs_tagscompat.h
12134 @@ -17,24 +17,23 @@
12135  #define __YAFFS_TAGSCOMPAT_H__
12136
12137  #include "yaffs_guts.h"
12138 -int yaffs_TagsCompatabilityWriteChunkWithTagsToNAND(yaffs_Device * dev,
12139 -                                                   int chunkInNAND,
12140 -                                                   const __u8 * data,
12141 -                                                   const yaffs_ExtendedTags *
12142 -                                                   tags);
12143 -int yaffs_TagsCompatabilityReadChunkWithTagsFromNAND(yaffs_Device * dev,
12144 -                                                    int chunkInNAND,
12145 -                                                    __u8 * data,
12146 -                                                    yaffs_ExtendedTags *
12147 -                                                    tags);
12148 +int yaffs_TagsCompatabilityWriteChunkWithTagsToNAND(yaffs_Device *dev,
12149 +                                               int chunkInNAND,
12150 +                                               const __u8 *data,
12151 +                                               const yaffs_ExtendedTags *tags);
12152 +int yaffs_TagsCompatabilityReadChunkWithTagsFromNAND(yaffs_Device *dev,
12153 +                                               int chunkInNAND,
12154 +                                               __u8 *data,
12155 +                                               yaffs_ExtendedTags *tags);
12156  int yaffs_TagsCompatabilityMarkNANDBlockBad(struct yaffs_DeviceStruct *dev,
12157                                             int blockNo);
12158  int yaffs_TagsCompatabilityQueryNANDBlock(struct yaffs_DeviceStruct *dev,
12159 -                                         int blockNo, yaffs_BlockState *
12160 -                                         state, int *sequenceNumber);
12161 +                                         int blockNo,
12162 +                                         yaffs_BlockState *state,
12163 +                                         __u32 *sequenceNumber);
12164
12165 -void yaffs_CalcTagsECC(yaffs_Tags * tags);
12166 -int yaffs_CheckECCOnTags(yaffs_Tags * tags);
12167 +void yaffs_CalcTagsECC(yaffs_Tags *tags);
12168 +int yaffs_CheckECCOnTags(yaffs_Tags *tags);
12169  int yaffs_CountBits(__u8 byte);
12170
12171  #endif
12172 --- a/fs/yaffs2/yaffs_tagsvalidity.c
12173 +++ b/fs/yaffs2/yaffs_tagsvalidity.c
12174 @@ -13,14 +13,14 @@
12175
12176  #include "yaffs_tagsvalidity.h"
12177
12178 -void yaffs_InitialiseTags(yaffs_ExtendedTags * tags)
12179 +void yaffs_InitialiseTags(yaffs_ExtendedTags *tags)
12180  {
12181         memset(tags, 0, sizeof(yaffs_ExtendedTags));
12182         tags->validMarker0 = 0xAAAAAAAA;
12183         tags->validMarker1 = 0x55555555;
12184  }
12185
12186 -int yaffs_ValidateTags(yaffs_ExtendedTags * tags)
12187 +int yaffs_ValidateTags(yaffs_ExtendedTags *tags)
12188  {
12189         return (tags->validMarker0 == 0xAAAAAAAA &&
12190                 tags->validMarker1 == 0x55555555);
12191 --- a/fs/yaffs2/yaffs_tagsvalidity.h
12192 +++ b/fs/yaffs2/yaffs_tagsvalidity.h
12193 @@ -19,6 +19,6 @@
12194
12195  #include "yaffs_guts.h"
12196
12197 -void yaffs_InitialiseTags(yaffs_ExtendedTags * tags);
12198 -int yaffs_ValidateTags(yaffs_ExtendedTags * tags);
12199 +void yaffs_InitialiseTags(yaffs_ExtendedTags *tags);
12200 +int yaffs_ValidateTags(yaffs_ExtendedTags *tags);
12201  #endif
12202 --- a/fs/yaffs2/yportenv.h
12203 +++ b/fs/yaffs2/yportenv.h
12204 @@ -17,17 +17,28 @@
12205  #ifndef __YPORTENV_H__
12206  #define __YPORTENV_H__
12207
12208 +/*
12209 + * Define the MTD version in terms of Linux Kernel versions
12210 + * This allows yaffs to be used independantly of the kernel
12211 + * as well as with it.
12212 + */
12213 +
12214 +#define MTD_VERSION(a, b, c) (((a) << 16) + ((b) << 8) + (c))
12215 +
12216  #if defined CONFIG_YAFFS_WINCE
12217
12218  #include "ywinceenv.h"
12219
12220 -#elif  defined __KERNEL__
12221 +#elif defined __KERNEL__
12222
12223  #include "moduleconfig.h"
12224
12225  /* Linux kernel */
12226 +
12227  #include <linux/version.h>
12228 -#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19))
12229 +#define MTD_VERSION_CODE LINUX_VERSION_CODE
12230 +
12231 +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 19))
12232  #include <linux/config.h>
12233  #endif
12234  #include <linux/kernel.h>
12235 @@ -40,12 +51,13 @@
12236  #define YCHAR char
12237  #define YUCHAR unsigned char
12238  #define _Y(x)     x
12239 -#define yaffs_strcpy(a,b)    strcpy(a,b)
12240 -#define yaffs_strncpy(a,b,c) strncpy(a,b,c)
12241 -#define yaffs_strncmp(a,b,c) strncmp(a,b,c)
12242 -#define yaffs_strlen(s)             strlen(s)
12243 -#define yaffs_sprintf       sprintf
12244 -#define yaffs_toupper(a)     toupper(a)
12245 +#define yaffs_strcat(a, b)     strcat(a, b)
12246 +#define yaffs_strcpy(a, b)     strcpy(a, b)
12247 +#define yaffs_strncpy(a, b, c) strncpy(a, b, c)
12248 +#define yaffs_strncmp(a, b, c) strncmp(a, b, c)
12249 +#define yaffs_strlen(s)               strlen(s)
12250 +#define yaffs_sprintf         sprintf
12251 +#define yaffs_toupper(a)       toupper(a)
12252
12253  #define Y_INLINE inline
12254
12255 @@ -53,19 +65,19 @@
12256  #define YAFFS_LOSTNFOUND_PREFIX                "obj"
12257
12258  /* #define YPRINTF(x) printk x */
12259 -#define YMALLOC(x) kmalloc(x,GFP_KERNEL)
12260 +#define YMALLOC(x) kmalloc(x, GFP_NOFS)
12261  #define YFREE(x)   kfree(x)
12262  #define YMALLOC_ALT(x) vmalloc(x)
12263  #define YFREE_ALT(x)   vfree(x)
12264  #define YMALLOC_DMA(x) YMALLOC(x)
12265
12266 -// KR - added for use in scan so processes aren't blocked indefinitely.
12267 +/* KR - added for use in scan so processes aren't blocked indefinitely. */
12268  #define YYIELD() schedule()
12269
12270  #define YAFFS_ROOT_MODE                        0666
12271  #define YAFFS_LOSTNFOUND_MODE          0666
12272
12273 -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
12274 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0))
12275  #define Y_CURRENT_TIME CURRENT_TIME.tv_sec
12276  #define Y_TIME_CONVERT(x) (x).tv_sec
12277  #else
12278 @@ -73,11 +85,12 @@
12279  #define Y_TIME_CONVERT(x) (x)
12280  #endif
12281
12282 -#define yaffs_SumCompare(x,y) ((x) == (y))
12283 -#define yaffs_strcmp(a,b) strcmp(a,b)
12284 +#define yaffs_SumCompare(x, y) ((x) == (y))
12285 +#define yaffs_strcmp(a, b) strcmp(a, b)
12286
12287  #define TENDSTR "\n"
12288  #define TSTR(x) KERN_WARNING x
12289 +#define TCONT(x) x
12290  #define TOUT(p) printk p
12291
12292  #define yaffs_trace(mask, fmt, args...) \
12293 @@ -90,6 +103,8 @@
12294
12295  #elif defined CONFIG_YAFFS_DIRECT
12296
12297 +#define MTD_VERSION_CODE MTD_VERSION(2, 6, 22)
12298 +
12299  /* Direct interface */
12300  #include "ydirectenv.h"
12301
12302 @@ -111,11 +126,12 @@
12303  #define YCHAR char
12304  #define YUCHAR unsigned char
12305  #define _Y(x)     x
12306 -#define yaffs_strcpy(a,b)    strcpy(a,b)
12307 -#define yaffs_strncpy(a,b,c) strncpy(a,b,c)
12308 -#define yaffs_strlen(s)             strlen(s)
12309 -#define yaffs_sprintf       sprintf
12310 -#define yaffs_toupper(a)     toupper(a)
12311 +#define yaffs_strcat(a, b)     strcat(a, b)
12312 +#define yaffs_strcpy(a, b)     strcpy(a, b)
12313 +#define yaffs_strncpy(a, b, c) strncpy(a, b, c)
12314 +#define yaffs_strlen(s)               strlen(s)
12315 +#define yaffs_sprintf         sprintf
12316 +#define yaffs_toupper(a)       toupper(a)
12317
12318  #define Y_INLINE inline
12319
12320 @@ -133,8 +149,8 @@
12321  #define YAFFS_ROOT_MODE                                0666
12322  #define YAFFS_LOSTNFOUND_MODE          0666
12323
12324 -#define yaffs_SumCompare(x,y) ((x) == (y))
12325 -#define yaffs_strcmp(a,b) strcmp(a,b)
12326 +#define yaffs_SumCompare(x, y) ((x) == (y))
12327 +#define yaffs_strcmp(a, b) strcmp(a, b)
12328
12329  #else
12330  /* Should have specified a configuration type */
12331 @@ -178,10 +194,10 @@ extern unsigned int yaffs_wr_attempts;
12332  #define YAFFS_TRACE_ALWAYS             0xF0000000
12333
12334
12335 -#define T(mask,p) do{ if((mask) & (yaffs_traceMask | YAFFS_TRACE_ALWAYS)) TOUT(p);} while(0)
12336 +#define T(mask, p) do { if ((mask) & (yaffs_traceMask | YAFFS_TRACE_ALWAYS)) TOUT(p); } while (0)
12337
12338 -#ifndef CONFIG_YAFFS_WINCE
12339 -#define YBUG() T(YAFFS_TRACE_BUG,(TSTR("==>> yaffs bug: " __FILE__ " %d" TENDSTR),__LINE__))
12340 +#ifndef YBUG
12341 +#define YBUG() do {T(YAFFS_TRACE_BUG, (TSTR("==>> yaffs bug: " __FILE__ " %d" TENDSTR), __LINE__)); } while (0)
12342  #endif
12343
12344  #endif