diff options
Diffstat (limited to 'target/linux')
| -rw-r--r-- | target/linux/generic/patches-2.6.36/511-yaffs-git-2010-10-20.patch (renamed from target/linux/generic/patches-2.6.36/511-yaffs-git-2010-10-01.patch) | 14618 |
1 files changed, 8933 insertions, 5685 deletions
diff --git a/target/linux/generic/patches-2.6.36/511-yaffs-git-2010-10-01.patch b/target/linux/generic/patches-2.6.36/511-yaffs-git-2010-10-20.patch index 1ba5b1f468..f58c48168e 100644 --- a/target/linux/generic/patches-2.6.36/511-yaffs-git-2010-10-01.patch +++ b/target/linux/generic/patches-2.6.36/511-yaffs-git-2010-10-20.patch @@ -1,5 +1,39 @@ ---- a/fs/yaffs2/devextras.h -+++ b/fs/yaffs2/devextras.h +diff -Nrup linux-2.6.36-rc8/fs/Kconfig linux-2.6.36-rc8.new/fs/Kconfig +--- linux-2.6.36-rc8/fs/Kconfig 2010-10-20 13:11:25.295000294 +0300 ++++ linux-2.6.36-rc8.new/fs/Kconfig 2010-10-20 13:28:15.952000294 +0300 +@@ -44,7 +44,6 @@ source "fs/gfs2/Kconfig" + source "fs/ocfs2/Kconfig" + source "fs/btrfs/Kconfig" + source "fs/nilfs2/Kconfig" +-source "fs/yaffs2/Kconfig" + + endif # BLOCK + +@@ -175,6 +174,10 @@ source "fs/hfsplus/Kconfig" + source "fs/befs/Kconfig" + source "fs/bfs/Kconfig" + source "fs/efs/Kconfig" ++ ++# Patched by YAFFS ++source "fs/yaffs2/Kconfig" ++ + source "fs/jffs2/Kconfig" + # UBIFS File system configuration + source "fs/ubifs/Kconfig" +diff -Nrup linux-2.6.36-rc8/fs/Makefile linux-2.6.36-rc8.new/fs/Makefile +--- linux-2.6.36-rc8/fs/Makefile 2010-10-20 13:11:25.295000294 +0300 ++++ linux-2.6.36-rc8.new/fs/Makefile 2010-10-20 13:28:15.953000294 +0300 +@@ -127,5 +127,6 @@ obj-$(CONFIG_BTRFS_FS) += btrfs/ + obj-$(CONFIG_GFS2_FS) += gfs2/ + obj-$(CONFIG_EXOFS_FS) += exofs/ + obj-$(CONFIG_CEPH_FS) += ceph/ +-obj-$(CONFIG_YAFFS_FS) += yaffs2/ + ++# Patched by YAFFS ++obj-$(CONFIG_YAFFS_FS) += yaffs2/ +diff -Nrup linux-2.6.36-rc8/fs/yaffs2/devextras.h linux-2.6.36-rc8.new/fs/yaffs2/devextras.h +--- linux-2.6.36-rc8/fs/yaffs2/devextras.h 2010-10-20 13:17:58.937000294 +0300 ++++ linux-2.6.36-rc8.new/fs/yaffs2/devextras.h 2010-10-20 13:28:16.050000294 +0300 @@ -1,7 +1,7 @@ /* * YAFFS: Yet another Flash File System . A NAND-flash specific file system. @@ -122,8 +156,9 @@ #if !(defined __KERNEL__) ---- a/fs/yaffs2/Kconfig -+++ b/fs/yaffs2/Kconfig +diff -Nrup linux-2.6.36-rc8/fs/yaffs2/Kconfig linux-2.6.36-rc8.new/fs/yaffs2/Kconfig +--- linux-2.6.36-rc8/fs/yaffs2/Kconfig 2010-10-20 13:17:58.937000294 +0300 ++++ linux-2.6.36-rc8.new/fs/yaffs2/Kconfig 2010-10-20 13:28:15.993000294 +0300 @@ -90,23 +90,15 @@ config YAFFS_AUTO_YAFFS2 If unsure, say Y. @@ -201,8 +236,9 @@ + If unsure, say Y. + + ---- a/fs/yaffs2/Makefile -+++ b/fs/yaffs2/Makefile +diff -Nrup linux-2.6.36-rc8/fs/yaffs2/Makefile linux-2.6.36-rc8.new/fs/yaffs2/Makefile +--- linux-2.6.36-rc8/fs/yaffs2/Makefile 2010-10-20 13:17:58.937000294 +0300 ++++ linux-2.6.36-rc8.new/fs/yaffs2/Makefile 2010-10-20 13:28:15.989000294 +0300 @@ -4,7 +4,14 @@ obj-$(CONFIG_YAFFS_FS) += yaffs.o @@ -220,8 +256,9 @@ +yaffs-y += yaffs_bitmap.o +yaffs-y += yaffs_verify.o + ---- a/fs/yaffs2/moduleconfig.h -+++ b/fs/yaffs2/moduleconfig.h +diff -Nrup linux-2.6.36-rc8/fs/yaffs2/moduleconfig.h linux-2.6.36-rc8.new/fs/yaffs2/moduleconfig.h +--- linux-2.6.36-rc8/fs/yaffs2/moduleconfig.h 2010-10-20 13:17:58.938000294 +0300 ++++ linux-2.6.36-rc8.new/fs/yaffs2/moduleconfig.h 2010-10-20 13:28:16.055000294 +0300 @@ -1,7 +1,7 @@ /* * YAFFS: Yet another Flash File System . A NAND-flash specific file system. @@ -231,7 +268,7 @@ * for Toby Churchill Ltd and Brightstar Engineering * * Created by Martin Fouts <Martin.Fouts@palmsource.com> -@@ -29,22 +29,43 @@ +@@ -29,25 +29,46 @@ /* Meaning: Yaffs does its own ECC, rather than using MTD ECC */ /* #define CONFIG_YAFFS_DOES_ECC */ @@ -280,9 +317,23 @@ +#define CONFIG_YAFFS_XATTR /* - Older-style on-NAND data format has a "pageStatus" byte to record ---- /dev/null -+++ b/fs/yaffs2/yaffs_allocator.c +-Older-style on-NAND data format has a "pageStatus" byte to record ++Older-style on-NAND data format has a "page_status" byte to record + chunk/page state. This byte is zeroed when the page is discarded. + Choose this option if you have existing on-NAND data in this format + that you need to continue to support. New data written also uses the +@@ -57,7 +78,7 @@ adjusted to use the older-style format. + MTD versions in yaffs_mtdif1.c. + */ + /* Default: Not selected */ +-/* Meaning: Use older-style on-NAND data format with pageStatus byte */ ++/* Meaning: Use older-style on-NAND data format with page_status byte */ + /* #define CONFIG_YAFFS_9BYTE_TAGS */ + + #endif /* YAFFS_OUT_OF_TREE */ +diff -Nrup linux-2.6.36-rc8/fs/yaffs2/yaffs_allocator.c linux-2.6.36-rc8.new/fs/yaffs2/yaffs_allocator.c +--- linux-2.6.36-rc8/fs/yaffs2/yaffs_allocator.c 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.36-rc8.new/fs/yaffs2/yaffs_allocator.c 2010-10-20 13:28:15.998000294 +0300 @@ -0,0 +1,409 @@ +/* + * YAFFS: Yet another Flash File System . A NAND-flash specific file system. @@ -307,45 +358,45 @@ + +#ifdef CONFIG_YAFFS_YMALLOC_ALLOCATOR + -+void yaffs_DeinitialiseRawTnodesAndObjects(yaffs_Device *dev) ++void yaffs_deinit_raw_tnodes_and_objs(yaffs_dev_t *dev) +{ + dev = dev; +} + -+void yaffs_InitialiseRawTnodesAndObjects(yaffs_Device *dev) ++void yaffs_init_raw_tnodes_and_objs(yaffs_dev_t *dev) +{ + dev = dev; +} + -+yaffs_Tnode *yaffs_AllocateRawTnode(yaffs_Device *dev) ++yaffs_tnode_t *yaffs_alloc_raw_tnode(yaffs_dev_t *dev) +{ -+ return (yaffs_Tnode *)YMALLOC(dev->tnodeSize); ++ return (yaffs_tnode_t *)YMALLOC(dev->tnode_size); +} + -+void yaffs_FreeRawTnode(yaffs_Device *dev, yaffs_Tnode *tn) ++void yaffs_free_raw_tnode(yaffs_dev_t *dev, yaffs_tnode_t *tn) +{ + dev = dev; + YFREE(tn); +} + -+void yaffs_InitialiseRawObjects(yaffs_Device *dev) ++void yaffs_init_raw_objs(yaffs_dev_t *dev) +{ + dev = dev; +} + -+void yaffs_DeinitialiseRawObjects(yaffs_Device *dev) ++void yaffs_deinit_raw_objs(yaffs_dev_t *dev) +{ + dev = dev; +} + -+yaffs_Object *yaffs_AllocateRawObject(yaffs_Device *dev) ++yaffs_obj_t *yaffs_alloc_raw_obj(yaffs_dev_t *dev) +{ + dev = dev; -+ return (yaffs_Object *) YMALLOC(sizeof(yaffs_Object)); ++ return (yaffs_obj_t *) YMALLOC(sizeof(yaffs_obj_t)); +} + + -+void yaffs_FreeRawObject(yaffs_Device *dev, yaffs_Object *obj) ++void yaffs_free_raw_obj(yaffs_dev_t *dev, yaffs_obj_t *obj) +{ + + dev = dev; @@ -354,43 +405,43 @@ + +#else + -+struct yaffs_TnodeList_struct { -+ struct yaffs_TnodeList_struct *next; -+ yaffs_Tnode *tnodes; ++struct yaffs_tnode_list { ++ struct yaffs_tnode_list *next; ++ yaffs_tnode_t *tnodes; +}; + -+typedef struct yaffs_TnodeList_struct yaffs_TnodeList; ++typedef struct yaffs_tnode_list yaffs_tnodelist_t; + -+struct yaffs_ObjectList_struct { -+ yaffs_Object *objects; -+ struct yaffs_ObjectList_struct *next; ++struct yaffs_obj_tList_struct { ++ yaffs_obj_t *objects; ++ struct yaffs_obj_tList_struct *next; +}; + -+typedef struct yaffs_ObjectList_struct yaffs_ObjectList; ++typedef struct yaffs_obj_tList_struct yaffs_obj_tList; + + +struct yaffs_AllocatorStruct { -+ int nTnodesCreated; -+ yaffs_Tnode *freeTnodes; ++ int n_tnodesCreated; ++ yaffs_tnode_t *freeTnodes; + int nFreeTnodes; -+ yaffs_TnodeList *allocatedTnodeList; ++ yaffs_tnodelist_t *allocatedTnodeList; + -+ int nObjectsCreated; -+ yaffs_Object *freeObjects; ++ int n_objCreated; ++ yaffs_obj_t *freeObjects; + int nFreeObjects; + -+ yaffs_ObjectList *allocatedObjectList; ++ yaffs_obj_tList *allocatedObjectList; +}; + +typedef struct yaffs_AllocatorStruct yaffs_Allocator; + + -+static void yaffs_DeinitialiseRawTnodes(yaffs_Device *dev) ++static void yaffs_deinit_raw_tnodes(yaffs_dev_t *dev) +{ + + yaffs_Allocator *allocator = (yaffs_Allocator *)dev->allocator; + -+ yaffs_TnodeList *tmp; ++ yaffs_tnodelist_t *tmp; + + if(!allocator){ + YBUG(); @@ -408,10 +459,10 @@ + + allocator->freeTnodes = NULL; + allocator->nFreeTnodes = 0; -+ allocator->nTnodesCreated = 0; ++ allocator->n_tnodesCreated = 0; +} + -+static void yaffs_InitialiseRawTnodes(yaffs_Device *dev) ++static void yaffs_init_raw_tnodes(yaffs_dev_t *dev) +{ + yaffs_Allocator *allocator = dev->allocator; + @@ -419,33 +470,33 @@ + allocator->allocatedTnodeList = NULL; + allocator->freeTnodes = NULL; + allocator->nFreeTnodes = 0; -+ allocator->nTnodesCreated = 0; ++ allocator->n_tnodesCreated = 0; + } else + YBUG(); +} + -+static int yaffs_CreateTnodes(yaffs_Device *dev, int nTnodes) ++static int yaffs_create_tnodes(yaffs_dev_t *dev, int n_tnodes) +{ + yaffs_Allocator *allocator = (yaffs_Allocator *)dev->allocator; + int i; -+ yaffs_Tnode *newTnodes; ++ yaffs_tnode_t *newTnodes; + __u8 *mem; -+ yaffs_Tnode *curr; -+ yaffs_Tnode *next; -+ yaffs_TnodeList *tnl; ++ yaffs_tnode_t *curr; ++ yaffs_tnode_t *next; ++ yaffs_tnodelist_t *tnl; + + if(!allocator){ + YBUG(); + return YAFFS_FAIL; + } + -+ if (nTnodes < 1) ++ if (n_tnodes < 1) + return YAFFS_OK; + + + /* make these things */ + -+ newTnodes = YMALLOC(nTnodes * dev->tnodeSize); ++ newTnodes = YMALLOC(n_tnodes * dev->tnode_size); + mem = (__u8 *)newTnodes; + + if (!newTnodes) { @@ -455,25 +506,25 @@ + } + + /* New hookup for wide tnodes */ -+ for (i = 0; i < nTnodes - 1; i++) { -+ curr = (yaffs_Tnode *) &mem[i * dev->tnodeSize]; -+ next = (yaffs_Tnode *) &mem[(i+1) * dev->tnodeSize]; ++ for (i = 0; i < n_tnodes - 1; i++) { ++ curr = (yaffs_tnode_t *) &mem[i * dev->tnode_size]; ++ next = (yaffs_tnode_t *) &mem[(i+1) * dev->tnode_size]; + curr->internal[0] = next; + } + -+ curr = (yaffs_Tnode *) &mem[(nTnodes - 1) * dev->tnodeSize]; ++ curr = (yaffs_tnode_t *) &mem[(n_tnodes - 1) * dev->tnode_size]; + curr->internal[0] = allocator->freeTnodes; -+ allocator->freeTnodes = (yaffs_Tnode *)mem; ++ allocator->freeTnodes = (yaffs_tnode_t *)mem; + -+ allocator->nFreeTnodes += nTnodes; -+ allocator->nTnodesCreated += nTnodes; ++ allocator->nFreeTnodes += n_tnodes; ++ allocator->n_tnodesCreated += n_tnodes; + + /* Now add this bunch of tnodes to a list for freeing up. + * NB If we can't add this to the management list it isn't fatal + * but it just means we can't free this bunch of tnodes later. + */ + -+ tnl = YMALLOC(sizeof(yaffs_TnodeList)); ++ tnl = YMALLOC(sizeof(yaffs_tnodelist_t)); + if (!tnl) { + T(YAFFS_TRACE_ERROR, + (TSTR @@ -491,10 +542,10 @@ +} + + -+yaffs_Tnode *yaffs_AllocateRawTnode(yaffs_Device *dev) ++yaffs_tnode_t *yaffs_alloc_raw_tnode(yaffs_dev_t *dev) +{ + yaffs_Allocator *allocator = (yaffs_Allocator *)dev->allocator; -+ yaffs_Tnode *tn = NULL; ++ yaffs_tnode_t *tn = NULL; + + if(!allocator){ + YBUG(); @@ -503,7 +554,7 @@ + + /* If there are none left make more */ + if (!allocator->freeTnodes) -+ yaffs_CreateTnodes(dev, YAFFS_ALLOCATION_NTNODES); ++ yaffs_create_tnodes(dev, YAFFS_ALLOCATION_NTNODES); + + if (allocator->freeTnodes) { + tn = allocator->freeTnodes; @@ -515,7 +566,7 @@ +} + +/* FreeTnode frees up a tnode and puts it back on the free list */ -+void yaffs_FreeRawTnode(yaffs_Device *dev, yaffs_Tnode *tn) ++void yaffs_free_raw_tnode(yaffs_dev_t *dev, yaffs_tnode_t *tn) +{ + yaffs_Allocator *allocator = dev->allocator; + @@ -529,12 +580,12 @@ + allocator->freeTnodes = tn; + allocator->nFreeTnodes++; + } -+ dev->nCheckpointBlocksRequired = 0; /* force recalculation*/ ++ dev->checkpoint_blocks_required = 0; /* force recalculation*/ +} + + + -+static void yaffs_InitialiseRawObjects(yaffs_Device *dev) ++static void yaffs_init_raw_objs(yaffs_dev_t *dev) +{ + yaffs_Allocator *allocator = dev->allocator; + @@ -546,10 +597,10 @@ + YBUG(); +} + -+static void yaffs_DeinitialiseRawObjects(yaffs_Device *dev) ++static void yaffs_deinit_raw_objs(yaffs_dev_t *dev) +{ + yaffs_Allocator *allocator = dev->allocator; -+ yaffs_ObjectList *tmp; ++ yaffs_obj_tList *tmp; + + if(!allocator){ + YBUG(); @@ -566,29 +617,29 @@ + + allocator->freeObjects = NULL; + allocator->nFreeObjects = 0; -+ allocator->nObjectsCreated = 0; ++ allocator->n_objCreated = 0; +} + + -+static int yaffs_CreateFreeObjects(yaffs_Device *dev, int nObjects) ++static int yaffs_create_free_objs(yaffs_dev_t *dev, int n_obj) +{ + yaffs_Allocator *allocator = dev->allocator; + + int i; -+ yaffs_Object *newObjects; -+ yaffs_ObjectList *list; ++ yaffs_obj_t *newObjects; ++ yaffs_obj_tList *list; + + if(!allocator){ + YBUG(); + return YAFFS_FAIL; + } + -+ if (nObjects < 1) ++ if (n_obj < 1) + return YAFFS_OK; + + /* make these things */ -+ newObjects = YMALLOC(nObjects * sizeof(yaffs_Object)); -+ list = YMALLOC(sizeof(yaffs_ObjectList)); ++ newObjects = YMALLOC(n_obj * sizeof(yaffs_obj_t)); ++ list = YMALLOC(sizeof(yaffs_obj_tList)); + + if (!newObjects || !list) { + if (newObjects){ @@ -605,15 +656,15 @@ + } + + /* Hook them into the free list */ -+ for (i = 0; i < nObjects - 1; i++) { ++ for (i = 0; i < n_obj - 1; i++) { + newObjects[i].siblings.next = + (struct ylist_head *)(&newObjects[i + 1]); + } + -+ newObjects[nObjects - 1].siblings.next = (void *)allocator->freeObjects; ++ newObjects[n_obj - 1].siblings.next = (void *)allocator->freeObjects; + allocator->freeObjects = newObjects; -+ allocator->nFreeObjects += nObjects; -+ allocator->nObjectsCreated += nObjects; ++ allocator->nFreeObjects += n_obj; ++ allocator->n_objCreated += n_obj; + + /* Now add this bunch of Objects to a list for freeing up. */ + @@ -624,9 +675,9 @@ + return YAFFS_OK; +} + -+yaffs_Object *yaffs_AllocateRawObject(yaffs_Device *dev) ++yaffs_obj_t *yaffs_alloc_raw_obj(yaffs_dev_t *dev) +{ -+ yaffs_Object *obj = NULL; ++ yaffs_obj_t *obj = NULL; + yaffs_Allocator *allocator = dev->allocator; + + if(!allocator) { @@ -636,12 +687,12 @@ + + /* If there are none left make more */ + if (!allocator->freeObjects) -+ yaffs_CreateFreeObjects(dev, YAFFS_ALLOCATION_NOBJECTS); ++ yaffs_create_free_objs(dev, YAFFS_ALLOCATION_NOBJECTS); + + if (allocator->freeObjects) { + obj = allocator->freeObjects; + allocator->freeObjects = -+ (yaffs_Object *) (allocator->freeObjects->siblings.next); ++ (yaffs_obj_t *) (allocator->freeObjects->siblings.next); + allocator->nFreeObjects--; + } + @@ -649,7 +700,7 @@ +} + + -+void yaffs_FreeRawObject(yaffs_Device *dev, yaffs_Object *obj) ++void yaffs_free_raw_obj(yaffs_dev_t *dev, yaffs_obj_t *obj) +{ + + yaffs_Allocator *allocator = dev->allocator; @@ -664,11 +715,11 @@ + } +} + -+void yaffs_DeinitialiseRawTnodesAndObjects(yaffs_Device *dev) ++void yaffs_deinit_raw_tnodes_and_objs(yaffs_dev_t *dev) +{ + if(dev->allocator){ -+ yaffs_DeinitialiseRawTnodes(dev); -+ yaffs_DeinitialiseRawObjects(dev); ++ yaffs_deinit_raw_tnodes(dev); ++ yaffs_deinit_raw_objs(dev); + + YFREE(dev->allocator); + dev->allocator=NULL; @@ -676,7 +727,7 @@ + YBUG(); +} + -+void yaffs_InitialiseRawTnodesAndObjects(yaffs_Device *dev) ++void yaffs_init_raw_tnodes_and_objs(yaffs_dev_t *dev) +{ + yaffs_Allocator *allocator; + @@ -684,8 +735,8 @@ + allocator = YMALLOC(sizeof(yaffs_Allocator)); + if(allocator){ + dev->allocator = allocator; -+ yaffs_InitialiseRawTnodes(dev); -+ yaffs_InitialiseRawObjects(dev); ++ yaffs_init_raw_tnodes(dev); ++ yaffs_init_raw_objs(dev); + } + } else + YBUG(); @@ -693,8 +744,9 @@ + + +#endif ---- /dev/null -+++ b/fs/yaffs2/yaffs_allocator.h +diff -Nrup linux-2.6.36-rc8/fs/yaffs2/yaffs_allocator.h linux-2.6.36-rc8.new/fs/yaffs2/yaffs_allocator.h +--- linux-2.6.36-rc8/fs/yaffs2/yaffs_allocator.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.36-rc8.new/fs/yaffs2/yaffs_allocator.h 2010-10-20 13:28:16.058000294 +0300 @@ -0,0 +1,30 @@ +/* + * YAFFS: Yet another Flash File System . A NAND-flash specific file system. @@ -716,18 +768,19 @@ + +#include "yaffs_guts.h" + -+void yaffs_InitialiseRawTnodesAndObjects(yaffs_Device *dev); -+void yaffs_DeinitialiseRawTnodesAndObjects(yaffs_Device *dev); ++void yaffs_init_raw_tnodes_and_objs(yaffs_dev_t *dev); ++void yaffs_deinit_raw_tnodes_and_objs(yaffs_dev_t *dev); + -+yaffs_Tnode *yaffs_AllocateRawTnode(yaffs_Device *dev); -+void yaffs_FreeRawTnode(yaffs_Device *dev, yaffs_Tnode *tn); ++yaffs_tnode_t *yaffs_alloc_raw_tnode(yaffs_dev_t *dev); ++void yaffs_free_raw_tnode(yaffs_dev_t *dev, yaffs_tnode_t *tn); + -+yaffs_Object *yaffs_AllocateRawObject(yaffs_Device *dev); -+void yaffs_FreeRawObject(yaffs_Device *dev, yaffs_Object *obj); ++yaffs_obj_t *yaffs_alloc_raw_obj(yaffs_dev_t *dev); ++void yaffs_free_raw_obj(yaffs_dev_t *dev, yaffs_obj_t *obj); + +#endif ---- /dev/null -+++ b/fs/yaffs2/yaffs_bitmap.c +diff -Nrup linux-2.6.36-rc8/fs/yaffs2/yaffs_bitmap.c linux-2.6.36-rc8.new/fs/yaffs2/yaffs_bitmap.c +--- linux-2.6.36-rc8/fs/yaffs2/yaffs_bitmap.c 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.36-rc8.new/fs/yaffs2/yaffs_bitmap.c 2010-10-20 13:28:15.998000294 +0300 @@ -0,0 +1,105 @@ +/* + * YAFFS: Yet Another Flash File System. A NAND-flash specific file system. @@ -748,22 +801,22 @@ + * Chunk bitmap manipulations + */ + -+static Y_INLINE __u8 *yaffs_BlockBits(yaffs_Device *dev, int blk) ++static Y_INLINE __u8 *yaffs_BlockBits(yaffs_dev_t *dev, int blk) +{ -+ if (blk < dev->internalStartBlock || blk > dev->internalEndBlock) { ++ if (blk < dev->internal_start_block || blk > dev->internal_end_block) { + T(YAFFS_TRACE_ERROR, + (TSTR("**>> yaffs: BlockBits block %d is not valid" TENDSTR), + blk)); + YBUG(); + } -+ return dev->chunkBits + -+ (dev->chunkBitmapStride * (blk - dev->internalStartBlock)); ++ return dev->chunk_bits + ++ (dev->chunk_bit_stride * (blk - dev->internal_start_block)); +} + -+void yaffs_VerifyChunkBitId(yaffs_Device *dev, int blk, int chunk) ++void yaffs_verify_chunk_bit_id(yaffs_dev_t *dev, int blk, int chunk) +{ -+ if (blk < dev->internalStartBlock || blk > dev->internalEndBlock || -+ chunk < 0 || chunk >= dev->param.nChunksPerBlock) { ++ if (blk < dev->internal_start_block || blk > dev->internal_end_block || ++ chunk < 0 || chunk >= dev->param.chunks_per_block) { + T(YAFFS_TRACE_ERROR, + (TSTR("**>> yaffs: Chunk Id (%d:%d) invalid"TENDSTR), + blk, chunk)); @@ -771,44 +824,44 @@ + } +} + -+void yaffs_ClearChunkBits(yaffs_Device *dev, int blk) ++void yaffs_clear_chunk_bits(yaffs_dev_t *dev, int blk) +{ + __u8 *blkBits = yaffs_BlockBits(dev, blk); + -+ memset(blkBits, 0, dev->chunkBitmapStride); ++ memset(blkBits, 0, dev->chunk_bit_stride); +} + -+void yaffs_ClearChunkBit(yaffs_Device *dev, int blk, int chunk) ++void yaffs_clear_chunk_bit(yaffs_dev_t *dev, int blk, int chunk) +{ + __u8 *blkBits = yaffs_BlockBits(dev, blk); + -+ yaffs_VerifyChunkBitId(dev, blk, chunk); ++ yaffs_verify_chunk_bit_id(dev, blk, chunk); + + blkBits[chunk / 8] &= ~(1 << (chunk & 7)); +} + -+void yaffs_SetChunkBit(yaffs_Device *dev, int blk, int chunk) ++void yaffs_set_chunk_bit(yaffs_dev_t *dev, int blk, int chunk) +{ + __u8 *blkBits = yaffs_BlockBits(dev, blk); + -+ yaffs_VerifyChunkBitId(dev, blk, chunk); ++ yaffs_verify_chunk_bit_id(dev, blk, chunk); + + blkBits[chunk / 8] |= (1 << (chunk & 7)); +} + -+int yaffs_CheckChunkBit(yaffs_Device *dev, int blk, int chunk) ++int yaffs_check_chunk_bit(yaffs_dev_t *dev, int blk, int chunk) +{ + __u8 *blkBits = yaffs_BlockBits(dev, blk); -+ yaffs_VerifyChunkBitId(dev, blk, chunk); ++ yaffs_verify_chunk_bit_id(dev, blk, chunk); + + return (blkBits[chunk / 8] & (1 << (chunk & 7))) ? 1 : 0; +} + -+int yaffs_StillSomeChunkBits(yaffs_Device *dev, int blk) ++int yaffs_still_some_chunks(yaffs_dev_t *dev, int blk) +{ + __u8 *blkBits = yaffs_BlockBits(dev, blk); + int i; -+ for (i = 0; i < dev->chunkBitmapStride; i++) { ++ for (i = 0; i < dev->chunk_bit_stride; i++) { + if (*blkBits) + return 1; + blkBits++; @@ -816,12 +869,12 @@ + return 0; +} + -+int yaffs_CountChunkBits(yaffs_Device *dev, int blk) ++int yaffs_count_chunk_bits(yaffs_dev_t *dev, int blk) +{ + __u8 *blkBits = yaffs_BlockBits(dev, blk); + int i; + int n = 0; -+ for (i = 0; i < dev->chunkBitmapStride; i++) { ++ for (i = 0; i < dev->chunk_bit_stride; i++) { + __u8 x = *blkBits; + while (x) { + if (x & 1) @@ -834,8 +887,9 @@ + return n; +} + ---- /dev/null -+++ b/fs/yaffs2/yaffs_bitmap.h +diff -Nrup linux-2.6.36-rc8/fs/yaffs2/yaffs_bitmap.h linux-2.6.36-rc8.new/fs/yaffs2/yaffs_bitmap.h +--- linux-2.6.36-rc8/fs/yaffs2/yaffs_bitmap.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.36-rc8.new/fs/yaffs2/yaffs_bitmap.h 2010-10-20 13:28:16.058000294 +0300 @@ -0,0 +1,31 @@ +/* + * YAFFS: Yet Another Flash File System. A NAND-flash specific file system. @@ -859,17 +913,18 @@ + +#include "yaffs_guts.h" + -+void yaffs_VerifyChunkBitId(yaffs_Device *dev, int blk, int chunk); -+void yaffs_ClearChunkBits(yaffs_Device *dev, int blk); -+void yaffs_ClearChunkBit(yaffs_Device *dev, int blk, int chunk); -+void yaffs_SetChunkBit(yaffs_Device *dev, int blk, int chunk); -+int yaffs_CheckChunkBit(yaffs_Device *dev, int blk, int chunk); -+int yaffs_StillSomeChunkBits(yaffs_Device *dev, int blk); -+int yaffs_CountChunkBits(yaffs_Device *dev, int blk); ++void yaffs_verify_chunk_bit_id(yaffs_dev_t *dev, int blk, int chunk); ++void yaffs_clear_chunk_bits(yaffs_dev_t *dev, int blk); ++void yaffs_clear_chunk_bit(yaffs_dev_t *dev, int blk, int chunk); ++void yaffs_set_chunk_bit(yaffs_dev_t *dev, int blk, int chunk); ++int yaffs_check_chunk_bit(yaffs_dev_t *dev, int blk, int chunk); ++int yaffs_still_some_chunks(yaffs_dev_t *dev, int blk); ++int yaffs_count_chunk_bits(yaffs_dev_t *dev, int blk); + +#endif ---- a/fs/yaffs2/yaffs_checkptrw.c -+++ b/fs/yaffs2/yaffs_checkptrw.c +diff -Nrup linux-2.6.36-rc8/fs/yaffs2/yaffs_checkptrw.c linux-2.6.36-rc8.new/fs/yaffs2/yaffs_checkptrw.c +--- linux-2.6.36-rc8/fs/yaffs2/yaffs_checkptrw.c 2010-10-20 13:17:58.941000294 +0300 ++++ linux-2.6.36-rc8.new/fs/yaffs2/yaffs_checkptrw.c 2010-10-20 13:28:15.999000294 +0300 @@ -1,7 +1,7 @@ /* * YAFFS: Yet Another Flash File System. A NAND-flash specific file system. @@ -891,300 +946,536 @@ #include "yaffs_getblockinfo.h" -static int yaffs_CheckpointSpaceOk(yaffs_Device *dev) -+static int yaffs2_CheckpointSpaceOk(yaffs_Device *dev) ++static int yaffs2_checkpt_space_ok(yaffs_dev_t *dev) { - int blocksAvailable = dev->nErasedBlocks - dev->nReservedBlocks; -+ int blocksAvailable = dev->nErasedBlocks - dev->param.nReservedBlocks; ++ int blocksAvailable = dev->n_erased_blocks - dev->param.n_reserved_blocks; T(YAFFS_TRACE_CHECKPOINT, (TSTR("checkpt blocks available = %d" TENDSTR), -@@ -30,11 +26,11 @@ static int yaffs_CheckpointSpaceOk(yaffs +@@ -30,53 +26,56 @@ static int yaffs_CheckpointSpaceOk(yaffs } -static int yaffs_CheckpointErase(yaffs_Device *dev) -+static int yaffs2_CheckpointErase(yaffs_Device *dev) ++static int yaffs_checkpt_erase(yaffs_dev_t *dev) { int i; - if (!dev->eraseBlockInNAND) -+ if (!dev->param.eraseBlockInNAND) ++ if (!dev->param.erase_fn) return 0; T(YAFFS_TRACE_CHECKPOINT, (TSTR("checking blocks %d to %d"TENDSTR), - dev->internalStartBlock, dev->internalEndBlock)); -@@ -43,12 +39,15 @@ static int yaffs_CheckpointErase(yaffs_D - yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, i); - if (bi->blockState == YAFFS_BLOCK_STATE_CHECKPOINT) { +- dev->internalStartBlock, dev->internalEndBlock)); ++ dev->internal_start_block, dev->internal_end_block)); + +- for (i = dev->internalStartBlock; i <= dev->internalEndBlock; i++) { +- yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, i); +- if (bi->blockState == YAFFS_BLOCK_STATE_CHECKPOINT) { ++ for (i = dev->internal_start_block; i <= dev->internal_end_block; i++) { ++ yaffs_block_info_t *bi = yaffs_get_block_info(dev, i); ++ if (bi->block_state == YAFFS_BLOCK_STATE_CHECKPOINT) { T(YAFFS_TRACE_CHECKPOINT, (TSTR("erasing checkpt block %d"TENDSTR), i)); - if (dev->eraseBlockInNAND(dev, i - dev->blockOffset /* realign */)) { +- bi->blockState = YAFFS_BLOCK_STATE_EMPTY; +- dev->nErasedBlocks++; +- dev->nFreeChunks += dev->nChunksPerBlock; + -+ dev->nBlockErasures++; ++ dev->n_erasures++; + -+ if (dev->param.eraseBlockInNAND(dev, i - dev->blockOffset /* realign */)) { - bi->blockState = YAFFS_BLOCK_STATE_EMPTY; - dev->nErasedBlocks++; -- dev->nFreeChunks += dev->nChunksPerBlock; -+ dev->nFreeChunks += dev->param.nChunksPerBlock; ++ if (dev->param.erase_fn(dev, i - dev->block_offset /* realign */)) { ++ bi->block_state = YAFFS_BLOCK_STATE_EMPTY; ++ dev->n_erased_blocks++; ++ dev->n_free_chunks += dev->param.chunks_per_block; } else { - dev->markNANDBlockBad(dev, i); -+ dev->param.markNANDBlockBad(dev, i); - bi->blockState = YAFFS_BLOCK_STATE_DEAD; +- bi->blockState = YAFFS_BLOCK_STATE_DEAD; ++ dev->param.bad_block_fn(dev, i); ++ bi->block_state = YAFFS_BLOCK_STATE_DEAD; } } -@@ -60,13 +59,13 @@ static int yaffs_CheckpointErase(yaffs_D + } + +- dev->blocksInCheckpoint = 0; ++ dev->blocks_in_checkpt = 0; + + return 1; } -static void yaffs_CheckpointFindNextErasedBlock(yaffs_Device *dev) -+static void yaffs2_CheckpointFindNextErasedBlock(yaffs_Device *dev) ++static void yaffs2_checkpt_find_erased_block(yaffs_dev_t *dev) { int i; - int blocksAvailable = dev->nErasedBlocks - dev->nReservedBlocks; -+ int blocksAvailable = dev->nErasedBlocks - dev->param.nReservedBlocks; ++ int blocksAvailable = dev->n_erased_blocks - dev->param.n_reserved_blocks; T(YAFFS_TRACE_CHECKPOINT, (TSTR("allocating checkpt block: erased %d reserved %d avail %d next %d "TENDSTR), - dev->nErasedBlocks, dev->nReservedBlocks, blocksAvailable, dev->checkpointNextBlock)); -+ dev->nErasedBlocks, dev->param.nReservedBlocks, blocksAvailable, dev->checkpointNextBlock)); ++ dev->n_erased_blocks, dev->param.n_reserved_blocks, blocksAvailable, dev->checkpt_next_block)); + +- if (dev->checkpointNextBlock >= 0 && +- dev->checkpointNextBlock <= dev->internalEndBlock && ++ if (dev->checkpt_next_block >= 0 && ++ dev->checkpt_next_block <= dev->internal_end_block && + blocksAvailable > 0) { + +- for (i = dev->checkpointNextBlock; i <= dev->internalEndBlock; i++) { +- yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, i); +- if (bi->blockState == YAFFS_BLOCK_STATE_EMPTY) { +- dev->checkpointNextBlock = i + 1; +- dev->checkpointCurrentBlock = i; ++ for (i = dev->checkpt_next_block; i <= dev->internal_end_block; i++) { ++ yaffs_block_info_t *bi = yaffs_get_block_info(dev, i); ++ if (bi->block_state == YAFFS_BLOCK_STATE_EMPTY) { ++ dev->checkpt_next_block = i + 1; ++ dev->checkpt_cur_block = i; + T(YAFFS_TRACE_CHECKPOINT, (TSTR("allocating checkpt block %d"TENDSTR), i)); + return; + } +@@ -84,34 +83,34 @@ static void yaffs_CheckpointFindNextEras + } + T(YAFFS_TRACE_CHECKPOINT, (TSTR("out of checkpt blocks"TENDSTR))); - if (dev->checkpointNextBlock >= 0 && - dev->checkpointNextBlock <= dev->internalEndBlock && -@@ -88,7 +87,7 @@ static void yaffs_CheckpointFindNextEras - dev->checkpointCurrentBlock = -1; +- dev->checkpointNextBlock = -1; +- dev->checkpointCurrentBlock = -1; ++ dev->checkpt_next_block = -1; ++ dev->checkpt_cur_block = -1; } -static void yaffs_CheckpointFindNextCheckpointBlock(yaffs_Device *dev) -+static void yaffs2_CheckpointFindNextCheckpointBlock(yaffs_Device *dev) ++static void yaffs2_checkpt_find_block(yaffs_dev_t *dev) { int i; - yaffs_ExtendedTags tags; -@@ -98,10 +97,10 @@ static void yaffs_CheckpointFindNextChec +- yaffs_ExtendedTags tags; ++ yaffs_ext_tags tags; + + T(YAFFS_TRACE_CHECKPOINT, (TSTR("find next checkpt block: start: blocks %d next %d" TENDSTR), +- dev->blocksInCheckpoint, dev->checkpointNextBlock)); ++ dev->blocks_in_checkpt, dev->checkpt_next_block)); - if (dev->blocksInCheckpoint < dev->checkpointMaxBlocks) - for (i = dev->checkpointNextBlock; i <= dev->internalEndBlock; i++) { +- if (dev->blocksInCheckpoint < dev->checkpointMaxBlocks) +- for (i = dev->checkpointNextBlock; i <= dev->internalEndBlock; i++) { - int chunk = i * dev->nChunksPerBlock; -+ int chunk = i * dev->param.nChunksPerBlock; - int realignedChunk = chunk - dev->chunkOffset; +- int realignedChunk = chunk - dev->chunkOffset; ++ if (dev->blocks_in_checkpt < dev->checkpt_max_blocks) ++ for (i = dev->checkpt_next_block; i <= dev->internal_end_block; i++) { ++ int chunk = i * dev->param.chunks_per_block; ++ int realignedChunk = chunk - dev->chunk_offset; - dev->readChunkWithTagsFromNAND(dev, realignedChunk, -+ dev->param.readChunkWithTagsFromNAND(dev, realignedChunk, ++ dev->param.read_chunk_tags_fn(dev, realignedChunk, NULL, &tags); T(YAFFS_TRACE_CHECKPOINT, (TSTR("find next checkpt block: search: block %d oid %d seq %d eccr %d" TENDSTR), - i, tags.objectId, tags.sequenceNumber, tags.eccResult)); -@@ -124,29 +123,29 @@ static void yaffs_CheckpointFindNextChec +- i, tags.objectId, tags.sequenceNumber, tags.eccResult)); ++ i, tags.obj_id, tags.seq_number, tags.ecc_result)); + +- if (tags.sequenceNumber == YAFFS_SEQUENCE_CHECKPOINT_DATA) { ++ if (tags.seq_number == YAFFS_SEQUENCE_CHECKPOINT_DATA) { + /* Right kind of block */ +- dev->checkpointNextBlock = tags.objectId; +- dev->checkpointCurrentBlock = i; +- dev->checkpointBlockList[dev->blocksInCheckpoint] = i; +- dev->blocksInCheckpoint++; ++ dev->checkpt_next_block = tags.obj_id; ++ dev->checkpt_cur_block = i; ++ dev->checkpt_block_list[dev->blocks_in_checkpt] = i; ++ dev->blocks_in_checkpt++; + T(YAFFS_TRACE_CHECKPOINT, (TSTR("found checkpt block %d"TENDSTR), i)); + return; + } +@@ -119,122 +118,127 @@ static void yaffs_CheckpointFindNextChec + + T(YAFFS_TRACE_CHECKPOINT, (TSTR("found no more checkpt blocks"TENDSTR))); + +- dev->checkpointNextBlock = -1; +- dev->checkpointCurrentBlock = -1; ++ dev->checkpt_next_block = -1; ++ dev->checkpt_cur_block = -1; } -int yaffs_CheckpointOpen(yaffs_Device *dev, int forWriting) -+int yaffs2_CheckpointOpen(yaffs_Device *dev, int forWriting) ++int yaffs2_checkpt_open(yaffs_dev_t *dev, int forWriting) { + -+ dev->checkpointOpenForWrite = forWriting; ++ dev->checkpt_open_write = forWriting; + /* Got the functions we need? */ - if (!dev->writeChunkWithTagsToNAND || - !dev->readChunkWithTagsFromNAND || - !dev->eraseBlockInNAND || - !dev->markNANDBlockBad) -+ if (!dev->param.writeChunkWithTagsToNAND || -+ !dev->param.readChunkWithTagsFromNAND || -+ !dev->param.eraseBlockInNAND || -+ !dev->param.markNANDBlockBad) ++ if (!dev->param.write_chunk_tags_fn || ++ !dev->param.read_chunk_tags_fn || ++ !dev->param.erase_fn || ++ !dev->param.bad_block_fn) return 0; - if (forWriting && !yaffs_CheckpointSpaceOk(dev)) -+ if (forWriting && !yaffs2_CheckpointSpaceOk(dev)) ++ if (forWriting && !yaffs2_checkpt_space_ok(dev)) return 0; - if (!dev->checkpointBuffer) +- if (!dev->checkpointBuffer) - dev->checkpointBuffer = YMALLOC_DMA(dev->totalBytesPerChunk); -+ dev->checkpointBuffer = YMALLOC_DMA(dev->param.totalBytesPerChunk); - if (!dev->checkpointBuffer) +- if (!dev->checkpointBuffer) ++ if (!dev->checkpt_buffer) ++ dev->checkpt_buffer = YMALLOC_DMA(dev->param.total_bytes_per_chunk); ++ if (!dev->checkpt_buffer) return 0; - dev->checkpointPageSequence = 0; +- dev->checkpointPageSequence = 0; - - dev->checkpointOpenForWrite = forWriting; - - dev->checkpointByteCount = 0; - dev->checkpointSum = 0; - dev->checkpointXor = 0; -@@ -158,7 +157,7 @@ int yaffs_CheckpointOpen(yaffs_Device *d +- dev->checkpointByteCount = 0; +- dev->checkpointSum = 0; +- dev->checkpointXor = 0; +- dev->checkpointCurrentBlock = -1; +- dev->checkpointCurrentChunk = -1; +- dev->checkpointNextBlock = dev->internalStartBlock; ++ dev->checkpt_page_seq = 0; ++ dev->checkpt_byte_count = 0; ++ dev->checkpt_sum = 0; ++ dev->checkpt_xor = 0; ++ dev->checkpt_cur_block = -1; ++ dev->checkpt_cur_chunk = -1; ++ dev->checkpt_next_block = dev->internal_start_block; + + /* Erase all the blocks in the checkpoint area */ if (forWriting) { - memset(dev->checkpointBuffer, 0, dev->nDataBytesPerChunk); - dev->checkpointByteOffset = 0; +- memset(dev->checkpointBuffer, 0, dev->nDataBytesPerChunk); +- dev->checkpointByteOffset = 0; - return yaffs_CheckpointErase(dev); -+ return yaffs2_CheckpointErase(dev); ++ memset(dev->checkpt_buffer, 0, dev->data_bytes_per_chunk); ++ dev->checkpt_byte_offs = 0; ++ return yaffs_checkpt_erase(dev); } else { int i; /* Set to a value that will kick off a read */ -@@ -168,6 +167,9 @@ int yaffs_CheckpointOpen(yaffs_Device *d - dev->blocksInCheckpoint = 0; - dev->checkpointMaxBlocks = (dev->internalEndBlock - dev->internalStartBlock)/16 + 2; - dev->checkpointBlockList = YMALLOC(sizeof(int) * dev->checkpointMaxBlocks); -+ if(!dev->checkpointBlockList) +- dev->checkpointByteOffset = dev->nDataBytesPerChunk; ++ dev->checkpt_byte_offs = dev->data_bytes_per_chunk; + /* A checkpoint block list of 1 checkpoint block per 16 block is (hopefully) + * going to be way more than we need */ +- dev->blocksInCheckpoint = 0; +- dev->checkpointMaxBlocks = (dev->internalEndBlock - dev->internalStartBlock)/16 + 2; +- dev->checkpointBlockList = YMALLOC(sizeof(int) * dev->checkpointMaxBlocks); +- for (i = 0; i < dev->checkpointMaxBlocks; i++) +- dev->checkpointBlockList[i] = -1; ++ dev->blocks_in_checkpt = 0; ++ dev->checkpt_max_blocks = (dev->internal_end_block - dev->internal_start_block)/16 + 2; ++ dev->checkpt_block_list = YMALLOC(sizeof(int) * dev->checkpt_max_blocks); ++ if(!dev->checkpt_block_list) + return 0; + - for (i = 0; i < dev->checkpointMaxBlocks; i++) - dev->checkpointBlockList[i] = -1; ++ for (i = 0; i < dev->checkpt_max_blocks; i++) ++ dev->checkpt_block_list[i] = -1; } -@@ -175,7 +177,7 @@ int yaffs_CheckpointOpen(yaffs_Device *d + return 1; } -int yaffs_GetCheckpointSum(yaffs_Device *dev, __u32 *sum) -+int yaffs2_GetCheckpointSum(yaffs_Device *dev, __u32 *sum) ++int yaffs2_get_checkpt_sum(yaffs_dev_t *dev, __u32 *sum) { __u32 compositeSum; - compositeSum = (dev->checkpointSum << 8) | (dev->checkpointXor & 0xFF); -@@ -183,7 +185,7 @@ int yaffs_GetCheckpointSum(yaffs_Device +- compositeSum = (dev->checkpointSum << 8) | (dev->checkpointXor & 0xFF); ++ compositeSum = (dev->checkpt_sum << 8) | (dev->checkpt_xor & 0xFF); + *sum = compositeSum; return 1; } -static int yaffs_CheckpointFlushBuffer(yaffs_Device *dev) -+static int yaffs2_CheckpointFlushBuffer(yaffs_Device *dev) ++static int yaffs2_checkpt_flush_buffer(yaffs_dev_t *dev) { int chunk; int realignedChunk; -@@ -191,7 +193,7 @@ static int yaffs_CheckpointFlushBuffer(y - yaffs_ExtendedTags tags; - if (dev->checkpointCurrentBlock < 0) { +- yaffs_ExtendedTags tags; ++ yaffs_ext_tags tags; + +- if (dev->checkpointCurrentBlock < 0) { - yaffs_CheckpointFindNextErasedBlock(dev); -+ yaffs2_CheckpointFindNextErasedBlock(dev); - dev->checkpointCurrentChunk = 0; +- dev->checkpointCurrentChunk = 0; ++ if (dev->checkpt_cur_block < 0) { ++ yaffs2_checkpt_find_erased_block(dev); ++ dev->checkpt_cur_chunk = 0; } -@@ -211,7 +213,7 @@ static int yaffs_CheckpointFlushBuffer(y - dev->blocksInCheckpoint++; +- if (dev->checkpointCurrentBlock < 0) ++ if (dev->checkpt_cur_block < 0) + return 0; + +- tags.chunkDeleted = 0; +- tags.objectId = dev->checkpointNextBlock; /* Hint to next place to look */ +- tags.chunkId = dev->checkpointPageSequence + 1; +- tags.sequenceNumber = YAFFS_SEQUENCE_CHECKPOINT_DATA; +- tags.byteCount = dev->nDataBytesPerChunk; +- if (dev->checkpointCurrentChunk == 0) { ++ tags.is_deleted = 0; ++ tags.obj_id = dev->checkpt_next_block; /* Hint to next place to look */ ++ tags.chunk_id = dev->checkpt_page_seq + 1; ++ tags.seq_number = YAFFS_SEQUENCE_CHECKPOINT_DATA; ++ tags.n_bytes = dev->data_bytes_per_chunk; ++ if (dev->checkpt_cur_chunk == 0) { + /* First chunk we write for the block? Set block state to + checkpoint */ +- yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, dev->checkpointCurrentBlock); +- bi->blockState = YAFFS_BLOCK_STATE_CHECKPOINT; +- dev->blocksInCheckpoint++; ++ yaffs_block_info_t *bi = yaffs_get_block_info(dev, dev->checkpt_cur_block); ++ bi->block_state = YAFFS_BLOCK_STATE_CHECKPOINT; ++ dev->blocks_in_checkpt++; } - chunk = dev->checkpointCurrentBlock * dev->nChunksPerBlock + dev->checkpointCurrentChunk; -+ chunk = dev->checkpointCurrentBlock * dev->param.nChunksPerBlock + dev->checkpointCurrentChunk; ++ chunk = dev->checkpt_cur_block * dev->param.chunks_per_block + dev->checkpt_cur_chunk; T(YAFFS_TRACE_CHECKPOINT, (TSTR("checkpoint wite buffer nand %d(%d:%d) objid %d chId %d" TENDSTR), -@@ -219,12 +221,14 @@ static int yaffs_CheckpointFlushBuffer(y +- chunk, dev->checkpointCurrentBlock, dev->checkpointCurrentChunk, tags.objectId, tags.chunkId)); ++ chunk, dev->checkpt_cur_block, dev->checkpt_cur_chunk, tags.obj_id, tags.chunk_id)); - realignedChunk = chunk - dev->chunkOffset; +- realignedChunk = chunk - dev->chunkOffset; ++ realignedChunk = chunk - dev->chunk_offset; - dev->writeChunkWithTagsToNAND(dev, realignedChunk, -+ dev->nPageWrites++; -+ -+ dev->param.writeChunkWithTagsToNAND(dev, realignedChunk, - dev->checkpointBuffer, &tags); - dev->checkpointByteOffset = 0; - dev->checkpointPageSequence++; - dev->checkpointCurrentChunk++; +- dev->checkpointBuffer, &tags); +- dev->checkpointByteOffset = 0; +- dev->checkpointPageSequence++; +- dev->checkpointCurrentChunk++; - if (dev->checkpointCurrentChunk >= dev->nChunksPerBlock) { -+ if (dev->checkpointCurrentChunk >= dev->param.nChunksPerBlock) { - dev->checkpointCurrentChunk = 0; - dev->checkpointCurrentBlock = -1; +- dev->checkpointCurrentChunk = 0; +- dev->checkpointCurrentBlock = -1; ++ dev->n_page_writes++; ++ ++ dev->param.write_chunk_tags_fn(dev, realignedChunk, ++ dev->checkpt_buffer, &tags); ++ dev->checkpt_byte_offs = 0; ++ dev->checkpt_page_seq++; ++ dev->checkpt_cur_chunk++; ++ if (dev->checkpt_cur_chunk >= dev->param.chunks_per_block) { ++ dev->checkpt_cur_chunk = 0; ++ dev->checkpt_cur_block = -1; } -@@ -234,7 +238,7 @@ static int yaffs_CheckpointFlushBuffer(y +- memset(dev->checkpointBuffer, 0, dev->nDataBytesPerChunk); ++ memset(dev->checkpt_buffer, 0, dev->data_bytes_per_chunk); + + return 1; } -int yaffs_CheckpointWrite(yaffs_Device *dev, const void *data, int nBytes) -+int yaffs2_CheckpointWrite(yaffs_Device *dev, const void *data, int nBytes) ++int yaffs2_checkpt_wr(yaffs_dev_t *dev, const void *data, int n_bytes) { int i = 0; int ok = 1; -@@ -263,13 +267,13 @@ int yaffs_CheckpointWrite(yaffs_Device * +@@ -244,36 +248,36 @@ int yaffs_CheckpointWrite(yaffs_Device * + - if (dev->checkpointByteOffset < 0 || - dev->checkpointByteOffset >= dev->nDataBytesPerChunk) + +- if (!dev->checkpointBuffer) ++ if (!dev->checkpt_buffer) + return 0; + +- if (!dev->checkpointOpenForWrite) ++ if (!dev->checkpt_open_write) + return -1; + +- while (i < nBytes && ok) { +- dev->checkpointBuffer[dev->checkpointByteOffset] = *dataBytes; +- dev->checkpointSum += *dataBytes; +- dev->checkpointXor ^= *dataBytes; ++ while (i < n_bytes && ok) { ++ dev->checkpt_buffer[dev->checkpt_byte_offs] = *dataBytes; ++ dev->checkpt_sum += *dataBytes; ++ dev->checkpt_xor ^= *dataBytes; + +- dev->checkpointByteOffset++; ++ dev->checkpt_byte_offs++; + i++; + dataBytes++; +- dev->checkpointByteCount++; ++ dev->checkpt_byte_count++; + + +- if (dev->checkpointByteOffset < 0 || +- dev->checkpointByteOffset >= dev->nDataBytesPerChunk) - ok = yaffs_CheckpointFlushBuffer(dev); -+ ok = yaffs2_CheckpointFlushBuffer(dev); ++ if (dev->checkpt_byte_offs < 0 || ++ dev->checkpt_byte_offs >= dev->data_bytes_per_chunk) ++ ok = yaffs2_checkpt_flush_buffer(dev); } return i; } -int yaffs_CheckpointRead(yaffs_Device *dev, void *data, int nBytes) -+int yaffs2_CheckpointRead(yaffs_Device *dev, void *data, int nBytes) ++int yaffs2_checkpt_rd(yaffs_dev_t *dev, void *data, int n_bytes) { int i = 0; int ok = 1; -@@ -294,7 +298,7 @@ int yaffs_CheckpointRead(yaffs_Device *d - dev->checkpointByteOffset >= dev->nDataBytesPerChunk) { +- yaffs_ExtendedTags tags; ++ yaffs_ext_tags tags; + + + int chunk; +@@ -281,113 +285,116 @@ int yaffs_CheckpointRead(yaffs_Device *d + + __u8 *dataBytes = (__u8 *)data; + +- if (!dev->checkpointBuffer) ++ if (!dev->checkpt_buffer) + return 0; + +- if (dev->checkpointOpenForWrite) ++ if (dev->checkpt_open_write) + return -1; - if (dev->checkpointCurrentBlock < 0) { +- while (i < nBytes && ok) { ++ while (i < n_bytes && ok) { + + +- if (dev->checkpointByteOffset < 0 || +- dev->checkpointByteOffset >= dev->nDataBytesPerChunk) { ++ if (dev->checkpt_byte_offs < 0 || ++ dev->checkpt_byte_offs >= dev->data_bytes_per_chunk) { + +- if (dev->checkpointCurrentBlock < 0) { - yaffs_CheckpointFindNextCheckpointBlock(dev); -+ yaffs2_CheckpointFindNextCheckpointBlock(dev); - dev->checkpointCurrentChunk = 0; +- dev->checkpointCurrentChunk = 0; ++ if (dev->checkpt_cur_block < 0) { ++ yaffs2_checkpt_find_block(dev); ++ dev->checkpt_cur_chunk = 0; } -@@ -302,14 +306,16 @@ int yaffs_CheckpointRead(yaffs_Device *d +- if (dev->checkpointCurrentBlock < 0) ++ if (dev->checkpt_cur_block < 0) ok = 0; else { - chunk = dev->checkpointCurrentBlock * +- chunk = dev->checkpointCurrentBlock * - dev->nChunksPerBlock + -+ dev->param.nChunksPerBlock + - dev->checkpointCurrentChunk; - - realignedChunk = chunk - dev->chunkOffset; +- dev->checkpointCurrentChunk; +- +- realignedChunk = chunk - dev->chunkOffset; ++ chunk = dev->checkpt_cur_block * ++ dev->param.chunks_per_block + ++ dev->checkpt_cur_chunk; ++ ++ realignedChunk = chunk - dev->chunk_offset; + -+ dev->nPageReads++; ++ dev->n_page_reads++; /* read in the next chunk */ /* printf("read checkpoint page %d\n",dev->checkpointPage); */ - dev->readChunkWithTagsFromNAND(dev, -+ dev->param.readChunkWithTagsFromNAND(dev, ++ dev->param.read_chunk_tags_fn(dev, realignedChunk, - dev->checkpointBuffer, +- dev->checkpointBuffer, ++ dev->checkpt_buffer, &tags); -@@ -323,7 +329,7 @@ int yaffs_CheckpointRead(yaffs_Device *d - dev->checkpointPageSequence++; - dev->checkpointCurrentChunk++; + +- if (tags.chunkId != (dev->checkpointPageSequence + 1) || +- tags.eccResult > YAFFS_ECC_RESULT_FIXED || +- tags.sequenceNumber != YAFFS_SEQUENCE_CHECKPOINT_DATA) ++ if (tags.chunk_id != (dev->checkpt_page_seq + 1) || ++ tags.ecc_result > YAFFS_ECC_RESULT_FIXED || ++ tags.seq_number != YAFFS_SEQUENCE_CHECKPOINT_DATA) + ok = 0; + +- dev->checkpointByteOffset = 0; +- dev->checkpointPageSequence++; +- dev->checkpointCurrentChunk++; ++ dev->checkpt_byte_offs = 0; ++ dev->checkpt_page_seq++; ++ dev->checkpt_cur_chunk++; - if (dev->checkpointCurrentChunk >= dev->nChunksPerBlock) -+ if (dev->checkpointCurrentChunk >= dev->param.nChunksPerBlock) - dev->checkpointCurrentBlock = -1; +- dev->checkpointCurrentBlock = -1; ++ if (dev->checkpt_cur_chunk >= dev->param.chunks_per_block) ++ dev->checkpt_cur_block = -1; } } -@@ -342,17 +348,20 @@ int yaffs_CheckpointRead(yaffs_Device *d + + if (ok) { +- *dataBytes = dev->checkpointBuffer[dev->checkpointByteOffset]; +- dev->checkpointSum += *dataBytes; +- dev->checkpointXor ^= *dataBytes; +- dev->checkpointByteOffset++; ++ *dataBytes = dev->checkpt_buffer[dev->checkpt_byte_offs]; ++ dev->checkpt_sum += *dataBytes; ++ dev->checkpt_xor ^= *dataBytes; ++ dev->checkpt_byte_offs++; + i++; + dataBytes++; +- dev->checkpointByteCount++; ++ dev->checkpt_byte_count++; + } + } + return i; } -int yaffs_CheckpointClose(yaffs_Device *dev) -+int yaffs2_CheckpointClose(yaffs_Device *dev) ++int yaffs_checkpt_close(yaffs_dev_t *dev) { - if (dev->checkpointOpenForWrite) { - if (dev->checkpointByteOffset != 0) +- if (dev->checkpointOpenForWrite) { +- if (dev->checkpointByteOffset != 0) - yaffs_CheckpointFlushBuffer(dev); - } else { -+ yaffs2_CheckpointFlushBuffer(dev); -+ } else if(dev->checkpointBlockList){ ++ if (dev->checkpt_open_write) { ++ if (dev->checkpt_byte_offs != 0) ++ yaffs2_checkpt_flush_buffer(dev); ++ } else if(dev->checkpt_block_list){ int i; - for (i = 0; i < dev->blocksInCheckpoint && dev->checkpointBlockList[i] >= 0; i++) { +- for (i = 0; i < dev->blocksInCheckpoint && dev->checkpointBlockList[i] >= 0; i++) { - yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, dev->checkpointBlockList[i]); - if (bi->blockState == YAFFS_BLOCK_STATE_EMPTY) -+ int blk = dev->checkpointBlockList[i]; -+ yaffs_BlockInfo *bi = NULL; -+ if( dev->internalStartBlock <= blk && blk <= dev->internalEndBlock) -+ bi = yaffs_GetBlockInfo(dev, blk); -+ if (bi && bi->blockState == YAFFS_BLOCK_STATE_EMPTY) - bi->blockState = YAFFS_BLOCK_STATE_CHECKPOINT; +- bi->blockState = YAFFS_BLOCK_STATE_CHECKPOINT; ++ for (i = 0; i < dev->blocks_in_checkpt && dev->checkpt_block_list[i] >= 0; i++) { ++ int blk = dev->checkpt_block_list[i]; ++ yaffs_block_info_t *bi = NULL; ++ if( dev->internal_start_block <= blk && blk <= dev->internal_end_block) ++ bi = yaffs_get_block_info(dev, blk); ++ if (bi && bi->block_state == YAFFS_BLOCK_STATE_EMPTY) ++ bi->block_state = YAFFS_BLOCK_STATE_CHECKPOINT; else { /* Todo this looks odd... */ -@@ -362,7 +371,7 @@ int yaffs_CheckpointClose(yaffs_Device * - dev->checkpointBlockList = NULL; + } + } +- YFREE(dev->checkpointBlockList); +- dev->checkpointBlockList = NULL; ++ YFREE(dev->checkpt_block_list); ++ dev->checkpt_block_list = NULL; } - dev->nFreeChunks -= dev->blocksInCheckpoint * dev->nChunksPerBlock; -+ dev->nFreeChunks -= dev->blocksInCheckpoint * dev->param.nChunksPerBlock; - dev->nErasedBlocks -= dev->blocksInCheckpoint; - - -@@ -378,16 +387,14 @@ int yaffs_CheckpointClose(yaffs_Device * +- dev->nErasedBlocks -= dev->blocksInCheckpoint; ++ dev->n_free_chunks -= dev->blocks_in_checkpt * dev->param.chunks_per_block; ++ dev->n_erased_blocks -= dev->blocks_in_checkpt; + + + T(YAFFS_TRACE_CHECKPOINT, (TSTR("checkpoint byte count %d" TENDSTR), +- dev->checkpointByteCount)); ++ dev->checkpt_byte_count)); + +- if (dev->checkpointBuffer) { ++ if (dev->checkpt_buffer) { + /* free the buffer */ +- YFREE(dev->checkpointBuffer); +- dev->checkpointBuffer = NULL; ++ YFREE(dev->checkpt_buffer); ++ dev->checkpt_buffer = NULL; + return 1; + } else return 0; } -int yaffs_CheckpointInvalidateStream(yaffs_Device *dev) -+int yaffs2_CheckpointInvalidateStream(yaffs_Device *dev) ++int yaffs2_checkpt_invalidate_stream(yaffs_dev_t *dev) { - /* Erase the first checksum block */ - @@ -1194,15 +1485,16 @@ - if (!yaffs_CheckpointSpaceOk(dev)) - return 0; + T(YAFFS_TRACE_CHECKPOINT, (TSTR("checkpoint invalidate of %d blocks"TENDSTR), -+ dev->blocksInCheckpoint)); ++ dev->blocks_in_checkpt)); - return yaffs_CheckpointErase(dev); -+ return yaffs2_CheckpointErase(dev); ++ return yaffs_checkpt_erase(dev); } ---- a/fs/yaffs2/yaffs_checkptrw.h -+++ b/fs/yaffs2/yaffs_checkptrw.h +diff -Nrup linux-2.6.36-rc8/fs/yaffs2/yaffs_checkptrw.h linux-2.6.36-rc8.new/fs/yaffs2/yaffs_checkptrw.h +--- linux-2.6.36-rc8/fs/yaffs2/yaffs_checkptrw.h 2010-10-20 13:17:58.941000294 +0300 ++++ linux-2.6.36-rc8.new/fs/yaffs2/yaffs_checkptrw.h 2010-10-20 13:28:16.058000294 +0300 @@ -1,7 +1,7 @@ /* * YAFFS: Yet another Flash File System . A NAND-flash specific file system. @@ -1217,28 +1509,29 @@ #include "yaffs_guts.h" -int yaffs_CheckpointOpen(yaffs_Device *dev, int forWriting); -+int yaffs2_CheckpointOpen(yaffs_Device *dev, int forWriting); ++int yaffs2_checkpt_open(yaffs_dev_t *dev, int forWriting); -int yaffs_CheckpointWrite(yaffs_Device *dev, const void *data, int nBytes); -+int yaffs2_CheckpointWrite(yaffs_Device *dev, const void *data, int nBytes); ++int yaffs2_checkpt_wr(yaffs_dev_t *dev, const void *data, int n_bytes); -int yaffs_CheckpointRead(yaffs_Device *dev, void *data, int nBytes); -+int yaffs2_CheckpointRead(yaffs_Device *dev, void *data, int nBytes); ++int yaffs2_checkpt_rd(yaffs_dev_t *dev, void *data, int n_bytes); -int yaffs_GetCheckpointSum(yaffs_Device *dev, __u32 *sum); -+int yaffs2_GetCheckpointSum(yaffs_Device *dev, __u32 *sum); ++int yaffs2_get_checkpt_sum(yaffs_dev_t *dev, __u32 *sum); -int yaffs_CheckpointClose(yaffs_Device *dev); -+int yaffs2_CheckpointClose(yaffs_Device *dev); ++int yaffs_checkpt_close(yaffs_dev_t *dev); -int yaffs_CheckpointInvalidateStream(yaffs_Device *dev); -+int yaffs2_CheckpointInvalidateStream(yaffs_Device *dev); ++int yaffs2_checkpt_invalidate_stream(yaffs_dev_t *dev); #endif - ---- a/fs/yaffs2/yaffs_ecc.c -+++ b/fs/yaffs2/yaffs_ecc.c +diff -Nrup linux-2.6.36-rc8/fs/yaffs2/yaffs_ecc.c linux-2.6.36-rc8.new/fs/yaffs2/yaffs_ecc.c +--- linux-2.6.36-rc8/fs/yaffs2/yaffs_ecc.c 2010-10-20 13:17:58.942000294 +0300 ++++ linux-2.6.36-rc8.new/fs/yaffs2/yaffs_ecc.c 2010-10-20 13:28:16.025000294 +0300 @@ -1,7 +1,7 @@ /* * YAFFS: Yet Another Flash File System. A NAND-flash specific file system. @@ -1258,8 +1551,105 @@ #include "yportenv.h" #include "yaffs_ecc.h" ---- a/fs/yaffs2/yaffs_ecc.h -+++ b/fs/yaffs2/yaffs_ecc.h +@@ -72,7 +69,7 @@ static const unsigned char column_parity + + /* Count the bits in an unsigned char or a U32 */ + +-static int yaffs_CountBits(unsigned char x) ++static int yaffs_count_bits(unsigned char x) + { + int r = 0; + while (x) { +@@ -83,7 +80,7 @@ static int yaffs_CountBits(unsigned char + return r; + } + +-static int yaffs_CountBits32(unsigned x) ++static int yaffs_count_bits32(unsigned x) + { + int r = 0; + while (x) { +@@ -95,7 +92,7 @@ static int yaffs_CountBits32(unsigned x) + } + + /* Calculate the ECC for a 256-byte block of data */ +-void yaffs_ECCCalculate(const unsigned char *data, unsigned char *ecc) ++void yaffs_ecc_cacl(const unsigned char *data, unsigned char *ecc) + { + unsigned int i; + +@@ -166,7 +163,7 @@ void yaffs_ECCCalculate(const unsigned c + + /* Correct the ECC on a 256 byte block of data */ + +-int yaffs_ECCCorrect(unsigned char *data, unsigned char *read_ecc, ++int yaffs_ecc_correct(unsigned char *data, unsigned char *read_ecc, + const unsigned char *test_ecc) + { + unsigned char d0, d1, d2; /* deltas */ +@@ -226,9 +223,9 @@ int yaffs_ECCCorrect(unsigned char *data + return 1; /* Corrected the error */ + } + +- if ((yaffs_CountBits(d0) + +- yaffs_CountBits(d1) + +- yaffs_CountBits(d2)) == 1) { ++ if ((yaffs_count_bits(d0) + ++ yaffs_count_bits(d1) + ++ yaffs_count_bits(d2)) == 1) { + /* Reccoverable error in ecc */ + + read_ecc[0] = test_ecc[0]; +@@ -248,7 +245,7 @@ int yaffs_ECCCorrect(unsigned char *data + /* + * ECCxxxOther does ECC calcs on arbitrary n bytes of data + */ +-void yaffs_ECCCalculateOther(const unsigned char *data, unsigned nBytes, ++void yaffs_ecc_calc_other(const unsigned char *data, unsigned n_bytes, + yaffs_ECCOther *eccOther) + { + unsigned int i; +@@ -258,7 +255,7 @@ void yaffs_ECCCalculateOther(const unsig + unsigned line_parity_prime = 0; + unsigned char b; + +- for (i = 0; i < nBytes; i++) { ++ for (i = 0; i < n_bytes; i++) { + b = column_parity_table[*data++]; + col_parity ^= b; + +@@ -275,7 +272,7 @@ void yaffs_ECCCalculateOther(const unsig + eccOther->lineParityPrime = line_parity_prime; + } + +-int yaffs_ECCCorrectOther(unsigned char *data, unsigned nBytes, ++int yaffs_ecc_correct_other(unsigned char *data, unsigned n_bytes, + yaffs_ECCOther *read_ecc, + const yaffs_ECCOther *test_ecc) + { +@@ -304,7 +301,7 @@ int yaffs_ECCCorrectOther(unsigned char + if (cDelta & 0x02) + bit |= 0x01; + +- if (lDelta >= nBytes) ++ if (lDelta >= n_bytes) + return -1; + + data[lDelta] ^= (1 << bit); +@@ -312,8 +309,8 @@ int yaffs_ECCCorrectOther(unsigned char + return 1; /* corrected */ + } + +- if ((yaffs_CountBits32(lDelta) + yaffs_CountBits32(lDeltaPrime) + +- yaffs_CountBits(cDelta)) == 1) { ++ if ((yaffs_count_bits32(lDelta) + yaffs_count_bits32(lDeltaPrime) + ++ yaffs_count_bits(cDelta)) == 1) { + /* Reccoverable error in ecc */ + + *read_ecc = *test_ecc; +diff -Nrup linux-2.6.36-rc8/fs/yaffs2/yaffs_ecc.h linux-2.6.36-rc8.new/fs/yaffs2/yaffs_ecc.h +--- linux-2.6.36-rc8/fs/yaffs2/yaffs_ecc.h 2010-10-20 13:17:58.942000294 +0300 ++++ linux-2.6.36-rc8.new/fs/yaffs2/yaffs_ecc.h 2010-10-20 13:28:16.058000294 +0300 @@ -1,7 +1,7 @@ /* * YAFFS: Yet another Flash File System . A NAND-flash specific file system. @@ -1269,8 +1659,27 @@ * for Toby Churchill Ltd and Brightstar Engineering * * Created by Charles Manning <charles@aleph1.co.uk> ---- a/fs/yaffs2/yaffs_fs.c -+++ /dev/null +@@ -32,13 +32,13 @@ typedef struct { + unsigned lineParityPrime; + } yaffs_ECCOther; + +-void yaffs_ECCCalculate(const unsigned char *data, unsigned char *ecc); +-int yaffs_ECCCorrect(unsigned char *data, unsigned char *read_ecc, ++void yaffs_ecc_cacl(const unsigned char *data, unsigned char *ecc); ++int yaffs_ecc_correct(unsigned char *data, unsigned char *read_ecc, + const unsigned char *test_ecc); + +-void yaffs_ECCCalculateOther(const unsigned char *data, unsigned nBytes, ++void yaffs_ecc_calc_other(const unsigned char *data, unsigned n_bytes, + yaffs_ECCOther *ecc); +-int yaffs_ECCCorrectOther(unsigned char *data, unsigned nBytes, ++int yaffs_ecc_correct_other(unsigned char *data, unsigned n_bytes, + yaffs_ECCOther *read_ecc, + const yaffs_ECCOther *test_ecc); + #endif +diff -Nrup linux-2.6.36-rc8/fs/yaffs2/yaffs_fs.c linux-2.6.36-rc8.new/fs/yaffs2/yaffs_fs.c +--- linux-2.6.36-rc8/fs/yaffs2/yaffs_fs.c 2010-10-20 13:17:58.944000294 +0300 ++++ linux-2.6.36-rc8.new/fs/yaffs2/yaffs_fs.c 1970-01-01 02:00:00.000000000 +0200 @@ -1,2529 +0,0 @@ -/* - * YAFFS: Yet Another Flash File System. A NAND-flash specific file system. @@ -3801,8 +4210,9 @@ -MODULE_DESCRIPTION("YAFFS2 - a NAND specific flash file system"); -MODULE_AUTHOR("Charles Manning, Aleph One Ltd., 2002-2006"); -MODULE_LICENSE("GPL"); ---- a/fs/yaffs2/yaffs_getblockinfo.h -+++ b/fs/yaffs2/yaffs_getblockinfo.h +diff -Nrup linux-2.6.36-rc8/fs/yaffs2/yaffs_getblockinfo.h linux-2.6.36-rc8.new/fs/yaffs2/yaffs_getblockinfo.h +--- linux-2.6.36-rc8/fs/yaffs2/yaffs_getblockinfo.h 2010-10-20 13:17:58.945000294 +0300 ++++ linux-2.6.36-rc8.new/fs/yaffs2/yaffs_getblockinfo.h 2010-10-20 13:28:16.058000294 +0300 @@ -1,7 +1,7 @@ /* * YAFFS: Yet another Flash File System . A NAND-flash specific file system. @@ -3812,16 +4222,32 @@ * for Toby Churchill Ltd and Brightstar Engineering * * Created by Charles Manning <charles@aleph1.co.uk> -@@ -17,6 +17,7 @@ +@@ -17,18 +17,19 @@ #define __YAFFS_GETBLOCKINFO_H__ #include "yaffs_guts.h" +#include "yaffs_trace.h" /* Function to manipulate block info */ - static Y_INLINE yaffs_BlockInfo *yaffs_GetBlockInfo(yaffs_Device * dev, int blk) ---- a/fs/yaffs2/yaffs_guts.c -+++ b/fs/yaffs2/yaffs_guts.c +-static Y_INLINE yaffs_BlockInfo *yaffs_GetBlockInfo(yaffs_Device * dev, int blk) ++static Y_INLINE yaffs_block_info_t *yaffs_get_block_info(yaffs_dev_t * dev, int blk) + { +- if (blk < dev->internalStartBlock || blk > dev->internalEndBlock) { ++ if (blk < dev->internal_start_block || blk > dev->internal_end_block) { + T(YAFFS_TRACE_ERROR, + (TSTR + ("**>> yaffs: getBlockInfo block %d is not valid" TENDSTR), + blk)); + YBUG(); + } +- return &dev->blockInfo[blk - dev->internalStartBlock]; ++ return &dev->block_info[blk - dev->internal_start_block]; + } + + #endif +diff -Nrup linux-2.6.36-rc8/fs/yaffs2/yaffs_guts.c linux-2.6.36-rc8.new/fs/yaffs2/yaffs_guts.c +--- linux-2.6.36-rc8/fs/yaffs2/yaffs_guts.c 2010-10-20 13:17:58.951000294 +0300 ++++ linux-2.6.36-rc8.new/fs/yaffs2/yaffs_guts.c 2010-10-20 13:28:16.027000294 +0300 @@ -1,7 +1,7 @@ /* * YAFFS: Yet Another Flash File System. A NAND-flash specific file system. @@ -3844,7 +4270,7 @@ #include "yaffsinterface.h" #include "yaffs_guts.h" -@@ -22,22 +19,28 @@ const char *yaffs_guts_c_version = +@@ -22,118 +19,109 @@ const char *yaffs_guts_c_version = #include "yaffs_getblockinfo.h" #include "yaffs_tagscompat.h" @@ -3876,55 +4302,82 @@ + /* Robustification (if it ever comes about...) */ - static void yaffs_RetireBlock(yaffs_Device *dev, int blockInNAND); - static void yaffs_HandleWriteChunkError(yaffs_Device *dev, int chunkInNAND, -@@ -49,33 +52,26 @@ static void yaffs_HandleUpdateChunk(yaff - const yaffs_ExtendedTags *tags); +-static void yaffs_RetireBlock(yaffs_Device *dev, int blockInNAND); +-static void yaffs_HandleWriteChunkError(yaffs_Device *dev, int chunkInNAND, ++static void yaffs_retire_block(yaffs_dev_t *dev, int flash_block); ++static void yaffs_handle_chunk_wr_error(yaffs_dev_t *dev, int nand_chunk, + int erasedOk); +-static void yaffs_HandleWriteChunkOk(yaffs_Device *dev, int chunkInNAND, ++static void yaffs_handle_chunk_wr_ok(yaffs_dev_t *dev, int nand_chunk, + const __u8 *data, +- const yaffs_ExtendedTags *tags); +-static void yaffs_HandleUpdateChunk(yaffs_Device *dev, int chunkInNAND, +- const yaffs_ExtendedTags *tags); ++ const yaffs_ext_tags *tags); ++static void yaffs_handle_chunk_update(yaffs_dev_t *dev, int nand_chunk, ++ const yaffs_ext_tags *tags); /* Other local prototypes */ -+static void yaffs_UpdateParent(yaffs_Object *obj); - static int yaffs_UnlinkObject(yaffs_Object *obj); - static int yaffs_ObjectHasCachedWriteData(yaffs_Object *obj); - --static void yaffs_HardlinkFixup(yaffs_Device *dev, yaffs_Object *hardList); +-static int yaffs_UnlinkObject(yaffs_Object *obj); +-static int yaffs_ObjectHasCachedWriteData(yaffs_Object *obj); - - static int yaffs_WriteNewChunkWithTagsToNAND(yaffs_Device *dev, +-static void yaffs_HardlinkFixup(yaffs_Device *dev, yaffs_Object *hardList); ++static void yaffs_update_parent(yaffs_obj_t *obj); ++static int yaffs_unlink_obj(yaffs_obj_t *obj); ++static int yaffs_obj_cache_dirty(yaffs_obj_t *obj); + +-static int yaffs_WriteNewChunkWithTagsToNAND(yaffs_Device *dev, ++static int yaffs_write_new_chunk(yaffs_dev_t *dev, const __u8 *buffer, - yaffs_ExtendedTags *tags, +- yaffs_ExtendedTags *tags, ++ yaffs_ext_tags *tags, int useReserve); -static int yaffs_PutChunkIntoFile(yaffs_Object *in, int chunkInInode, - int chunkInNAND, int inScan); -+ - static yaffs_Object *yaffs_CreateNewObject(yaffs_Device *dev, int number, - yaffs_ObjectType type); +-static yaffs_Object *yaffs_CreateNewObject(yaffs_Device *dev, int number, +- yaffs_ObjectType type); -static void yaffs_AddObjectToDirectory(yaffs_Object *directory, - yaffs_Object *obj); -static int yaffs_UpdateObjectHeader(yaffs_Object *in, const YCHAR *name, - int force, int isShrink, int shadows); -+ -+ -+static int yaffs_ApplyXMod(yaffs_Object *obj, char *buffer, yaffs_XAttrMod *xmod); -+ - static void yaffs_RemoveObjectFromDirectory(yaffs_Object *obj); - static int yaffs_CheckStructures(void); +-static void yaffs_RemoveObjectFromDirectory(yaffs_Object *obj); +-static int yaffs_CheckStructures(void); -static int yaffs_DeleteWorker(yaffs_Object *in, yaffs_Tnode *tn, __u32 level, - int chunkOffset, int *limit); - static int yaffs_DoGenericObjectDeletion(yaffs_Object *in); - --static yaffs_BlockInfo *yaffs_GetBlockInfo(yaffs_Device *dev, int blockNo); -- +-static int yaffs_DoGenericObjectDeletion(yaffs_Object *in); - - static int yaffs_CheckChunkErased(struct yaffs_DeviceStruct *dev, - int chunkInNAND); +-static yaffs_BlockInfo *yaffs_GetBlockInfo(yaffs_Device *dev, int blockNo); -@@ -87,30 +83,22 @@ static int yaffs_TagsMatch(const yaffs_E - static int yaffs_AllocateChunk(yaffs_Device *dev, int useReserve, - yaffs_BlockInfo **blockUsedPtr); ++static yaffs_obj_t *yaffs_new_obj(yaffs_dev_t *dev, int number, ++ yaffs_obj_type type); + +-static int yaffs_CheckChunkErased(struct yaffs_DeviceStruct *dev, +- int chunkInNAND); + +-static int yaffs_UnlinkWorker(yaffs_Object *obj); ++static int yaffs_apply_xattrib_mod(yaffs_obj_t *obj, char *buffer, yaffs_xattr_mod *xmod); + +-static int yaffs_TagsMatch(const yaffs_ExtendedTags *tags, int objectId, +- int chunkInObject); ++static void yaffs_remove_obj_from_dir(yaffs_obj_t *obj); ++static int yaffs_check_structures(void); ++static int yaffs_generic_obj_del(yaffs_obj_t *in); ++ ++static int yaffs_check_chunk_erased(struct yaffs_dev_s *dev, ++ int nand_chunk); + +-static int yaffs_AllocateChunk(yaffs_Device *dev, int useReserve, +- yaffs_BlockInfo **blockUsedPtr); ++static int yaffs_unlink_worker(yaffs_obj_t *obj); -static void yaffs_VerifyFreeChunks(yaffs_Device *dev); -- - static void yaffs_CheckObjectDetailsLoaded(yaffs_Object *in); ++static int yaffs_tags_match(const yaffs_ext_tags *tags, int obj_id, ++ int chunkInObject); + +-static void yaffs_CheckObjectDetailsLoaded(yaffs_Object *in); ++static int yaffs_alloc_chunk(yaffs_dev_t *dev, int useReserve, ++ yaffs_block_info_t **blockUsedPtr); -static void yaffs_VerifyDirectory(yaffs_Object *directory); -#ifdef YAFFS_PARANOID @@ -3932,31 +4385,64 @@ -#else -#define yaffs_CheckFileSanity(in) -#endif -- - static void yaffs_InvalidateWholeChunkCache(yaffs_Object *in); - static void yaffs_InvalidateChunkCache(yaffs_Object *object, int chunkId); ++static void yaffs_check_obj_details_loaded(yaffs_obj_t *in); ++ ++static void yaffs_invalidate_whole_cache(yaffs_obj_t *in); ++static void yaffs_invalidate_chunk_cache(yaffs_obj_t *object, int chunk_id); + +-static void yaffs_InvalidateWholeChunkCache(yaffs_Object *in); +-static void yaffs_InvalidateChunkCache(yaffs_Object *object, int chunkId); ++static int yaffs_find_chunk_in_file(yaffs_obj_t *in, int inode_chunk, ++ yaffs_ext_tags *tags); -static void yaffs_InvalidateCheckpoint(yaffs_Device *dev); -- - static int yaffs_FindChunkInFile(yaffs_Object *in, int chunkInInode, - yaffs_ExtendedTags *tags); ++static int yaffs_verify_chunk_written(yaffs_dev_t *dev, ++ int nand_chunk, ++ const __u8 *data, ++ yaffs_ext_tags *tags); + +-static int yaffs_FindChunkInFile(yaffs_Object *in, int chunkInInode, +- yaffs_ExtendedTags *tags); -static __u32 yaffs_GetChunkGroupBase(yaffs_Device *dev, yaffs_Tnode *tn, - unsigned pos); -static yaffs_Tnode *yaffs_FindLevel0Tnode(yaffs_Device *dev, - yaffs_FileStructure *fStruct, - __u32 chunkId); -+static int yaffs_VerifyChunkWritten(yaffs_Device *dev, -+ int chunkInNAND, -+ const __u8 *data, -+ yaffs_ExtendedTags *tags); -+ -+ -+static void yaffs_LoadNameFromObjectHeader(yaffs_Device *dev,YCHAR *name, const YCHAR *ohName, int bufferSize); -+static void yaffs_LoadObjectHeaderFromName(yaffs_Device *dev,YCHAR *ohName, const YCHAR *name); ++static void yaffs_load_name_from_oh(yaffs_dev_t *dev,YCHAR *name, const YCHAR *ohName, int bufferSize); ++static void yaffs_load_oh_from_name(yaffs_dev_t *dev,YCHAR *ohName, const YCHAR *name); /* Function to calculate chunk and offset */ + +-static void yaffs_AddrToChunk(yaffs_Device *dev, loff_t addr, int *chunkOut, ++static void yaffs_addr_to_chunk(yaffs_dev_t *dev, loff_t addr, int *chunkOut, + __u32 *offsetOut) + { + int chunk; + __u32 offset; + +- chunk = (__u32)(addr >> dev->chunkShift); ++ chunk = (__u32)(addr >> dev->chunk_shift); + +- if (dev->chunkDiv == 1) { ++ if (dev->chunk_div == 1) { + /* easy power of 2 case */ +- offset = (__u32)(addr & dev->chunkMask); ++ offset = (__u32)(addr & dev->chunk_mask); + } else { + /* Non power-of-2 case */ + + loff_t chunkBase; + +- chunk /= dev->chunkDiv; ++ chunk /= dev->chunk_div; + +- chunkBase = ((loff_t)chunk) * dev->nDataBytesPerChunk; ++ chunkBase = ((loff_t)chunk) * dev->data_bytes_per_chunk; + offset = (__u32)(addr - chunkBase); + } + @@ -172,7 +160,7 @@ static __u32 ShiftsGE(__u32 x) static __u32 Shifts(__u32 x) @@ -3966,25 +4452,143 @@ nShifts = 0; -@@ -203,7 +191,7 @@ static int yaffs_InitialiseTempBuffers(y +@@ -193,49 +181,49 @@ static __u32 Shifts(__u32 x) + * Temporary buffer manipulations. + */ + +-static int yaffs_InitialiseTempBuffers(yaffs_Device *dev) ++static int yaffs_init_tmp_buffers(yaffs_dev_t *dev) + { + int i; + __u8 *buf = (__u8 *)1; + +- memset(dev->tempBuffer, 0, sizeof(dev->tempBuffer)); ++ memset(dev->temp_buffer, 0, sizeof(dev->temp_buffer)); + for (i = 0; buf && i < YAFFS_N_TEMP_BUFFERS; i++) { - dev->tempBuffer[i].line = 0; /* not in use */ - dev->tempBuffer[i].buffer = buf = +- dev->tempBuffer[i].line = 0; /* not in use */ +- dev->tempBuffer[i].buffer = buf = - YMALLOC_DMA(dev->totalBytesPerChunk); -+ YMALLOC_DMA(dev->param.totalBytesPerChunk); ++ dev->temp_buffer[i].line = 0; /* not in use */ ++ dev->temp_buffer[i].buffer = buf = ++ YMALLOC_DMA(dev->param.total_bytes_per_chunk); } return buf ? YAFFS_OK : YAFFS_FAIL; -@@ -286,7 +274,7 @@ int yaffs_IsManagedTempBuffer(yaffs_Devi + } + +-__u8 *yaffs_GetTempBuffer(yaffs_Device *dev, int lineNo) ++__u8 *yaffs_get_temp_buffer(yaffs_dev_t *dev, int line_no) + { + int i, j; + +- dev->tempInUse++; +- if (dev->tempInUse > dev->maxTemp) +- dev->maxTemp = dev->tempInUse; ++ dev->temp_in_use++; ++ if (dev->temp_in_use > dev->max_temp) ++ dev->max_temp = dev->temp_in_use; + + for (i = 0; i < YAFFS_N_TEMP_BUFFERS; i++) { +- if (dev->tempBuffer[i].line == 0) { +- dev->tempBuffer[i].line = lineNo; +- if ((i + 1) > dev->maxTemp) { +- dev->maxTemp = i + 1; ++ if (dev->temp_buffer[i].line == 0) { ++ dev->temp_buffer[i].line = line_no; ++ if ((i + 1) > dev->max_temp) { ++ dev->max_temp = i + 1; + for (j = 0; j <= i; j++) +- dev->tempBuffer[j].maxLine = +- dev->tempBuffer[j].line; ++ dev->temp_buffer[j].max_line = ++ dev->temp_buffer[j].line; + } + +- return dev->tempBuffer[i].buffer; ++ return dev->temp_buffer[i].buffer; + } + } + + T(YAFFS_TRACE_BUFFERS, + (TSTR("Out of temp buffers at line %d, other held by lines:"), +- lineNo)); ++ line_no)); + for (i = 0; i < YAFFS_N_TEMP_BUFFERS; i++) +- T(YAFFS_TRACE_BUFFERS, (TSTR(" %d "), dev->tempBuffer[i].line)); ++ T(YAFFS_TRACE_BUFFERS, (TSTR(" %d "), dev->temp_buffer[i].line)); + + T(YAFFS_TRACE_BUFFERS, (TSTR(" " TENDSTR))); + +@@ -244,21 +232,21 @@ __u8 *yaffs_GetTempBuffer(yaffs_Device * + * This is not good. + */ + +- dev->unmanagedTempAllocations++; +- return YMALLOC(dev->nDataBytesPerChunk); ++ dev->unmanaged_buffer_allocs++; ++ return YMALLOC(dev->data_bytes_per_chunk); + + } + +-void yaffs_ReleaseTempBuffer(yaffs_Device *dev, __u8 *buffer, +- int lineNo) ++void yaffs_release_temp_buffer(yaffs_dev_t *dev, __u8 *buffer, ++ int line_no) + { + int i; + +- dev->tempInUse--; ++ dev->temp_in_use--; + + for (i = 0; i < YAFFS_N_TEMP_BUFFERS; i++) { +- if (dev->tempBuffer[i].buffer == buffer) { +- dev->tempBuffer[i].line = 0; ++ if (dev->temp_buffer[i].buffer == buffer) { ++ dev->temp_buffer[i].line = 0; + return; + } + } +@@ -267,9 +255,9 @@ void yaffs_ReleaseTempBuffer(yaffs_Devic + /* assume it is an unmanaged one. */ + T(YAFFS_TRACE_BUFFERS, + (TSTR("Releasing unmanaged temp buffer in line %d" TENDSTR), +- lineNo)); ++ line_no)); + YFREE(buffer); +- dev->unmanagedTempDeallocations++; ++ dev->unmanaged_buffer_deallocs++; + } + + } +@@ -277,21 +265,21 @@ void yaffs_ReleaseTempBuffer(yaffs_Devic + /* + * Determine if we have a managed buffer. + */ +-int yaffs_IsManagedTempBuffer(yaffs_Device *dev, const __u8 *buffer) ++int yaffs_is_managed_tmp_buffer(yaffs_dev_t *dev, const __u8 *buffer) + { + int i; + + for (i = 0; i < YAFFS_N_TEMP_BUFFERS; i++) { +- if (dev->tempBuffer[i].buffer == buffer) ++ if (dev->temp_buffer[i].buffer == buffer) return 1; } - for (i = 0; i < dev->nShortOpCaches; i++) { -+ for (i = 0; i < dev->param.nShortOpCaches; i++) { - if (dev->srCache[i].data == buffer) +- if (dev->srCache[i].data == buffer) ++ for (i = 0; i < dev->param.n_caches; i++) { ++ if (dev->cache[i].data == buffer) return 1; } -@@ -299,6374 +287,4183 @@ int yaffs_IsManagedTempBuffer(yaffs_Devi + +- if (buffer == dev->checkpointBuffer) ++ if (buffer == dev->checkpt_buffer) + return 1; + + T(YAFFS_TRACE_ALWAYS, +@@ -299,6397 +287,4205 @@ int yaffs_IsManagedTempBuffer(yaffs_Devi return 0; } @@ -4029,7 +4633,7 @@ + */ -static Y_INLINE void yaffs_ClearChunkBit(yaffs_Device *dev, int blk, int chunk) -+static Y_INLINE int yaffs_HashFunction(int n) ++static Y_INLINE int yaffs_hash_fn(int n) { - __u8 *blkBits = yaffs_BlockBits(dev, blk); - @@ -4054,17 +4658,17 @@ + */ -static Y_INLINE int yaffs_CheckChunkBit(yaffs_Device *dev, int blk, int chunk) -+yaffs_Object *yaffs_Root(yaffs_Device *dev) ++yaffs_obj_t *yaffs_root(yaffs_dev_t *dev) { - __u8 *blkBits = yaffs_BlockBits(dev, blk); - yaffs_VerifyChunkBitId(dev, blk, chunk); - - return (blkBits[chunk / 8] & (1 << (chunk & 7))) ? 1 : 0; -+ return dev->rootDir; ++ return dev->root_dir; } -static Y_INLINE int yaffs_StillSomeChunkBits(yaffs_Device *dev, int blk) -+yaffs_Object *yaffs_LostNFound(yaffs_Device *dev) ++yaffs_obj_t *yaffs_lost_n_found(yaffs_dev_t *dev) { - __u8 *blkBits = yaffs_BlockBits(dev, blk); - int i; @@ -4074,7 +4678,7 @@ - blkBits++; - } - return 0; -+ return dev->lostNFoundDir; ++ return dev->lost_n_found; } -static int yaffs_CountChunkBits(yaffs_Device *dev, int blk) @@ -4111,11 +4715,11 @@ -} - -static int yaffs_SkipNANDVerification(yaffs_Device *dev) -+int yaffs_CheckFF(__u8 *buffer, int nBytes) ++int yaffs_check_ff(__u8 *buffer, int n_bytes) { - return !(yaffs_traceMask & (YAFFS_TRACE_VERIFY_NAND)); + /* Horrible, slow implementation */ -+ while (nBytes--) { ++ while (n_bytes--) { + if (*buffer != 0xFF) + return 0; + buffer++; @@ -4137,24 +4741,24 @@ -}; - -static void yaffs_VerifyBlock(yaffs_Device *dev, yaffs_BlockInfo *bi, int n) -+static int yaffs_CheckChunkErased(struct yaffs_DeviceStruct *dev, -+ int chunkInNAND) ++static int yaffs_check_chunk_erased(struct yaffs_dev_s *dev, ++ int nand_chunk) { - int actuallyUsed; - int inUse; + int retval = YAFFS_OK; -+ __u8 *data = yaffs_GetTempBuffer(dev, __LINE__); -+ yaffs_ExtendedTags tags; ++ __u8 *data = yaffs_get_temp_buffer(dev, __LINE__); ++ yaffs_ext_tags tags; + int result; - if (yaffs_SkipVerification(dev)) - return; -+ result = yaffs_ReadChunkWithTagsFromNAND(dev, chunkInNAND, data, &tags); ++ result = yaffs_rd_chunk_tags_nand(dev, nand_chunk, data, &tags); - /* Report illegal runtime states */ - if (bi->blockState >= YAFFS_NUMBER_OF_BLOCK_STATES) - T(YAFFS_TRACE_VERIFY, (TSTR("Block %d has undefined state %d"TENDSTR), n, bi->blockState)); -+ if (tags.eccResult > YAFFS_ECC_RESULT_NO_ERROR) ++ if (tags.ecc_result > YAFFS_ECC_RESULT_NO_ERROR) + retval = YAFFS_FAIL; - switch (bi->blockState) { @@ -4163,9 +4767,9 @@ - case YAFFS_BLOCK_STATE_NEEDS_SCANNING: - T(YAFFS_TRACE_VERIFY, (TSTR("Block %d has bad run-state %s"TENDSTR), - n, blockStateName[bi->blockState])); -+ if (!yaffs_CheckFF(data, dev->nDataBytesPerChunk) || tags.chunkUsed) { ++ if (!yaffs_check_ff(data, dev->data_bytes_per_chunk) || tags.chunk_used) { + T(YAFFS_TRACE_NANDACCESS, -+ (TSTR("Chunk %d not erased" TENDSTR), chunkInNAND)); ++ (TSTR("Chunk %d not erased" TENDSTR), nand_chunk)); + retval = YAFFS_FAIL; } @@ -4179,7 +4783,7 @@ - T(YAFFS_TRACE_VERIFY, (TSTR("Block %d has illegal values pagesInUsed %d softDeletions %d"TENDSTR), - n, bi->pagesInUse, bi->softDeletions)); - -+ yaffs_ReleaseTempBuffer(dev, data, __LINE__); ++ yaffs_release_temp_buffer(dev, data, __LINE__); - /* Check chunk bitmap legal */ - inUse = yaffs_CountChunkBits(dev, n); @@ -4201,27 +4805,27 @@ -static void yaffs_VerifyCollectedBlock(yaffs_Device *dev, yaffs_BlockInfo *bi, - int n) + -+static int yaffs_VerifyChunkWritten(yaffs_Device *dev, -+ int chunkInNAND, ++static int yaffs_verify_chunk_written(yaffs_dev_t *dev, ++ int nand_chunk, + const __u8 *data, -+ yaffs_ExtendedTags *tags) ++ yaffs_ext_tags *tags) { - yaffs_VerifyBlock(dev, bi, n); + int retval = YAFFS_OK; -+ yaffs_ExtendedTags tempTags; -+ __u8 *buffer = yaffs_GetTempBuffer(dev,__LINE__); ++ yaffs_ext_tags tempTags; ++ __u8 *buffer = yaffs_get_temp_buffer(dev,__LINE__); + int result; + -+ result = yaffs_ReadChunkWithTagsFromNAND(dev,chunkInNAND,buffer,&tempTags); -+ if(memcmp(buffer,data,dev->nDataBytesPerChunk) || -+ tempTags.objectId != tags->objectId || -+ tempTags.chunkId != tags->chunkId || -+ tempTags.byteCount != tags->byteCount) ++ result = yaffs_rd_chunk_tags_nand(dev,nand_chunk,buffer,&tempTags); ++ if(memcmp(buffer,data,dev->data_bytes_per_chunk) || ++ tempTags.obj_id != tags->obj_id || ++ tempTags.chunk_id != tags->chunk_id || ++ tempTags.n_bytes != tags->n_bytes) + retval = YAFFS_FAIL; - /* After collection the block should be in the erased state */ - /* This will need to change if we do partial gc */ -+ yaffs_ReleaseTempBuffer(dev, buffer, __LINE__); ++ yaffs_release_temp_buffer(dev, buffer, __LINE__); - if (bi->blockState != YAFFS_BLOCK_STATE_COLLECTING && - bi->blockState != YAFFS_BLOCK_STATE_EMPTY) { @@ -4232,9 +4836,9 @@ } -static void yaffs_VerifyBlocks(yaffs_Device *dev) -+static int yaffs_WriteNewChunkWithTagsToNAND(struct yaffs_DeviceStruct *dev, ++static int yaffs_write_new_chunk(struct yaffs_dev_s *dev, + const __u8 *data, -+ yaffs_ExtendedTags *tags, ++ yaffs_ext_tags *tags, + int useReserve) { - int i; @@ -4261,20 +4865,20 @@ - T(YAFFS_TRACE_VERIFY, (TSTR(""TENDSTR))); - T(YAFFS_TRACE_VERIFY, (TSTR("Block summary"TENDSTR))); -+ yaffs2_InvalidateCheckpoint(dev); ++ yaffs2_checkpt_invalidate(dev); - T(YAFFS_TRACE_VERIFY, (TSTR("%d blocks have illegal states"TENDSTR), nIllegalBlockStates)); - if (nBlocksPerState[YAFFS_BLOCK_STATE_ALLOCATING] > 1) - T(YAFFS_TRACE_VERIFY, (TSTR("Too many allocating blocks"TENDSTR))); + do { -+ yaffs_BlockInfo *bi = 0; ++ yaffs_block_info_t *bi = 0; + int erasedOk = 0; - for (i = 0; i < YAFFS_NUMBER_OF_BLOCK_STATES; i++) - T(YAFFS_TRACE_VERIFY, - (TSTR("%s %d blocks"TENDSTR), - blockStateName[i], nBlocksPerState[i])); -+ chunk = yaffs_AllocateChunk(dev, useReserve, &bi); ++ chunk = yaffs_alloc_chunk(dev, useReserve, &bi); + if (chunk < 0) { + /* no space */ + break; @@ -4319,12 +4923,12 @@ - T(YAFFS_TRACE_VERIFY, - (TSTR("Too many collecting blocks %d (max is 1)"TENDSTR), - nBlocksPerState[YAFFS_BLOCK_STATE_COLLECTING])); -+ if(dev->param.alwaysCheckErased) -+ bi->skipErasedCheck = 0; ++ if(dev->param.always_check_erased) ++ bi->skip_erased_check = 0; - T(YAFFS_TRACE_VERIFY, (TSTR(""TENDSTR))); -+ if (!bi->skipErasedCheck) { -+ erasedOk = yaffs_CheckChunkErased(dev, chunk); ++ if (!bi->skip_erased_check) { ++ erasedOk = yaffs_check_chunk_erased(dev, chunk); + if (erasedOk != YAFFS_OK) { + T(YAFFS_TRACE_ERROR, + (TSTR("**>> yaffs chunk %d was not erased" @@ -4334,8 +4938,8 @@ + /* If not erased, delete this one, + * skip rest of block and + * try another chunk */ -+ yaffs_DeleteChunk(dev,chunk,1,__LINE__); -+ yaffs_SkipRestOfBlock(dev); ++ yaffs_chunk_del(dev,chunk,1,__LINE__); ++ yaffs_skip_rest_of_block(dev); + continue; + } + } @@ -4348,7 +4952,7 @@ -{ - if (obj && yaffs_SkipVerification(obj->myDev)) - return; -+ writeOk = yaffs_WriteChunkWithTagsToNAND(dev, chunk, ++ writeOk = yaffs_wr_chunk_tags_nand(dev, chunk, + data, tags); - if (!(tags && obj && oh)) { @@ -4357,8 +4961,8 @@ - (__u32)tags, (__u32)obj, (__u32)oh)); - return; - } -+ if(!bi->skipErasedCheck) -+ writeOk = yaffs_VerifyChunkWritten(dev, chunk, data, tags); ++ if(!bi->skip_erased_check) ++ writeOk = yaffs_verify_chunk_written(dev, chunk, data, tags); - if (oh->type <= YAFFS_OBJECT_TYPE_UNKNOWN || - oh->type > YAFFS_OBJECT_TYPE_MAX) @@ -4368,7 +4972,7 @@ + if (writeOk != YAFFS_OK) { + /* Clean up aborted write, skip to next block and + * try another chunk */ -+ yaffs_HandleWriteChunkError(dev, chunk, erasedOk); ++ yaffs_handle_chunk_wr_error(dev, chunk, erasedOk); + continue; + } @@ -4376,10 +4980,10 @@ - T(YAFFS_TRACE_VERIFY, - (TSTR("Obj %d header mismatch objectId %d"TENDSTR), - tags->objectId, obj->objectId)); -+ bi->skipErasedCheck = 1; ++ bi->skip_erased_check = 1; + /* Copy the data into the robustification buffer */ -+ yaffs_HandleWriteChunkOk(dev, chunk, data, tags); ++ yaffs_handle_chunk_wr_ok(dev, chunk, data, tags); - /* - * Check that the object's parent ids match if parentCheck requested. @@ -4412,7 +5016,7 @@ - T(YAFFS_TRACE_VERIFY, - (TSTR("Obj %d header name is NULL"TENDSTR), - obj->objectId)); -+ dev->nRetriedWrites += (attempts - 1); ++ dev->n_retired_writes += (attempts - 1); + } - if (tags->objectId > 1 && ((__u8)(oh->name[0])) == 0xff) /* Trashed name */ @@ -4430,18 +5034,18 @@ -static int yaffs_VerifyTnodeWorker(yaffs_Object *obj, yaffs_Tnode *tn, - __u32 level, int chunkOffset) -+static void yaffs_RetireBlock(yaffs_Device *dev, int blockInNAND) ++static void yaffs_retire_block(yaffs_dev_t *dev, int flash_block) { - int i; - yaffs_Device *dev = obj->myDev; - int ok = 1; -+ yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, blockInNAND); ++ yaffs_block_info_t *bi = yaffs_get_block_info(dev, flash_block); - if (tn) { - if (level > 0) { -+ yaffs2_InvalidateCheckpoint(dev); ++ yaffs2_checkpt_invalidate(dev); + -+ yaffs2_ClearOldestDirtySequence(dev,bi); ++ yaffs2_clear_oldest_dirty_seq(dev,bi); - for (i = 0; i < YAFFS_NTNODES_INTERNAL && ok; i++) { - if (tn->internal[i]) { @@ -4452,29 +5056,30 @@ - } - } - } else if (level == 0) { -+ if (yaffs_MarkBlockBad(dev, blockInNAND) != YAFFS_OK) { -+ if (yaffs_EraseBlockInNAND(dev, blockInNAND) != YAFFS_OK) { +- yaffs_ExtendedTags tags; +- __u32 objectId = obj->objectId; ++ if (yaffs_mark_bad(dev, flash_block) != YAFFS_OK) { ++ if (yaffs_erase_block(dev, flash_block) != YAFFS_OK) { + T(YAFFS_TRACE_ALWAYS, (TSTR( + "yaffs: Failed to mark bad and erase block %d" -+ TENDSTR), blockInNAND)); ++ TENDSTR), flash_block)); + } else { - yaffs_ExtendedTags tags; -- __u32 objectId = obj->objectId; -+ int chunkId = blockInNAND * dev->param.nChunksPerBlock; ++ yaffs_ext_tags tags; ++ int chunk_id = flash_block * dev->param.chunks_per_block; - chunkOffset <<= YAFFS_TNODES_LEVEL0_BITS; -+ __u8 *buffer = yaffs_GetTempBuffer(dev, __LINE__); ++ __u8 *buffer = yaffs_get_temp_buffer(dev, __LINE__); - for (i = 0; i < YAFFS_NTNODES_LEVEL0; i++) { - __u32 theChunk = yaffs_GetChunkGroupBase(dev, tn, i); -+ memset(buffer, 0xff, dev->nDataBytesPerChunk); -+ yaffs_InitialiseTags(&tags); -+ tags.sequenceNumber = YAFFS_SEQUENCE_BAD_BLOCK; -+ if (dev->param.writeChunkWithTagsToNAND(dev, chunkId - -+ dev->chunkOffset, buffer, &tags) != YAFFS_OK) ++ memset(buffer, 0xff, dev->data_bytes_per_chunk); ++ yaffs_init_tags(&tags); ++ tags.seq_number = YAFFS_SEQUENCE_BAD_BLOCK; ++ if (dev->param.write_chunk_tags_fn(dev, chunk_id - ++ dev->chunk_offset, buffer, &tags) != YAFFS_OK) + T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: Failed to " + TCONT("write bad block marker to block %d") -+ TENDSTR), blockInNAND)); ++ TENDSTR), flash_block)); - if (theChunk > 0) { - /* T(~0,(TSTR("verifying (%d:%d) %d"TENDSTR),tags.objectId,tags.chunkId,theChunk)); */ @@ -4487,16 +5092,16 @@ - } - chunkOffset++; - } -+ yaffs_ReleaseTempBuffer(dev, buffer, __LINE__); ++ yaffs_release_temp_buffer(dev, buffer, __LINE__); } } - return ok; -+ bi->blockState = YAFFS_BLOCK_STATE_DEAD; -+ bi->gcPrioritise = 0; -+ bi->needsRetiring = 0; ++ bi->block_state = YAFFS_BLOCK_STATE_DEAD; ++ bi->gc_prioritise = 0; ++ bi->needs_retiring = 0; -+ dev->nRetiredBlocks++; ++ dev->n_retired_blocks++; } +/* @@ -4505,9 +5110,9 @@ + */ -static void yaffs_VerifyFile(yaffs_Object *obj) -+static void yaffs_HandleWriteChunkOk(yaffs_Device *dev, int chunkInNAND, ++static void yaffs_handle_chunk_wr_ok(yaffs_dev_t *dev, int nand_chunk, + const __u8 *data, -+ const yaffs_ExtendedTags *tags) ++ const yaffs_ext_tags *tags) { - int requiredTallness; - int actualTallness; @@ -4519,34 +5124,34 @@ - yaffs_Tnode *tn; - __u32 objectId; + dev=dev; -+ chunkInNAND=chunkInNAND; ++ nand_chunk=nand_chunk; + data=data; + tags=tags; +} - if (!obj) - return; -+static void yaffs_HandleUpdateChunk(yaffs_Device *dev, int chunkInNAND, -+ const yaffs_ExtendedTags *tags) ++static void yaffs_handle_chunk_update(yaffs_dev_t *dev, int nand_chunk, ++ const yaffs_ext_tags *tags) +{ + dev=dev; -+ chunkInNAND=chunkInNAND; ++ nand_chunk=nand_chunk; + tags=tags; +} - if (yaffs_SkipVerification(obj->myDev)) - return; -+void yaffs_HandleChunkError(yaffs_Device *dev, yaffs_BlockInfo *bi) ++void yaffs_handle_chunk_error(yaffs_dev_t *dev, yaffs_block_info_t *bi) +{ -+ if (!bi->gcPrioritise) { -+ bi->gcPrioritise = 1; -+ dev->hasPendingPrioritisedGCs = 1; -+ bi->chunkErrorStrikes++; ++ if (!bi->gc_prioritise) { ++ bi->gc_prioritise = 1; ++ dev->has_pending_prioritised_gc = 1; ++ bi->chunk_error_strikes++; - dev = obj->myDev; - objectId = obj->objectId; -+ if (bi->chunkErrorStrikes > 3) { -+ bi->needsRetiring = 1; /* Too many stikes, so retire this */ ++ if (bi->chunk_error_strikes > 3) { ++ bi->needs_retiring = 1; /* Too many stikes, so retire this */ + T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: Block struck out" TENDSTR))); - /* Check file size is consistent with tnode depth */ @@ -4559,51 +5164,42 @@ + } } +} -+ -+static void yaffs_HandleWriteChunkError(yaffs_Device *dev, int chunkInNAND, -+ int erasedOk) -+{ -+ int blockInNAND = chunkInNAND / dev->param.nChunksPerBlock; -+ yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, blockInNAND); - actualTallness = obj->variant.fileVariant.topLevel; -+ yaffs_HandleChunkError(dev, bi); ++static void yaffs_handle_chunk_wr_error(yaffs_dev_t *dev, int nand_chunk, ++ int erasedOk) ++{ ++ int flash_block = nand_chunk / dev->param.chunks_per_block; ++ yaffs_block_info_t *bi = yaffs_get_block_info(dev, flash_block); - if (requiredTallness > actualTallness) - T(YAFFS_TRACE_VERIFY, - (TSTR("Obj %d had tnode tallness %d, needs to be %d"TENDSTR), - obj->objectId, actualTallness, requiredTallness)); ++ yaffs_handle_chunk_error(dev, bi); + + if (erasedOk) { + /* Was an actual write failure, so mark the block for retirement */ -+ bi->needsRetiring = 1; ++ bi->needs_retiring = 1; + T(YAFFS_TRACE_ERROR | YAFFS_TRACE_BAD_BLOCKS, -+ (TSTR("**>> Block %d needs retiring" TENDSTR), blockInNAND)); ++ (TSTR("**>> Block %d needs retiring" TENDSTR), flash_block)); + } -+ -+ /* Delete the chunk */ -+ yaffs_DeleteChunk(dev, chunkInNAND, 1, __LINE__); -+ yaffs_SkipRestOfBlock(dev); -+} - - /* Check that the chunks in the tnode tree are all correct. - * We do this by scanning through the tnode tree and - * checking the tags for every chunk match. - */ -+/*---------------- Name handling functions ------------*/ ++ /* Delete the chunk */ ++ yaffs_chunk_del(dev, nand_chunk, 1, __LINE__); ++ yaffs_skip_rest_of_block(dev); ++} - if (yaffs_SkipNANDVerification(dev)) - return; -+static __u16 yaffs_CalcNameSum(const YCHAR *name) -+{ -+ __u16 sum = 0; -+ __u16 i = 1; - for (i = 1; i <= lastChunk; i++) { - tn = yaffs_FindLevel0Tnode(dev, &obj->variant.fileVariant, i); -+ const YUCHAR *bname = (const YUCHAR *) name; -+ if (bname) { -+ while ((*bname) && (i < (YAFFS_MAX_NAME_LENGTH/2))) { ++/*---------------- Name handling functions ------------*/ - if (tn) { - __u32 theChunk = yaffs_GetChunkGroupBase(dev, tn, i); @@ -4616,6 +5212,15 @@ - tags.objectId, tags.chunkId)); - } - } ++static __u16 yaffs_calc_name_sum(const YCHAR *name) ++{ ++ __u16 sum = 0; ++ __u16 i = 1; ++ ++ const YUCHAR *bname = (const YUCHAR *) name; ++ if (bname) { ++ while ((*bname) && (i < (YAFFS_MAX_NAME_LENGTH/2))) { ++ +#ifdef CONFIG_YAFFS_CASE_INSENSITIVE + sum += yaffs_toupper(*bname) * i; +#else @@ -4630,72 +5235,47 @@ - -static void yaffs_VerifyHardLink(yaffs_Object *obj) -+void yaffs_SetObjectName(yaffs_Object *obj, const YCHAR *name) ++void yaffs_set_obj_name(yaffs_obj_t *obj, const YCHAR *name) { - if (obj && yaffs_SkipVerification(obj->myDev)) - return; +- +- /* Verify sane equivalent object */ +#ifdef CONFIG_YAFFS_SHORT_NAMES_IN_RAM -+ memset(obj->shortName, 0, sizeof(YCHAR) * (YAFFS_SHORT_NAME_LENGTH+1)); ++ memset(obj->short_name, 0, sizeof(YCHAR) * (YAFFS_SHORT_NAME_LENGTH+1)); + if (name && yaffs_strnlen(name,YAFFS_SHORT_NAME_LENGTH+1) <= YAFFS_SHORT_NAME_LENGTH) -+ yaffs_strcpy(obj->shortName, name); ++ yaffs_strcpy(obj->short_name, name); + else -+ obj->shortName[0] = _Y('\0'); -+#endif -+ obj->sum = yaffs_CalcNameSum(name); -+} - -- /* Verify sane equivalent object */ -+void yaffs_SetObjectNameFromOH(yaffs_Object *obj, const yaffs_ObjectHeader *oh) -+{ -+#ifdef CONFIG_YAFFS_AUTO_UNICODE -+ YCHAR tmpName[YAFFS_MAX_NAME_LENGTH+1]; -+ memset(tmpName,0,sizeof(tmpName)); -+ yaffs_LoadNameFromObjectHeader(obj->myDev,tmpName,oh->name,YAFFS_MAX_NAME_LENGTH+1); -+ yaffs_SetObjectName(obj,tmpName); -+#else -+ yaffs_SetObjectName(obj,oh->name); ++ obj->short_name[0] = _Y('\0'); +#endif ++ obj->sum = yaffs_calc_name_sum(name); } -static void yaffs_VerifySymlink(yaffs_Object *obj) -+/*-------------------- TNODES ------------------- -+ -+ * List of spare tnodes -+ * The list is hooked together using the first pointer -+ * in the tnode. -+ */ -+ -+ -+yaffs_Tnode *yaffs_GetTnode(yaffs_Device *dev) ++void yaffs_set_obj_name_from_oh(yaffs_obj_t *obj, const yaffs_obj_header *oh) { - if (obj && yaffs_SkipVerification(obj->myDev)) - return; -+ yaffs_Tnode *tn = yaffs_AllocateRawTnode(dev); -+ if (tn){ -+ memset(tn, 0, dev->tnodeSize); -+ dev->nTnodes++; -+ } -+ -+ dev->nCheckpointBlocksRequired = 0; /* force recalculation*/ - +- - /* Verify symlink string */ -+ return tn; ++#ifdef CONFIG_YAFFS_AUTO_UNICODE ++ YCHAR tmpName[YAFFS_MAX_NAME_LENGTH+1]; ++ memset(tmpName,0,sizeof(tmpName)); ++ yaffs_load_name_from_oh(obj->my_dev,tmpName,oh->name,YAFFS_MAX_NAME_LENGTH+1); ++ yaffs_set_obj_name(obj,tmpName); ++#else ++ yaffs_set_obj_name(obj,oh->name); ++#endif } -static void yaffs_VerifySpecial(yaffs_Object *obj) -+/* FreeTnode frees up a tnode and puts it back on the free list */ -+static void yaffs_FreeTnode(yaffs_Device *dev, yaffs_Tnode *tn) - { +-{ - if (obj && yaffs_SkipVerification(obj->myDev)) - return; -+ yaffs_FreeRawTnode(dev,tn); -+ dev->nTnodes--; -+ dev->nCheckpointBlocksRequired = 0; /* force recalculation*/ - } - +-} +- -static void yaffs_VerifyObject(yaffs_Object *obj) -+static void yaffs_DeinitialiseTnodesAndObjects(yaffs_Device *dev) - { +-{ - yaffs_Device *dev; - - __u32 chunkMin; @@ -4708,37 +5288,32 @@ - - if (!obj) - return; -+ yaffs_DeinitialiseRawTnodesAndObjects(dev); -+ dev->nObjects = 0; -+ dev->nTnodes = 0; -+} - +- - if (obj->beingCreated) - return; ++/*-------------------- TNODES ------------------- - dev = obj->myDev; -+void yaffs_LoadLevel0Tnode(yaffs_Device *dev, yaffs_Tnode *tn, unsigned pos, -+ unsigned val) -+{ -+ __u32 *map = (__u32 *)tn; -+ __u32 bitInMap; -+ __u32 bitInWord; -+ __u32 wordInMap; -+ __u32 mask; ++ * List of spare tnodes ++ * The list is hooked together using the first pointer ++ * in the tnode. ++ */ - if (yaffs_SkipVerification(dev)) - return; -+ pos &= YAFFS_TNODES_LEVEL0_MASK; -+ val >>= dev->chunkGroupBits; - /* Check sane object header chunk */ -+ bitInMap = pos * dev->tnodeWidth; -+ wordInMap = bitInMap / 32; -+ bitInWord = bitInMap & (32 - 1); ++yaffs_tnode_t *yaffs_get_tnode(yaffs_dev_t *dev) ++{ ++ yaffs_tnode_t *tn = yaffs_alloc_raw_tnode(dev); ++ if (tn){ ++ memset(tn, 0, dev->tnode_size); ++ dev->n_tnodes++; ++ } - chunkMin = dev->internalStartBlock * dev->nChunksPerBlock; - chunkMax = (dev->internalEndBlock+1) * dev->nChunksPerBlock - 1; -+ mask = dev->tnodeMask << bitInWord; ++ dev->checkpoint_blocks_required = 0; /* force recalculation*/ - chunkInRange = (((unsigned)(obj->hdrChunk)) >= chunkMin && ((unsigned)(obj->hdrChunk)) <= chunkMax); - chunkIdOk = chunkInRange || obj->hdrChunk == 0; @@ -4747,8 +5322,8 @@ - obj->hdrChunk / dev->nChunksPerBlock, - obj->hdrChunk % dev->nChunksPerBlock); - chunkShouldNotBeDeleted = chunkInRange && !chunkValid; -+ map[wordInMap] &= ~mask; -+ map[wordInMap] |= (mask & (val << bitInWord)); ++ return tn; ++} - if (!obj->fake && - (!chunkIdOk || chunkShouldNotBeDeleted)) { @@ -4757,42 +5332,48 @@ - obj->objectId, obj->hdrChunk, - chunkIdOk ? "" : ",out of range", - chunkShouldNotBeDeleted ? ",marked as deleted" : "")); -+ if (dev->tnodeWidth > (32 - bitInWord)) { -+ bitInWord = (32 - bitInWord); -+ wordInMap++;; -+ mask = dev->tnodeMask >> (/*dev->tnodeWidth -*/ bitInWord); -+ map[wordInMap] &= ~mask; -+ map[wordInMap] |= (mask & (val >> bitInWord)); - } +- } ++/* FreeTnode frees up a tnode and puts it back on the free list */ ++static void yaffs_free_tnode(yaffs_dev_t *dev, yaffs_tnode_t *tn) ++{ ++ yaffs_free_raw_tnode(dev,tn); ++ dev->n_tnodes--; ++ dev->checkpoint_blocks_required = 0; /* force recalculation*/ +} - if (chunkValid && !yaffs_SkipNANDVerification(dev)) { - yaffs_ExtendedTags tags; - yaffs_ObjectHeader *oh; - __u8 *buffer = yaffs_GetTempBuffer(dev, __LINE__); -- ++static void yaffs_deinit_tnodes_and_objs(yaffs_dev_t *dev) ++{ ++ yaffs_deinit_raw_tnodes_and_objs(dev); ++ dev->n_obj = 0; ++ dev->n_tnodes = 0; ++} + - oh = (yaffs_ObjectHeader *)buffer; -+__u32 yaffs_GetChunkGroupBase(yaffs_Device *dev, yaffs_Tnode *tn, -+ unsigned pos) + +- yaffs_ReadChunkWithTagsFromNAND(dev, obj->hdrChunk, buffer, +- &tags); ++void yaffs_load_tnode_0(yaffs_dev_t *dev, yaffs_tnode_t *tn, unsigned pos, ++ unsigned val) +{ + __u32 *map = (__u32 *)tn; + __u32 bitInMap; + __u32 bitInWord; + __u32 wordInMap; -+ __u32 val; - -- yaffs_ReadChunkWithTagsFromNAND(dev, obj->hdrChunk, buffer, -- &tags); -+ pos &= YAFFS_TNODES_LEVEL0_MASK; ++ __u32 mask; - yaffs_VerifyObjectHeader(obj, oh, &tags, 1); -+ bitInMap = pos * dev->tnodeWidth; -+ wordInMap = bitInMap / 32; -+ bitInWord = bitInMap & (32 - 1); ++ pos &= YAFFS_TNODES_LEVEL0_MASK; ++ val >>= dev->chunk_grp_bits; - yaffs_ReleaseTempBuffer(dev, buffer, __LINE__); - } -+ val = map[wordInMap] >> bitInWord; ++ bitInMap = pos * dev->tnode_width; ++ wordInMap = bitInMap / 32; ++ bitInWord = bitInMap & (32 - 1); - /* Verify it has a parent */ - if (obj && !obj->fake && @@ -4800,11 +5381,8 @@ - T(YAFFS_TRACE_VERIFY, - (TSTR("Obj %d has parent pointer %p which does not look like an object"TENDSTR), - obj->objectId, obj->parent)); -+ if (dev->tnodeWidth > (32 - bitInWord)) { -+ bitInWord = (32 - bitInWord); -+ wordInMap++;; -+ val |= (map[wordInMap] << bitInWord); - } +- } ++ mask = dev->tnode_mask << bitInWord; - /* Verify parent is a directory */ - if (obj->parent && obj->parent->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) { @@ -4812,8 +5390,8 @@ - (TSTR("Obj %d's parent is not a directory (type %d)"TENDSTR), - obj->objectId, obj->parent->variantType)); - } -+ val &= dev->tnodeMask; -+ val <<= dev->chunkGroupBits; ++ map[wordInMap] &= ~mask; ++ map[wordInMap] |= (mask & (val << bitInWord)); - switch (obj->variantType) { - case YAFFS_OBJECT_TYPE_FILE: @@ -4837,39 +5415,36 @@ - (TSTR("Obj %d has illegaltype %d"TENDSTR), - obj->objectId, obj->variantType)); - break; -- } -+ return val; ++ if (dev->tnode_width > (32 - bitInWord)) { ++ bitInWord = (32 - bitInWord); ++ wordInMap++;; ++ mask = dev->tnode_mask >> (/*dev->tnode_width -*/ bitInWord); ++ map[wordInMap] &= ~mask; ++ map[wordInMap] |= (mask & (val >> bitInWord)); + } } -static void yaffs_VerifyObjects(yaffs_Device *dev) -+/* ------------------- End of individual tnode manipulation -----------------*/ -+ -+/* ---------Functions to manipulate the look-up tree (made up of tnodes) ------ -+ * The look up tree is represented by the top tnode and the number of topLevel -+ * in the tree. 0 means only the level 0 tnode is in the tree. -+ */ -+ -+/* FindLevel0Tnode finds the level 0 tnode, if one exists. */ -+yaffs_Tnode *yaffs_FindLevel0Tnode(yaffs_Device *dev, -+ yaffs_FileStructure *fStruct, -+ __u32 chunkId) ++__u32 yaffs_get_group_base(yaffs_dev_t *dev, yaffs_tnode_t *tn, ++ unsigned pos) { - yaffs_Object *obj; - int i; - struct ylist_head *lh; -+ yaffs_Tnode *tn = fStruct->top; -+ __u32 i; -+ int requiredTallness; -+ int level = fStruct->topLevel; ++ __u32 *map = (__u32 *)tn; ++ __u32 bitInMap; ++ __u32 bitInWord; ++ __u32 wordInMap; ++ __u32 val; - if (yaffs_SkipVerification(dev)) - return; -+ dev=dev; ++ pos &= YAFFS_TNODES_LEVEL0_MASK; - /* Iterate through the objects in each hash entry */ -+ /* Check sane level and chunk Id */ -+ if (level < 0 || level > YAFFS_TNODES_MAX_LEVEL) -+ return NULL; ++ bitInMap = pos * dev->tnode_width; ++ wordInMap = bitInMap / 32; ++ bitInWord = bitInMap & (32 - 1); - for (i = 0; i < YAFFS_NOBJECT_BUCKETS; i++) { - ylist_for_each(lh, &dev->objectBucket[i].list) { @@ -4878,81 +5453,66 @@ - yaffs_VerifyObject(obj); - } - } -+ if (chunkId > YAFFS_MAX_CHUNK_ID) -+ return NULL; -+ -+ /* First check we're tall enough (ie enough topLevel) */ -+ -+ i = chunkId >> YAFFS_TNODES_LEVEL0_BITS; -+ requiredTallness = 0; -+ while (i) { -+ i >>= YAFFS_TNODES_INTERNAL_BITS; -+ requiredTallness++; - } +- } -} ++ val = map[wordInMap] >> bitInWord; -+ if (requiredTallness > fStruct->topLevel) -+ return NULL; /* Not tall enough, so we can't find it */ ++ if (dev->tnode_width > (32 - bitInWord)) { ++ bitInWord = (32 - bitInWord); ++ wordInMap++;; ++ val |= (map[wordInMap] << bitInWord); ++ } -/* - * Simple hash function. Needs to have a reasonable spread - */ -+ /* Traverse down to level 0 */ -+ while (level > 0 && tn) { -+ tn = tn->internal[(chunkId >> -+ (YAFFS_TNODES_LEVEL0_BITS + -+ (level - 1) * -+ YAFFS_TNODES_INTERNAL_BITS)) & -+ YAFFS_TNODES_INTERNAL_MASK]; -+ level--; -+ } ++ val &= dev->tnode_mask; ++ val <<= dev->chunk_grp_bits; -static Y_INLINE int yaffs_HashFunction(int n) -{ - n = abs(n); - return n % YAFFS_NOBJECT_BUCKETS; -+ return tn; ++ return val; } -/* - * Access functions to useful fake objects. - * Note that root might have a presence in NAND if permissions are set. -+/* AddOrFindLevel0Tnode finds the level 0 tnode if it exists, otherwise first expands the tree. -+ * This happens in two steps: -+ * 1. If the tree isn't tall enough, then make it taller. -+ * 2. Scan down the tree towards the level 0 tnode adding tnodes if required. -+ * -+ * Used when modifying the tree. -+ * -+ * If the tn argument is NULL, then a fresh tnode will be added otherwise the specified tn will -+ * be plugged into the ttree. ++/* ------------------- End of individual tnode manipulation -----------------*/ ++ ++/* ---------Functions to manipulate the look-up tree (made up of tnodes) ------ ++ * The look up tree is represented by the top tnode and the number of top_level ++ * in the tree. 0 means only the level 0 tnode is in the tree. */ -yaffs_Object *yaffs_Root(yaffs_Device *dev) -+yaffs_Tnode *yaffs_AddOrFindLevel0Tnode(yaffs_Device *dev, -+ yaffs_FileStructure *fStruct, -+ __u32 chunkId, -+ yaffs_Tnode *passedTn) ++/* FindLevel0Tnode finds the level 0 tnode, if one exists. */ ++yaffs_tnode_t *yaffs_find_tnode_0(yaffs_dev_t *dev, ++ yaffs_file_s *file_struct, ++ __u32 chunk_id) { - return dev->rootDir; -} ++ yaffs_tnode_t *tn = file_struct->top; ++ __u32 i; + int requiredTallness; -+ int i; -+ int l; -+ yaffs_Tnode *tn; ++ int level = file_struct->top_level; -yaffs_Object *yaffs_LostNFound(yaffs_Device *dev) -{ - return dev->lostNFoundDir; -} -+ __u32 x; ++ dev=dev; ++ /* Check sane level and chunk Id */ ++ if (level < 0 || level > YAFFS_TNODES_MAX_LEVEL) ++ return NULL; -/* - * Erased NAND checking functions - */ -+ /* Check sane level and page Id */ -+ if (fStruct->topLevel < 0 || fStruct->topLevel > YAFFS_TNODES_MAX_LEVEL) ++ if (chunk_id > YAFFS_MAX_CHUNK_ID) + return NULL; -int yaffs_CheckFF(__u8 *buffer, int nBytes) @@ -4962,10 +5522,17 @@ - if (*buffer != 0xFF) - return 0; - buffer++; -- } ++ /* First check we're tall enough (ie enough top_level) */ ++ ++ i = chunk_id >> YAFFS_TNODES_LEVEL0_BITS; ++ requiredTallness = 0; ++ while (i) { ++ i >>= YAFFS_TNODES_INTERNAL_BITS; ++ requiredTallness++; + } - return 1; -} -- + -static int yaffs_CheckChunkErased(struct yaffs_DeviceStruct *dev, - int chunkInNAND) -{ @@ -4973,24 +5540,61 @@ - __u8 *data = yaffs_GetTempBuffer(dev, __LINE__); - yaffs_ExtendedTags tags; - int result; -- ++ if (requiredTallness > file_struct->top_level) ++ return NULL; /* Not tall enough, so we can't find it */ ++ ++ /* Traverse down to level 0 */ ++ while (level > 0 && tn) { ++ tn = tn->internal[(chunk_id >> ++ (YAFFS_TNODES_LEVEL0_BITS + ++ (level - 1) * ++ YAFFS_TNODES_INTERNAL_BITS)) & ++ YAFFS_TNODES_INTERNAL_MASK]; ++ level--; ++ } + - result = yaffs_ReadChunkWithTagsFromNAND(dev, chunkInNAND, data, &tags); -- ++ return tn; ++} + - if (tags.eccResult > YAFFS_ECC_RESULT_NO_ERROR) - retval = YAFFS_FAIL; -- ++/* AddOrFindLevel0Tnode finds the level 0 tnode if it exists, otherwise first expands the tree. ++ * This happens in two steps: ++ * 1. If the tree isn't tall enough, then make it taller. ++ * 2. Scan down the tree towards the level 0 tnode adding tnodes if required. ++ * ++ * Used when modifying the tree. ++ * ++ * If the tn argument is NULL, then a fresh tnode will be added otherwise the specified tn will ++ * be plugged into the ttree. ++ */ + - if (!yaffs_CheckFF(data, dev->nDataBytesPerChunk) || tags.chunkUsed) { - T(YAFFS_TRACE_NANDACCESS, - (TSTR("Chunk %d not erased" TENDSTR), chunkInNAND)); - retval = YAFFS_FAIL; - } -- ++yaffs_tnode_t *yaffs_add_find_tnode_0(yaffs_dev_t *dev, ++ yaffs_file_s *file_struct, ++ __u32 chunk_id, ++ yaffs_tnode_t *passed_tn) ++{ ++ int requiredTallness; ++ int i; ++ int l; ++ yaffs_tnode_t *tn; + - yaffs_ReleaseTempBuffer(dev, data, __LINE__); -- ++ __u32 x; + - return retval; -- + -} -- ++ /* Check sane level and page Id */ ++ if (file_struct->top_level < 0 || file_struct->top_level > YAFFS_TNODES_MAX_LEVEL) ++ return NULL; + -static int yaffs_WriteNewChunkWithTagsToNAND(struct yaffs_DeviceStruct *dev, - const __u8 *data, - yaffs_ExtendedTags *tags, @@ -4999,19 +5603,28 @@ - int attempts = 0; - int writeOk = 0; - int chunk; -- ++ if (chunk_id > YAFFS_MAX_CHUNK_ID) ++ return NULL; + - yaffs_InvalidateCheckpoint(dev); -- ++ /* First check we're tall enough (ie enough top_level) */ + - do { - yaffs_BlockInfo *bi = 0; - int erasedOk = 0; -- ++ x = chunk_id >> YAFFS_TNODES_LEVEL0_BITS; ++ requiredTallness = 0; ++ while (x) { ++ x >>= YAFFS_TNODES_INTERNAL_BITS; ++ requiredTallness++; ++ } + - chunk = yaffs_AllocateChunk(dev, useReserve, &bi); - if (chunk < 0) { - /* no space */ - break; - } -- + - /* First check this chunk is erased, if it needs - * checking. The checking policy (unless forced - * always on) is as follows: @@ -5036,26 +5649,38 @@ - /* try another chunk */ - continue; - } -- ++ if (requiredTallness > file_struct->top_level) { ++ /* Not tall enough, gotta make the tree taller */ ++ for (i = file_struct->top_level; i < requiredTallness; i++) { + - /* let's give it a try */ - attempts++; -- ++ tn = yaffs_get_tnode(dev); + -#ifdef CONFIG_YAFFS_ALWAYS_CHECK_CHUNK_ERASED - bi->skipErasedCheck = 0; -#endif - if (!bi->skipErasedCheck) { - erasedOk = yaffs_CheckChunkErased(dev, chunk); - if (erasedOk != YAFFS_OK) { -- T(YAFFS_TRACE_ERROR, ++ if (tn) { ++ tn->internal[0] = file_struct->top; ++ file_struct->top = tn; ++ file_struct->top_level++; ++ } else { + T(YAFFS_TRACE_ERROR, - (TSTR("**>> yaffs chunk %d was not erased" - TENDSTR), chunk)); - - /* try another chunk */ - continue; -- } ++ (TSTR("yaffs: no more tnodes" TENDSTR))); ++ return NULL; + } - bi->skipErasedCheck = 1; -- } -- + } ++ } + - writeOk = yaffs_WriteChunkWithTagsToNAND(dev, chunk, - data, tags); - if (writeOk != YAFFS_OK) { @@ -5063,37 +5688,99 @@ - /* try another chunk */ - continue; - } -- ++ /* Traverse down to level 0, adding anything we need */ + - /* Copy the data into the robustification buffer */ - yaffs_HandleWriteChunkOk(dev, chunk, data, tags); -- ++ l = file_struct->top_level; ++ tn = file_struct->top; + - } while (writeOk != YAFFS_OK && - (yaffs_wr_attempts <= 0 || attempts <= yaffs_wr_attempts)); -- ++ if (l > 0) { ++ while (l > 0 && tn) { ++ x = (chunk_id >> ++ (YAFFS_TNODES_LEVEL0_BITS + ++ (l - 1) * YAFFS_TNODES_INTERNAL_BITS)) & ++ YAFFS_TNODES_INTERNAL_MASK; + - if (!writeOk) - chunk = -1; -- + - if (attempts > 1) { - T(YAFFS_TRACE_ERROR, - (TSTR("**>> yaffs write required %d attempts" TENDSTR), - attempts)); -- ++ if ((l > 1) && !tn->internal[x]) { ++ /* Add missing non-level-zero tnode */ ++ tn->internal[x] = yaffs_get_tnode(dev); ++ if(!tn->internal[x]) ++ return NULL; ++ } else if (l == 1) { ++ /* Looking from level 1 at level 0 */ ++ if (passed_tn) { ++ /* If we already have one, then release it.*/ ++ if (tn->internal[x]) ++ yaffs_free_tnode(dev, tn->internal[x]); ++ tn->internal[x] = passed_tn; ++ ++ } else if (!tn->internal[x]) { ++ /* Don't have one, none passed in */ ++ tn->internal[x] = yaffs_get_tnode(dev); ++ if(!tn->internal[x]) ++ return NULL; ++ } ++ } + - dev->nRetriedWrites += (attempts - 1); -- } -- ++ tn = tn->internal[x]; ++ l--; ++ } ++ } else { ++ /* top is level 0 */ ++ if (passed_tn) { ++ memcpy(tn, passed_tn, (dev->tnode_width * YAFFS_NTNODES_LEVEL0)/8); ++ yaffs_free_tnode(dev, passed_tn); ++ } + } + - return chunk; --} -- ++ return tn; + } + -/* - * Block retiring for handling a broken block. - */ - -static void yaffs_RetireBlock(yaffs_Device *dev, int blockInNAND) --{ ++static int yaffs_find_chunk_in_group(yaffs_dev_t *dev, int theChunk, ++ yaffs_ext_tags *tags, int obj_id, ++ int inode_chunk) + { - yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, blockInNAND); -- ++ int j; + - yaffs_InvalidateCheckpoint(dev); -- ++ for (j = 0; theChunk && j < dev->chunk_grp_size; j++) { ++ if (yaffs_check_chunk_bit(dev, theChunk / dev->param.chunks_per_block, ++ theChunk % dev->param.chunks_per_block)) { ++ ++ if(dev->chunk_grp_size == 1) ++ return theChunk; ++ else { ++ yaffs_rd_chunk_tags_nand(dev, theChunk, NULL, ++ tags); ++ if (yaffs_tags_match(tags, obj_id, inode_chunk)) { ++ /* found it; */ ++ return theChunk; ++ } ++ } ++ } ++ theChunk++; ++ } ++ return -1; ++} + - if (yaffs_MarkBlockBad(dev, blockInNAND) != YAFFS_OK) { - if (yaffs_EraseBlockInNAND(dev, blockInNAND) != YAFFS_OK) { - T(YAFFS_TRACE_ALWAYS, (TSTR( @@ -5102,9 +5789,25 @@ - } else { - yaffs_ExtendedTags tags; - int chunkId = blockInNAND * dev->nChunksPerBlock; -- ++#if 0 ++/* Experimental code not being used yet. Might speed up file deletion */ ++/* DeleteWorker scans backwards through the tnode tree and deletes all the ++ * chunks and tnodes in the file. ++ * Returns 1 if the tree was deleted. ++ * Returns 0 if it stopped early due to hitting the limit and the delete is incomplete. ++ */ + - __u8 *buffer = yaffs_GetTempBuffer(dev, __LINE__); -- ++static int yaffs_del_worker(yaffs_obj_t *in, yaffs_tnode_t *tn, __u32 level, ++ int chunk_offset, int *limit) ++{ ++ int i; ++ int inode_chunk; ++ int theChunk; ++ yaffs_ext_tags tags; ++ int foundChunk; ++ yaffs_dev_t *dev = in->my_dev; + - memset(buffer, 0xff, dev->nDataBytesPerChunk); - yaffs_InitialiseTags(&tags); - tags.sequenceNumber = YAFFS_SEQUENCE_BAD_BLOCK; @@ -5113,80 +5816,208 @@ - T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: Failed to " - TCONT("write bad block marker to block %d") - TENDSTR), blockInNAND)); -- ++ int allDone = 1; + - yaffs_ReleaseTempBuffer(dev, buffer, __LINE__); - } - } -- ++ if (tn) { ++ if (level > 0) { ++ for (i = YAFFS_NTNODES_INTERNAL - 1; allDone && i >= 0; ++ i--) { ++ if (tn->internal[i]) { ++ if (limit && (*limit) < 0) { ++ allDone = 0; ++ } else { ++ allDone = ++ yaffs_del_worker(in, ++ tn-> ++ internal ++ [i], ++ level - ++ 1, ++ (chunk_offset ++ << ++ YAFFS_TNODES_INTERNAL_BITS) ++ + i, ++ limit); ++ } ++ if (allDone) { ++ yaffs_free_tnode(dev, ++ tn-> ++ internal[i]); ++ tn->internal[i] = NULL; ++ } ++ } ++ } ++ return (allDone) ? 1 : 0; ++ } else if (level == 0) { ++ int hitLimit = 0; + - bi->blockState = YAFFS_BLOCK_STATE_DEAD; - bi->gcPrioritise = 0; - bi->needsRetiring = 0; -- ++ for (i = YAFFS_NTNODES_LEVEL0 - 1; i >= 0 && !hitLimit; ++ i--) { ++ theChunk = yaffs_get_group_base(dev, tn, i); ++ if (theChunk) { + - dev->nRetiredBlocks++; -} -- ++ inode_chunk = (chunk_offset << ++ YAFFS_TNODES_LEVEL0_BITS) + i; + -/* - * Functions for robustisizing TODO - * - */ -- ++ foundChunk = ++ yaffs_find_chunk_in_group(dev, ++ theChunk, ++ &tags, ++ in->obj_id, ++ inode_chunk); + -static void yaffs_HandleWriteChunkOk(yaffs_Device *dev, int chunkInNAND, - const __u8 *data, - const yaffs_ExtendedTags *tags) -{ -} -- ++ if (foundChunk > 0) { ++ yaffs_chunk_del(dev, ++ foundChunk, 1, ++ __LINE__); ++ in->n_data_chunks--; ++ if (limit) { ++ *limit = *limit - 1; ++ if (*limit <= 0) ++ hitLimit = 1; ++ } + -static void yaffs_HandleUpdateChunk(yaffs_Device *dev, int chunkInNAND, - const yaffs_ExtendedTags *tags) -{ -} -- ++ } + -void yaffs_HandleChunkError(yaffs_Device *dev, yaffs_BlockInfo *bi) -{ - if (!bi->gcPrioritise) { - bi->gcPrioritise = 1; - dev->hasPendingPrioritisedGCs = 1; - bi->chunkErrorStrikes++; -- ++ yaffs_load_tnode_0(dev, tn, i, 0); ++ } + - if (bi->chunkErrorStrikes > 3) { - bi->needsRetiring = 1; /* Too many stikes, so retire this */ - T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: Block struck out" TENDSTR))); -- -- } -- } --} -- ++ } ++ return (i < 0) ? 1 : 0; + + } ++ + } ++ ++ return 1; ++ + } + -static void yaffs_HandleWriteChunkError(yaffs_Device *dev, int chunkInNAND, - int erasedOk) --{ ++#endif ++ ++static void yaffs_soft_del_chunk(yaffs_dev_t *dev, int chunk) + { - int blockInNAND = chunkInNAND / dev->nChunksPerBlock; - yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, blockInNAND); -- ++ yaffs_block_info_t *theBlock; ++ unsigned block_no; + - yaffs_HandleChunkError(dev, bi); -- ++ T(YAFFS_TRACE_DELETION, (TSTR("soft delete chunk %d" TENDSTR), chunk)); + - if (erasedOk) { - /* Was an actual write failure, so mark the block for retirement */ - bi->needsRetiring = 1; - T(YAFFS_TRACE_ERROR | YAFFS_TRACE_BAD_BLOCKS, - (TSTR("**>> Block %d needs retiring" TENDSTR), blockInNAND)); -- } ++ block_no = chunk / dev->param.chunks_per_block; ++ theBlock = yaffs_get_block_info(dev, block_no); ++ if (theBlock) { ++ theBlock->soft_del_pages++; ++ dev->n_free_chunks++; ++ yaffs2_update_oldest_dirty_seq(dev, block_no, theBlock); + } - - /* Delete the chunk */ - yaffs_DeleteChunk(dev, chunkInNAND, 1, __LINE__); --} -- -- + } + ++/* SoftDeleteWorker scans backwards through the tnode tree and soft deletes all the chunks in the file. ++ * All soft deleting does is increment the block's softdelete count and pulls the chunk out ++ * of the tnode. ++ * Thus, essentially this is the same as DeleteWorker except that the chunks are soft deleted. ++ */ + -/*---------------- Name handling functions ------------*/ - -static __u16 yaffs_CalcNameSum(const YCHAR *name) --{ ++static int yaffs_soft_del_worker(yaffs_obj_t *in, yaffs_tnode_t *tn, ++ __u32 level, int chunk_offset) + { - __u16 sum = 0; - __u16 i = 1; -- ++ int i; ++ int theChunk; ++ int allDone = 1; ++ yaffs_dev_t *dev = in->my_dev; + - const YUCHAR *bname = (const YUCHAR *) name; - if (bname) { - while ((*bname) && (i < (YAFFS_MAX_NAME_LENGTH/2))) { -- ++ if (tn) { ++ if (level > 0) { ++ ++ for (i = YAFFS_NTNODES_INTERNAL - 1; allDone && i >= 0; ++ i--) { ++ if (tn->internal[i]) { ++ allDone = ++ yaffs_soft_del_worker(in, ++ tn-> ++ internal[i], ++ level - 1, ++ (chunk_offset ++ << ++ YAFFS_TNODES_INTERNAL_BITS) ++ + i); ++ if (allDone) { ++ yaffs_free_tnode(dev, ++ tn-> ++ internal[i]); ++ tn->internal[i] = NULL; ++ } else { ++ /* Hoosterman... how could this happen? */ ++ } ++ } ++ } ++ return (allDone) ? 1 : 0; ++ } else if (level == 0) { ++ ++ for (i = YAFFS_NTNODES_LEVEL0 - 1; i >= 0; i--) { ++ theChunk = yaffs_get_group_base(dev, tn, i); ++ if (theChunk) { ++ /* Note this does not find the real chunk, only the chunk group. ++ * We make an assumption that a chunk group is not larger than ++ * a block. ++ */ ++ yaffs_soft_del_chunk(dev, theChunk); ++ yaffs_load_tnode_0(dev, tn, i, 0); ++ } ++ ++ } ++ return 1; + -#ifdef CONFIG_YAFFS_CASE_INSENSITIVE - sum += yaffs_toupper(*bname) * i; -#else @@ -5194,13 +6025,18 @@ -#endif - i++; - bname++; -- } -- } + } ++ + } - return sum; --} -- ++ ++ return 1; ++ + } + -static void yaffs_SetObjectName(yaffs_Object *obj, const YCHAR *name) --{ ++static void yaffs_soft_del_file(yaffs_obj_t *obj) + { -#ifdef CONFIG_YAFFS_SHORT_NAMES_IN_RAM - memset(obj->shortName, 0, sizeof(YCHAR) * (YAFFS_SHORT_NAME_LENGTH+1)); - if (name && yaffs_strlen(name) <= YAFFS_SHORT_NAME_LENGTH) @@ -5209,8 +6045,27 @@ - obj->shortName[0] = _Y('\0'); -#endif - obj->sum = yaffs_CalcNameSum(name); --} -- ++ if (obj->deleted && ++ obj->variant_type == YAFFS_OBJECT_TYPE_FILE && !obj->soft_del) { ++ if (obj->n_data_chunks <= 0) { ++ /* Empty file with no duplicate object headers, just delete it immediately */ ++ yaffs_free_tnode(obj->my_dev, ++ obj->variant.file_variant.top); ++ obj->variant.file_variant.top = NULL; ++ T(YAFFS_TRACE_TRACING, ++ (TSTR("yaffs: Deleting empty file %d" TENDSTR), ++ obj->obj_id)); ++ yaffs_generic_obj_del(obj); ++ } else { ++ yaffs_soft_del_worker(obj, ++ obj->variant.file_variant.top, ++ obj->variant.file_variant. ++ top_level, 0); ++ obj->soft_del = 1; ++ } ++ } + } + -/*-------------------- TNODES ------------------- - - * List of spare tnodes @@ -5221,39 +6076,81 @@ -/* yaffs_CreateTnodes creates a bunch more tnodes and - * adds them to the tnode free list. - * Don't use this function directly -- */ -- ++/* Pruning removes any part of the file structure tree that is beyond the ++ * bounds of the file (ie that does not point to chunks). ++ * ++ * A file should only get pruned when its size is reduced. ++ * ++ * Before pruning, the chunks must be pulled from the tree and the ++ * level 0 tnode entries must be zeroed out. ++ * Could also use this for file deletion, but that's probably better handled ++ * by a special case. ++ * ++ * This function is recursive. For levels > 0 the function is called again on ++ * any sub-tree. For level == 0 we just check if the sub-tree has data. ++ * If there is no data in a subtree then it is pruned. + */ + -static int yaffs_CreateTnodes(yaffs_Device *dev, int nTnodes) --{ -- int i; ++static yaffs_tnode_t *yaffs_prune_worker(yaffs_dev_t *dev, yaffs_tnode_t *tn, ++ __u32 level, int del0) + { + int i; - int tnodeSize; - yaffs_Tnode *newTnodes; - __u8 *mem; - yaffs_Tnode *curr; - yaffs_Tnode *next; - yaffs_TnodeList *tnl; -- ++ int hasData; + - if (nTnodes < 1) - return YAFFS_OK; -- ++ if (tn) { ++ hasData = 0; + - /* Calculate the tnode size in bytes for variable width tnode support. - * Must be a multiple of 32-bits */ - tnodeSize = (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8; -- ++ if(level > 0){ ++ for (i = 0; i < YAFFS_NTNODES_INTERNAL; i++) { ++ if (tn->internal[i]) { ++ tn->internal[i] = ++ yaffs_prune_worker(dev, tn->internal[i], ++ level - 1, ++ (i == 0) ? del0 : 1); ++ } + - if (tnodeSize < sizeof(yaffs_Tnode)) - tnodeSize = sizeof(yaffs_Tnode); -- ++ if (tn->internal[i]) ++ hasData++; ++ } ++ } else { ++ int tnode_size_u32 = dev->tnode_size/sizeof(__u32); ++ __u32 *map = (__u32 *)tn; + - /* make these things */ -- ++ for(i = 0; !hasData && i < tnode_size_u32; i++){ ++ if(map[i]) ++ hasData++; ++ } ++ } + - newTnodes = YMALLOC(nTnodes * tnodeSize); - mem = (__u8 *)newTnodes; -- ++ if (hasData == 0 && del0) { ++ /* Free and return NULL */ + - if (!newTnodes) { - T(YAFFS_TRACE_ERROR, - (TSTR("yaffs: Could not allocate Tnodes" TENDSTR))); - return YAFFS_FAIL; - } -- ++ yaffs_free_tnode(dev, tn); ++ tn = NULL; ++ } + - /* Hook them into the free list */ -#if 0 - for (i = 0; i < nTnodes - 1; i++) { @@ -5261,8 +6158,8 @@ -#ifdef CONFIG_YAFFS_TNODE_LIST_DEBUG - newTnodes[i].internal[YAFFS_NTNODES_INTERNAL] = (void *)1; -#endif -- } -- + } + - newTnodes[nTnodes - 1].internal[0] = dev->freeTnodes; -#ifdef CONFIG_YAFFS_TNODE_LIST_DEBUG - newTnodes[nTnodes - 1].internal[YAFFS_NTNODES_INTERNAL] = (void *)1; @@ -5275,22 +6172,48 @@ - next = (yaffs_Tnode *) &mem[(i+1) * tnodeSize]; - curr->internal[0] = next; - } -- ++ return tn; + - curr = (yaffs_Tnode *) &mem[(nTnodes - 1) * tnodeSize]; - curr->internal[0] = dev->freeTnodes; - dev->freeTnodes = (yaffs_Tnode *)mem; -- ++} + -#endif -- -- ++static int yaffs_prune_tree(yaffs_dev_t *dev, ++ yaffs_file_s *file_struct) ++{ ++ int i; ++ int hasData; ++ int done = 0; ++ yaffs_tnode_t *tn; + ++ if (file_struct->top_level > 0) { ++ file_struct->top = ++ yaffs_prune_worker(dev, file_struct->top, file_struct->top_level, 0); ++ ++ /* Now we have a tree with all the non-zero branches NULL but the height ++ * is the same as it was. ++ * Let's see if we can trim internal tnodes to shorten the tree. ++ * We can do this if only the 0th element in the tnode is in use ++ * (ie all the non-zero are NULL) ++ */ + - dev->nFreeTnodes += nTnodes; - dev->nTnodesCreated += nTnodes; -- ++ while (file_struct->top_level && !done) { ++ tn = file_struct->top; + - /* Now add this bunch of tnodes to a list for freeing up. - * NB If we can't add this to the management list it isn't fatal - * but it just means we can't free this bunch of tnodes later. - */ -- ++ hasData = 0; ++ for (i = 1; i < YAFFS_NTNODES_INTERNAL; i++) { ++ if (tn->internal[i]) ++ hasData++; ++ } + - tnl = YMALLOC(sizeof(yaffs_TnodeList)); - if (!tnl) { - T(YAFFS_TRACE_ERROR, @@ -5301,19 +6224,32 @@ - tnl->tnodes = newTnodes; - tnl->next = dev->allocatedTnodeList; - dev->allocatedTnodeList = tnl; -- } -- ++ if (!hasData) { ++ file_struct->top = tn->internal[0]; ++ file_struct->top_level--; ++ yaffs_free_tnode(dev, tn); ++ } else { ++ done = 1; ++ } ++ } + } + - T(YAFFS_TRACE_ALLOCATE, (TSTR("yaffs: Tnodes added" TENDSTR))); - -- return YAFFS_OK; --} -- + return YAFFS_OK; + } + -/* GetTnode gets us a clean tnode. Tries to make allocate more if we run out */ -- ++/*-------------------- End of File Structure functions.-------------------*/ ++ + -static yaffs_Tnode *yaffs_GetTnodeRaw(yaffs_Device *dev) --{ ++/* AllocateEmptyObject gets us a clean Object. Tries to make allocate more if we run out */ ++static yaffs_obj_t *yaffs_alloc_empty_obj(yaffs_dev_t *dev) + { - yaffs_Tnode *tn = NULL; -- ++ yaffs_obj_t *obj = yaffs_alloc_raw_obj(dev); + - /* If there are none left make more */ - if (!dev->freeTnodes) - yaffs_CreateTnodes(dev, YAFFS_ALLOCATION_NTNODES); @@ -5330,29 +6266,60 @@ - dev->freeTnodes = dev->freeTnodes->internal[0]; - dev->nFreeTnodes--; - } -- ++ if (obj) { ++ dev->n_obj++; + - dev->nCheckpointBlocksRequired = 0; /* force recalculation*/ -- ++ /* Now sweeten it up... */ + - return tn; -} -- ++ memset(obj, 0, sizeof(yaffs_obj_t)); ++ obj->being_created = 1; + -static yaffs_Tnode *yaffs_GetTnode(yaffs_Device *dev) -{ - yaffs_Tnode *tn = yaffs_GetTnodeRaw(dev); - int tnodeSize = (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8; -- ++ obj->my_dev = dev; ++ obj->hdr_chunk = 0; ++ obj->variant_type = YAFFS_OBJECT_TYPE_UNKNOWN; ++ YINIT_LIST_HEAD(&(obj->hard_links)); ++ YINIT_LIST_HEAD(&(obj->hash_link)); ++ YINIT_LIST_HEAD(&obj->siblings); + - if (tnodeSize < sizeof(yaffs_Tnode)) - tnodeSize = sizeof(yaffs_Tnode); -- + - if (tn) - memset(tn, 0, tnodeSize); -- ++ /* Now make the directory sane */ ++ if (dev->root_dir) { ++ obj->parent = dev->root_dir; ++ ylist_add(&(obj->siblings), &dev->root_dir->variant.dir_variant.children); ++ } + - return tn; --} -- ++ /* Add it to the lost and found directory. ++ * NB Can't put root or lostNFound in lostNFound so ++ * check if lostNFound exists first ++ */ ++ if (dev->lost_n_found) ++ yaffs_add_obj_to_dir(dev->lost_n_found, obj); ++ ++ obj->being_created = 0; ++ } ++ ++ dev->checkpoint_blocks_required = 0; /* force recalculation*/ ++ ++ return obj; + } + -/* FreeTnode frees up a tnode and puts it back on the free list */ -static void yaffs_FreeTnode(yaffs_Device *dev, yaffs_Tnode *tn) --{ ++static yaffs_obj_t *yaffs_create_fake_dir(yaffs_dev_t *dev, int number, ++ __u32 mode) + { - if (tn) { -#ifdef CONFIG_YAFFS_TNODE_LIST_DEBUG - if (tn->internal[YAFFS_NTNODES_INTERNAL] != 0) { @@ -5365,40 +6332,90 @@ - tn->internal[0] = dev->freeTnodes; - dev->freeTnodes = tn; - dev->nFreeTnodes++; -- } ++ ++ yaffs_obj_t *obj = ++ yaffs_new_obj(dev, number, YAFFS_OBJECT_TYPE_DIRECTORY); ++ if (obj) { ++ obj->fake = 1; /* it is fake so it might have no NAND presence... */ ++ obj->rename_allowed = 0; /* ... and we're not allowed to rename it... */ ++ obj->unlink_allowed = 0; /* ... or unlink it */ ++ obj->deleted = 0; ++ obj->unlinked = 0; ++ obj->yst_mode = mode; ++ obj->my_dev = dev; ++ obj->hdr_chunk = 0; /* Not a valid chunk. */ ++ } ++ ++ return obj; ++ ++} ++ ++static void yaffs_unhash_obj(yaffs_obj_t *obj) ++{ ++ int bucket; ++ yaffs_dev_t *dev = obj->my_dev; ++ ++ /* If it is still linked into the bucket list, free from the list */ ++ if (!ylist_empty(&obj->hash_link)) { ++ ylist_del_init(&obj->hash_link); ++ bucket = yaffs_hash_fn(obj->obj_id); ++ dev->obj_bucket[bucket].count--; + } - dev->nCheckpointBlocksRequired = 0; /* force recalculation*/ --} -- + } + -static void yaffs_DeinitialiseTnodes(yaffs_Device *dev) --{ ++/* FreeObject frees up a Object and puts it back on the free list */ ++static void yaffs_free_obj(yaffs_obj_t *obj) + { - /* Free the list of allocated tnodes */ - yaffs_TnodeList *tmp; -- ++ yaffs_dev_t *dev = obj->my_dev; ++ ++ T(YAFFS_TRACE_OS, (TSTR("FreeObject %p inode %p"TENDSTR), obj, obj->my_inode)); + - while (dev->allocatedTnodeList) { - tmp = dev->allocatedTnodeList->next; -- ++ if (!obj) ++ YBUG(); ++ if (obj->parent) ++ YBUG(); ++ if (!ylist_empty(&obj->siblings)) ++ YBUG(); + - YFREE(dev->allocatedTnodeList->tnodes); - YFREE(dev->allocatedTnodeList); - dev->allocatedTnodeList = tmp; -- -- } -- + ++ if (obj->my_inode) { ++ /* We're still hooked up to a cached inode. ++ * Don't delete now, but mark for later deletion ++ */ ++ obj->defered_free = 1; ++ return; + } + - dev->freeTnodes = NULL; - dev->nFreeTnodes = 0; -} -- ++ yaffs_unhash_obj(obj); + -static void yaffs_InitialiseTnodes(yaffs_Device *dev) -{ - dev->allocatedTnodeList = NULL; - dev->freeTnodes = NULL; - dev->nFreeTnodes = 0; - dev->nTnodesCreated = 0; --} -- -- ++ yaffs_free_raw_obj(dev,obj); ++ dev->n_obj--; ++ dev->checkpoint_blocks_required = 0; /* force recalculation*/ + } + + -void yaffs_PutLevel0Tnode(yaffs_Device *dev, yaffs_Tnode *tn, unsigned pos, - unsigned val) --{ ++void yaffs_handle_defered_free(yaffs_obj_t *obj) + { - __u32 *map = (__u32 *)tn; - __u32 bitInMap; - __u32 bitInWord; @@ -5407,54 +6424,81 @@ - - pos &= YAFFS_TNODES_LEVEL0_MASK; - val >>= dev->chunkGroupBits; -- ++ if (obj->defered_free) ++ yaffs_free_obj(obj); ++} + - bitInMap = pos * dev->tnodeWidth; - wordInMap = bitInMap / 32; - bitInWord = bitInMap & (32 - 1); -- ++static void yaffs_init_tnodes_and_objs(yaffs_dev_t *dev) ++{ ++ int i; + - mask = dev->tnodeMask << bitInWord; -- ++ dev->n_obj = 0; ++ dev->n_tnodes = 0; + - map[wordInMap] &= ~mask; - map[wordInMap] |= (mask & (val << bitInWord)); -- ++ yaffs_init_raw_tnodes_and_objs(dev); + - if (dev->tnodeWidth > (32 - bitInWord)) { - bitInWord = (32 - bitInWord); - wordInMap++;; - mask = dev->tnodeMask >> (/*dev->tnodeWidth -*/ bitInWord); - map[wordInMap] &= ~mask; - map[wordInMap] |= (mask & (val >> bitInWord)); -- } --} -- ++ for (i = 0; i < YAFFS_NOBJECT_BUCKETS; i++) { ++ YINIT_LIST_HEAD(&dev->obj_bucket[i].list); ++ dev->obj_bucket[i].count = 0; + } + } + -static __u32 yaffs_GetChunkGroupBase(yaffs_Device *dev, yaffs_Tnode *tn, - unsigned pos) --{ ++static int yaffs_find_nice_bucket(yaffs_dev_t *dev) + { - __u32 *map = (__u32 *)tn; - __u32 bitInMap; - __u32 bitInWord; - __u32 wordInMap; - __u32 val; -- ++ int i; ++ int l = 999; ++ int lowest = 999999; + - pos &= YAFFS_TNODES_LEVEL0_MASK; -- + - bitInMap = pos * dev->tnodeWidth; - wordInMap = bitInMap / 32; - bitInWord = bitInMap & (32 - 1); -- ++ /* Search for the shortest list or one that ++ * isn't too long. ++ */ + - val = map[wordInMap] >> bitInWord; -- ++ for (i = 0; i < 10 && lowest > 4; i++) { ++ dev->bucket_finder++; ++ dev->bucket_finder %= YAFFS_NOBJECT_BUCKETS; ++ if (dev->obj_bucket[dev->bucket_finder].count < lowest) { ++ lowest = dev->obj_bucket[dev->bucket_finder].count; ++ l = dev->bucket_finder; ++ } + - if (dev->tnodeWidth > (32 - bitInWord)) { - bitInWord = (32 - bitInWord); - wordInMap++;; - val |= (map[wordInMap] << bitInWord); -- } -- + } + - val &= dev->tnodeMask; - val <<= dev->chunkGroupBits; - - return val; --} -- ++ return l; + } + -/* ------------------- End of individual tnode manipulation -----------------*/ - -/* ---------Functions to manipulate the look-up tree (made up of tnodes) ------ @@ -5466,7 +6510,8 @@ -static yaffs_Tnode *yaffs_FindLevel0Tnode(yaffs_Device *dev, - yaffs_FileStructure *fStruct, - __u32 chunkId) --{ ++static int yaffs_new_obj_id(yaffs_dev_t *dev) + { - yaffs_Tnode *tn = fStruct->top; - __u32 i; - int requiredTallness; @@ -5475,22 +6520,30 @@ - /* Check sane level and chunk Id */ - if (level < 0 || level > YAFFS_TNODES_MAX_LEVEL) - return NULL; -- ++ int bucket = yaffs_find_nice_bucket(dev); + - if (chunkId > YAFFS_MAX_CHUNK_ID) - return NULL; -- ++ /* Now find an object value that has not already been taken ++ * by scanning the list. ++ */ + - /* First check we're tall enough (ie enough topLevel) */ -- ++ int found = 0; ++ struct ylist_head *i; + - i = chunkId >> YAFFS_TNODES_LEVEL0_BITS; - requiredTallness = 0; - while (i) { - i >>= YAFFS_TNODES_INTERNAL_BITS; - requiredTallness++; - } -- ++ __u32 n = (__u32) bucket; + - if (requiredTallness > fStruct->topLevel) - return NULL; /* Not tall enough, so we can't find it */ -- ++ /* yaffs_check_obj_hash_sane(); */ + - /* Traverse down to level 0 */ - while (level > 0 && tn) { - tn = tn->internal[(chunkId >> @@ -5499,11 +6552,24 @@ - YAFFS_TNODES_INTERNAL_BITS)) & - YAFFS_TNODES_INTERNAL_MASK]; - level--; -- } -- ++ while (!found) { ++ found = 1; ++ n += YAFFS_NOBJECT_BUCKETS; ++ if (1 || dev->obj_bucket[bucket].count > 0) { ++ ylist_for_each(i, &dev->obj_bucket[bucket].list) { ++ /* If there is already one in the list */ ++ if (i && ylist_entry(i, yaffs_obj_t, ++ hash_link)->obj_id == n) { ++ found = 0; ++ } ++ } ++ } + } + - return tn; --} -- ++ return n; + } + -/* AddOrFindLevel0Tnode finds the level 0 tnode if it exists, otherwise first expands the tree. - * This happens in two steps: - * 1. If the tree isn't tall enough, then make it taller. @@ -5519,38 +6585,69 @@ - yaffs_FileStructure *fStruct, - __u32 chunkId, - yaffs_Tnode *passedTn) --{ ++static void yaffs_hash_obj(yaffs_obj_t *in) + { - int requiredTallness; - int i; - int l; - yaffs_Tnode *tn; - - __u32 x; -- -- ++ int bucket = yaffs_hash_fn(in->obj_id); ++ yaffs_dev_t *dev = in->my_dev; + ++ ylist_add(&in->hash_link, &dev->obj_bucket[bucket].list); ++ dev->obj_bucket[bucket].count++; ++} + - /* Check sane level and page Id */ - if (fStruct->topLevel < 0 || fStruct->topLevel > YAFFS_TNODES_MAX_LEVEL) - return NULL; -- ++yaffs_obj_t *yaffs_find_by_number(yaffs_dev_t *dev, __u32 number) ++{ ++ int bucket = yaffs_hash_fn(number); ++ struct ylist_head *i; ++ yaffs_obj_t *in; + - if (chunkId > YAFFS_MAX_CHUNK_ID) - return NULL; -- ++ ylist_for_each(i, &dev->obj_bucket[bucket].list) { ++ /* Look if it is in the list */ ++ if (i) { ++ in = ylist_entry(i, yaffs_obj_t, hash_link); ++ if (in->obj_id == number) { + - /* First check we're tall enough (ie enough topLevel) */ -- ++ /* Don't tell the VFS about this one if it is defered free */ ++ if (in->defered_free) ++ return NULL; + - x = chunkId >> YAFFS_TNODES_LEVEL0_BITS; - requiredTallness = 0; - while (x) { - x >>= YAFFS_TNODES_INTERNAL_BITS; - requiredTallness++; -- } -- -- ++ return in; ++ } ++ } + } + ++ return NULL; ++} + - if (requiredTallness > fStruct->topLevel) { - /* Not tall enough, gotta make the tree taller */ - for (i = fStruct->topLevel; i < requiredTallness; i++) { -- ++yaffs_obj_t *yaffs_new_obj(yaffs_dev_t *dev, int number, ++ yaffs_obj_type type) ++{ ++ yaffs_obj_t *theObject=NULL; ++ yaffs_tnode_t *tn = NULL; + - tn = yaffs_GetTnode(dev); -- ++ if (number < 0) ++ number = yaffs_new_obj_id(dev); + - if (tn) { - tn->internal[0] = fStruct->top; - fStruct->top = tn; @@ -5559,27 +6656,86 @@ - (TSTR("yaffs: no more tnodes" TENDSTR))); - } - } -- ++ if (type == YAFFS_OBJECT_TYPE_FILE) { ++ tn = yaffs_get_tnode(dev); ++ if (!tn) ++ return NULL; ++ } + - fStruct->topLevel = requiredTallness; -- } -- ++ theObject = yaffs_alloc_empty_obj(dev); ++ if (!theObject){ ++ if(tn) ++ yaffs_free_tnode(dev,tn); ++ return NULL; + } + - /* Traverse down to level 0, adding anything we need */ -- + - l = fStruct->topLevel; - tn = fStruct->top; -- ++ if (theObject) { ++ theObject->fake = 0; ++ theObject->rename_allowed = 1; ++ theObject->unlink_allowed = 1; ++ theObject->obj_id = number; ++ yaffs_hash_obj(theObject); ++ theObject->variant_type = type; ++#ifdef CONFIG_YAFFS_WINCE ++ yfsd_win_file_time_now(theObject->win_atime); ++ theObject->win_ctime[0] = theObject->win_mtime[0] = ++ theObject->win_atime[0]; ++ theObject->win_ctime[1] = theObject->win_mtime[1] = ++ theObject->win_atime[1]; ++ ++#else + - if (l > 0) { - while (l > 0 && tn) { - x = (chunkId >> - (YAFFS_TNODES_LEVEL0_BITS + - (l - 1) * YAFFS_TNODES_INTERNAL_BITS)) & - YAFFS_TNODES_INTERNAL_MASK; -- -- ++ theObject->yst_atime = theObject->yst_mtime = ++ theObject->yst_ctime = Y_CURRENT_TIME; ++#endif ++ switch (type) { ++ case YAFFS_OBJECT_TYPE_FILE: ++ theObject->variant.file_variant.file_size = 0; ++ theObject->variant.file_variant.scanned_size = 0; ++ theObject->variant.file_variant.shrink_size = 0xFFFFFFFF; /* max __u32 */ ++ theObject->variant.file_variant.top_level = 0; ++ theObject->variant.file_variant.top = tn; ++ break; ++ case YAFFS_OBJECT_TYPE_DIRECTORY: ++ YINIT_LIST_HEAD(&theObject->variant.dir_variant. ++ children); ++ YINIT_LIST_HEAD(&theObject->variant.dir_variant. ++ dirty); ++ break; ++ case YAFFS_OBJECT_TYPE_SYMLINK: ++ case YAFFS_OBJECT_TYPE_HARDLINK: ++ case YAFFS_OBJECT_TYPE_SPECIAL: ++ /* No action required */ ++ break; ++ case YAFFS_OBJECT_TYPE_UNKNOWN: ++ /* todo this should not happen */ ++ break; ++ } ++ } + ++ return theObject; ++} + - if ((l > 1) && !tn->internal[x]) { - /* Add missing non-level-zero tnode */ - tn->internal[x] = yaffs_GetTnode(dev); -- ++yaffs_obj_t *yaffs_find_or_create_by_number(yaffs_dev_t *dev, ++ int number, ++ yaffs_obj_type type) ++{ ++ yaffs_obj_t *theObject = NULL; + - } else if (l == 1) { - /* Looking from level 1 at level 0 */ - if (passedTn) { @@ -5587,13 +6743,17 @@ - if (tn->internal[x]) - yaffs_FreeTnode(dev, tn->internal[x]); - tn->internal[x] = passedTn; -- ++ if (number > 0) ++ theObject = yaffs_find_by_number(dev, number); + - } else if (!tn->internal[x]) { - /* Don't have one, none passed in */ - tn->internal[x] = yaffs_GetTnode(dev); - } - } -- ++ if (!theObject) ++ theObject = yaffs_new_obj(dev, number, type); + - tn = tn->internal[x]; - l--; - } @@ -5604,16 +6764,21 @@ - yaffs_FreeTnode(dev, passedTn); - } - } -- ++ return theObject; + - return tn; --} -- + } + -static int yaffs_FindChunkInGroup(yaffs_Device *dev, int theChunk, - yaffs_ExtendedTags *tags, int objectId, - int chunkInInode) --{ ++ ++YCHAR *yaffs_clone_str(const YCHAR *str) + { - int j; -- ++ YCHAR *newStr = NULL; ++ int len; + - for (j = 0; theChunk && j < dev->chunkGroupSize; j++) { - if (yaffs_CheckChunkBit(dev, theChunk / dev->nChunksPerBlock, - theChunk % dev->nChunksPerBlock)) { @@ -5625,20 +6790,43 @@ - } - } - theChunk++; -- } ++ if (!str) ++ str = _Y(""); ++ ++ len = yaffs_strnlen(str,YAFFS_MAX_ALIAS_LENGTH); ++ newStr = YMALLOC((len + 1) * sizeof(YCHAR)); ++ if (newStr){ ++ yaffs_strncpy(newStr, str,len); ++ newStr[len] = 0; + } - return -1; -} -- -- ++ return newStr; + ++} + -/* DeleteWorker scans backwards through the tnode tree and deletes all the - * chunks and tnodes in the file - * Returns 1 if the tree was deleted. - * Returns 0 if it stopped early due to hitting the limit and the delete is incomplete. -- */ -- ++/* ++ * Mknod (create) a new object. ++ * equiv_obj only has meaning for a hard link; ++ * aliasString only has meaning for a symlink. ++ * rdev only has meaning for devices (a subset of special objects) + */ + -static int yaffs_DeleteWorker(yaffs_Object *in, yaffs_Tnode *tn, __u32 level, - int chunkOffset, int *limit) --{ ++static yaffs_obj_t *yaffs_create_obj(yaffs_obj_type type, ++ yaffs_obj_t *parent, ++ const YCHAR *name, ++ __u32 mode, ++ __u32 uid, ++ __u32 gid, ++ yaffs_obj_t *equiv_obj, ++ const YCHAR *aliasString, __u32 rdev) + { - int i; - int chunkInInode; - int theChunk; @@ -7237,9 +8425,7 @@ - } - - yaffs_VerifyCollectedBlock(dev, bi, block); -+ if (chunkId > YAFFS_MAX_CHUNK_ID) -+ return NULL; - +- - chunksAfter = yaffs_GetErasedChunks(dev); - if (chunksBefore >= chunksAfter) { - T(YAFFS_TRACE_GC, @@ -7247,24 +8433,18 @@ - ("gc did not increase free chunks before %d after %d" - TENDSTR), chunksBefore, chunksAfter)); - } -+ /* First check we're tall enough (ie enough topLevel) */ - +- - /* If the gc completed then clear the current gcBlock so that we find another. */ - if (bi->blockState != YAFFS_BLOCK_STATE_COLLECTING) { - dev->gcBlock = -1; - dev->gcChunk = 0; -+ x = chunkId >> YAFFS_TNODES_LEVEL0_BITS; -+ requiredTallness = 0; -+ while (x) { -+ x >>= YAFFS_TNODES_INTERNAL_BITS; -+ requiredTallness++; - } - +- } +- - dev->isDoingGC = 0; - - return retVal; -} - +- -/* New garbage collector - * If we're very low on erased blocks then we do aggressive garbage collection - * otherwise we do "leasurely" garbage collection. @@ -7280,28 +8460,14 @@ - int aggressive; - int gcOk = YAFFS_OK; - int maxTries = 0; -+ if (requiredTallness > fStruct->topLevel) { -+ /* Not tall enough, gotta make the tree taller */ -+ for (i = fStruct->topLevel; i < requiredTallness; i++) { - +- - int checkpointBlockAdjust; -+ tn = yaffs_GetTnode(dev); - +- - if (dev->isDoingGC) { - /* Bail out so we don't get recursive gc */ - return YAFFS_OK; -+ if (tn) { -+ tn->internal[0] = fStruct->top; -+ fStruct->top = tn; -+ fStruct->topLevel++; -+ } else { -+ T(YAFFS_TRACE_ERROR, -+ (TSTR("yaffs: no more tnodes" TENDSTR))); -+ return NULL; -+ } -+ } - } - +- } +- - /* This loop should pass the first time. - * We'll only see looping here if the erase of the collected block fails. - */ @@ -7312,8 +8478,7 @@ - checkpointBlockAdjust = yaffs_CalcCheckpointBlocksRequired(dev) - dev->blocksInCheckpoint; - if (checkpointBlockAdjust < 0) - checkpointBlockAdjust = 0; -+ /* Traverse down to level 0, adding anything we need */ - +- - if (dev->nErasedBlocks < (dev->nReservedBlocks + checkpointBlockAdjust + 2)) { - /* We need a block soon...*/ - aggressive = 1; @@ -7321,189 +8486,81 @@ - /* We're in no hurry */ - aggressive = 0; - } -+ l = fStruct->topLevel; -+ tn = fStruct->top; - +- - if (dev->gcBlock <= 0) { - dev->gcBlock = yaffs_FindBlockForGarbageCollection(dev, aggressive); - dev->gcChunk = 0; - } -+ if (l > 0) { -+ while (l > 0 && tn) { -+ x = (chunkId >> -+ (YAFFS_TNODES_LEVEL0_BITS + -+ (l - 1) * YAFFS_TNODES_INTERNAL_BITS)) & -+ YAFFS_TNODES_INTERNAL_MASK; - +- - block = dev->gcBlock; - +- - if (block > 0) { - dev->garbageCollections++; - if (!aggressive) - dev->passiveGarbageCollections++; -+ if ((l > 1) && !tn->internal[x]) { -+ /* Add missing non-level-zero tnode */ -+ tn->internal[x] = yaffs_GetTnode(dev); -+ if(!tn->internal[x]) -+ return NULL; -+ } else if (l == 1) { -+ /* Looking from level 1 at level 0 */ -+ if (passedTn) { -+ /* If we already have one, then release it.*/ -+ if (tn->internal[x]) -+ yaffs_FreeTnode(dev, tn->internal[x]); -+ tn->internal[x] = passedTn; - +- - T(YAFFS_TRACE_GC, - (TSTR - ("yaffs: GC erasedBlocks %d aggressive %d" TENDSTR), - dev->nErasedBlocks, aggressive)); -+ } else if (!tn->internal[x]) { -+ /* Don't have one, none passed in */ -+ tn->internal[x] = yaffs_GetTnode(dev); -+ if(!tn->internal[x]) -+ return NULL; -+ } -+ } - +- - gcOk = yaffs_GarbageCollectBlock(dev, block, aggressive); -+ tn = tn->internal[x]; -+ l--; - } +- } - - if (dev->nErasedBlocks < (dev->nReservedBlocks) && block > 0) { - T(YAFFS_TRACE_GC, - (TSTR - ("yaffs: GC !!!no reclaim!!! erasedBlocks %d after try %d block %d" - TENDSTR), dev->nErasedBlocks, maxTries, block)); -+ } else { -+ /* top is level 0 */ -+ if (passedTn) { -+ memcpy(tn, passedTn, (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8); -+ yaffs_FreeTnode(dev, passedTn); - } +- } - } while ((dev->nErasedBlocks < dev->nReservedBlocks) && - (block > 0) && - (maxTries < 2)); -+ } - +- - return aggressive ? gcOk : YAFFS_OK; -+ return tn; - } - +-} +- -/*------------------------- TAGS --------------------------------*/ - -static int yaffs_TagsMatch(const yaffs_ExtendedTags *tags, int objectId, - int chunkInObject) -+static int yaffs_FindChunkInGroup(yaffs_Device *dev, int theChunk, -+ yaffs_ExtendedTags *tags, int objectId, -+ int chunkInInode) - { +-{ - return (tags->chunkId == chunkInObject && - tags->objectId == objectId && !tags->chunkDeleted) ? 1 : 0; -+ int j; - -+ for (j = 0; theChunk && j < dev->chunkGroupSize; j++) { -+ if (yaffs_CheckChunkBit(dev, theChunk / dev->param.nChunksPerBlock, -+ theChunk % dev->param.nChunksPerBlock)) { -+ -+ if(dev->chunkGroupSize == 1) -+ return theChunk; -+ else { -+ yaffs_ReadChunkWithTagsFromNAND(dev, theChunk, NULL, -+ tags); -+ if (yaffs_TagsMatch(tags, objectId, chunkInInode)) { -+ /* found it; */ -+ return theChunk; -+ } -+ } -+ } -+ theChunk++; -+ } -+ return -1; - } - -+#if 0 -+/* Experimental code not being used yet. Might speed up file deletion */ -+/* DeleteWorker scans backwards through the tnode tree and deletes all the -+ * chunks and tnodes in the file. -+ * Returns 1 if the tree was deleted. -+ * Returns 0 if it stopped early due to hitting the limit and the delete is incomplete. -+ */ - +- +-} +- +- -/*-------------------- Data file manipulation -----------------*/ - -static int yaffs_FindChunkInFile(yaffs_Object *in, int chunkInInode, - yaffs_ExtendedTags *tags) -+static int yaffs_DeleteWorker(yaffs_Object *in, yaffs_Tnode *tn, __u32 level, -+ int chunkOffset, int *limit) - { +-{ - /*Get the Tnode, then get the level 0 offset chunk offset */ - yaffs_Tnode *tn; - int theChunk = -1; - yaffs_ExtendedTags localTags; - int retVal = -1; - -+ int i; -+ int chunkInInode; -+ int theChunk; -+ yaffs_ExtendedTags tags; -+ int foundChunk; - yaffs_Device *dev = in->myDev; - +- yaffs_Device *dev = in->myDev; +- - if (!tags) { - /* Passed a NULL, so use our own tags space */ - tags = &localTags; - } - - tn = yaffs_FindLevel0Tnode(dev, &in->variant.fileVariant, chunkInInode); -+ int allDone = 1; - - if (tn) { +- +- if (tn) { - theChunk = yaffs_GetChunkGroupBase(dev, tn, chunkInInode); -+ if (level > 0) { -+ for (i = YAFFS_NTNODES_INTERNAL - 1; allDone && i >= 0; -+ i--) { -+ if (tn->internal[i]) { -+ if (limit && (*limit) < 0) { -+ allDone = 0; -+ } else { -+ allDone = -+ yaffs_DeleteWorker(in, -+ tn-> -+ internal -+ [i], -+ level - -+ 1, -+ (chunkOffset -+ << -+ YAFFS_TNODES_INTERNAL_BITS) -+ + i, -+ limit); -+ } -+ if (allDone) { -+ yaffs_FreeTnode(dev, -+ tn-> -+ internal[i]); -+ tn->internal[i] = NULL; -+ } -+ } -+ } -+ return (allDone) ? 1 : 0; -+ } else if (level == 0) { -+ int hitLimit = 0; - +- - retVal = - yaffs_FindChunkInGroup(dev, theChunk, tags, in->objectId, - chunkInInode); - } - return retVal; -} -+ for (i = YAFFS_NTNODES_LEVEL0 - 1; i >= 0 && !hitLimit; -+ i--) { -+ theChunk = yaffs_GetChunkGroupBase(dev, tn, i); -+ if (theChunk) { - +- -static int yaffs_FindAndDeleteChunkInFile(yaffs_Object *in, int chunkInInode, - yaffs_ExtendedTags *tags) -{ @@ -7511,88 +8568,37 @@ - yaffs_Tnode *tn; - int theChunk = -1; - yaffs_ExtendedTags localTags; -+ chunkInInode = (chunkOffset << -+ YAFFS_TNODES_LEVEL0_BITS) + i; -+ -+ foundChunk = -+ yaffs_FindChunkInGroup(dev, -+ theChunk, -+ &tags, -+ in->objectId, -+ chunkInInode); -+ -+ if (foundChunk > 0) { -+ yaffs_DeleteChunk(dev, -+ foundChunk, 1, -+ __LINE__); -+ in->nDataChunks--; -+ if (limit) { -+ *limit = *limit - 1; -+ if (*limit <= 0) -+ hitLimit = 1; -+ } - +- - yaffs_Device *dev = in->myDev; - int retVal = -1; -+ } -+ -+ yaffs_LoadLevel0Tnode(dev, tn, i, 0); -+ } -+ -+ } -+ return (i < 0) ? 1 : 0; -+ -+ } - +- - if (!tags) { - /* Passed a NULL, so use our own tags space */ - tags = &localTags; - } - +- } +- - tn = yaffs_FindLevel0Tnode(dev, &in->variant.fileVariant, chunkInInode); -+ return 1; - +- - if (tn) { -+} - +- - theChunk = yaffs_GetChunkGroupBase(dev, tn, chunkInInode); -+#endif - +- - retVal = - yaffs_FindChunkInGroup(dev, theChunk, tags, in->objectId, - chunkInInode); -+static void yaffs_SoftDeleteChunk(yaffs_Device *dev, int chunk) -+{ -+ yaffs_BlockInfo *theBlock; -+ unsigned blockNo; - +- - /* Delete the entry in the filestructure (if found) */ - if (retVal != -1) - yaffs_PutLevel0Tnode(dev, tn, chunkInInode, 0); - } -+ T(YAFFS_TRACE_DELETION, (TSTR("soft delete chunk %d" TENDSTR), chunk)); - +- - return retVal; -+ blockNo = chunk / dev->param.nChunksPerBlock; -+ theBlock = yaffs_GetBlockInfo(dev, blockNo); -+ if (theBlock) { -+ theBlock->softDeletions++; -+ dev->nFreeChunks++; -+ yaffs2_UpdateOldestDirtySequence(dev, blockNo, theBlock); -+ } - } - +-} +- -#ifdef YAFFS_PARANOID -+/* SoftDeleteWorker scans backwards through the tnode tree and soft deletes all the chunks in the file. -+ * All soft deleting does is increment the block's softdelete count and pulls the chunk out -+ * of the tnode. -+ * Thus, essentially this is the same as DeleteWorker except that the chunks are soft deleted. -+ */ - +- -static int yaffs_CheckFileSanity(yaffs_Object *in) -+static int yaffs_SoftDeleteWorker(yaffs_Object *in, yaffs_Tnode *tn, -+ __u32 level, int chunkOffset) - { +-{ - int chunk; - int nChunks; - int fSize; @@ -7601,17 +8607,12 @@ - yaffs_Tnode *tn; - yaffs_Tags localTags; - yaffs_Tags *tags = &localTags; -+ int i; - int theChunk; +- int theChunk; - int chunkDeleted; -+ int allDone = 1; -+ yaffs_Device *dev = in->myDev; - +- - if (in->variantType != YAFFS_OBJECT_TYPE_FILE) - return YAFFS_FAIL; -+ if (tn) { -+ if (level > 0) { - +- - objId = in->objectId; - fSize = in->variant.fileVariant.fileSize; - nChunks = @@ -7635,118 +8636,38 @@ - if (yaffs_TagsMatch - (tags, in->objectId, chunk, chunkDeleted)) { - /* found it; */ -+ for (i = YAFFS_NTNODES_INTERNAL - 1; allDone && i >= 0; -+ i--) { -+ if (tn->internal[i]) { -+ allDone = -+ yaffs_SoftDeleteWorker(in, -+ tn-> -+ internal[i], -+ level - 1, -+ (chunkOffset -+ << -+ YAFFS_TNODES_INTERNAL_BITS) -+ + i); -+ if (allDone) { -+ yaffs_FreeTnode(dev, -+ tn-> -+ internal[i]); -+ tn->internal[i] = NULL; -+ } else { -+ /* Hoosterman... how could this happen? */ -+ } -+ } -+ } -+ return (allDone) ? 1 : 0; -+ } else if (level == 0) { - -+ for (i = YAFFS_NTNODES_LEVEL0 - 1; i >= 0; i--) { -+ theChunk = yaffs_GetChunkGroupBase(dev, tn, i); -+ if (theChunk) { -+ /* Note this does not find the real chunk, only the chunk group. -+ * We make an assumption that a chunk group is not larger than -+ * a block. -+ */ -+ yaffs_SoftDeleteChunk(dev, theChunk); -+ yaffs_LoadLevel0Tnode(dev, tn, i, 0); - } +- +- } - } else { - +- - failed = 1; - } -+ return 1; - +- } +- - } else { - /* T(("No level 0 found for %d\n", chunk)); */ - } -+ - } - +- } +- } +- - return failed ? YAFFS_FAIL : YAFFS_OK; -+ return 1; -+ - } - +-} +- -#endif -+static void yaffs_SoftDeleteFile(yaffs_Object *obj) -+{ -+ if (obj->deleted && -+ obj->variantType == YAFFS_OBJECT_TYPE_FILE && !obj->softDeleted) { -+ if (obj->nDataChunks <= 0) { -+ /* Empty file with no duplicate object headers, just delete it immediately */ -+ yaffs_FreeTnode(obj->myDev, -+ obj->variant.fileVariant.top); -+ obj->variant.fileVariant.top = NULL; -+ T(YAFFS_TRACE_TRACING, -+ (TSTR("yaffs: Deleting empty file %d" TENDSTR), -+ obj->objectId)); -+ yaffs_DoGenericObjectDeletion(obj); -+ } else { -+ yaffs_SoftDeleteWorker(obj, -+ obj->variant.fileVariant.top, -+ obj->variant.fileVariant. -+ topLevel, 0); -+ obj->softDeleted = 1; -+ } -+ } -+} - +- -static int yaffs_PutChunkIntoFile(yaffs_Object *in, int chunkInInode, - int chunkInNAND, int inScan) -+/* Pruning removes any part of the file structure tree that is beyond the -+ * bounds of the file (ie that does not point to chunks). -+ * -+ * A file should only get pruned when its size is reduced. -+ * -+ * Before pruning, the chunks must be pulled from the tree and the -+ * level 0 tnode entries must be zeroed out. -+ * Could also use this for file deletion, but that's probably better handled -+ * by a special case. -+ * -+ * This function is recursive. For levels > 0 the function is called again on -+ * any sub-tree. For level == 0 we just check if the sub-tree has data. -+ * If there is no data in a subtree then it is pruned. -+ */ -+ -+static yaffs_Tnode *yaffs_PruneWorker(yaffs_Device *dev, yaffs_Tnode *tn, -+ __u32 level, int del0) - { +-{ - /* NB inScan is zero unless scanning. - * For forward scanning, inScan is > 0; - * for backward scanning inScan is < 0 - */ -+ int i; -+ int hasData; - +- - yaffs_Tnode *tn; - yaffs_Device *dev = in->myDev; - int existingChunk; - yaffs_ExtendedTags existingTags; - yaffs_ExtendedTags newTags; - unsigned existingSerial, newSerial; -+ if (tn) { -+ hasData = 0; - +- - if (in->variantType != YAFFS_OBJECT_TYPE_FILE) { - /* Just ignore an attempt at putting a chunk into a non-file during scanning - * If it is not during Scanning then something went wrong! @@ -7758,41 +8679,20 @@ - TENDSTR))); - YBUG(); - } -+ if(level > 0){ -+ for (i = 0; i < YAFFS_NTNODES_INTERNAL; i++) { -+ if (tn->internal[i]) { -+ tn->internal[i] = -+ yaffs_PruneWorker(dev, tn->internal[i], -+ level - 1, -+ (i == 0) ? del0 : 1); -+ } - +- - yaffs_DeleteChunk(dev, chunkInNAND, 1, __LINE__); - return YAFFS_OK; - } -+ if (tn->internal[i]) -+ hasData++; -+ } -+ } else { -+ int tnodeSize_u32 = dev->tnodeSize/sizeof(__u32); -+ __u32 *map = (__u32 *)tn; - +- - tn = yaffs_AddOrFindLevel0Tnode(dev, - &in->variant.fileVariant, - chunkInInode, - NULL); - if (!tn) - return YAFFS_FAIL; -+ for(i = 0; !hasData && i < tnodeSize_u32; i++){ -+ if(map[i]) -+ hasData++; -+ } -+ } - +- - existingChunk = yaffs_GetChunkGroupBase(dev, tn, chunkInInode); -+ if (hasData == 0 && del0) { -+ /* Free and return NULL */ - +- - if (inScan != 0) { - /* If we're scanning then we need to test for duplicates - * NB This does not need to be efficient since it should only ever @@ -7802,10 +8702,7 @@ - * Correction for YAFFS2: This could happen quite a lot and we need to think about efficiency! TODO - * Update: For backward scanning we don't need to re-read tags so this is quite cheap. - */ -+ yaffs_FreeTnode(dev, tn); -+ tn = NULL; -+ } - +- - if (existingChunk > 0) { - /* NB Right now existing chunk will not be real chunkId if the device >= 32MB - * thus we have to do a FindChunkInFile to get the real chunk id. @@ -7816,62 +8713,37 @@ - * Forward scanning YAFFS2: The new one is what we use, dump the old one. - * YAFFS1: Get both sets of tags and compare serial numbers. - */ -+ } - +- - if (inScan > 0) { - /* Only do this for forward scanning */ - yaffs_ReadChunkWithTagsFromNAND(dev, - chunkInNAND, - NULL, &newTags); -+ return tn; - +- - /* Do a proper find */ - existingChunk = - yaffs_FindChunkInFile(in, chunkInInode, - &existingTags); - } -+} - +- - if (existingChunk <= 0) { - /*Hoosterman - how did this happen? */ -+static int yaffs_PruneFileStructure(yaffs_Device *dev, -+ yaffs_FileStructure *fStruct) -+{ -+ int i; -+ int hasData; -+ int done = 0; -+ yaffs_Tnode *tn; - +- - T(YAFFS_TRACE_ERROR, - (TSTR - ("yaffs tragedy: existing chunk < 0 in scan" - TENDSTR))); -+ if (fStruct->topLevel > 0) { -+ fStruct->top = -+ yaffs_PruneWorker(dev, fStruct->top, fStruct->topLevel, 0); - +- - } -+ /* Now we have a tree with all the non-zero branches NULL but the height -+ * is the same as it was. -+ * Let's see if we can trim internal tnodes to shorten the tree. -+ * We can do this if only the 0th element in the tnode is in use -+ * (ie all the non-zero are NULL) -+ */ - +- - /* NB The deleted flags should be false, otherwise the chunks will - * not be loaded during a scan - */ -+ while (fStruct->topLevel && !done) { -+ tn = fStruct->top; - +- - if (inScan > 0) { - newSerial = newTags.serialNumber; - existingSerial = existingTags.serialNumber; -+ hasData = 0; -+ for (i = 1; i < YAFFS_NTNODES_INTERNAL; i++) { -+ if (tn->internal[i]) -+ hasData++; - } +- } - - if ((inScan > 0) && - (in->myDev->isYaffs2 || @@ -7891,26 +8763,19 @@ - yaffs_DeleteChunk(dev, chunkInNAND, 1, - __LINE__); - return YAFFS_OK; -+ -+ if (!hasData) { -+ fStruct->top = tn->internal[0]; -+ fStruct->topLevel--; -+ yaffs_FreeTnode(dev, tn); -+ } else { -+ done = 1; - } - } +- } +- } +- +- } - - } - - if (existingChunk == 0) - in->nDataChunks++; - - yaffs_PutLevel0Tnode(dev, tn, chunkInInode, chunkInNAND); - - return YAFFS_OK; - } - +- return YAFFS_OK; +-} +- -static int yaffs_ReadChunkDataFromObject(yaffs_Object *in, int chunkInInode, - __u8 *buffer) -{ @@ -7927,78 +8792,47 @@ - memset(buffer, 0, in->myDev->nDataBytesPerChunk); - return 0; - } -+/*-------------------- End of File Structure functions.-------------------*/ - +- -} - +- -void yaffs_DeleteChunk(yaffs_Device *dev, int chunkId, int markNAND, int lyn) -+/* AllocateEmptyObject gets us a clean Object. Tries to make allocate more if we run out */ -+static yaffs_Object *yaffs_AllocateEmptyObject(yaffs_Device *dev) - { +-{ - int block; - int page; - yaffs_ExtendedTags tags; - yaffs_BlockInfo *bi; -+ yaffs_Object *obj = yaffs_AllocateRawObject(dev); - +- - if (chunkId <= 0) - return; -+ if (obj) { -+ dev->nObjects++; - +- - dev->nDeletions++; - block = chunkId / dev->nChunksPerBlock; - page = chunkId % dev->nChunksPerBlock; -+ /* Now sweeten it up... */ - -+ memset(obj, 0, sizeof(yaffs_Object)); -+ obj->beingCreated = 1; - +- +- - if (!yaffs_CheckChunkBit(dev, block, page)) - T(YAFFS_TRACE_VERIFY, - (TSTR("Deleting invalid chunk %d"TENDSTR), - chunkId)); -+ obj->myDev = dev; -+ obj->hdrChunk = 0; -+ obj->variantType = YAFFS_OBJECT_TYPE_UNKNOWN; -+ YINIT_LIST_HEAD(&(obj->hardLinks)); -+ YINIT_LIST_HEAD(&(obj->hashLink)); -+ YINIT_LIST_HEAD(&obj->siblings); - +- - bi = yaffs_GetBlockInfo(dev, block); - +- - T(YAFFS_TRACE_DELETION, - (TSTR("line %d delete of chunk %d" TENDSTR), lyn, chunkId)); -+ /* Now make the directory sane */ -+ if (dev->rootDir) { -+ obj->parent = dev->rootDir; -+ ylist_add(&(obj->siblings), &dev->rootDir->variant.directoryVariant.children); -+ } - +- - if (markNAND && - bi->blockState != YAFFS_BLOCK_STATE_COLLECTING && !dev->isYaffs2) { -+ /* Add it to the lost and found directory. -+ * NB Can't put root or lostNFound in lostNFound so -+ * check if lostNFound exists first -+ */ -+ if (dev->lostNFoundDir) -+ yaffs_AddObjectToDirectory(dev->lostNFoundDir, obj); - +- - yaffs_InitialiseTags(&tags); -+ obj->beingCreated = 0; -+ } - +- - tags.chunkDeleted = 1; -+ dev->nCheckpointBlocksRequired = 0; /* force recalculation*/ - +- - yaffs_WriteChunkWithTagsToNAND(dev, chunkId, NULL, &tags); - yaffs_HandleUpdateChunk(dev, chunkId, &tags); - } else { - dev->nUnmarkedDeletions++; - } -+ return obj; -+} - +- - /* Pull out of the management area. - * If the whole block became dirty, this will kick off an erasure. - */ @@ -8007,290 +8841,151 @@ - bi->blockState == YAFFS_BLOCK_STATE_NEEDS_SCANNING || - bi->blockState == YAFFS_BLOCK_STATE_COLLECTING) { - dev->nFreeChunks++; -+static yaffs_Object *yaffs_CreateFakeDirectory(yaffs_Device *dev, int number, -+ __u32 mode) -+{ - +- - yaffs_ClearChunkBit(dev, block, page); -+ yaffs_Object *obj = -+ yaffs_CreateNewObject(dev, number, YAFFS_OBJECT_TYPE_DIRECTORY); -+ if (obj) { -+ obj->fake = 1; /* it is fake so it might have no NAND presence... */ -+ obj->renameAllowed = 0; /* ... and we're not allowed to rename it... */ -+ obj->unlinkAllowed = 0; /* ... or unlink it */ -+ obj->deleted = 0; -+ obj->unlinked = 0; -+ obj->yst_mode = mode; -+ obj->myDev = dev; -+ obj->hdrChunk = 0; /* Not a valid chunk. */ -+ } - +- - bi->pagesInUse--; -+ return obj; - +- - if (bi->pagesInUse == 0 && - !bi->hasShrinkHeader && - bi->blockState != YAFFS_BLOCK_STATE_ALLOCATING && - bi->blockState != YAFFS_BLOCK_STATE_NEEDS_SCANNING) { - yaffs_BlockBecameDirty(dev, block); - } -+} - +- - } -+static void yaffs_UnhashObject(yaffs_Object *obj) -+{ -+ int bucket; -+ yaffs_Device *dev = obj->myDev; - -+ /* If it is still linked into the bucket list, free from the list */ -+ if (!ylist_empty(&obj->hashLink)) { -+ ylist_del_init(&obj->hashLink); -+ bucket = yaffs_HashFunction(obj->objectId); -+ dev->objectBucket[bucket].count--; -+ } - } - +- +-} +- -static int yaffs_WriteChunkDataToObject(yaffs_Object *in, int chunkInInode, - const __u8 *buffer, int nBytes, - int useReserve) -+/* FreeObject frees up a Object and puts it back on the free list */ -+static void yaffs_FreeObject(yaffs_Object *obj) - { +-{ - /* Find old chunk Need to do this to get serial number - * Write new one and patch into tree. - * Invalidate old tags. - */ -+ yaffs_Device *dev = obj->myDev; - +- - int prevChunkId; - yaffs_ExtendedTags prevTags; -+ T(YAFFS_TRACE_OS, (TSTR("FreeObject %p inode %p"TENDSTR), obj, obj->myInode)); - +- - int newChunkId; - yaffs_ExtendedTags newTags; -+ if (!obj) -+ YBUG(); -+ if (obj->parent) -+ YBUG(); -+ if (!ylist_empty(&obj->siblings)) -+ YBUG(); - +- - yaffs_Device *dev = in->myDev; - +- - yaffs_CheckGarbageCollection(dev); -+ if (obj->myInode) { -+ /* We're still hooked up to a cached inode. -+ * Don't delete now, but mark for later deletion -+ */ -+ obj->deferedFree = 1; -+ return; -+ } -+ -+ yaffs_UnhashObject(obj); - +- - /* Get the previous chunk at this location in the file if it exists */ - prevChunkId = yaffs_FindChunkInFile(in, chunkInInode, &prevTags); -+ yaffs_FreeRawObject(dev,obj); -+ dev->nObjects--; -+ dev->nCheckpointBlocksRequired = 0; /* force recalculation*/ -+} - +- - /* Set up new tags */ - yaffs_InitialiseTags(&newTags); - +- - newTags.chunkId = chunkInInode; - newTags.objectId = in->objectId; - newTags.serialNumber = - (prevChunkId >= 0) ? prevTags.serialNumber + 1 : 1; - newTags.byteCount = nBytes; -+void yaffs_HandleDeferedFree(yaffs_Object *obj) -+{ -+ if (obj->deferedFree) -+ yaffs_FreeObject(obj); -+} - +- - if (nBytes < 1 || nBytes > dev->totalBytesPerChunk) { - T(YAFFS_TRACE_ERROR, - (TSTR("Writing %d bytes to chunk!!!!!!!!!" TENDSTR), nBytes)); - YBUG(); -+static void yaffs_InitialiseTnodesAndObjects(yaffs_Device *dev) -+{ -+ int i; -+ -+ dev->nObjects = 0; -+ dev->nTnodes = 0; -+ -+ yaffs_InitialiseRawTnodesAndObjects(dev); -+ -+ for (i = 0; i < YAFFS_NOBJECT_BUCKETS; i++) { -+ YINIT_LIST_HEAD(&dev->objectBucket[i].list); -+ dev->objectBucket[i].count = 0; - } -+} - +- } +- - newChunkId = - yaffs_WriteNewChunkWithTagsToNAND(dev, buffer, &newTags, - useReserve); -+static int yaffs_FindNiceObjectBucket(yaffs_Device *dev) -+{ -+ int i; -+ int l = 999; -+ int lowest = 999999; - +- - if (newChunkId >= 0) { - yaffs_PutChunkIntoFile(in, chunkInInode, newChunkId, 0); - +- - if (prevChunkId >= 0) - yaffs_DeleteChunk(dev, prevChunkId, 1, __LINE__); -+ /* Search for the shortest list or one that -+ * isn't too long. -+ */ -+ -+ for (i = 0; i < 10 && lowest > 4; i++) { -+ dev->bucketFinder++; -+ dev->bucketFinder %= YAFFS_NOBJECT_BUCKETS; -+ if (dev->objectBucket[dev->bucketFinder].count < lowest) { -+ lowest = dev->objectBucket[dev->bucketFinder].count; -+ l = dev->bucketFinder; -+ } - +- - yaffs_CheckFileSanity(in); - } +- } - return newChunkId; - -+ return l; - } - +- +-} +- -/* UpdateObjectHeader updates the header on NAND for an object. - * If name is not NULL, then that new name is used. - */ -int yaffs_UpdateObjectHeader(yaffs_Object *in, const YCHAR *name, int force, - int isShrink, int shadows) -+static int yaffs_CreateNewObjectNumber(yaffs_Device *dev) - { -+ int bucket = yaffs_FindNiceObjectBucket(dev); - +-{ +- - yaffs_BlockInfo *bi; -+ /* Now find an object value that has not already been taken -+ * by scanning the list. -+ */ - +- - yaffs_Device *dev = in->myDev; -+ int found = 0; -+ struct ylist_head *i; - +- - int prevChunkId; - int retVal = 0; - int result = 0; -+ __u32 n = (__u32) bucket; - +- - int newChunkId; - yaffs_ExtendedTags newTags; - yaffs_ExtendedTags oldTags; -+ /* yaffs_CheckObjectHashSanity(); */ - +- - __u8 *buffer = NULL; - YCHAR oldName[YAFFS_MAX_NAME_LENGTH + 1]; -+ while (!found) { -+ found = 1; -+ n += YAFFS_NOBJECT_BUCKETS; -+ if (1 || dev->objectBucket[bucket].count > 0) { -+ ylist_for_each(i, &dev->objectBucket[bucket].list) { -+ /* If there is already one in the list */ -+ if (i && ylist_entry(i, yaffs_Object, -+ hashLink)->objectId == n) { -+ found = 0; -+ } -+ } -+ } -+ } - +- - yaffs_ObjectHeader *oh = NULL; -+ return n; -+} ++ yaffs_obj_t *in; ++ YCHAR *str = NULL; - yaffs_strcpy(oldName, _Y("silly old name")); -+static void yaffs_HashObject(yaffs_Object *in) -+{ -+ int bucket = yaffs_HashFunction(in->objectId); -+ yaffs_Device *dev = in->myDev; ++ yaffs_dev_t *dev = parent->my_dev; -+ ylist_add(&in->hashLink, &dev->objectBucket[bucket].list); -+ dev->objectBucket[bucket].count++; -+} ++ /* Check if the entry exists. If it does then fail the call since we don't want a dup.*/ ++ if (yaffs_find_by_name(parent, name)) ++ return NULL; - if (!in->fake || - in == dev->rootDir || /* The rootDir should also be saved */ - force) { -+yaffs_Object *yaffs_FindObjectByNumber(yaffs_Device *dev, __u32 number) -+{ -+ int bucket = yaffs_HashFunction(number); -+ struct ylist_head *i; -+ yaffs_Object *in; ++ if (type == YAFFS_OBJECT_TYPE_SYMLINK) { ++ str = yaffs_clone_str(aliasString); ++ if (!str) ++ return NULL; ++ } - yaffs_CheckGarbageCollection(dev); - yaffs_CheckObjectDetailsLoaded(in); -+ ylist_for_each(i, &dev->objectBucket[bucket].list) { -+ /* Look if it is in the list */ -+ if (i) { -+ in = ylist_entry(i, yaffs_Object, hashLink); -+ if (in->objectId == number) { ++ in = yaffs_new_obj(dev, -1, type); - buffer = yaffs_GetTempBuffer(in->myDev, __LINE__); - oh = (yaffs_ObjectHeader *) buffer; -+ /* Don't tell the VFS about this one if it is defered free */ -+ if (in->deferedFree) -+ return NULL; ++ if (!in){ ++ if(str) ++ YFREE(str); ++ return NULL; ++ } - prevChunkId = in->hdrChunk; -+ return in; -+ } -+ } -+ } - if (prevChunkId > 0) { - result = yaffs_ReadChunkWithTagsFromNAND(dev, prevChunkId, - buffer, &oldTags); -+ return NULL; -+} - yaffs_VerifyObjectHeader(in, oh, &oldTags, 0); -+yaffs_Object *yaffs_CreateNewObject(yaffs_Device *dev, int number, -+ yaffs_ObjectType type) -+{ -+ yaffs_Object *theObject=NULL; -+ yaffs_Tnode *tn = NULL; -+ -+ if (number < 0) -+ number = yaffs_CreateNewObjectNumber(dev); - memcpy(oldName, oh->name, sizeof(oh->name)); - } -+ if (type == YAFFS_OBJECT_TYPE_FILE) { -+ tn = yaffs_GetTnode(dev); -+ if (!tn) -+ return NULL; -+ } - memset(buffer, 0xFF, dev->nDataBytesPerChunk); -+ theObject = yaffs_AllocateEmptyObject(dev); -+ if (!theObject){ -+ if(tn) -+ yaffs_FreeTnode(dev,tn); -+ return NULL; -+ } ++ if (in) { ++ in->hdr_chunk = 0; ++ in->valid = 1; ++ in->variant_type = type; - oh->type = in->variantType; - oh->yst_mode = in->yst_mode; - oh->shadowsObject = oh->inbandShadowsObject = shadows; ++ in->yst_mode = mode; -+ if (theObject) { -+ theObject->fake = 0; -+ theObject->renameAllowed = 1; -+ theObject->unlinkAllowed = 1; -+ theObject->objectId = number; -+ yaffs_HashObject(theObject); -+ theObject->variantType = type; #ifdef CONFIG_YAFFS_WINCE - oh->win_atime[0] = in->win_atime[0]; - oh->win_ctime[0] = in->win_ctime[0]; @@ -8298,19 +8993,29 @@ - oh->win_atime[1] = in->win_atime[1]; - oh->win_ctime[1] = in->win_ctime[1]; - oh->win_mtime[1] = in->win_mtime[1]; --#else ++ yfsd_win_file_time_now(in->win_atime); ++ in->win_ctime[0] = in->win_mtime[0] = in->win_atime[0]; ++ in->win_ctime[1] = in->win_mtime[1] = in->win_atime[1]; ++ + #else - oh->yst_uid = in->yst_uid; - oh->yst_gid = in->yst_gid; - oh->yst_atime = in->yst_atime; - oh->yst_mtime = in->yst_mtime; - oh->yst_ctime = in->yst_ctime; - oh->yst_rdev = in->yst_rdev; --#endif ++ in->yst_atime = in->yst_mtime = in->yst_ctime = Y_CURRENT_TIME; ++ ++ in->yst_rdev = rdev; ++ in->yst_uid = uid; ++ in->yst_gid = gid; + #endif - if (in->parent) - oh->parentObjectId = in->parent->objectId; - else - oh->parentObjectId = 0; -- ++ in->n_data_chunks = 0; + - if (name && *name) { - memset(oh->name, 0, sizeof(oh->name)); - yaffs_strncpy(oh->name, name, YAFFS_MAX_NAME_LENGTH); @@ -8318,63 +9023,54 @@ - memcpy(oh->name, oldName, sizeof(oh->name)); - else - memset(oh->name, 0, sizeof(oh->name)); -+ yfsd_WinFileTimeNow(theObject->win_atime); -+ theObject->win_ctime[0] = theObject->win_mtime[0] = -+ theObject->win_atime[0]; -+ theObject->win_ctime[1] = theObject->win_mtime[1] = -+ theObject->win_atime[1]; ++ yaffs_set_obj_name(in, name); ++ in->dirty = 1; - oh->isShrink = isShrink; -+#else ++ yaffs_add_obj_to_dir(parent, in); - switch (in->variantType) { - case YAFFS_OBJECT_TYPE_UNKNOWN: - /* Should not happen */ - break; -+ theObject->yst_atime = theObject->yst_mtime = -+ theObject->yst_ctime = Y_CURRENT_TIME; -+#endif -+ switch (type) { - case YAFFS_OBJECT_TYPE_FILE: +- case YAFFS_OBJECT_TYPE_FILE: - oh->fileSize = - (oh->parentObjectId == YAFFS_OBJECTID_DELETED - || oh->parentObjectId == - YAFFS_OBJECTID_UNLINKED) ? 0 : in->variant. - fileVariant.fileSize; -- break; -- case YAFFS_OBJECT_TYPE_HARDLINK: ++ in->my_dev = parent->my_dev; ++ ++ switch (type) { ++ case YAFFS_OBJECT_TYPE_SYMLINK: ++ in->variant.symlink_variant.alias = str; + break; + case YAFFS_OBJECT_TYPE_HARDLINK: - oh->equivalentObjectId = - in->variant.hardLinkVariant.equivalentObjectId; - break; - case YAFFS_OBJECT_TYPE_SPECIAL: - /* Do nothing */ -+ theObject->variant.fileVariant.fileSize = 0; -+ theObject->variant.fileVariant.scannedFileSize = 0; -+ theObject->variant.fileVariant.shrinkSize = 0xFFFFFFFF; /* max __u32 */ -+ theObject->variant.fileVariant.topLevel = 0; -+ theObject->variant.fileVariant.top = tn; ++ in->variant.hardlink_variant.equiv_obj = ++ equiv_obj; ++ in->variant.hardlink_variant.equiv_id = ++ equiv_obj->obj_id; ++ ylist_add(&in->hard_links, &equiv_obj->hard_links); break; ++ case YAFFS_OBJECT_TYPE_FILE: case YAFFS_OBJECT_TYPE_DIRECTORY: - /* Do nothing */ -+ YINIT_LIST_HEAD(&theObject->variant.directoryVariant. -+ children); -+ YINIT_LIST_HEAD(&theObject->variant.directoryVariant. -+ dirty); - break; - case YAFFS_OBJECT_TYPE_SYMLINK: +- break; +- case YAFFS_OBJECT_TYPE_SYMLINK: - yaffs_strncpy(oh->alias, - in->variant.symLinkVariant.alias, - YAFFS_MAX_ALIAS_LENGTH); - oh->alias[YAFFS_MAX_ALIAS_LENGTH] = 0; -+ case YAFFS_OBJECT_TYPE_HARDLINK: + case YAFFS_OBJECT_TYPE_SPECIAL: -+ /* No action required */ -+ break; + case YAFFS_OBJECT_TYPE_UNKNOWN: -+ /* todo this should not happen */ ++ /* do nothing */ break; } -+ } - /* Tags */ - yaffs_InitialiseTags(&newTags); @@ -8394,66 +9090,47 @@ - newTags.extraObjectType = in->variantType; - - yaffs_VerifyObjectHeader(in, oh, &newTags, 1); -+ return theObject; -+} - +- - /* Create new chunk in NAND */ - newChunkId = - yaffs_WriteNewChunkWithTagsToNAND(dev, buffer, &newTags, - (prevChunkId >= 0) ? 1 : 0); -+yaffs_Object *yaffs_FindOrCreateObjectByNumber(yaffs_Device *dev, -+ int number, -+ yaffs_ObjectType type) -+{ -+ yaffs_Object *theObject = NULL; - +- - if (newChunkId >= 0) { -+ if (number > 0) -+ theObject = yaffs_FindObjectByNumber(dev, number); - +- - in->hdrChunk = newChunkId; -+ if (!theObject) -+ theObject = yaffs_CreateNewObject(dev, number, type); - +- - if (prevChunkId >= 0) { - yaffs_DeleteChunk(dev, prevChunkId, 1, - __LINE__); - } -+ return theObject; - +- - if (!yaffs_ObjectHasCachedWriteData(in)) - in->dirty = 0; -+} - +- - /* If this was a shrink, then mark the block that the chunk lives on */ - if (isShrink) { - bi = yaffs_GetBlockInfo(in->myDev, - newChunkId / in->myDev->nChunksPerBlock); - bi->hasShrinkHeader = 1; - } - -- } -+YCHAR *yaffs_CloneString(const YCHAR *str) -+{ -+ YCHAR *newStr = NULL; -+ int len; +- ++ if (yaffs_update_oh(in, name, 0, 0, 0, NULL) < 0) { ++ /* Could not create the object header, fail the creation */ ++ yaffs_del_obj(in); ++ in = NULL; + } - retVal = newChunkId; -+ if (!str) -+ str = _Y(""); - -+ len = yaffs_strnlen(str,YAFFS_MAX_ALIAS_LENGTH); -+ newStr = YMALLOC((len + 1) * sizeof(YCHAR)); -+ if (newStr){ -+ yaffs_strncpy(newStr, str,len); -+ newStr[len] = 0; +- ++ yaffs_update_parent(parent); } -+ return newStr; - if (buffer) - yaffs_ReleaseTempBuffer(dev, buffer, __LINE__); - - return retVal; ++ return in; } -/*------------------------ Short Operations Cache ---------------------------------------- @@ -8467,69 +9144,66 @@ - * - * There are a limited number (~10) of cache chunks per device so that we don't - * need a very intelligent search. -+/* -+ * Mknod (create) a new object. -+ * equivalentObject only has meaning for a hard link; -+ * aliasString only has meaning for a symlink. -+ * rdev only has meaning for devices (a subset of special objects) - */ - +- */ +- -static int yaffs_ObjectHasCachedWriteData(yaffs_Object *obj) -+static yaffs_Object *yaffs_MknodObject(yaffs_ObjectType type, -+ yaffs_Object *parent, -+ const YCHAR *name, -+ __u32 mode, -+ __u32 uid, -+ __u32 gid, -+ yaffs_Object *equivalentObject, -+ const YCHAR *aliasString, __u32 rdev) ++yaffs_obj_t *yaffs_create_file(yaffs_obj_t *parent, const YCHAR *name, ++ __u32 mode, __u32 uid, __u32 gid) { - yaffs_Device *dev = obj->myDev; - int i; - yaffs_ChunkCache *cache; - int nCaches = obj->myDev->nShortOpCaches; -+ yaffs_Object *in; -+ YCHAR *str = NULL; - +- - for (i = 0; i < nCaches; i++) { - cache = &dev->srCache[i]; - if (cache->object == obj && - cache->dirty) - return 1; -+ yaffs_Device *dev = parent->myDev; -+ -+ /* Check if the entry exists. If it does then fail the call since we don't want a dup.*/ -+ if (yaffs_FindObjectByName(parent, name)) -+ return NULL; -+ -+ if (type == YAFFS_OBJECT_TYPE_SYMLINK) { -+ str = yaffs_CloneString(aliasString); -+ if (!str) -+ return NULL; - } +- } ++ return yaffs_create_obj(YAFFS_OBJECT_TYPE_FILE, parent, name, mode, ++ uid, gid, NULL, NULL, 0); ++} - return 0; --} -+ in = yaffs_CreateNewObject(dev, -1, type); ++yaffs_obj_t *yaffs_create_dir(yaffs_obj_t *parent, const YCHAR *name, ++ __u32 mode, __u32 uid, __u32 gid) ++{ ++ return yaffs_create_obj(YAFFS_OBJECT_TYPE_DIRECTORY, parent, name, ++ mode, uid, gid, NULL, NULL, 0); + } -+ if (!in){ -+ if(str) -+ YFREE(str); -+ return NULL; -+ } ++yaffs_obj_t *yaffs_create_special(yaffs_obj_t *parent, const YCHAR *name, ++ __u32 mode, __u32 uid, __u32 gid, __u32 rdev) ++{ ++ return yaffs_create_obj(YAFFS_OBJECT_TYPE_SPECIAL, parent, name, mode, ++ uid, gid, NULL, NULL, rdev); ++} -static void yaffs_FlushFilesChunkCache(yaffs_Object *obj) --{ ++yaffs_obj_t *yaffs_create_symlink(yaffs_obj_t *parent, const YCHAR *name, ++ __u32 mode, __u32 uid, __u32 gid, ++ const YCHAR *alias) + { - yaffs_Device *dev = obj->myDev; - int lowest = -99; /* Stop compiler whining. */ - int i; - yaffs_ChunkCache *cache; - int chunkWritten = 0; - int nCaches = obj->myDev->nShortOpCaches; ++ return yaffs_create_obj(YAFFS_OBJECT_TYPE_SYMLINK, parent, name, mode, ++ uid, gid, NULL, alias, 0); ++} - if (nCaches > 0) { - do { - cache = NULL; ++/* yaffs_link_obj returns the object id of the equivalent object.*/ ++yaffs_obj_t *yaffs_link_obj(yaffs_obj_t *parent, const YCHAR *name, ++ yaffs_obj_t *equiv_obj) ++{ ++ /* Get the real object in case we were fed a hard link as an equivalent object */ ++ equiv_obj = yaffs_get_equivalent_obj(equiv_obj); - /* Find the dirty cache for this object with the lowest chunk id. */ - for (i = 0; i < nCaches; i++) { @@ -8543,9 +9217,17 @@ - } - } - } ++ if (yaffs_create_obj ++ (YAFFS_OBJECT_TYPE_HARDLINK, parent, name, 0, 0, 0, ++ equiv_obj, NULL, 0)) { ++ return equiv_obj; ++ } else { ++ return NULL; ++ } - if (cache && !cache->locked) { - /* Write it out and free it up */ ++} - chunkWritten = - yaffs_WriteChunkDataToObject(cache->object, @@ -8556,86 +9238,59 @@ - cache->dirty = 0; - cache->object = NULL; - } -+ if (in) { -+ in->hdrChunk = 0; -+ in->valid = 1; -+ in->variantType = type; ++static int yaffs_change_obj_name(yaffs_obj_t *obj, yaffs_obj_t *new_dir, ++ const YCHAR *new_name, int force, int shadows) ++{ ++ int unlinkOp; ++ int deleteOp; - } while (cache && chunkWritten > 0); -+ in->yst_mode = mode; ++ yaffs_obj_t *existingTarget; - if (cache) { - /* Hoosterman, disk full while writing cache out. */ - T(YAFFS_TRACE_ERROR, - (TSTR("yaffs tragedy: no space during cache write" TENDSTR))); -+#ifdef CONFIG_YAFFS_WINCE -+ yfsd_WinFileTimeNow(in->win_atime); -+ in->win_ctime[0] = in->win_mtime[0] = in->win_atime[0]; -+ in->win_ctime[1] = in->win_mtime[1] = in->win_atime[1]; -+ -+#else -+ in->yst_atime = in->yst_mtime = in->yst_ctime = Y_CURRENT_TIME; -+ -+ in->yst_rdev = rdev; -+ in->yst_uid = uid; -+ in->yst_gid = gid; -+#endif -+ in->nDataChunks = 0; -+ -+ yaffs_SetObjectName(in, name); -+ in->dirty = 1; -+ -+ yaffs_AddObjectToDirectory(parent, in); -+ -+ in->myDev = parent->myDev; -+ -+ switch (type) { -+ case YAFFS_OBJECT_TYPE_SYMLINK: -+ in->variant.symLinkVariant.alias = str; -+ break; -+ case YAFFS_OBJECT_TYPE_HARDLINK: -+ in->variant.hardLinkVariant.equivalentObject = -+ equivalentObject; -+ in->variant.hardLinkVariant.equivalentObjectId = -+ equivalentObject->objectId; -+ ylist_add(&in->hardLinks, &equivalentObject->hardLinks); -+ break; -+ case YAFFS_OBJECT_TYPE_FILE: -+ case YAFFS_OBJECT_TYPE_DIRECTORY: -+ case YAFFS_OBJECT_TYPE_SPECIAL: -+ case YAFFS_OBJECT_TYPE_UNKNOWN: -+ /* do nothing */ -+ break; -+ } ++ if (new_dir == NULL) ++ new_dir = obj->parent; /* use the old directory */ -+ if (yaffs_UpdateObjectHeader(in, name, 0, 0, 0, NULL) < 0) { -+ /* Could not create the object header, fail the creation */ -+ yaffs_DeleteObject(in); -+ in = NULL; - } -+ -+ yaffs_UpdateParent(parent); +- } ++ if (new_dir->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) { ++ T(YAFFS_TRACE_ALWAYS, ++ (TSTR ++ ("tragedy: yaffs_change_obj_name: new_dir is not a directory" ++ TENDSTR))); ++ YBUG(); } -+ return in; - } +-} ++ /* TODO: Do we need this different handling for YAFFS2 and YAFFS1?? */ ++ if (obj->my_dev->param.is_yaffs2) ++ unlinkOp = (new_dir == obj->my_dev->unlinked_dir); ++ else ++ unlinkOp = (new_dir == obj->my_dev->unlinked_dir ++ && obj->variant_type == YAFFS_OBJECT_TYPE_FILE); -/*yaffs_FlushEntireDeviceCache(dev) - * - * - */ -- ++ deleteOp = (new_dir == obj->my_dev->del_dir); + -void yaffs_FlushEntireDeviceCache(yaffs_Device *dev) -+yaffs_Object *yaffs_MknodFile(yaffs_Object *parent, const YCHAR *name, -+ __u32 mode, __u32 uid, __u32 gid) - { +-{ - yaffs_Object *obj; - int nCaches = dev->nShortOpCaches; - int i; -- ++ existingTarget = yaffs_find_by_name(new_dir, new_name); + - /* Find a dirty object in the cache and flush it... - * until there are no further dirty objects. -- */ ++ /* If the object is a file going into the unlinked directory, ++ * then it is OK to just stuff it in since duplicate names are allowed. ++ * else only proceed if the new name does not exist and if we're putting ++ * it into a directory. + */ - do { - obj = NULL; - for (i = 0; i < nCaches && !obj; i++) { @@ -8646,32 +9301,20 @@ - } - if (obj) - yaffs_FlushFilesChunkCache(obj); -+ return yaffs_MknodObject(YAFFS_OBJECT_TYPE_FILE, parent, name, mode, -+ uid, gid, NULL, NULL, 0); -+} - +- - } while (obj); -+yaffs_Object *yaffs_MknodDirectory(yaffs_Object *parent, const YCHAR *name, -+ __u32 mode, __u32 uid, __u32 gid) -+{ -+ return yaffs_MknodObject(YAFFS_OBJECT_TYPE_DIRECTORY, parent, name, -+ mode, uid, gid, NULL, NULL, 0); -+} - -+yaffs_Object *yaffs_MknodSpecial(yaffs_Object *parent, const YCHAR *name, -+ __u32 mode, __u32 uid, __u32 gid, __u32 rdev) -+{ -+ return yaffs_MknodObject(YAFFS_OBJECT_TYPE_SPECIAL, parent, name, mode, -+ uid, gid, NULL, NULL, rdev); - } +- +-} ++ if ((unlinkOp || ++ deleteOp || ++ force || ++ (shadows > 0) || ++ !existingTarget) && ++ new_dir->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY) { ++ yaffs_set_obj_name(obj, new_name); ++ obj->dirty = 1; -+yaffs_Object *yaffs_MknodSymLink(yaffs_Object *parent, const YCHAR *name, -+ __u32 mode, __u32 uid, __u32 gid, -+ const YCHAR *alias) -+{ -+ return yaffs_MknodObject(YAFFS_OBJECT_TYPE_SYMLINK, parent, name, mode, -+ uid, gid, NULL, alias, 0); -+} ++ yaffs_add_obj_to_dir(new_dir, obj); -/* Grab us a cache chunk for use. - * First look for an empty one. @@ -8679,33 +9322,28 @@ - * Then look for the least recently used dirty one...., flush and look again. - */ -static yaffs_ChunkCache *yaffs_GrabChunkCacheWorker(yaffs_Device *dev) -+/* yaffs_Link returns the object id of the equivalent object.*/ -+yaffs_Object *yaffs_Link(yaffs_Object *parent, const YCHAR *name, -+ yaffs_Object *equivalentObject) - { +-{ - int i; -+ /* Get the real object in case we were fed a hard link as an equivalent object */ -+ equivalentObject = yaffs_GetEquivalentObject(equivalentObject); ++ if (unlinkOp) ++ obj->unlinked = 1; - if (dev->nShortOpCaches > 0) { - for (i = 0; i < dev->nShortOpCaches; i++) { - if (!dev->srCache[i].object) - return &dev->srCache[i]; - } -+ if (yaffs_MknodObject -+ (YAFFS_OBJECT_TYPE_HARDLINK, parent, name, 0, 0, 0, -+ equivalentObject, NULL, 0)) { -+ return equivalentObject; -+ } else { -+ return NULL; ++ /* If it is a deletion then we mark it as a shrink for gc purposes. */ ++ if (yaffs_update_oh(obj, new_name, 0, deleteOp, shadows, NULL) >= 0) ++ return YAFFS_OK; } - return NULL; ++ return YAFFS_FAIL; } -static yaffs_ChunkCache *yaffs_GrabChunkCache(yaffs_Device *dev) -+static int yaffs_ChangeObjectName(yaffs_Object *obj, yaffs_Object *newDir, -+ const YCHAR *newName, int force, int shadows) ++int yaffs_rename_obj(yaffs_obj_t *old_dir, const YCHAR *old_name, ++ yaffs_obj_t *new_dir, const YCHAR *new_name) { - yaffs_ChunkCache *cache; - yaffs_Object *theObj; @@ -8715,11 +9353,13 @@ - - if (dev->nShortOpCaches > 0) { - /* Try find a non-dirty one... */ -+ int unlinkOp; -+ int deleteOp; - +- - cache = yaffs_GrabChunkCacheWorker(dev); -+ yaffs_Object *existingTarget; ++ yaffs_obj_t *obj = NULL; ++ yaffs_obj_t *existingTarget = NULL; ++ int force = 0; ++ int result; ++ yaffs_dev_t *dev; - if (!cache) { - /* They were all dirty, find the last recently used object and flush @@ -8727,28 +9367,18 @@ - * NB what's here is not very accurate, we actually flush the object - * the last recently used page. - */ -+ if (newDir == NULL) -+ newDir = obj->parent; /* use the old directory */ - /* With locking we can't assume we can use entry zero */ -+ if (newDir->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) { -+ T(YAFFS_TRACE_ALWAYS, -+ (TSTR -+ ("tragedy: yaffs_ChangeObjectName: newDir is not a directory" -+ TENDSTR))); ++ if (!old_dir || old_dir->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) ++ YBUG(); ++ if (!new_dir || new_dir->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) + YBUG(); -+ } - theObj = NULL; - usage = -1; - cache = NULL; - pushout = -1; -+ /* TODO: Do we need this different handling for YAFFS2 and YAFFS1?? */ -+ if (obj->myDev->param.isYaffs2) -+ unlinkOp = (newDir == obj->myDev->unlinkedDir); -+ else -+ unlinkOp = (newDir == obj->myDev->unlinkedDir -+ && obj->variantType == YAFFS_OBJECT_TYPE_FILE); ++ dev = old_dir->my_dev; - for (i = 0; i < dev->nShortOpCaches; i++) { - if (dev->srCache[i].object && @@ -8760,35 +9390,32 @@ - pushout = i; - } - } -+ deleteOp = (newDir == obj->myDev->deletedDir); ++#ifdef CONFIG_YAFFS_CASE_INSENSITIVE ++ /* Special case for case insemsitive systems (eg. WinCE). ++ * While look-up is case insensitive, the name isn't. ++ * Therefore we might want to change x.txt to X.txt ++ */ ++ if (old_dir == new_dir && yaffs_strcmp(old_name, new_name) == 0) ++ force = 1; ++#endif - if (!cache || cache->dirty) { - /* Flush and try again */ - yaffs_FlushFilesChunkCache(theObj); - cache = yaffs_GrabChunkCacheWorker(dev); - } -+ existingTarget = yaffs_FindObjectByName(newDir, newName); ++ if(yaffs_strnlen(new_name,YAFFS_MAX_NAME_LENGTH+1) > YAFFS_MAX_NAME_LENGTH) ++ /* ENAMETOOLONG */ ++ return YAFFS_FAIL; - } - return cache; - } else - return NULL; -+ /* If the object is a file going into the unlinked directory, -+ * then it is OK to just stuff it in since duplicate names are allowed. -+ * else only proceed if the new name does not exist and if we're putting -+ * it into a directory. -+ */ -+ if ((unlinkOp || -+ deleteOp || -+ force || -+ (shadows > 0) || -+ !existingTarget) && -+ newDir->variantType == YAFFS_OBJECT_TYPE_DIRECTORY) { -+ yaffs_SetObjectName(obj, newName); -+ obj->dirty = 1; ++ obj = yaffs_find_by_name(old_dir, old_name); -} -+ yaffs_AddObjectToDirectory(newDir, obj); ++ if (obj && obj->rename_allowed) { -/* Find a cached chunk */ -static yaffs_ChunkCache *yaffs_FindChunkCache(const yaffs_Object *obj, @@ -8801,32 +9428,51 @@ - if (dev->srCache[i].object == obj && - dev->srCache[i].chunkId == chunkId) { - dev->cacheHits++; -+ if (unlinkOp) -+ obj->unlinked = 1; ++ /* Now do the handling for an existing target, if there is one */ - return &dev->srCache[i]; - } -- } -+ /* If it is a deletion then we mark it as a shrink for gc purposes. */ -+ if (yaffs_UpdateObjectHeader(obj, newName, 0, deleteOp, shadows, NULL) >= 0) -+ return YAFFS_OK; ++ existingTarget = yaffs_find_by_name(new_dir, new_name); ++ if (existingTarget && ++ existingTarget->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY && ++ !ylist_empty(&existingTarget->variant.dir_variant.children)) { ++ /* There is a target that is a non-empty directory, so we fail */ ++ return YAFFS_FAIL; /* EEXIST or ENOTEMPTY */ ++ } else if (existingTarget && existingTarget != obj) { ++ /* Nuke the target first, using shadowing, ++ * but only if it isn't the same object. ++ * ++ * Note we must disable gc otherwise it can mess up the shadowing. ++ * ++ */ ++ dev->gc_disable=1; ++ yaffs_change_obj_name(obj, new_dir, new_name, force, ++ existingTarget->obj_id); ++ existingTarget->is_shadowed = 1; ++ yaffs_unlink_obj(existingTarget); ++ dev->gc_disable=0; + } ++ ++ result = yaffs_change_obj_name(obj, new_dir, new_name, 1, 0); ++ ++ yaffs_update_parent(old_dir); ++ if(new_dir != old_dir) ++ yaffs_update_parent(new_dir); ++ ++ return result; } - return NULL; -+ + return YAFFS_FAIL; } -/* Mark the chunk for the least recently used algorithym */ -static void yaffs_UseChunkCache(yaffs_Device *dev, yaffs_ChunkCache *cache, - int isAWrite) -+int yaffs_RenameObject(yaffs_Object *oldDir, const YCHAR *oldName, -+ yaffs_Object *newDir, const YCHAR *newName) ++/*------------------------- Block Management and Page Allocation ----------------*/ ++ ++static int yaffs_init_blocks(yaffs_dev_t *dev) { -+ yaffs_Object *obj = NULL; -+ yaffs_Object *existingTarget = NULL; -+ int force = 0; -+ int result; -+ yaffs_Device *dev; ++ int nBlocks = dev->internal_end_block - dev->internal_start_block + 1; - if (dev->nShortOpCaches > 0) { - if (dev->srLastUse < 0 || dev->srLastUse > 100000000) { @@ -8834,50 +9480,64 @@ - int i; - for (i = 1; i < dev->nShortOpCaches; i++) - dev->srCache[i].lastUse = 0; ++ dev->block_info = NULL; ++ dev->chunk_bits = NULL; - dev->srLastUse = 0; - } -+ if (!oldDir || oldDir->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) -+ YBUG(); -+ if (!newDir || newDir->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) -+ YBUG(); ++ dev->alloc_block = -1; /* force it to get a new one */ - dev->srLastUse++; -+ dev = oldDir->myDev; ++ /* If the first allocation strategy fails, thry the alternate one */ ++ dev->block_info = YMALLOC(nBlocks * sizeof(yaffs_block_info_t)); ++ if (!dev->block_info) { ++ dev->block_info = YMALLOC_ALT(nBlocks * sizeof(yaffs_block_info_t)); ++ dev->block_info_alt = 1; ++ } else ++ dev->block_info_alt = 0; - cache->lastUse = dev->srLastUse; -+#ifdef CONFIG_YAFFS_CASE_INSENSITIVE -+ /* Special case for case insemsitive systems (eg. WinCE). -+ * While look-up is case insensitive, the name isn't. -+ * Therefore we might want to change x.txt to X.txt -+ */ -+ if (oldDir == newDir && yaffs_strcmp(oldName, newName) == 0) -+ force = 1; -+#endif ++ if (dev->block_info) { ++ /* Set up dynamic blockinfo stuff. */ ++ dev->chunk_bit_stride = (dev->param.chunks_per_block + 7) / 8; /* round up bytes */ ++ dev->chunk_bits = YMALLOC(dev->chunk_bit_stride * nBlocks); ++ if (!dev->chunk_bits) { ++ dev->chunk_bits = YMALLOC_ALT(dev->chunk_bit_stride * nBlocks); ++ dev->chunk_bits_alt = 1; ++ } else ++ dev->chunk_bits_alt = 0; ++ } - if (isAWrite) - cache->dirty = 1; -- } --} -+ if(yaffs_strnlen(newName,YAFFS_MAX_NAME_LENGTH+1) > YAFFS_MAX_NAME_LENGTH) -+ /* ENAMETOOLONG */ -+ return YAFFS_FAIL; ++ if (dev->block_info && dev->chunk_bits) { ++ memset(dev->block_info, 0, nBlocks * sizeof(yaffs_block_info_t)); ++ memset(dev->chunk_bits, 0, dev->chunk_bit_stride * nBlocks); ++ return YAFFS_OK; + } ++ ++ return YAFFS_FAIL; + } -/* Invalidate a single cache page. - * Do this when a whole page gets written, - * ie the short cache for this page is no longer valid. - */ -static void yaffs_InvalidateChunkCache(yaffs_Object *object, int chunkId) --{ ++static void yaffs_deinit_blocks(yaffs_dev_t *dev) + { - if (object->myDev->nShortOpCaches > 0) { - yaffs_ChunkCache *cache = yaffs_FindChunkCache(object, chunkId); -+ obj = yaffs_FindObjectByName(oldDir, oldName); ++ if (dev->block_info_alt && dev->block_info) ++ YFREE_ALT(dev->block_info); ++ else if (dev->block_info) ++ YFREE(dev->block_info); - if (cache) - cache->object = NULL; - } -} -+ if (obj && obj->renameAllowed) { ++ dev->block_info_alt = 0; -/* Invalidate all the cache pages associated with this object - * Do this whenever ther file is deleted or resized. @@ -8886,96 +9546,66 @@ -{ - int i; - yaffs_Device *dev = in->myDev; -+ /* Now do the handling for an existing target, if there is one */ ++ dev->block_info = NULL; - if (dev->nShortOpCaches > 0) { - /* Invalidate it. */ - for (i = 0; i < dev->nShortOpCaches; i++) { - if (dev->srCache[i].object == in) - dev->srCache[i].object = NULL; -+ existingTarget = yaffs_FindObjectByName(newDir, newName); -+ if (existingTarget && -+ existingTarget->variantType == YAFFS_OBJECT_TYPE_DIRECTORY && -+ !ylist_empty(&existingTarget->variant.directoryVariant.children)) { -+ /* There is a target that is a non-empty directory, so we fail */ -+ return YAFFS_FAIL; /* EEXIST or ENOTEMPTY */ -+ } else if (existingTarget && existingTarget != obj) { -+ /* Nuke the target first, using shadowing, -+ * but only if it isn't the same object. -+ * -+ * Note we must disable gc otherwise it can mess up the shadowing. -+ * -+ */ -+ dev->gcDisable=1; -+ yaffs_ChangeObjectName(obj, newDir, newName, force, -+ existingTarget->objectId); -+ existingTarget->isShadowed = 1; -+ yaffs_UnlinkObject(existingTarget); -+ dev->gcDisable=0; - } -+ -+ result = yaffs_ChangeObjectName(obj, newDir, newName, 1, 0); -+ -+ yaffs_UpdateParent(oldDir); -+ if(newDir != oldDir) -+ yaffs_UpdateParent(newDir); -+ -+ return result; - } -+ return YAFFS_FAIL; +- } +- } ++ if (dev->chunk_bits_alt && dev->chunk_bits) ++ YFREE_ALT(dev->chunk_bits); ++ else if (dev->chunk_bits) ++ YFREE(dev->chunk_bits); ++ dev->chunk_bits_alt = 0; ++ dev->chunk_bits = NULL; } -/*--------------------- Checkpointing --------------------*/ -- -+/*------------------------- Block Management and Page Allocation ----------------*/ ++void yaffs_block_became_dirty(yaffs_dev_t *dev, int block_no) ++{ ++ yaffs_block_info_t *bi = yaffs_get_block_info(dev, block_no); + ++ int erasedOk = 0; -static int yaffs_WriteCheckpointValidityMarker(yaffs_Device *dev, int head) -+static int yaffs_InitialiseBlocks(yaffs_Device *dev) - { +-{ - yaffs_CheckpointValidity cp; -+ int nBlocks = dev->internalEndBlock - dev->internalStartBlock + 1; ++ /* If the block is still healthy erase it and mark as clean. ++ * If the block has had a data failure, then retire it. ++ */ - memset(&cp, 0, sizeof(cp)); -+ dev->blockInfo = NULL; -+ dev->chunkBits = NULL; ++ T(YAFFS_TRACE_GC | YAFFS_TRACE_ERASE, ++ (TSTR("yaffs_block_became_dirty block %d state %d %s"TENDSTR), ++ block_no, bi->block_state, (bi->needs_retiring) ? "needs retiring" : "")); - cp.structType = sizeof(cp); - cp.magic = YAFFS_MAGIC; - cp.version = YAFFS_CHECKPOINT_VERSION; - cp.head = (head) ? 1 : 0; -+ dev->allocationBlock = -1; /* force it to get a new one */ ++ yaffs2_clear_oldest_dirty_seq(dev,bi); - return (yaffs_CheckpointWrite(dev, &cp, sizeof(cp)) == sizeof(cp)) ? - 1 : 0; -} -+ /* If the first allocation strategy fails, thry the alternate one */ -+ dev->blockInfo = YMALLOC(nBlocks * sizeof(yaffs_BlockInfo)); -+ if (!dev->blockInfo) { -+ dev->blockInfo = YMALLOC_ALT(nBlocks * sizeof(yaffs_BlockInfo)); -+ dev->blockInfoAlt = 1; -+ } else -+ dev->blockInfoAlt = 0; ++ bi->block_state = YAFFS_BLOCK_STATE_DIRTY; -static int yaffs_ReadCheckpointValidityMarker(yaffs_Device *dev, int head) -{ - yaffs_CheckpointValidity cp; - int ok; -+ if (dev->blockInfo) { -+ /* Set up dynamic blockinfo stuff. */ -+ dev->chunkBitmapStride = (dev->param.nChunksPerBlock + 7) / 8; /* round up bytes */ -+ dev->chunkBits = YMALLOC(dev->chunkBitmapStride * nBlocks); -+ if (!dev->chunkBits) { -+ dev->chunkBits = YMALLOC_ALT(dev->chunkBitmapStride * nBlocks); -+ dev->chunkBitsAlt = 1; -+ } else -+ dev->chunkBitsAlt = 0; -+ } ++ /* If this is the block being garbage collected then stop gc'ing this block */ ++ if(block_no == dev->gc_block) ++ dev->gc_block = 0; - ok = (yaffs_CheckpointRead(dev, &cp, sizeof(cp)) == sizeof(cp)); -+ if (dev->blockInfo && dev->chunkBits) { -+ memset(dev->blockInfo, 0, nBlocks * sizeof(yaffs_BlockInfo)); -+ memset(dev->chunkBits, 0, dev->chunkBitmapStride * nBlocks); -+ return YAFFS_OK; ++ /* If this block is currently the best candidate for gc then drop as a candidate */ ++ if(block_no == dev->gc_dirtiest){ ++ dev->gc_dirtiest = 0; ++ dev->gc_pages_in_use = 0; + } - if (ok) @@ -8984,100 +9614,130 @@ - (cp.version == YAFFS_CHECKPOINT_VERSION) && - (cp.head == ((head) ? 1 : 0)); - return ok ? 1 : 0; -+ return YAFFS_FAIL; - } +-} ++ if (!bi->needs_retiring) { ++ yaffs2_checkpt_invalidate(dev); ++ erasedOk = yaffs_erase_block(dev, block_no); ++ if (!erasedOk) { ++ dev->n_erase_failures++; ++ T(YAFFS_TRACE_ERROR | YAFFS_TRACE_BAD_BLOCKS, ++ (TSTR("**>> Erasure failed %d" TENDSTR), block_no)); ++ } ++ } -static void yaffs_DeviceToCheckpointDevice(yaffs_CheckpointDevice *cp, - yaffs_Device *dev) -+static void yaffs_DeinitialiseBlocks(yaffs_Device *dev) - { +-{ - cp->nErasedBlocks = dev->nErasedBlocks; - cp->allocationBlock = dev->allocationBlock; - cp->allocationPage = dev->allocationPage; - cp->nFreeChunks = dev->nFreeChunks; -+ if (dev->blockInfoAlt && dev->blockInfo) -+ YFREE_ALT(dev->blockInfo); -+ else if (dev->blockInfo) -+ YFREE(dev->blockInfo); ++ if (erasedOk && ++ ((yaffs_trace_mask & YAFFS_TRACE_ERASE) || !yaffs_skip_verification(dev))) { ++ int i; ++ for (i = 0; i < dev->param.chunks_per_block; i++) { ++ if (!yaffs_check_chunk_erased ++ (dev, block_no * dev->param.chunks_per_block + i)) { ++ T(YAFFS_TRACE_ERROR, ++ (TSTR ++ (">>Block %d erasure supposedly OK, but chunk %d not erased" ++ TENDSTR), block_no, i)); ++ } ++ } ++ } + -+ dev->blockInfoAlt = 0; ++ if (erasedOk) { ++ /* Clean it up... */ ++ bi->block_state = YAFFS_BLOCK_STATE_EMPTY; ++ bi->seq_number = 0; ++ dev->n_erased_blocks++; ++ bi->pages_in_use = 0; ++ bi->soft_del_pages = 0; ++ bi->has_shrink_hdr = 0; ++ bi->skip_erased_check = 1; /* This is clean, so no need to check */ ++ bi->gc_prioritise = 0; ++ yaffs_clear_chunk_bits(dev, block_no); - cp->nDeletedFiles = dev->nDeletedFiles; - cp->nUnlinkedFiles = dev->nUnlinkedFiles; - cp->nBackgroundDeletions = dev->nBackgroundDeletions; - cp->sequenceNumber = dev->sequenceNumber; - cp->oldestDirtySequence = dev->oldestDirtySequence; -+ dev->blockInfo = NULL; - -+ if (dev->chunkBitsAlt && dev->chunkBits) -+ YFREE_ALT(dev->chunkBits); -+ else if (dev->chunkBits) -+ YFREE(dev->chunkBits); -+ dev->chunkBitsAlt = 0; -+ dev->chunkBits = NULL; ++ T(YAFFS_TRACE_ERASE, ++ (TSTR("Erased block %d" TENDSTR), block_no)); ++ } else { ++ dev->n_free_chunks -= dev->param.chunks_per_block; /* We lost a block of free space */ + ++ yaffs_retire_block(dev, block_no); ++ T(YAFFS_TRACE_ERROR | YAFFS_TRACE_BAD_BLOCKS, ++ (TSTR("**>> Block %d retired" TENDSTR), block_no)); ++ } } -static void yaffs_CheckpointDeviceToDevice(yaffs_Device *dev, - yaffs_CheckpointDevice *cp) -+void yaffs_BlockBecameDirty(yaffs_Device *dev, int blockNo) ++static int yaffs_find_alloc_block(yaffs_dev_t *dev) { - dev->nErasedBlocks = cp->nErasedBlocks; - dev->allocationBlock = cp->allocationBlock; - dev->allocationPage = cp->allocationPage; - dev->nFreeChunks = cp->nFreeChunks; -+ yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, blockNo); - +- - dev->nDeletedFiles = cp->nDeletedFiles; - dev->nUnlinkedFiles = cp->nUnlinkedFiles; - dev->nBackgroundDeletions = cp->nBackgroundDeletions; - dev->sequenceNumber = cp->sequenceNumber; - dev->oldestDirtySequence = cp->oldestDirtySequence; -} -+ int erasedOk = 0; ++ int i; -+ /* If the block is still healthy erase it and mark as clean. -+ * If the block has had a data failure, then retire it. -+ */ ++ yaffs_block_info_t *bi; -static int yaffs_WriteCheckpointDevice(yaffs_Device *dev) -{ - yaffs_CheckpointDevice cp; - __u32 nBytes; - __u32 nBlocks = (dev->internalEndBlock - dev->internalStartBlock + 1); -+ T(YAFFS_TRACE_GC | YAFFS_TRACE_ERASE, -+ (TSTR("yaffs_BlockBecameDirty block %d state %d %s"TENDSTR), -+ blockNo, bi->blockState, (bi->needsRetiring) ? "needs retiring" : "")); ++ if (dev->n_erased_blocks < 1) { ++ /* Hoosterman we've got a problem. ++ * Can't get space to gc ++ */ ++ T(YAFFS_TRACE_ERROR, ++ (TSTR("yaffs tragedy: no more erased blocks" TENDSTR))); - int ok; -+ yaffs2_ClearOldestDirtySequence(dev,bi); ++ return -1; ++ } - /* Write device runtime values*/ - yaffs_DeviceToCheckpointDevice(&cp, dev); - cp.structType = sizeof(cp); -+ bi->blockState = YAFFS_BLOCK_STATE_DIRTY; ++ /* Find an empty block. */ - ok = (yaffs_CheckpointWrite(dev, &cp, sizeof(cp)) == sizeof(cp)); -+ /* If this is the block being garbage collected then stop gc'ing this block */ -+ if(blockNo == dev->gcBlock) -+ dev->gcBlock = 0; -+ -+ /* If this block is currently the best candidate for gc then drop as a candidate */ -+ if(blockNo == dev->gcDirtiest){ -+ dev->gcDirtiest = 0; -+ dev->gcPagesInUse = 0; -+ } ++ for (i = dev->internal_start_block; i <= dev->internal_end_block; i++) { ++ dev->alloc_block_finder++; ++ if (dev->alloc_block_finder < dev->internal_start_block ++ || dev->alloc_block_finder > dev->internal_end_block) { ++ dev->alloc_block_finder = dev->internal_start_block; ++ } - /* Write block info */ - if (ok) { - nBytes = nBlocks * sizeof(yaffs_BlockInfo); - ok = (yaffs_CheckpointWrite(dev, dev->blockInfo, nBytes) == nBytes); -+ if (!bi->needsRetiring) { -+ yaffs2_InvalidateCheckpoint(dev); -+ erasedOk = yaffs_EraseBlockInNAND(dev, blockNo); -+ if (!erasedOk) { -+ dev->nErasureFailures++; -+ T(YAFFS_TRACE_ERROR | YAFFS_TRACE_BAD_BLOCKS, -+ (TSTR("**>> Erasure failed %d" TENDSTR), blockNo)); ++ bi = yaffs_get_block_info(dev, dev->alloc_block_finder); ++ ++ if (bi->block_state == YAFFS_BLOCK_STATE_EMPTY) { ++ bi->block_state = YAFFS_BLOCK_STATE_ALLOCATING; ++ dev->seq_number++; ++ bi->seq_number = dev->seq_number; ++ dev->n_erased_blocks--; ++ T(YAFFS_TRACE_ALLOCATE, ++ (TSTR("Allocated block %d, seq %d, %d left" TENDSTR), ++ dev->alloc_block_finder, dev->seq_number, ++ dev->n_erased_blocks)); ++ return dev->alloc_block_finder; + } } @@ -9085,123 +9745,103 @@ - if (ok) { - nBytes = nBlocks * dev->chunkBitmapStride; - ok = (yaffs_CheckpointWrite(dev, dev->chunkBits, nBytes) == nBytes); -+ if (erasedOk && -+ ((yaffs_traceMask & YAFFS_TRACE_ERASE) || !yaffs_SkipVerification(dev))) { -+ int i; -+ for (i = 0; i < dev->param.nChunksPerBlock; i++) { -+ if (!yaffs_CheckChunkErased -+ (dev, blockNo * dev->param.nChunksPerBlock + i)) { -+ T(YAFFS_TRACE_ERROR, -+ (TSTR -+ (">>Block %d erasure supposedly OK, but chunk %d not erased" -+ TENDSTR), blockNo, i)); -+ } -+ } - } +- } - return ok ? 1 : 0; ++ T(YAFFS_TRACE_ALWAYS, ++ (TSTR ++ ("yaffs tragedy: no more erased blocks, but there should have been %d" ++ TENDSTR), dev->n_erased_blocks)); -+ if (erasedOk) { -+ /* Clean it up... */ -+ bi->blockState = YAFFS_BLOCK_STATE_EMPTY; -+ bi->sequenceNumber = 0; -+ dev->nErasedBlocks++; -+ bi->pagesInUse = 0; -+ bi->softDeletions = 0; -+ bi->hasShrinkHeader = 0; -+ bi->skipErasedCheck = 1; /* This is clean, so no need to check */ -+ bi->gcPrioritise = 0; -+ yaffs_ClearChunkBits(dev, blockNo); -+ -+ T(YAFFS_TRACE_ERASE, -+ (TSTR("Erased block %d" TENDSTR), blockNo)); -+ } else { -+ dev->nFreeChunks -= dev->param.nChunksPerBlock; /* We lost a block of free space */ -+ -+ yaffs_RetireBlock(dev, blockNo); -+ T(YAFFS_TRACE_ERROR | YAFFS_TRACE_BAD_BLOCKS, -+ (TSTR("**>> Block %d retired" TENDSTR), blockNo)); -+ } ++ return -1; } -static int yaffs_ReadCheckpointDevice(yaffs_Device *dev) -+static int yaffs_FindBlockForAllocation(yaffs_Device *dev) ++ ++/* ++ * Check if there's space to allocate... ++ * Thinks.... do we need top make this ths same as yaffs_get_free_chunks()? ++ */ ++int yaffs_check_alloc_available(yaffs_dev_t *dev, int n_chunks) { - yaffs_CheckpointDevice cp; - __u32 nBytes; - __u32 nBlocks = (dev->internalEndBlock - dev->internalStartBlock + 1); -- ++ int reservedChunks; ++ int reservedBlocks = dev->param.n_reserved_blocks; ++ int checkpointBlocks; + - int ok; -+ int i; ++ checkpointBlocks = yaffs_calc_checkpt_blocks_required(dev); - ok = (yaffs_CheckpointRead(dev, &cp, sizeof(cp)) == sizeof(cp)); - if (!ok) - return 0; -+ yaffs_BlockInfo *bi; ++ reservedChunks = ((reservedBlocks + checkpointBlocks) * dev->param.chunks_per_block); - if (cp.structType != sizeof(cp)) - return 0; -+ if (dev->nErasedBlocks < 1) { -+ /* Hoosterman we've got a problem. -+ * Can't get space to gc -+ */ -+ T(YAFFS_TRACE_ERROR, -+ (TSTR("yaffs tragedy: no more erased blocks" TENDSTR))); ++ return (dev->n_free_chunks > (reservedChunks + n_chunks)); ++} ++ ++static int yaffs_alloc_chunk(yaffs_dev_t *dev, int useReserve, ++ yaffs_block_info_t **blockUsedPtr) ++{ ++ int retVal; ++ yaffs_block_info_t *bi; ++ ++ if (dev->alloc_block < 0) { ++ /* Get next block to allocate off */ ++ dev->alloc_block = yaffs_find_alloc_block(dev); ++ dev->alloc_page = 0; ++ } ++ if (!useReserve && !yaffs_check_alloc_available(dev, 1)) { ++ /* Not enough space to allocate unless we're allowed to use the reserve. */ + return -1; + } - yaffs_CheckpointDeviceToDevice(dev, &cp); -+ /* Find an empty block. */ ++ if (dev->n_erased_blocks < dev->param.n_reserved_blocks ++ && dev->alloc_page == 0) { ++ T(YAFFS_TRACE_ALLOCATE, (TSTR("Allocating reserve" TENDSTR))); ++ } - nBytes = nBlocks * sizeof(yaffs_BlockInfo); -+ for (i = dev->internalStartBlock; i <= dev->internalEndBlock; i++) { -+ dev->allocationBlockFinder++; -+ if (dev->allocationBlockFinder < dev->internalStartBlock -+ || dev->allocationBlockFinder > dev->internalEndBlock) { -+ dev->allocationBlockFinder = dev->internalStartBlock; -+ } ++ /* Next page please.... */ ++ if (dev->alloc_block >= 0) { ++ bi = yaffs_get_block_info(dev, dev->alloc_block); - ok = (yaffs_CheckpointRead(dev, dev->blockInfo, nBytes) == nBytes); -+ bi = yaffs_GetBlockInfo(dev, dev->allocationBlockFinder); ++ retVal = (dev->alloc_block * dev->param.chunks_per_block) + ++ dev->alloc_page; ++ bi->pages_in_use++; ++ yaffs_set_chunk_bit(dev, dev->alloc_block, ++ dev->alloc_page); - if (!ok) - return 0; - nBytes = nBlocks * dev->chunkBitmapStride; -+ if (bi->blockState == YAFFS_BLOCK_STATE_EMPTY) { -+ bi->blockState = YAFFS_BLOCK_STATE_ALLOCATING; -+ dev->sequenceNumber++; -+ bi->sequenceNumber = dev->sequenceNumber; -+ dev->nErasedBlocks--; -+ T(YAFFS_TRACE_ALLOCATE, -+ (TSTR("Allocated block %d, seq %d, %d left" TENDSTR), -+ dev->allocationBlockFinder, dev->sequenceNumber, -+ dev->nErasedBlocks)); -+ return dev->allocationBlockFinder; -+ } -+ } ++ dev->alloc_page++; - ok = (yaffs_CheckpointRead(dev, dev->chunkBits, nBytes) == nBytes); -+ T(YAFFS_TRACE_ALWAYS, -+ (TSTR -+ ("yaffs tragedy: no more erased blocks, but there should have been %d" -+ TENDSTR), dev->nErasedBlocks)); ++ dev->n_free_chunks--; - return ok ? 1 : 0; -+ return -1; - } +-} ++ /* If the block is full set the state to full */ ++ if (dev->alloc_page >= dev->param.chunks_per_block) { ++ bi->block_state = YAFFS_BLOCK_STATE_FULL; ++ dev->alloc_block = -1; ++ } -static void yaffs_ObjectToCheckpointObject(yaffs_CheckpointObject *cp, - yaffs_Object *obj) +-{ ++ if (blockUsedPtr) ++ *blockUsedPtr = bi; + -+/* -+ * Check if there's space to allocate... -+ * Thinks.... do we need top make this ths same as yaffs_GetFreeChunks()? -+ */ -+int yaffs_CheckSpaceForAllocation(yaffs_Device *dev, int nChunks) - { -+ int reservedChunks; -+ int reservedBlocks = dev->param.nReservedBlocks; -+ int checkpointBlocks; ++ return retVal; ++ } - cp->objectId = obj->objectId; - cp->parentId = (obj->parent) ? obj->parent->objectId : 0; @@ -9215,30 +9855,23 @@ - cp->unlinkAllowed = obj->unlinkAllowed; - cp->serial = obj->serial; - cp->nDataChunks = obj->nDataChunks; -+ checkpointBlocks = yaffs2_CalcCheckpointBlocksRequired(dev); ++ T(YAFFS_TRACE_ERROR, ++ (TSTR("!!!!!!!!! Allocator out !!!!!!!!!!!!!!!!!" TENDSTR))); - if (obj->variantType == YAFFS_OBJECT_TYPE_FILE) - cp->fileSizeOrEquivalentObjectId = obj->variant.fileVariant.fileSize; - else if (obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK) - cp->fileSizeOrEquivalentObjectId = obj->variant.hardLinkVariant.equivalentObjectId; -+ reservedChunks = ((reservedBlocks + checkpointBlocks) * dev->param.nChunksPerBlock); -+ -+ return (dev->nFreeChunks > (reservedChunks + nChunks)); ++ return -1; } -static int yaffs_CheckpointObjectToObject(yaffs_Object *obj, yaffs_CheckpointObject *cp) -+static int yaffs_AllocateChunk(yaffs_Device *dev, int useReserve, -+ yaffs_BlockInfo **blockUsedPtr) ++static int yaffs_get_erased_chunks(yaffs_dev_t *dev) { -+ int retVal; -+ yaffs_BlockInfo *bi; ++ int n; - yaffs_Object *parent; -+ if (dev->allocationBlock < 0) { -+ /* Get next block to allocate off */ -+ dev->allocationBlock = yaffs_FindBlockForAllocation(dev); -+ dev->allocationPage = 0; -+ } ++ n = dev->n_erased_blocks * dev->param.chunks_per_block; - if (obj->variantType != cp->variantType) { - T(YAFFS_TRACE_ERROR, (TSTR("Checkpoint read object %d type %d " @@ -9246,16 +9879,12 @@ - TENDSTR), cp->objectId, cp->variantType, cp->hdrChunk, - obj->variantType)); - return 0; -+ if (!useReserve && !yaffs_CheckSpaceForAllocation(dev, 1)) { -+ /* Not enough space to allocate unless we're allowed to use the reserve. */ -+ return -1; - } +- } ++ if (dev->alloc_block > 0) ++ n += (dev->param.chunks_per_block - dev->alloc_page); - obj->objectId = cp->objectId; -+ if (dev->nErasedBlocks < dev->param.nReservedBlocks -+ && dev->allocationPage == 0) { -+ T(YAFFS_TRACE_ALLOCATE, (TSTR("Allocating reserve" TENDSTR))); -+ } ++ return n; - if (cp->parentId) - parent = yaffs_FindOrCreateObjectByNumber( @@ -9264,9 +9893,7 @@ - YAFFS_OBJECT_TYPE_DIRECTORY); - else - parent = NULL; -+ /* Next page please.... */ -+ if (dev->allocationBlock >= 0) { -+ bi = yaffs_GetBlockInfo(dev, dev->allocationBlock); ++} - if (parent) { - if (parent->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) { @@ -9276,15 +9903,21 @@ - cp->objectId, cp->parentId, cp->variantType, - cp->hdrChunk, parent->variantType)); - return 0; -- } ++/* ++ * yaffs_skip_rest_of_block() skips over the rest of the allocation block ++ * if we don't want to write to it. ++ */ ++void yaffs_skip_rest_of_block(yaffs_dev_t *dev) ++{ ++ if(dev->alloc_block > 0){ ++ yaffs_block_info_t *bi = yaffs_get_block_info(dev, dev->alloc_block); ++ if(bi->block_state == YAFFS_BLOCK_STATE_ALLOCATING){ ++ bi->block_state = YAFFS_BLOCK_STATE_FULL; ++ dev->alloc_block = -1; + } - yaffs_AddObjectToDirectory(parent, obj); -- } -+ retVal = (dev->allocationBlock * dev->param.nChunksPerBlock) + -+ dev->allocationPage; -+ bi->pagesInUse++; -+ yaffs_SetChunkBit(dev, dev->allocationBlock, -+ dev->allocationPage); - + } +- - obj->hdrChunk = cp->hdrChunk; - obj->variantType = cp->variantType; - obj->deleted = cp->deleted; @@ -9295,52 +9928,45 @@ - obj->unlinkAllowed = cp->unlinkAllowed; - obj->serial = cp->serial; - obj->nDataChunks = cp->nDataChunks; -+ dev->allocationPage++; - +- - if (obj->variantType == YAFFS_OBJECT_TYPE_FILE) - obj->variant.fileVariant.fileSize = cp->fileSizeOrEquivalentObjectId; - else if (obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK) - obj->variant.hardLinkVariant.equivalentObjectId = cp->fileSizeOrEquivalentObjectId; -+ dev->nFreeChunks--; - +- - if (obj->hdrChunk > 0) - obj->lazyLoaded = 1; - return 1; --} -+ /* If the block is full set the state to full */ -+ if (dev->allocationPage >= dev->param.nChunksPerBlock) { -+ bi->blockState = YAFFS_BLOCK_STATE_FULL; -+ dev->allocationBlock = -1; -+ } - -+ if (blockUsedPtr) -+ *blockUsedPtr = bi; + } -+ return retVal; -+ } +- -static int yaffs_CheckpointTnodeWorker(yaffs_Object *in, yaffs_Tnode *tn, - __u32 level, int chunkOffset) --{ -- int i; ++static int yaffs_gc_block(yaffs_dev_t *dev, int block, ++ int wholeBlock) + { ++ int oldChunk; ++ int newChunk; ++ int mark_flash; ++ int retVal = YAFFS_OK; + int i; - yaffs_Device *dev = in->myDev; - int ok = 1; - int tnodeSize = (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8; -+ T(YAFFS_TRACE_ERROR, -+ (TSTR("!!!!!!!!! Allocator out !!!!!!!!!!!!!!!!!" TENDSTR))); - +- - if (tnodeSize < sizeof(yaffs_Tnode)) - tnodeSize = sizeof(yaffs_Tnode); -+ return -1; -+} ++ int isCheckpointBlock; ++ int matchingChunk; ++ int maxCopies; -+static int yaffs_GetErasedChunks(yaffs_Device *dev) -+{ -+ int n; ++ int chunksBefore = yaffs_get_erased_chunks(dev); ++ int chunksAfter; - if (tn) { - if (level > 0) { -+ n = dev->nErasedBlocks * dev->param.nChunksPerBlock; ++ yaffs_ext_tags tags; - for (i = 0; i < YAFFS_NTNODES_INTERNAL && ok; i++) { - if (tn->internal[i]) { @@ -9357,24 +9983,19 @@ - ok = (yaffs_CheckpointWrite(dev, tn, tnodeSize) == tnodeSize); - } - } -+ if (dev->allocationBlock > 0) -+ n += (dev->param.nChunksPerBlock - dev->allocationPage); ++ yaffs_block_info_t *bi = yaffs_get_block_info(dev, block); - return ok; -+ return n; ++ yaffs_obj_t *object; - } +-} ++ isCheckpointBlock = (bi->block_state == YAFFS_BLOCK_STATE_CHECKPOINT); -static int yaffs_WriteCheckpointTnodes(yaffs_Object *obj) -+/* -+ * yaffs_SkipRestOfBlock() skips over the rest of the allocation block -+ * if we don't want to write to it. -+ */ -+void yaffs_SkipRestOfBlock(yaffs_Device *dev) - { +-{ - __u32 endMarker = ~0; - int ok = 1; -- + - if (obj->variantType == YAFFS_OBJECT_TYPE_FILE) { - ok = yaffs_CheckpointTnodeWorker(obj, - obj->variant.fileVariant.top, @@ -9383,16 +10004,17 @@ - if (ok) - ok = (yaffs_CheckpointWrite(obj->myDev, &endMarker, sizeof(endMarker)) == - sizeof(endMarker)); -+ if(dev->allocationBlock > 0){ -+ yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, dev->allocationBlock); -+ if(bi->blockState == YAFFS_BLOCK_STATE_ALLOCATING){ -+ bi->blockState = YAFFS_BLOCK_STATE_FULL; -+ dev->allocationBlock = -1; -+ } - } -- +- } ++ T(YAFFS_TRACE_TRACING, ++ (TSTR("Collecting block %d, in use %d, shrink %d, wholeBlock %d" TENDSTR), ++ block, ++ bi->pages_in_use, ++ bi->has_shrink_hdr, ++ wholeBlock)); + - return ok ? 1 : 0; - } +-} ++ /*yaffs_verify_free_chunks(dev); */ -static int yaffs_ReadCheckpointTnodes(yaffs_Object *obj) -{ @@ -9403,70 +10025,71 @@ - yaffs_Tnode *tn; - int nread = 0; - int tnodeSize = (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8; ++ if(bi->block_state == YAFFS_BLOCK_STATE_FULL) ++ bi->block_state = YAFFS_BLOCK_STATE_COLLECTING; ++ ++ bi->has_shrink_hdr = 0; /* clear the flag so that the block can erase */ - if (tnodeSize < sizeof(yaffs_Tnode)) - tnodeSize = sizeof(yaffs_Tnode); -+static int yaffs_GarbageCollectBlock(yaffs_Device *dev, int block, -+ int wholeBlock) -+{ -+ int oldChunk; -+ int newChunk; -+ int markNAND; -+ int retVal = YAFFS_OK; -+ int i; -+ int isCheckpointBlock; -+ int matchingChunk; -+ int maxCopies; ++ dev->gc_disable = 1; - ok = (yaffs_CheckpointRead(dev, &baseChunk, sizeof(baseChunk)) == sizeof(baseChunk)); -+ int chunksBefore = yaffs_GetErasedChunks(dev); -+ int chunksAfter; ++ if (isCheckpointBlock || ++ !yaffs_still_some_chunks(dev, block)) { ++ T(YAFFS_TRACE_TRACING, ++ (TSTR ++ ("Collecting block %d that has no chunks in use" TENDSTR), ++ block)); ++ yaffs_block_became_dirty(dev, block); ++ } else { - while (ok && (~baseChunk)) { - nread++; - /* Read level 0 tnode */ -+ yaffs_ExtendedTags tags; ++ __u8 *buffer = yaffs_get_temp_buffer(dev, __LINE__); -+ yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, block); ++ yaffs_verify_blk(dev, bi, block); - tn = yaffs_GetTnodeRaw(dev); - if (tn) - ok = (yaffs_CheckpointRead(dev, tn, tnodeSize) == tnodeSize); - else - ok = 0; -+ yaffs_Object *object; ++ maxCopies = (wholeBlock) ? dev->param.chunks_per_block : 5; ++ oldChunk = block * dev->param.chunks_per_block + dev->gc_chunk; - if (tn && ok) - ok = yaffs_AddOrFindLevel0Tnode(dev, - fileStructPtr, - baseChunk, - tn) ? 1 : 0; -+ isCheckpointBlock = (bi->blockState == YAFFS_BLOCK_STATE_CHECKPOINT); ++ for (/* init already done */; ++ retVal == YAFFS_OK && ++ dev->gc_chunk < dev->param.chunks_per_block && ++ (bi->block_state == YAFFS_BLOCK_STATE_COLLECTING) && ++ maxCopies > 0; ++ dev->gc_chunk++, oldChunk++) { ++ if (yaffs_check_chunk_bit(dev, block, dev->gc_chunk)) { - if (ok) - ok = (yaffs_CheckpointRead(dev, &baseChunk, sizeof(baseChunk)) == sizeof(baseChunk)); ++ /* This page is in use and might need to be copied off */ - } -+ T(YAFFS_TRACE_TRACING, -+ (TSTR("Collecting block %d, in use %d, shrink %d, wholeBlock %d" TENDSTR), -+ block, -+ bi->pagesInUse, -+ bi->hasShrinkHeader, -+ wholeBlock)); ++ maxCopies--; - T(YAFFS_TRACE_CHECKPOINT, ( - TSTR("Checkpoint read tnodes %d records, last %d. ok %d" TENDSTR), - nread, baseChunk, ok)); -+ /*yaffs_VerifyFreeChunks(dev); */ ++ mark_flash = 1; - return ok ? 1 : 0; -} -+ if(bi->blockState == YAFFS_BLOCK_STATE_FULL) -+ bi->blockState = YAFFS_BLOCK_STATE_COLLECTING; -+ -+ bi->hasShrinkHeader = 0; /* clear the flag so that the block can erase */ ++ yaffs_init_tags(&tags); -+ dev->gcDisable = 1; ++ yaffs_rd_chunk_tags_nand(dev, oldChunk, ++ buffer, &tags); -static int yaffs_WriteCheckpointObjects(yaffs_Device *dev) -{ @@ -9475,21 +10098,26 @@ - int i; - int ok = 1; - struct ylist_head *lh; -+ if (isCheckpointBlock || -+ !yaffs_StillSomeChunkBits(dev, block)) { -+ T(YAFFS_TRACE_TRACING, -+ (TSTR -+ ("Collecting block %d that has no chunks in use" TENDSTR), -+ block)); -+ yaffs_BlockBecameDirty(dev, block); -+ } else { ++ object = ++ yaffs_find_by_number(dev, ++ tags.obj_id); -+ __u8 *buffer = yaffs_GetTempBuffer(dev, __LINE__); ++ T(YAFFS_TRACE_GC_DETAIL, ++ (TSTR ++ ("Collecting chunk in block %d, %d %d %d " TENDSTR), ++ dev->gc_chunk, tags.obj_id, tags.chunk_id, ++ tags.n_bytes)); - /* Iterate through the objects in each hash entry, - * dumping them to the checkpointing stream. - */ -+ yaffs_VerifyBlock(dev, bi, block); ++ if (object && !yaffs_skip_verification(dev)) { ++ if (tags.chunk_id == 0) ++ matchingChunk = object->hdr_chunk; ++ else if (object->soft_del) ++ matchingChunk = oldChunk; /* Defeat the test */ ++ else ++ matchingChunk = yaffs_find_chunk_in_file(object, tags.chunk_id, NULL); - for (i = 0; ok && i < YAFFS_NOBJECT_BUCKETS; i++) { - ylist_for_each(lh, &dev->objectBucket[i].list) { @@ -9502,38 +10130,80 @@ - T(YAFFS_TRACE_CHECKPOINT, ( - TSTR("Checkpoint write object %d parent %d type %d chunk %d obj addr %x" TENDSTR), - cp.objectId, cp.parentId, cp.variantType, cp.hdrChunk, (unsigned) obj)); -+ maxCopies = (wholeBlock) ? dev->param.nChunksPerBlock : 5; -+ oldChunk = block * dev->param.nChunksPerBlock + dev->gcChunk; ++ if (oldChunk != matchingChunk) ++ T(YAFFS_TRACE_ERROR, ++ (TSTR("gc: page in gc mismatch: %d %d %d %d"TENDSTR), ++ oldChunk, matchingChunk, tags.obj_id, tags.chunk_id)); - ok = (yaffs_CheckpointWrite(dev, &cp, sizeof(cp)) == sizeof(cp)); -+ for (/* init already done */; -+ retVal == YAFFS_OK && -+ dev->gcChunk < dev->param.nChunksPerBlock && -+ (bi->blockState == YAFFS_BLOCK_STATE_COLLECTING) && -+ maxCopies > 0; -+ dev->gcChunk++, oldChunk++) { -+ if (yaffs_CheckChunkBit(dev, block, dev->gcChunk)) { ++ } - if (ok && obj->variantType == YAFFS_OBJECT_TYPE_FILE) - ok = yaffs_WriteCheckpointTnodes(obj); -- } ++ if (!object) { ++ T(YAFFS_TRACE_ERROR, ++ (TSTR ++ ("page %d in gc has no object: %d %d %d " ++ TENDSTR), oldChunk, ++ tags.obj_id, tags.chunk_id, tags.n_bytes)); + } - } - } - } -+ /* This page is in use and might need to be copied off */ - /* Dump end of list */ - memset(&cp, 0xFF, sizeof(yaffs_CheckpointObject)); - cp.structType = sizeof(cp); -+ maxCopies--; ++ if (object && ++ object->deleted && ++ object->soft_del && ++ tags.chunk_id != 0) { ++ /* Data chunk in a soft deleted file, throw it away ++ * It's a soft deleted data chunk, ++ * No need to copy this, just forget about it and ++ * fix up the object. ++ */ ++ ++ /* Free chunks already includes softdeleted chunks. ++ * How ever this chunk is going to soon be really deleted ++ * which will increment free chunks. ++ * We have to decrement free chunks so this works out properly. ++ */ ++ dev->n_free_chunks--; ++ bi->soft_del_pages--; ++ ++ object->n_data_chunks--; - if (ok) - ok = (yaffs_CheckpointWrite(dev, &cp, sizeof(cp)) == sizeof(cp)); -+ markNAND = 1; ++ if (object->n_data_chunks <= 0) { ++ /* remeber to clean up the object */ ++ dev->gc_cleanup_list[dev->n_clean_ups] = ++ tags.obj_id; ++ dev->n_clean_ups++; ++ } ++ mark_flash = 0; ++ } else if (0) { ++ /* Todo object && object->deleted && object->n_data_chunks == 0 */ ++ /* Deleted object header with no data chunks. ++ * Can be discarded and the file deleted. ++ */ ++ object->hdr_chunk = 0; ++ yaffs_free_tnode(object->my_dev, ++ object->variant. ++ file_variant.top); ++ object->variant.file_variant.top = NULL; ++ yaffs_generic_obj_del(object); - return ok ? 1 : 0; -} -+ yaffs_InitialiseTags(&tags); ++ } else if (object) { ++ /* It's either a data chunk in a live file or ++ * an ObjectHeader, so we're interested in it. ++ * NB Need to keep the ObjectHeaders of deleted files ++ * until the whole file has been deleted off ++ */ ++ tags.serial_number++; -static int yaffs_ReadCheckpointObjects(yaffs_Device *dev) -{ @@ -9542,8 +10212,7 @@ - int ok = 1; - int done = 0; - yaffs_Object *hardList = NULL; -+ yaffs_ReadChunkWithTagsFromNAND(dev, oldChunk, -+ buffer, &tags); ++ dev->n_gc_copies++; - while (ok && !done) { - ok = (yaffs_CheckpointRead(dev, &cp, sizeof(cp)) == sizeof(cp)); @@ -9575,160 +10244,139 @@ - ok = 0; - } - } -+ object = -+ yaffs_FindObjectByNumber(dev, -+ tags.objectId); ++ if (tags.chunk_id == 0) { ++ /* It is an object Id, ++ * We need to nuke the shrinkheader flags first ++ * Also need to clean up shadowing. ++ * We no longer want the shrinkHeader flag since its work is done ++ * and if it is left in place it will mess up scanning. ++ */ - if (ok) - yaffs_HardlinkFixup(dev, hardList); -+ T(YAFFS_TRACE_GC_DETAIL, -+ (TSTR -+ ("Collecting chunk in block %d, %d %d %d " TENDSTR), -+ dev->gcChunk, tags.objectId, tags.chunkId, -+ tags.byteCount)); ++ yaffs_obj_header *oh; ++ oh = (yaffs_obj_header *)buffer; - return ok ? 1 : 0; -} -+ if (object && !yaffs_SkipVerification(dev)) { -+ if (tags.chunkId == 0) -+ matchingChunk = object->hdrChunk; -+ else if (object->softDeleted) -+ matchingChunk = oldChunk; /* Defeat the test */ -+ else -+ matchingChunk = yaffs_FindChunkInFile(object, tags.chunkId, NULL); ++ oh->is_shrink = 0; ++ tags.extra_is_shrink = 0; -static int yaffs_WriteCheckpointSum(yaffs_Device *dev) -{ - __u32 checkpointSum; - int ok; -+ if (oldChunk != matchingChunk) -+ T(YAFFS_TRACE_ERROR, -+ (TSTR("gc: page in gc mismatch: %d %d %d %d"TENDSTR), -+ oldChunk, matchingChunk, tags.objectId, tags.chunkId)); ++ oh->shadows_obj = 0; ++ oh->inband_shadowed_obj_id = 0; ++ tags.extra_shadows = 0; ++ ++ /* Update file size */ ++ if(object->variant_type == YAFFS_OBJECT_TYPE_FILE){ ++ oh->file_size = object->variant.file_variant.file_size; ++ tags.extra_length = oh->file_size; ++ } ++ ++ yaffs_verify_oh(object, oh, &tags, 1); ++ newChunk = ++ yaffs_write_new_chunk(dev,(__u8 *) oh, &tags, 1); ++ } else ++ newChunk = ++ yaffs_write_new_chunk(dev, buffer, &tags, 1); ++ ++ if (newChunk < 0) { ++ retVal = YAFFS_FAIL; ++ } else { - yaffs_GetCheckpointSum(dev, &checkpointSum); -+ } ++ /* Ok, now fix up the Tnodes etc. */ - ok = (yaffs_CheckpointWrite(dev, &checkpointSum, sizeof(checkpointSum)) == sizeof(checkpointSum)); -+ if (!object) { -+ T(YAFFS_TRACE_ERROR, -+ (TSTR -+ ("page %d in gc has no object: %d %d %d " -+ TENDSTR), oldChunk, -+ tags.objectId, tags.chunkId, tags.byteCount)); ++ if (tags.chunk_id == 0) { ++ /* It's a header */ ++ object->hdr_chunk = newChunk; ++ object->serial = tags.serial_number; ++ } else { ++ /* It's a data chunk */ ++ int ok; ++ ok = yaffs_put_chunk_in_file ++ (object, ++ tags.chunk_id, ++ newChunk, 0); ++ } ++ } + } - if (!ok) - return 0; -+ if (object && -+ object->deleted && -+ object->softDeleted && -+ tags.chunkId != 0) { -+ /* Data chunk in a soft deleted file, throw it away -+ * It's a soft deleted data chunk, -+ * No need to copy this, just forget about it and -+ * fix up the object. -+ */ -+ -+ /* Free chunks already includes softdeleted chunks. -+ * How ever this chunk is going to soon be really deleted -+ * which will increment free chunks. -+ * We have to decrement free chunks so this works out properly. -+ */ -+ dev->nFreeChunks--; -+ bi->softDeletions--; ++ if (retVal == YAFFS_OK) ++ yaffs_chunk_del(dev, oldChunk, mark_flash, __LINE__); - return 1; -} -+ object->nDataChunks--; ++ } ++ } -static int yaffs_ReadCheckpointSum(yaffs_Device *dev) -{ - __u32 checkpointSum0; - __u32 checkpointSum1; - int ok; -+ if (object->nDataChunks <= 0) { -+ /* remeber to clean up the object */ -+ dev->gcCleanupList[dev->nCleanups] = -+ tags.objectId; -+ dev->nCleanups++; -+ } -+ markNAND = 0; -+ } else if (0) { -+ /* Todo object && object->deleted && object->nDataChunks == 0 */ -+ /* Deleted object header with no data chunks. -+ * Can be discarded and the file deleted. -+ */ -+ object->hdrChunk = 0; -+ yaffs_FreeTnode(object->myDev, -+ object->variant. -+ fileVariant.top); -+ object->variant.fileVariant.top = NULL; -+ yaffs_DoGenericObjectDeletion(object); ++ yaffs_release_temp_buffer(dev, buffer, __LINE__); - yaffs_GetCheckpointSum(dev, &checkpointSum0); -+ } else if (object) { -+ /* It's either a data chunk in a live file or -+ * an ObjectHeader, so we're interested in it. -+ * NB Need to keep the ObjectHeaders of deleted files -+ * until the whole file has been deleted off -+ */ -+ tags.serialNumber++; - ok = (yaffs_CheckpointRead(dev, &checkpointSum1, sizeof(checkpointSum1)) == sizeof(checkpointSum1)); -+ dev->nGCCopies++; - if (!ok) - return 0; -+ if (tags.chunkId == 0) { -+ /* It is an object Id, -+ * We need to nuke the shrinkheader flags first -+ * Also need to clean up shadowing. -+ * We no longer want the shrinkHeader flag since its work is done -+ * and if it is left in place it will mess up scanning. -+ */ ++ } - if (checkpointSum0 != checkpointSum1) - return 0; -+ yaffs_ObjectHeader *oh; -+ oh = (yaffs_ObjectHeader *)buffer; ++ yaffs_verify_collected_blk(dev, bi, block); - return 1; -} -+ oh->isShrink = 0; -+ tags.extraIsShrinkHeader = 0; -+ oh->shadowsObject = 0; -+ oh->inbandShadowsObject = 0; -+ tags.extraShadows = 0; -+ -+ /* Update file size */ -+ if(object->variantType == YAFFS_OBJECT_TYPE_FILE){ -+ oh->fileSize = object->variant.fileVariant.fileSize; -+ tags.extraFileLength = oh->fileSize; -+ } -static int yaffs_WriteCheckpointData(yaffs_Device *dev) -{ - int ok = 1; -+ yaffs_VerifyObjectHeader(object, oh, &tags, 1); -+ newChunk = -+ yaffs_WriteNewChunkWithTagsToNAND(dev,(__u8 *) oh, &tags, 1); -+ } else -+ newChunk = -+ yaffs_WriteNewChunkWithTagsToNAND(dev, buffer, &tags, 1); ++ if (bi->block_state == YAFFS_BLOCK_STATE_COLLECTING) { ++ /* ++ * The gc did not complete. Set block state back to FULL ++ * because checkpointing does not restore gc. ++ */ ++ bi->block_state = YAFFS_BLOCK_STATE_FULL; ++ } else { ++ /* The gc completed. */ ++ /* Do any required cleanups */ ++ for (i = 0; i < dev->n_clean_ups; i++) { ++ /* Time to delete the file too */ ++ object = ++ yaffs_find_by_number(dev, ++ dev->gc_cleanup_list[i]); ++ if (object) { ++ yaffs_free_tnode(dev, ++ object->variant.file_variant. ++ top); ++ object->variant.file_variant.top = NULL; ++ T(YAFFS_TRACE_GC, ++ (TSTR ++ ("yaffs: About to finally delete object %d" ++ TENDSTR), object->obj_id)); ++ yaffs_generic_obj_del(object); ++ object->my_dev->n_deleted_files--; ++ } - if (dev->skipCheckpointWrite || !dev->isYaffs2) { - T(YAFFS_TRACE_CHECKPOINT, (TSTR("skipping checkpoint write" TENDSTR))); - ok = 0; - } -+ if (newChunk < 0) { -+ retVal = YAFFS_FAIL; -+ } else { ++ } - if (ok) - ok = yaffs_CheckpointOpen(dev, 1); -+ /* Ok, now fix up the Tnodes etc. */ - if (ok) { - T(YAFFS_TRACE_CHECKPOINT, (TSTR("write checkpoint validity" TENDSTR))); @@ -9745,53 +10393,84 @@ - if (ok) { - T(YAFFS_TRACE_CHECKPOINT, (TSTR("write checkpoint validity" TENDSTR))); - ok = yaffs_WriteCheckpointValidityMarker(dev, 0); -- } -+ if (tags.chunkId == 0) { -+ /* It's a header */ -+ object->hdrChunk = newChunk; -+ object->serial = tags.serialNumber; -+ } else { -+ /* It's a data chunk */ -+ int ok; -+ ok = yaffs_PutChunkIntoFile -+ (object, -+ tags.chunkId, -+ newChunk, 0); -+ } -+ } -+ } ++ chunksAfter = yaffs_get_erased_chunks(dev); ++ if (chunksBefore >= chunksAfter) { ++ T(YAFFS_TRACE_GC, ++ (TSTR ++ ("gc did not increase free chunks before %d after %d" ++ TENDSTR), chunksBefore, chunksAfter)); ++ } ++ dev->gc_block = 0; ++ dev->gc_chunk = 0; ++ dev->n_clean_ups = 0; + } - if (ok) - ok = yaffs_WriteCheckpointSum(dev); -+ if (retVal == YAFFS_OK) -+ yaffs_DeleteChunk(dev, oldChunk, markNAND, __LINE__); - +- - if (!yaffs_CheckpointClose(dev)) - ok = 0; -+ } -+ } - +- - if (ok) - dev->isCheckpointed = 1; - else - dev->isCheckpointed = 0; -+ yaffs_ReleaseTempBuffer(dev, buffer, __LINE__); ++ dev->gc_disable = 0; - return dev->isCheckpointed; --} ++ return retVal; + } -static int yaffs_ReadCheckpointData(yaffs_Device *dev) --{ ++/* ++ * FindBlockForgarbageCollection is used to select the dirtiest block (or close enough) ++ * for garbage collection. ++ */ ++ ++static unsigned yaffs_find_gc_block(yaffs_dev_t *dev, ++ int aggressive, ++ int background) + { - int ok = 1; ++ int i; ++ int iterations; ++ unsigned selected = 0; ++ int prioritised = 0; ++ int prioritisedExists = 0; ++ yaffs_block_info_t *bi; ++ int threshold; - if (dev->skipCheckpointRead || !dev->isYaffs2) { - T(YAFFS_TRACE_CHECKPOINT, (TSTR("skipping checkpoint read" TENDSTR))); - ok = 0; - } +- } ++ /* First let's see if we need to grab a prioritised block */ ++ if (dev->has_pending_prioritised_gc && !aggressive) { ++ dev->gc_dirtiest = 0; ++ bi = dev->block_info; ++ for (i = dev->internal_start_block; ++ i <= dev->internal_end_block && !selected; ++ i++) { ++ ++ if (bi->gc_prioritise) { ++ prioritisedExists = 1; ++ if (bi->block_state == YAFFS_BLOCK_STATE_FULL && ++ yaffs_block_ok_for_gc(dev, bi)) { ++ selected = i; ++ prioritised = 1; ++ } ++ } ++ bi++; ++ } - if (ok) - ok = yaffs_CheckpointOpen(dev, 0); /* open for read */ -- ++ /* ++ * If there is a prioritised block and none was selected then ++ * this happened because there is at least one old dirty block gumming ++ * up the works. Let's gc the oldest dirty block. ++ */ + - if (ok) { - T(YAFFS_TRACE_CHECKPOINT, (TSTR("read checkpoint validity" TENDSTR))); - ok = yaffs_ReadCheckpointValidityMarker(dev, 1); @@ -9808,51 +10487,42 @@ - T(YAFFS_TRACE_CHECKPOINT, (TSTR("read checkpoint validity" TENDSTR))); - ok = yaffs_ReadCheckpointValidityMarker(dev, 0); - } -+ yaffs_VerifyCollectedBlock(dev, bi, block); ++ if(prioritisedExists && ++ !selected && ++ dev->oldest_dirty_block > 0) ++ selected = dev->oldest_dirty_block; - if (ok) { - ok = yaffs_ReadCheckpointSum(dev); - T(YAFFS_TRACE_CHECKPOINT, (TSTR("read checkpoint checksum %d" TENDSTR), ok)); -- } ++ if (!prioritisedExists) /* None found, so we can clear this */ ++ dev->has_pending_prioritised_gc = 0; + } - if (!yaffs_CheckpointClose(dev)) - ok = 0; - +- - if (ok) - dev->isCheckpointed = 1; - else - dev->isCheckpointed = 0; -+ if (bi->blockState == YAFFS_BLOCK_STATE_COLLECTING) { -+ /* -+ * The gc did not complete. Set block state back to FULL -+ * because checkpointing does not restore gc. -+ */ -+ bi->blockState = YAFFS_BLOCK_STATE_FULL; -+ } else { -+ /* The gc completed. */ -+ /* Do any required cleanups */ -+ for (i = 0; i < dev->nCleanups; i++) { -+ /* Time to delete the file too */ -+ object = -+ yaffs_FindObjectByNumber(dev, -+ dev->gcCleanupList[i]); -+ if (object) { -+ yaffs_FreeTnode(dev, -+ object->variant.fileVariant. -+ top); -+ object->variant.fileVariant.top = NULL; -+ T(YAFFS_TRACE_GC, -+ (TSTR -+ ("yaffs: About to finally delete object %d" -+ TENDSTR), object->objectId)); -+ yaffs_DoGenericObjectDeletion(object); -+ object->myDev->nDeletedFiles--; -+ } - +- - return ok ? 1 : 0; -+ } ++ /* If we're doing aggressive GC then we are happy to take a less-dirty block, and ++ * search harder. ++ * else (we're doing a leasurely gc), then we only bother to do this if the ++ * block has only a few pages in use. ++ */ -} ++ if (!selected){ ++ int pagesUsed; ++ int nBlocks = dev->internal_end_block - dev->internal_start_block + 1; ++ if (aggressive){ ++ threshold = dev->param.chunks_per_block; ++ iterations = nBlocks; ++ } else { ++ int maxThreshold; -static void yaffs_InvalidateCheckpoint(yaffs_Device *dev) -{ @@ -9862,115 +10532,126 @@ - yaffs_CheckpointInvalidateStream(dev); - if (dev->superBlock && dev->markSuperBlockDirty) - dev->markSuperBlockDirty(dev->superBlock); -+ chunksAfter = yaffs_GetErasedChunks(dev); -+ if (chunksBefore >= chunksAfter) { -+ T(YAFFS_TRACE_GC, -+ (TSTR -+ ("gc did not increase free chunks before %d after %d" -+ TENDSTR), chunksBefore, chunksAfter)); -+ } -+ dev->gcBlock = 0; -+ dev->gcChunk = 0; -+ dev->nCleanups = 0; - } +- } -} ++ if(background) ++ maxThreshold = dev->param.chunks_per_block/2; ++ else ++ maxThreshold = dev->param.chunks_per_block/8; -+ dev->gcDisable = 0; ++ if(maxThreshold < YAFFS_GC_PASSIVE_THRESHOLD) ++ maxThreshold = YAFFS_GC_PASSIVE_THRESHOLD; -int yaffs_CheckpointSave(yaffs_Device *dev) -{ -- ++ threshold = background ? ++ (dev->gc_not_done + 2) * 2 : 0; ++ if(threshold <YAFFS_GC_PASSIVE_THRESHOLD) ++ threshold = YAFFS_GC_PASSIVE_THRESHOLD; ++ if(threshold > maxThreshold) ++ threshold = maxThreshold; + - T(YAFFS_TRACE_CHECKPOINT, (TSTR("save entry: isCheckpointed %d"TENDSTR), dev->isCheckpointed)); -+ return retVal; -+} ++ iterations = nBlocks / 16 + 1; ++ if (iterations > 100) ++ iterations = 100; ++ } - yaffs_VerifyObjects(dev); - yaffs_VerifyBlocks(dev); - yaffs_VerifyFreeChunks(dev); -+/* -+ * FindBlockForgarbageCollection is used to select the dirtiest block (or close enough) -+ * for garbage collection. -+ */ ++ for (i = 0; ++ i < iterations && ++ (dev->gc_dirtiest < 1 || ++ dev->gc_pages_in_use > YAFFS_GC_GOOD_ENOUGH); ++ i++) { ++ dev->gc_block_finder++; ++ if (dev->gc_block_finder < dev->internal_start_block || ++ dev->gc_block_finder > dev->internal_end_block) ++ dev->gc_block_finder = dev->internal_start_block; - if (!dev->isCheckpointed) { - yaffs_InvalidateCheckpoint(dev); - yaffs_WriteCheckpointData(dev); - } -+static unsigned yaffs_FindBlockForGarbageCollection(yaffs_Device *dev, -+ int aggressive, -+ int background) -+{ -+ int i; -+ int iterations; -+ unsigned selected = 0; -+ int prioritised = 0; -+ int prioritisedExists = 0; -+ yaffs_BlockInfo *bi; -+ int threshold; ++ bi = yaffs_get_block_info(dev, dev->gc_block_finder); - T(YAFFS_TRACE_ALWAYS, (TSTR("save exit: isCheckpointed %d"TENDSTR), dev->isCheckpointed)); -+ /* First let's see if we need to grab a prioritised block */ -+ if (dev->hasPendingPrioritisedGCs && !aggressive) { -+ dev->gcDirtiest = 0; -+ bi = dev->blockInfo; -+ for (i = dev->internalStartBlock; -+ i <= dev->internalEndBlock && !selected; -+ i++) { ++ pagesUsed = bi->pages_in_use - bi->soft_del_pages; - return dev->isCheckpointed; -} -+ if (bi->gcPrioritise) { -+ prioritisedExists = 1; -+ if (bi->blockState == YAFFS_BLOCK_STATE_FULL && -+ yaffs2_BlockNotDisqualifiedFromGC(dev, bi)) { -+ selected = i; -+ prioritised = 1; -+ } ++ if (bi->block_state == YAFFS_BLOCK_STATE_FULL && ++ pagesUsed < dev->param.chunks_per_block && ++ (dev->gc_dirtiest < 1 || pagesUsed < dev->gc_pages_in_use) && ++ yaffs_block_ok_for_gc(dev, bi)) { ++ dev->gc_dirtiest = dev->gc_block_finder; ++ dev->gc_pages_in_use = pagesUsed; + } -+ bi++; + } -int yaffs_CheckpointRestore(yaffs_Device *dev) -{ - int retval; - T(YAFFS_TRACE_CHECKPOINT, (TSTR("restore entry: isCheckpointed %d"TENDSTR), dev->isCheckpointed)); -+ /* -+ * If there is a prioritised block and none was selected then -+ * this happened because there is at least one old dirty block gumming -+ * up the works. Let's gc the oldest dirty block. -+ */ ++ if(dev->gc_dirtiest > 0 && dev->gc_pages_in_use <= threshold) ++ selected = dev->gc_dirtiest; ++ } - retval = yaffs_ReadCheckpointData(dev); -+ if(prioritisedExists && -+ !selected && -+ dev->oldestDirtyBlock > 0) -+ selected = dev->oldestDirtyBlock; ++ /* ++ * If nothing has been selected for a while, try selecting the oldest dirty ++ * because that's gumming up the works. ++ */ - if (dev->isCheckpointed) { - yaffs_VerifyObjects(dev); - yaffs_VerifyBlocks(dev); - yaffs_VerifyFreeChunks(dev); -+ if (!prioritisedExists) /* None found, so we can clear this */ -+ dev->hasPendingPrioritisedGCs = 0; ++ if(!selected && dev->param.is_yaffs2 && ++ dev->gc_not_done >= ( background ? 10 : 20)){ ++ yaffs2_find_oldest_dirty_seq(dev); ++ if(dev->oldest_dirty_block > 0) { ++ selected = dev->oldest_dirty_block; ++ dev->gc_dirtiest = selected; ++ dev->oldest_dirty_gc_count++; ++ bi = yaffs_get_block_info(dev, selected); ++ dev->gc_pages_in_use = bi->pages_in_use - bi->soft_del_pages; ++ } else ++ dev->gc_not_done = 0; } - T(YAFFS_TRACE_CHECKPOINT, (TSTR("restore exit: isCheckpointed %d"TENDSTR), dev->isCheckpointed)); -+ /* If we're doing aggressive GC then we are happy to take a less-dirty block, and -+ * search harder. -+ * else (we're doing a leasurely gc), then we only bother to do this if the -+ * block has only a few pages in use. -+ */ ++ if(selected){ ++ T(YAFFS_TRACE_GC, ++ (TSTR("GC Selected block %d with %d free, prioritised:%d" TENDSTR), ++ selected, ++ dev->param.chunks_per_block - dev->gc_pages_in_use, ++ prioritised)); ++ ++ dev->n_gc_blocks++; ++ if(background) ++ dev->bg_gcs++; ++ ++ dev->gc_dirtiest = 0; ++ dev->gc_pages_in_use = 0; ++ dev->gc_not_done = 0; ++ if(dev->refresh_skip > 0) ++ dev->refresh_skip--; ++ } else{ ++ dev->gc_not_done++; ++ T(YAFFS_TRACE_GC, ++ (TSTR("GC none: finder %d skip %d threshold %d dirtiest %d using %d oldest %d%s" TENDSTR), ++ dev->gc_block_finder, dev->gc_not_done, ++ threshold, ++ dev->gc_dirtiest, dev->gc_pages_in_use, ++ dev->oldest_dirty_block, ++ background ? " bg" : "")); ++ } - return retval; --} -+ if (!selected){ -+ int pagesUsed; -+ int nBlocks = dev->internalEndBlock - dev->internalStartBlock + 1; -+ if (aggressive){ -+ threshold = dev->param.nChunksPerBlock; -+ iterations = nBlocks; -+ } else { -+ int maxThreshold; ++ return selected; + } -/*--------------------- File read/write ------------------------ - * Read and write have very similar structures. @@ -9978,19 +10659,27 @@ - * An incomplete chunk to start with (if the read/write is not chunk-aligned) - * Some complete chunks - * An incomplete chunk to end off with -- * ++/* New garbage collector ++ * If we're very low on erased blocks then we do aggressive garbage collection ++ * otherwise we do "leasurely" garbage collection. ++ * Aggressive gc looks further (whole array) and will accept less dirty blocks. ++ * Passive gc only inspects smaller areas and will only accept more dirty blocks. + * - * Curve-balls: the first chunk might also be the last chunk. -- */ -+ if(background) -+ maxThreshold = dev->param.nChunksPerBlock/2; -+ else -+ maxThreshold = dev->param.nChunksPerBlock/8; - ++ * The idea is to help clear out space in a more spread-out manner. ++ * Dunno if it really does anything useful. + */ +- -int yaffs_ReadDataFromFile(yaffs_Object *in, __u8 *buffer, loff_t offset, - int nBytes) --{ -+ if(maxThreshold < YAFFS_GC_PASSIVE_THRESHOLD) -+ maxThreshold = YAFFS_GC_PASSIVE_THRESHOLD; ++static int yaffs_check_gc(yaffs_dev_t *dev, int background) + { ++ int aggressive = 0; ++ int gcOk = YAFFS_OK; ++ int maxTries = 0; ++ int minErased; ++ int erasedChunks; ++ int checkpointBlockAdjust; - int chunk; - __u32 start; @@ -9998,37 +10687,17 @@ - int n = nBytes; - int nDone = 0; - yaffs_ChunkCache *cache; -+ threshold = background ? -+ (dev->gcNotDone + 2) * 2 : 0; -+ if(threshold <YAFFS_GC_PASSIVE_THRESHOLD) -+ threshold = YAFFS_GC_PASSIVE_THRESHOLD; -+ if(threshold > maxThreshold) -+ threshold = maxThreshold; - +- - yaffs_Device *dev; -+ iterations = nBlocks / 16 + 1; -+ if (iterations > 100) -+ iterations = 100; -+ } - +- - dev = in->myDev; -+ for (i = 0; -+ i < iterations && -+ (dev->gcDirtiest < 1 || -+ dev->gcPagesInUse > YAFFS_GC_GOOD_ENOUGH); -+ i++) { -+ dev->gcBlockFinder++; -+ if (dev->gcBlockFinder < dev->internalStartBlock || -+ dev->gcBlockFinder > dev->internalEndBlock) -+ dev->gcBlockFinder = dev->internalStartBlock; - +- - while (n > 0) { - /* chunk = offset / dev->nDataBytesPerChunk + 1; */ - /* start = offset % dev->nDataBytesPerChunk; */ - yaffs_AddrToChunk(dev, offset, &chunk, &start); - chunk++; -+ bi = yaffs_GetBlockInfo(dev, dev->gcBlockFinder); - +- - /* OK now check for the curveball where the start and end are in - * the same chunk. - */ @@ -10036,46 +10705,20 @@ - nToCopy = n; - else - nToCopy = dev->nDataBytesPerChunk - start; -+ pagesUsed = bi->pagesInUse - bi->softDeletions; - +- - cache = yaffs_FindChunkCache(in, chunk); -+ if (bi->blockState == YAFFS_BLOCK_STATE_FULL && -+ pagesUsed < dev->param.nChunksPerBlock && -+ (dev->gcDirtiest < 1 || pagesUsed < dev->gcPagesInUse) && -+ yaffs2_BlockNotDisqualifiedFromGC(dev, bi)) { -+ dev->gcDirtiest = dev->gcBlockFinder; -+ dev->gcPagesInUse = pagesUsed; -+ } -+ } - +- - /* If the chunk is already in the cache or it is less than a whole chunk - * or we're using inband tags then use the cache (if there is caching) - * else bypass the cache. - */ - if (cache || nToCopy != dev->nDataBytesPerChunk || dev->inbandTags) { - if (dev->nShortOpCaches > 0) { -+ if(dev->gcDirtiest > 0 && dev->gcPagesInUse <= threshold) -+ selected = dev->gcDirtiest; -+ } -+ -+ /* -+ * If nothing has been selected for a while, try selecting the oldest dirty -+ * because that's gumming up the works. -+ */ - +- - /* If we can't find the data in the cache, then load it up. */ -+ if(!selected && dev->param.isYaffs2 && -+ dev->gcNotDone >= ( background ? 10 : 20)){ -+ yaffs2_FindOldestDirtySequence(dev); -+ if(dev->oldestDirtyBlock > 0) { -+ selected = dev->oldestDirtyBlock; -+ dev->gcDirtiest = selected; -+ dev->oldestDirtyGCs++; -+ bi = yaffs_GetBlockInfo(dev, selected); -+ dev->gcPagesInUse = bi->pagesInUse - bi->softDeletions; -+ } else -+ dev->gcNotDone = 0; -+ } ++ if(dev->param.gc_control && ++ (dev->param.gc_control(dev) & 1) == 0) ++ return YAFFS_OK; - if (!cache) { - cache = yaffs_GrabChunkCache(in->myDev); @@ -10088,167 +10731,117 @@ - data); - cache->nBytes = 0; - } -+ if(selected){ -+ T(YAFFS_TRACE_GC, -+ (TSTR("GC Selected block %d with %d free, prioritised:%d" TENDSTR), -+ selected, -+ dev->param.nChunksPerBlock - dev->gcPagesInUse, -+ prioritised)); -+ -+ dev->nGCBlocks++; -+ if(background) -+ dev->backgroundGCs++; -+ -+ dev->gcDirtiest = 0; -+ dev->gcPagesInUse = 0; -+ dev->gcNotDone = 0; -+ if(dev->refreshSkip > 0) -+ dev->refreshSkip--; -+ } else{ -+ dev->gcNotDone++; -+ T(YAFFS_TRACE_GC, -+ (TSTR("GC none: finder %d skip %d threshold %d dirtiest %d using %d oldest %d%s" TENDSTR), -+ dev->gcBlockFinder, dev->gcNotDone, -+ threshold, -+ dev->gcDirtiest, dev->gcPagesInUse, -+ dev->oldestDirtyBlock, -+ background ? " bg" : "")); ++ if (dev->gc_disable) { ++ /* Bail out so we don't get recursive gc */ ++ return YAFFS_OK; + } - yaffs_UseChunkCache(dev, cache, 0); -+ return selected; -+} ++ /* This loop should pass the first time. ++ * We'll only see looping here if the collection does not increase space. ++ */ - cache->locked = 1; -+/* New garbage collector -+ * If we're very low on erased blocks then we do aggressive garbage collection -+ * otherwise we do "leasurely" garbage collection. -+ * Aggressive gc looks further (whole array) and will accept less dirty blocks. -+ * Passive gc only inspects smaller areas and will only accept more dirty blocks. -+ * -+ * The idea is to help clear out space in a more spread-out manner. -+ * Dunno if it really does anything useful. -+ */ -+static int yaffs_CheckGarbageCollection(yaffs_Device *dev, int background) -+{ -+ int aggressive = 0; -+ int gcOk = YAFFS_OK; -+ int maxTries = 0; -+ int minErased; -+ int erasedChunks; -+ int checkpointBlockAdjust; ++ do { ++ maxTries++; -+ if(dev->param.gcControl && -+ (dev->param.gcControl(dev) & 1) == 0) -+ return YAFFS_OK; ++ checkpointBlockAdjust = yaffs_calc_checkpt_blocks_required(dev); - memcpy(buffer, &cache->data[start], nToCopy); -+ if (dev->gcDisable) { -+ /* Bail out so we don't get recursive gc */ -+ return YAFFS_OK; -+ } ++ minErased = dev->param.n_reserved_blocks + checkpointBlockAdjust + 1; ++ erasedChunks = dev->n_erased_blocks * dev->param.chunks_per_block; - cache->locked = 0; - } else { - /* Read into the local buffer then copy..*/ -+ /* This loop should pass the first time. -+ * We'll only see looping here if the collection does not increase space. -+ */ ++ /* If we need a block soon then do aggressive gc.*/ ++ if (dev->n_erased_blocks < minErased) ++ aggressive = 1; ++ else { ++ if(!background && erasedChunks > (dev->n_free_chunks / 4)) ++ break; - __u8 *localBuffer = - yaffs_GetTempBuffer(dev, __LINE__); - yaffs_ReadChunkDataFromObject(in, chunk, - localBuffer); -+ do { -+ maxTries++; ++ if(dev->gc_skip > 20) ++ dev->gc_skip = 20; ++ if(erasedChunks < dev->n_free_chunks/2 || ++ dev->gc_skip < 1 || ++ background) ++ aggressive = 0; ++ else { ++ dev->gc_skip--; ++ break; ++ } ++ } - memcpy(buffer, &localBuffer[start], nToCopy); -+ checkpointBlockAdjust = yaffs2_CalcCheckpointBlocksRequired(dev); ++ dev->gc_skip = 5; -+ minErased = dev->param.nReservedBlocks + checkpointBlockAdjust + 1; -+ erasedChunks = dev->nErasedBlocks * dev->param.nChunksPerBlock; ++ /* If we don't already have a block being gc'd then see if we should start another */ - yaffs_ReleaseTempBuffer(dev, localBuffer, - __LINE__); -+ /* If we need a block soon then do aggressive gc.*/ -+ if (dev->nErasedBlocks < minErased) -+ aggressive = 1; -+ else { -+ if(!background && erasedChunks > (dev->nFreeChunks / 4)) -+ break; -+ -+ if(dev->gcSkip > 20) -+ dev->gcSkip = 20; -+ if(erasedChunks < dev->nFreeChunks/2 || -+ dev->gcSkip < 1 || -+ background) -+ aggressive = 0; -+ else { -+ dev->gcSkip--; -+ break; - } +- } ++ if (dev->gc_block < 1 && !aggressive) { ++ dev->gc_block = yaffs2_find_refresh_block(dev); ++ dev->gc_chunk = 0; ++ dev->n_clean_ups=0; ++ } ++ if (dev->gc_block < 1) { ++ dev->gc_block = yaffs_find_gc_block(dev, aggressive, background); ++ dev->gc_chunk = 0; ++ dev->n_clean_ups=0; + } - } else { -+ dev->gcSkip = 5; ++ if (dev->gc_block > 0) { ++ dev->all_gcs++; ++ if (!aggressive) ++ dev->passive_gc_count++; - /* A full chunk. Read directly into the supplied buffer. */ - yaffs_ReadChunkDataFromObject(in, chunk, buffer); -+ /* If we don't already have a block being gc'd then see if we should start another */ ++ T(YAFFS_TRACE_GC, ++ (TSTR ++ ("yaffs: GC erasedBlocks %d aggressive %d" TENDSTR), ++ dev->n_erased_blocks, aggressive)); -+ if (dev->gcBlock < 1 && !aggressive) { -+ dev->gcBlock = yaffs2_FindRefreshBlock(dev); -+ dev->gcChunk = 0; -+ dev->nCleanups=0; -+ } -+ if (dev->gcBlock < 1) { -+ dev->gcBlock = yaffs_FindBlockForGarbageCollection(dev, aggressive, background); -+ dev->gcChunk = 0; -+ dev->nCleanups=0; ++ gcOk = yaffs_gc_block(dev, dev->gc_block, aggressive); } - n -= nToCopy; - offset += nToCopy; - buffer += nToCopy; - nDone += nToCopy; -+ if (dev->gcBlock > 0) { -+ dev->allGCs++; -+ if (!aggressive) -+ dev->passiveGCs++; - +- - } -+ T(YAFFS_TRACE_GC, -+ (TSTR -+ ("yaffs: GC erasedBlocks %d aggressive %d" TENDSTR), -+ dev->nErasedBlocks, aggressive)); - -- return nDone; -+ gcOk = yaffs_GarbageCollectBlock(dev, dev->gcBlock, aggressive); -+ } -+ -+ if (dev->nErasedBlocks < (dev->param.nReservedBlocks) && dev->gcBlock > 0) { ++ if (dev->n_erased_blocks < (dev->param.n_reserved_blocks) && dev->gc_block > 0) { + T(YAFFS_TRACE_GC, + (TSTR + ("yaffs: GC !!!no reclaim!!! erasedBlocks %d after try %d block %d" -+ TENDSTR), dev->nErasedBlocks, maxTries, dev->gcBlock)); ++ TENDSTR), dev->n_erased_blocks, maxTries, dev->gc_block)); + } -+ } while ((dev->nErasedBlocks < dev->param.nReservedBlocks) && -+ (dev->gcBlock > 0) && ++ } while ((dev->n_erased_blocks < dev->param.n_reserved_blocks) && ++ (dev->gc_block > 0) && + (maxTries < 2)); -+ + +- return nDone; + return aggressive ? gcOk : YAFFS_OK; } -int yaffs_WriteDataToFile(yaffs_Object *in, const __u8 *buffer, loff_t offset, - int nBytes, int writeThrough) +/* -+ * yaffs_BackgroundGarbageCollect() ++ * yaffs_bg_gc() + * Garbage collects. Intended to be called from a background thread. + * Returns non-zero if at least half the free chunks are erased. + */ -+int yaffs_BackgroundGarbageCollect(yaffs_Device *dev, unsigned urgency) ++int yaffs_bg_gc(yaffs_dev_t *dev, unsigned urgency) { -+ int erasedChunks = dev->nErasedBlocks * dev->param.nChunksPerBlock; ++ int erasedChunks = dev->n_erased_blocks * dev->param.chunks_per_block; - int chunk; - __u32 start; @@ -10263,8 +10856,8 @@ + T(YAFFS_TRACE_BACKGROUND, (TSTR("Background gc %u" TENDSTR),urgency)); - yaffs_Device *dev; -+ yaffs_CheckGarbageCollection(dev, 1); -+ return erasedChunks > dev->nFreeChunks/2; ++ yaffs_check_gc(dev, 1); ++ return erasedChunks > dev->n_free_chunks/2; +} - dev = in->myDev; @@ -10274,11 +10867,11 @@ - /* chunk = offset / dev->nDataBytesPerChunk + 1; */ - /* start = offset % dev->nDataBytesPerChunk; */ - yaffs_AddrToChunk(dev, offset, &chunk, &start); -+static int yaffs_TagsMatch(const yaffs_ExtendedTags *tags, int objectId, ++static int yaffs_tags_match(const yaffs_ext_tags *tags, int obj_id, + int chunkInObject) +{ -+ return (tags->chunkId == chunkInObject && -+ tags->objectId == objectId && !tags->chunkDeleted) ? 1 : 0; ++ return (tags->chunk_id == chunkInObject && ++ tags->obj_id == obj_id && !tags->is_deleted) ? 1 : 0; - if (chunk * dev->nDataBytesPerChunk + start != offset || - start >= dev->nDataBytesPerChunk) { @@ -10302,17 +10895,17 @@ - * If we're overwriting and not writing to then end of file then - * we need to write back as much as was there before. - */ -+static int yaffs_FindChunkInFile(yaffs_Object *in, int chunkInInode, -+ yaffs_ExtendedTags *tags) ++static int yaffs_find_chunk_in_file(yaffs_obj_t *in, int inode_chunk, ++ yaffs_ext_tags *tags) +{ + /*Get the Tnode, then get the level 0 offset chunk offset */ -+ yaffs_Tnode *tn; ++ yaffs_tnode_t *tn; + int theChunk = -1; -+ yaffs_ExtendedTags localTags; ++ yaffs_ext_tags localTags; + int retVal = -1; - chunkStart = ((chunk - 1) * dev->nDataBytesPerChunk); -+ yaffs_Device *dev = in->myDev; ++ yaffs_dev_t *dev = in->my_dev; - if (chunkStart > in->variant.fileVariant.fileSize) - nBytesRead = 0; /* Past end of file */ @@ -10325,19 +10918,19 @@ - if (nBytesRead > dev->nDataBytesPerChunk) - nBytesRead = dev->nDataBytesPerChunk; -+ tn = yaffs_FindLevel0Tnode(dev, &in->variant.fileVariant, chunkInInode); ++ tn = yaffs_find_tnode_0(dev, &in->variant.file_variant, inode_chunk); - nToWriteBack = - (nBytesRead > - (start + n)) ? nBytesRead : (start + n); + if (tn) { -+ theChunk = yaffs_GetChunkGroupBase(dev, tn, chunkInInode); ++ theChunk = yaffs_get_group_base(dev, tn, inode_chunk); - if (nToWriteBack < 0 || nToWriteBack > dev->nDataBytesPerChunk) - YBUG(); + retVal = -+ yaffs_FindChunkInGroup(dev, theChunk, tags, in->objectId, -+ chunkInInode); ++ yaffs_find_chunk_in_group(dev, theChunk, tags, in->obj_id, ++ inode_chunk); + } + return retVal; +} @@ -10346,13 +10939,13 @@ - nToCopy = dev->nDataBytesPerChunk - start; - nToWriteBack = dev->nDataBytesPerChunk; - } -+static int yaffs_FindAndDeleteChunkInFile(yaffs_Object *in, int chunkInInode, -+ yaffs_ExtendedTags *tags) ++static int yaffs_find_del_file_chunk(yaffs_obj_t *in, int inode_chunk, ++ yaffs_ext_tags *tags) +{ + /* Get the Tnode, then get the level 0 offset chunk offset */ -+ yaffs_Tnode *tn; ++ yaffs_tnode_t *tn; + int theChunk = -1; -+ yaffs_ExtendedTags localTags; ++ yaffs_ext_tags localTags; - if (nToCopy != dev->nDataBytesPerChunk || dev->inbandTags) { - /* An incomplete start or end chunk (or maybe both start and end chunk), @@ -10362,7 +10955,7 @@ - yaffs_ChunkCache *cache; - /* If we can't find the data in the cache, then load the cache */ - cache = yaffs_FindChunkCache(in, chunk); -+ yaffs_Device *dev = in->myDev; ++ yaffs_dev_t *dev = in->my_dev; + int retVal = -1; - if (!cache @@ -10392,23 +10985,23 @@ - if (cache) { - yaffs_UseChunkCache(dev, cache, 1); - cache->locked = 1; -+ tn = yaffs_FindLevel0Tnode(dev, &in->variant.fileVariant, chunkInInode); ++ tn = yaffs_find_tnode_0(dev, &in->variant.file_variant, inode_chunk); + if (tn) { - memcpy(&cache->data[start], buffer, - nToCopy); -+ theChunk = yaffs_GetChunkGroupBase(dev, tn, chunkInInode); ++ theChunk = yaffs_get_group_base(dev, tn, inode_chunk); + retVal = -+ yaffs_FindChunkInGroup(dev, theChunk, tags, in->objectId, -+ chunkInInode); ++ yaffs_find_chunk_in_group(dev, theChunk, tags, in->obj_id, ++ inode_chunk); - cache->locked = 0; - cache->nBytes = nToWriteBack; + /* Delete the entry in the filestructure (if found) */ + if (retVal != -1) -+ yaffs_LoadLevel0Tnode(dev, tn, chunkInInode, 0); ++ yaffs_load_tnode_0(dev, tn, inode_chunk, 0); + } - if (writeThrough) { @@ -10433,28 +11026,30 @@ - __u8 *localBuffer = - yaffs_GetTempBuffer(dev, __LINE__); -+int yaffs_PutChunkIntoFile(yaffs_Object *in, int chunkInInode, -+ int chunkInNAND, int inScan) ++int yaffs_put_chunk_in_file(yaffs_obj_t *in, int inode_chunk, ++ int nand_chunk, int in_scan) +{ -+ /* NB inScan is zero unless scanning. -+ * For forward scanning, inScan is > 0; -+ * for backward scanning inScan is < 0 ++ /* NB in_scan is zero unless scanning. ++ * For forward scanning, in_scan is > 0; ++ * for backward scanning in_scan is < 0 + * -+ * chunkInNAND = 0 is a dummy insert to make sure the tnodes are there. ++ * nand_chunk = 0 is a dummy insert to make sure the tnodes are there. + */ -+ -+ yaffs_Tnode *tn; -+ yaffs_Device *dev = in->myDev; + +- yaffs_ReadChunkDataFromObject(in, chunk, +- localBuffer); ++ yaffs_tnode_t *tn; ++ yaffs_dev_t *dev = in->my_dev; + int existingChunk; -+ yaffs_ExtendedTags existingTags; -+ yaffs_ExtendedTags newTags; ++ yaffs_ext_tags existingTags; ++ yaffs_ext_tags newTags; + unsigned existingSerial, newSerial; -+ -+ if (in->variantType != YAFFS_OBJECT_TYPE_FILE) { + ++ if (in->variant_type != YAFFS_OBJECT_TYPE_FILE) { + /* Just ignore an attempt at putting a chunk into a non-file during scanning + * If it is not during Scanning then something went wrong! + */ -+ if (!inScan) { ++ if (!in_scan) { + T(YAFFS_TRACE_ERROR, + (TSTR + ("yaffs tragedy:attempt to put data chunk into a non-file" @@ -10462,27 +11057,32 @@ + YBUG(); + } -- yaffs_ReadChunkDataFromObject(in, chunk, -- localBuffer); -+ yaffs_DeleteChunk(dev, chunkInNAND, 1, __LINE__); ++ yaffs_chunk_del(dev, nand_chunk, 1, __LINE__); + return YAFFS_OK; + } -+ tn = yaffs_AddOrFindLevel0Tnode(dev, -+ &in->variant.fileVariant, -+ chunkInInode, +- memcpy(&localBuffer[start], buffer, nToCopy); ++ tn = yaffs_add_find_tnode_0(dev, ++ &in->variant.file_variant, ++ inode_chunk, + NULL); + if (!tn) + return YAFFS_FAIL; + -+ if(!chunkInNAND) ++ if(!nand_chunk) + /* Dummy insert, bail now */ + return YAFFS_OK; -+ existingChunk = yaffs_GetChunkGroupBase(dev, tn, chunkInInode); +- chunkWritten = +- yaffs_WriteChunkDataToObject(in, chunk, +- localBuffer, +- nToWriteBack, +- 0); ++ existingChunk = yaffs_get_group_base(dev, tn, inode_chunk); -- memcpy(&localBuffer[start], buffer, nToCopy); -+ if (inScan != 0) { +- yaffs_ReleaseTempBuffer(dev, localBuffer, +- __LINE__); ++ if (in_scan != 0) { + /* If we're scanning then we need to test for duplicates + * NB This does not need to be efficient since it should only ever + * happen when the power fails during a write, then only one @@ -10491,14 +11091,9 @@ + * Correction for YAFFS2: This could happen quite a lot and we need to think about efficiency! TODO + * Update: For backward scanning we don't need to re-read tags so this is quite cheap. + */ - -- chunkWritten = -- yaffs_WriteChunkDataToObject(in, chunk, -- localBuffer, -- nToWriteBack, -- 0); ++ + if (existingChunk > 0) { -+ /* NB Right now existing chunk will not be real chunkId if the chunk group size > 1 ++ /* NB Right now existing chunk will not be real chunk_id if the chunk group size > 1 + * thus we have to do a FindChunkInFile to get the real chunk id. + * + * We have a duplicate now we need to decide which one to use: @@ -10507,18 +11102,16 @@ + * Forward scanning YAFFS2: The new one is what we use, dump the old one. + * YAFFS1: Get both sets of tags and compare serial numbers. + */ - -- yaffs_ReleaseTempBuffer(dev, localBuffer, -- __LINE__); -+ if (inScan > 0) { ++ ++ if (in_scan > 0) { + /* Only do this for forward scanning */ -+ yaffs_ReadChunkWithTagsFromNAND(dev, -+ chunkInNAND, ++ yaffs_rd_chunk_tags_nand(dev, ++ nand_chunk, + NULL, &newTags); + /* Do a proper find */ + existingChunk = -+ yaffs_FindChunkInFile(in, chunkInInode, ++ yaffs_find_chunk_in_file(in, inode_chunk, + &existingTags); } @@ -10545,9 +11138,9 @@ - /* Since we've overwritten the cached data, we better invalidate it. */ - yaffs_InvalidateChunkCache(in, chunk); - } -+ if (inScan > 0) { -+ newSerial = newTags.serialNumber; -+ existingSerial = existingTags.serialNumber; ++ if (in_scan > 0) { ++ newSerial = newTags.serial_number; ++ existingSerial = existingTags.serial_number; + } - if (chunkWritten >= 0) { @@ -10555,21 +11148,21 @@ - offset += nToCopy; - buffer += nToCopy; - nDone += nToCopy; -+ if ((inScan > 0) && ++ if ((in_scan > 0) && + (existingChunk <= 0 || + ((existingSerial + 1) & 3) == newSerial)) { + /* Forward scanning. + * Use new + * Delete the old one and drop through to update the tnode + */ -+ yaffs_DeleteChunk(dev, existingChunk, 1, ++ yaffs_chunk_del(dev, existingChunk, 1, + __LINE__); + } else { + /* Backward scanning or we want to use the existing one + * Use existing. + * Delete the new one and return early so that the tnode isn't changed + */ -+ yaffs_DeleteChunk(dev, chunkInNAND, 1, ++ yaffs_chunk_del(dev, nand_chunk, 1, + __LINE__); + return YAFFS_OK; + } @@ -10582,66 +11175,98 @@ - if ((startOfWrite + nDone) > in->variant.fileVariant.fileSize) - in->variant.fileVariant.fileSize = (startOfWrite + nDone); + if (existingChunk == 0) -+ in->nDataChunks++; ++ in->n_data_chunks++; - in->dirty = 1; -+ yaffs_LoadLevel0Tnode(dev, tn, chunkInInode, chunkInNAND); ++ yaffs_load_tnode_0(dev, tn, inode_chunk, nand_chunk); - return nDone; + return YAFFS_OK; } -+static int yaffs_ReadChunkDataFromObject(yaffs_Object *in, int chunkInInode, ++static int yaffs_rd_data_obj(yaffs_obj_t *in, int inode_chunk, + __u8 *buffer) +{ -+ int chunkInNAND = yaffs_FindChunkInFile(in, chunkInInode, NULL); ++ int nand_chunk = yaffs_find_chunk_in_file(in, inode_chunk, NULL); -/* ---------------------- File resizing stuff ------------------ */ -+ if (chunkInNAND >= 0) -+ return yaffs_ReadChunkWithTagsFromNAND(in->myDev, chunkInNAND, ++ if (nand_chunk >= 0) ++ return yaffs_rd_chunk_tags_nand(in->my_dev, nand_chunk, + buffer, NULL); + else { + T(YAFFS_TRACE_NANDACCESS, + (TSTR("Chunk %d not found zero instead" TENDSTR), -+ chunkInNAND)); ++ nand_chunk)); + /* get sane (zero) data if you read a hole */ -+ memset(buffer, 0, in->myDev->nDataBytesPerChunk); ++ memset(buffer, 0, in->my_dev->data_bytes_per_chunk); + return 0; + } ++ ++} -static void yaffs_PruneResizedChunks(yaffs_Object *in, int newSize) --{ -+} ++void yaffs_chunk_del(yaffs_dev_t *dev, int chunk_id, int mark_flash, int lyn) + { ++ int block; ++ int page; ++ yaffs_ext_tags tags; ++ yaffs_block_info_t *bi; - yaffs_Device *dev = in->myDev; - int oldFileSize = in->variant.fileVariant.fileSize; -+void yaffs_DeleteChunk(yaffs_Device *dev, int chunkId, int markNAND, int lyn) -+{ -+ int block; -+ int page; -+ yaffs_ExtendedTags tags; -+ yaffs_BlockInfo *bi; ++ if (chunk_id <= 0) ++ return; - int lastDel = 1 + (oldFileSize - 1) / dev->nDataBytesPerChunk; -+ if (chunkId <= 0) -+ return; ++ dev->n_deletions++; ++ block = chunk_id / dev->param.chunks_per_block; ++ page = chunk_id % dev->param.chunks_per_block; - int startDel = 1 + (newSize + dev->nDataBytesPerChunk - 1) / - dev->nDataBytesPerChunk; - int i; - int chunkId; -+ dev->nDeletions++; -+ block = chunkId / dev->param.nChunksPerBlock; -+ page = chunkId % dev->param.nChunksPerBlock; - /* Delete backwards so that we don't end up with holes if - * power is lost part-way through the operation. -- */ ++ if (!yaffs_check_chunk_bit(dev, block, page)) ++ T(YAFFS_TRACE_VERIFY, ++ (TSTR("Deleting invalid chunk %d"TENDSTR), ++ chunk_id)); ++ ++ bi = yaffs_get_block_info(dev, block); ++ ++ yaffs2_update_oldest_dirty_seq(dev, block, bi); ++ ++ T(YAFFS_TRACE_DELETION, ++ (TSTR("line %d delete of chunk %d" TENDSTR), lyn, chunk_id)); ++ ++ if (!dev->param.is_yaffs2 && mark_flash && ++ bi->block_state != YAFFS_BLOCK_STATE_COLLECTING) { ++ ++ yaffs_init_tags(&tags); ++ ++ tags.is_deleted = 1; ++ ++ yaffs_wr_chunk_tags_nand(dev, chunk_id, NULL, &tags); ++ yaffs_handle_chunk_update(dev, chunk_id, &tags); ++ } else { ++ dev->n_unmarked_deletions++; ++ } ++ ++ /* Pull out of the management area. ++ * If the whole block became dirty, this will kick off an erasure. + */ - for (i = lastDel; i >= startDel; i--) { - /* NB this could be optimised somewhat, - * eg. could retrieve the tags and write them without - * using yaffs_DeleteChunk - */ ++ if (bi->block_state == YAFFS_BLOCK_STATE_ALLOCATING || ++ bi->block_state == YAFFS_BLOCK_STATE_FULL || ++ bi->block_state == YAFFS_BLOCK_STATE_NEEDS_SCANNING || ++ bi->block_state == YAFFS_BLOCK_STATE_COLLECTING) { ++ dev->n_free_chunks++; - chunkId = yaffs_FindAndDeleteChunkInFile(in, i, NULL); - if (chunkId > 0) { @@ -10657,128 +11282,136 @@ - in->nDataChunks--; - yaffs_DeleteChunk(dev, chunkId, 1, __LINE__); - } -- } -- } -+ if (!yaffs_CheckChunkBit(dev, block, page)) -+ T(YAFFS_TRACE_VERIFY, -+ (TSTR("Deleting invalid chunk %d"TENDSTR), -+ chunkId)); ++ yaffs_clear_chunk_bit(dev, block, page); ++ ++ bi->pages_in_use--; ++ ++ if (bi->pages_in_use == 0 && ++ !bi->has_shrink_hdr && ++ bi->block_state != YAFFS_BLOCK_STATE_ALLOCATING && ++ bi->block_state != YAFFS_BLOCK_STATE_NEEDS_SCANNING) { ++ yaffs_block_became_dirty(dev, block); + } ++ + } --} -+ bi = yaffs_GetBlockInfo(dev, block); -+ -+ yaffs2_UpdateOldestDirtySequence(dev, block, bi); + } -int yaffs_ResizeFile(yaffs_Object *in, loff_t newSize) --{ -+ T(YAFFS_TRACE_DELETION, -+ (TSTR("line %d delete of chunk %d" TENDSTR), lyn, chunkId)); ++static int yaffs_wr_data_obj(yaffs_obj_t *in, int inode_chunk, ++ const __u8 *buffer, int n_bytes, ++ int useReserve) + { ++ /* Find old chunk Need to do this to get serial number ++ * Write new one and patch into tree. ++ * Invalidate old tags. ++ */ - int oldFileSize = in->variant.fileVariant.fileSize; - __u32 newSizeOfPartialChunk; - int newFullChunks; -+ if (!dev->param.isYaffs2 && markNAND && -+ bi->blockState != YAFFS_BLOCK_STATE_COLLECTING) { ++ int prevChunkId; ++ yaffs_ext_tags prevTags; - yaffs_Device *dev = in->myDev; -+ yaffs_InitialiseTags(&tags); ++ int newChunkId; ++ yaffs_ext_tags newTags; - yaffs_AddrToChunk(dev, newSize, &newFullChunks, &newSizeOfPartialChunk); -+ tags.chunkDeleted = 1; ++ yaffs_dev_t *dev = in->my_dev; - yaffs_FlushFilesChunkCache(in); - yaffs_InvalidateWholeChunkCache(in); -+ yaffs_WriteChunkWithTagsToNAND(dev, chunkId, NULL, &tags); -+ yaffs_HandleUpdateChunk(dev, chunkId, &tags); -+ } else { -+ dev->nUnmarkedDeletions++; -+ } ++ yaffs_check_gc(dev,0); - yaffs_CheckGarbageCollection(dev); -+ /* Pull out of the management area. -+ * If the whole block became dirty, this will kick off an erasure. ++ /* Get the previous chunk at this location in the file if it exists. ++ * If it does not exist then put a zero into the tree. This creates ++ * the tnode now, rather than later when it is harder to clean up. + */ -+ if (bi->blockState == YAFFS_BLOCK_STATE_ALLOCATING || -+ bi->blockState == YAFFS_BLOCK_STATE_FULL || -+ bi->blockState == YAFFS_BLOCK_STATE_NEEDS_SCANNING || -+ bi->blockState == YAFFS_BLOCK_STATE_COLLECTING) { -+ dev->nFreeChunks++; ++ prevChunkId = yaffs_find_chunk_in_file(in, inode_chunk, &prevTags); ++ if(prevChunkId < 1 && ++ !yaffs_put_chunk_in_file(in, inode_chunk, 0, 0)) ++ return 0; - if (in->variantType != YAFFS_OBJECT_TYPE_FILE) - return YAFFS_FAIL; -+ yaffs_ClearChunkBit(dev, block, page); ++ /* Set up new tags */ ++ yaffs_init_tags(&newTags); - if (newSize == oldFileSize) - return YAFFS_OK; -+ bi->pagesInUse--; ++ newTags.chunk_id = inode_chunk; ++ newTags.obj_id = in->obj_id; ++ newTags.serial_number = ++ (prevChunkId > 0) ? prevTags.serial_number + 1 : 1; ++ newTags.n_bytes = n_bytes; - if (newSize < oldFileSize) { -+ if (bi->pagesInUse == 0 && -+ !bi->hasShrinkHeader && -+ bi->blockState != YAFFS_BLOCK_STATE_ALLOCATING && -+ bi->blockState != YAFFS_BLOCK_STATE_NEEDS_SCANNING) { -+ yaffs_BlockBecameDirty(dev, block); -+ } ++ if (n_bytes < 1 || n_bytes > dev->param.total_bytes_per_chunk) { ++ T(YAFFS_TRACE_ERROR, ++ (TSTR("Writing %d bytes to chunk!!!!!!!!!" TENDSTR), n_bytes)); ++ YBUG(); ++ } ++ ++ ++ newChunkId = ++ yaffs_write_new_chunk(dev, buffer, &newTags, ++ useReserve); - yaffs_PruneResizedChunks(in, newSize); -+ } ++ if (newChunkId > 0) { ++ yaffs_put_chunk_in_file(in, inode_chunk, newChunkId, 0); - if (newSizeOfPartialChunk != 0) { - int lastChunk = 1 + newFullChunks; -+} ++ if (prevChunkId > 0) ++ yaffs_chunk_del(dev, prevChunkId, 1, __LINE__); - __u8 *localBuffer = yaffs_GetTempBuffer(dev, __LINE__); -+static int yaffs_WriteChunkDataToObject(yaffs_Object *in, int chunkInInode, -+ const __u8 *buffer, int nBytes, -+ int useReserve) -+{ -+ /* Find old chunk Need to do this to get serial number -+ * Write new one and patch into tree. -+ * Invalidate old tags. -+ */ ++ yaffs_verify_file_sane(in); ++ } ++ return newChunkId; - /* Got to read and rewrite the last chunk with its new size and zero pad */ - yaffs_ReadChunkDataFromObject(in, lastChunk, - localBuffer); -+ int prevChunkId; -+ yaffs_ExtendedTags prevTags; ++} - memset(localBuffer + newSizeOfPartialChunk, 0, - dev->nDataBytesPerChunk - newSizeOfPartialChunk); -+ int newChunkId; -+ yaffs_ExtendedTags newTags; ++/* UpdateObjectHeader updates the header on NAND for an object. ++ * If name is not NULL, then that new name is used. ++ */ ++int yaffs_update_oh(yaffs_obj_t *in, const YCHAR *name, int force, ++ int is_shrink, int shadows, yaffs_xattr_mod *xmod) ++{ - yaffs_WriteChunkDataToObject(in, lastChunk, localBuffer, - newSizeOfPartialChunk, 1); -+ yaffs_Device *dev = in->myDev; ++ yaffs_block_info_t *bi; - yaffs_ReleaseTempBuffer(dev, localBuffer, __LINE__); - } -+ yaffs_CheckGarbageCollection(dev,0); ++ yaffs_dev_t *dev = in->my_dev; - in->variant.fileVariant.fileSize = newSize; -+ /* Get the previous chunk at this location in the file if it exists. -+ * If it does not exist then put a zero into the tree. This creates -+ * the tnode now, rather than later when it is harder to clean up. -+ */ -+ prevChunkId = yaffs_FindChunkInFile(in, chunkInInode, &prevTags); -+ if(prevChunkId < 1 && -+ !yaffs_PutChunkIntoFile(in, chunkInInode, 0, 0)) -+ return 0; ++ int prevChunkId; ++ int retVal = 0; ++ int result = 0; - yaffs_PruneFileStructure(dev, &in->variant.fileVariant); - } else { - /* newsSize > oldFileSize */ - in->variant.fileVariant.fileSize = newSize; - } -+ /* Set up new tags */ -+ yaffs_InitialiseTags(&newTags); ++ int newChunkId; ++ yaffs_ext_tags newTags; ++ yaffs_ext_tags oldTags; ++ const YCHAR *alias = NULL; -+ newTags.chunkId = chunkInInode; -+ newTags.objectId = in->objectId; -+ newTags.serialNumber = -+ (prevChunkId > 0) ? prevTags.serialNumber + 1 : 1; -+ newTags.byteCount = nBytes; ++ __u8 *buffer = NULL; ++ YCHAR old_name[YAFFS_MAX_NAME_LENGTH + 1]; - /* Write a new object header. - * show we've shrunk the file, if need be @@ -10789,27 +11422,15 @@ - in->parent->objectId != YAFFS_OBJECTID_DELETED) - yaffs_UpdateObjectHeader(in, NULL, 0, - (newSize < oldFileSize) ? 1 : 0, 0); -+ if (nBytes < 1 || nBytes > dev->param.totalBytesPerChunk) { -+ T(YAFFS_TRACE_ERROR, -+ (TSTR("Writing %d bytes to chunk!!!!!!!!!" TENDSTR), nBytes)); -+ YBUG(); -+ } -+ -+ -+ newChunkId = -+ yaffs_WriteNewChunkWithTagsToNAND(dev, buffer, &newTags, -+ useReserve); ++ yaffs_obj_header *oh = NULL; - return YAFFS_OK; -} -+ if (newChunkId > 0) { -+ yaffs_PutChunkIntoFile(in, chunkInInode, newChunkId, 0); ++ yaffs_strcpy(old_name, _Y("silly old name")); -loff_t yaffs_GetFileSize(yaffs_Object *obj) -{ - obj = yaffs_GetEquivalentObject(obj); -+ if (prevChunkId > 0) -+ yaffs_DeleteChunk(dev, prevChunkId, 1, __LINE__); - switch (obj->variantType) { - case YAFFS_OBJECT_TYPE_FILE: @@ -10818,20 +11439,34 @@ - return yaffs_strlen(obj->variant.symLinkVariant.alias); - default: - return 0; -+ yaffs_VerifyFileSanity(in); - } -+ return newChunkId; -+ - } +- } +-} ++ if (!in->fake || ++ in == dev->root_dir || /* The root_dir should also be saved */ ++ force || xmod) { -+/* UpdateObjectHeader updates the header on NAND for an object. -+ * If name is not NULL, then that new name is used. -+ */ -+int yaffs_UpdateObjectHeader(yaffs_Object *in, const YCHAR *name, int force, -+ int isShrink, int shadows, yaffs_XAttrMod *xmod) -+{ ++ yaffs_check_gc(dev,0); ++ yaffs_check_obj_details_loaded(in); -+ yaffs_BlockInfo *bi; ++ buffer = yaffs_get_temp_buffer(in->my_dev, __LINE__); ++ oh = (yaffs_obj_header *) buffer; ++ ++ prevChunkId = in->hdr_chunk; ++ ++ if (prevChunkId > 0) { ++ result = yaffs_rd_chunk_tags_nand(dev, prevChunkId, ++ buffer, &oldTags); ++ ++ yaffs_verify_oh(in, oh, &oldTags, 0); ++ ++ memcpy(old_name, oh->name, sizeof(oh->name)); ++ memset(buffer, 0xFF, sizeof(yaffs_obj_header)); ++ } else ++ memset(buffer, 0xFF, dev->data_bytes_per_chunk); ++ ++ oh->type = in->variant_type; ++ oh->yst_mode = in->yst_mode; ++ oh->shadows_obj = oh->inband_shadowed_obj_id = shadows; -int yaffs_FlushFile(yaffs_Object *in, int updateTime) -{ @@ -10839,69 +11474,129 @@ - if (in->dirty) { - yaffs_FlushFilesChunkCache(in); - if (updateTime) { --#ifdef CONFIG_YAFFS_WINCE + #ifdef CONFIG_YAFFS_WINCE - yfsd_WinFileTimeNow(in->win_mtime); --#else -+ yaffs_Device *dev = in->myDev; ++ oh->win_atime[0] = in->win_atime[0]; ++ oh->win_ctime[0] = in->win_ctime[0]; ++ oh->win_mtime[0] = in->win_mtime[0]; ++ oh->win_atime[1] = in->win_atime[1]; ++ oh->win_ctime[1] = in->win_ctime[1]; ++ oh->win_mtime[1] = in->win_mtime[1]; + #else ++ oh->yst_uid = in->yst_uid; ++ oh->yst_gid = in->yst_gid; ++ oh->yst_atime = in->yst_atime; ++ oh->yst_mtime = in->yst_mtime; ++ oh->yst_ctime = in->yst_ctime; ++ oh->yst_rdev = in->yst_rdev; ++#endif ++ if (in->parent) ++ oh->parent_obj_id = in->parent->obj_id; ++ else ++ oh->parent_obj_id = 0; ++ ++ if (name && *name) { ++ memset(oh->name, 0, sizeof(oh->name)); ++ yaffs_load_oh_from_name(dev,oh->name,name); ++ } else if (prevChunkId > 0) ++ memcpy(oh->name, old_name, sizeof(oh->name)); ++ else ++ memset(oh->name, 0, sizeof(oh->name)); - in->yst_mtime = Y_CURRENT_TIME; -+ int prevChunkId; -+ int retVal = 0; -+ int result = 0; ++ oh->is_shrink = is_shrink; -#endif -- } -+ int newChunkId; -+ yaffs_ExtendedTags newTags; -+ yaffs_ExtendedTags oldTags; -+ const YCHAR *alias = NULL; ++ switch (in->variant_type) { ++ case YAFFS_OBJECT_TYPE_UNKNOWN: ++ /* Should not happen */ ++ break; ++ case YAFFS_OBJECT_TYPE_FILE: ++ oh->file_size = ++ (oh->parent_obj_id == YAFFS_OBJECTID_DELETED ++ || oh->parent_obj_id == ++ YAFFS_OBJECTID_UNLINKED) ? 0 : in->variant. ++ file_variant.file_size; ++ break; ++ case YAFFS_OBJECT_TYPE_HARDLINK: ++ oh->equiv_id = ++ in->variant.hardlink_variant.equiv_id; ++ break; ++ case YAFFS_OBJECT_TYPE_SPECIAL: ++ /* Do nothing */ ++ break; ++ case YAFFS_OBJECT_TYPE_DIRECTORY: ++ /* Do nothing */ ++ break; ++ case YAFFS_OBJECT_TYPE_SYMLINK: ++ alias = in->variant.symlink_variant.alias; ++ if(!alias) ++ alias = _Y("no alias"); ++ yaffs_strncpy(oh->alias, ++ alias, ++ YAFFS_MAX_ALIAS_LENGTH); ++ oh->alias[YAFFS_MAX_ALIAS_LENGTH] = 0; ++ break; + } - retVal = (yaffs_UpdateObjectHeader(in, NULL, 0, 0, 0) >= - 0) ? YAFFS_OK : YAFFS_FAIL; - } else { - retVal = YAFFS_OK; - } -+ __u8 *buffer = NULL; -+ YCHAR oldName[YAFFS_MAX_NAME_LENGTH + 1]; ++ /* process any xattrib modifications */ ++ if(xmod) ++ yaffs_apply_xattrib_mod(in, (char *)buffer, xmod); - return retVal; -+ yaffs_ObjectHeader *oh = NULL; -} -+ yaffs_strcpy(oldName, _Y("silly old name")); ++ /* Tags */ ++ yaffs_init_tags(&newTags); ++ in->serial++; ++ newTags.chunk_id = 0; ++ newTags.obj_id = in->obj_id; ++ newTags.serial_number = in->serial; -static int yaffs_DoGenericObjectDeletion(yaffs_Object *in) -{ ++ /* Add extra info for file header */ - /* First off, invalidate the file's data in the cache, without flushing. */ - yaffs_InvalidateWholeChunkCache(in); -+ if (!in->fake || -+ in == dev->rootDir || /* The rootDir should also be saved */ -+ force || xmod) { ++ newTags.extra_available = 1; ++ newTags.extra_parent_id = oh->parent_obj_id; ++ newTags.extra_length = oh->file_size; ++ newTags.extra_is_shrink = oh->is_shrink; ++ newTags.extra_equiv_id = oh->equiv_id; ++ newTags.extra_shadows = (oh->shadows_obj > 0) ? 1 : 0; ++ newTags.extra_obj_type = in->variant_type; - if (in->myDev->isYaffs2 && (in->parent != in->myDev->deletedDir)) { - /* Move to the unlinked directory so we have a record that it was deleted. */ - yaffs_ChangeObjectName(in, in->myDev->deletedDir, _Y("deleted"), 0, 0); -+ yaffs_CheckGarbageCollection(dev,0); -+ yaffs_CheckObjectDetailsLoaded(in); ++ yaffs_verify_oh(in, oh, &newTags, 1); - } -+ buffer = yaffs_GetTempBuffer(in->myDev, __LINE__); -+ oh = (yaffs_ObjectHeader *) buffer; ++ /* Create new chunk in NAND */ ++ newChunkId = ++ yaffs_write_new_chunk(dev, buffer, &newTags, ++ (prevChunkId > 0) ? 1 : 0); - yaffs_RemoveObjectFromDirectory(in); - yaffs_DeleteChunk(in->myDev, in->hdrChunk, 1, __LINE__); - in->hdrChunk = 0; -+ prevChunkId = in->hdrChunk; ++ if (newChunkId >= 0) { - yaffs_FreeObject(in); - return YAFFS_OK; -+ if (prevChunkId > 0) { -+ result = yaffs_ReadChunkWithTagsFromNAND(dev, prevChunkId, -+ buffer, &oldTags); ++ in->hdr_chunk = newChunkId; -} -+ yaffs_VerifyObjectHeader(in, oh, &oldTags, 0); ++ if (prevChunkId > 0) { ++ yaffs_chunk_del(dev, prevChunkId, 1, ++ __LINE__); ++ } -/* yaffs_DeleteFile deletes the whole file data - * and the inode associated with the file. @@ -10909,41 +11604,28 @@ - */ -static int yaffs_UnlinkFileIfNeeded(yaffs_Object *in) -{ -+ memcpy(oldName, oh->name, sizeof(oh->name)); -+ memset(buffer, 0xFF, sizeof(yaffs_ObjectHeader)); -+ } else -+ memset(buffer, 0xFF, dev->nDataBytesPerChunk); ++ if (!yaffs_obj_cache_dirty(in)) ++ in->dirty = 0; - int retVal; - int immediateDeletion = 0; -+ oh->type = in->variantType; -+ oh->yst_mode = in->yst_mode; -+ oh->shadowsObject = oh->inbandShadowsObject = shadows; ++ /* If this was a shrink, then mark the block that the chunk lives on */ ++ if (is_shrink) { ++ bi = yaffs_get_block_info(in->my_dev, ++ newChunkId / in->my_dev->param.chunks_per_block); ++ bi->has_shrink_hdr = 1; ++ } -#ifdef __KERNEL__ - if (!in->myInode) - immediateDeletion = 1; -+#ifdef CONFIG_YAFFS_WINCE -+ oh->win_atime[0] = in->win_atime[0]; -+ oh->win_ctime[0] = in->win_ctime[0]; -+ oh->win_mtime[0] = in->win_mtime[0]; -+ oh->win_atime[1] = in->win_atime[1]; -+ oh->win_ctime[1] = in->win_ctime[1]; -+ oh->win_mtime[1] = in->win_mtime[1]; - #else +-#else - if (in->inUse <= 0) - immediateDeletion = 1; -+ oh->yst_uid = in->yst_uid; -+ oh->yst_gid = in->yst_gid; -+ oh->yst_atime = in->yst_atime; -+ oh->yst_mtime = in->yst_mtime; -+ oh->yst_ctime = in->yst_ctime; -+ oh->yst_rdev = in->yst_rdev; - #endif -+ if (in->parent) -+ oh->parentObjectId = in->parent->objectId; -+ else -+ oh->parentObjectId = 0; +-#endif ++ } ++ ++ retVal = newChunkId; - if (immediateDeletion) { - retVal = @@ -10961,74 +11643,28 @@ - retVal = - yaffs_ChangeObjectName(in, in->myDev->unlinkedDir, - _Y("unlinked"), 0, 0); -- } -+ if (name && *name) { -+ memset(oh->name, 0, sizeof(oh->name)); -+ yaffs_LoadObjectHeaderFromName(dev,oh->name,name); -+ } else if (prevChunkId > 0) -+ memcpy(oh->name, oldName, sizeof(oh->name)); -+ else -+ memset(oh->name, 0, sizeof(oh->name)); + } -+ oh->isShrink = isShrink; ++ if (buffer) ++ yaffs_release_temp_buffer(dev, buffer, __LINE__); -- return retVal; --} -+ switch (in->variantType) { -+ case YAFFS_OBJECT_TYPE_UNKNOWN: -+ /* Should not happen */ -+ break; -+ case YAFFS_OBJECT_TYPE_FILE: -+ oh->fileSize = -+ (oh->parentObjectId == YAFFS_OBJECTID_DELETED -+ || oh->parentObjectId == -+ YAFFS_OBJECTID_UNLINKED) ? 0 : in->variant. -+ fileVariant.fileSize; -+ break; -+ case YAFFS_OBJECT_TYPE_HARDLINK: -+ oh->equivalentObjectId = -+ in->variant.hardLinkVariant.equivalentObjectId; -+ break; -+ case YAFFS_OBJECT_TYPE_SPECIAL: -+ /* Do nothing */ -+ break; -+ case YAFFS_OBJECT_TYPE_DIRECTORY: -+ /* Do nothing */ -+ break; -+ case YAFFS_OBJECT_TYPE_SYMLINK: -+ alias = in->variant.symLinkVariant.alias; -+ if(!alias) -+ alias = _Y("no alias"); -+ yaffs_strncpy(oh->alias, -+ alias, -+ YAFFS_MAX_ALIAS_LENGTH); -+ oh->alias[YAFFS_MAX_ALIAS_LENGTH] = 0; -+ break; -+ } + return retVal; + } -int yaffs_DeleteFile(yaffs_Object *in) -{ - int retVal = YAFFS_OK; - int deleted = in->deleted; -+ /* process any xattrib modifications */ -+ if(xmod) -+ yaffs_ApplyXMod(in, (char *)buffer, xmod); - +- - yaffs_ResizeFile(in, 0); - +- - if (in->nDataChunks > 0) { - /* Use soft deletion if there is data in the file. - * That won't be the case if it has been resized to zero. - */ - if (!in->unlinked) - retVal = yaffs_UnlinkFileIfNeeded(in); -+ /* Tags */ -+ yaffs_InitialiseTags(&newTags); -+ in->serial++; -+ newTags.chunkId = 0; -+ newTags.objectId = in->objectId; -+ newTags.serialNumber = in->serial; - +- - if (retVal == YAFFS_OK && in->unlinked && !in->deleted) { - in->deleted = 1; - deleted = 1; @@ -11041,68 +11677,67 @@ - yaffs_FreeTnode(in->myDev, in->variant.fileVariant.top); - in->variant.fileVariant.top = NULL; - yaffs_DoGenericObjectDeletion(in); -+ /* Add extra info for file header */ - +- - return YAFFS_OK; - } -} -+ newTags.extraHeaderInfoAvailable = 1; -+ newTags.extraParentObjectId = oh->parentObjectId; -+ newTags.extraFileLength = oh->fileSize; -+ newTags.extraIsShrinkHeader = oh->isShrink; -+ newTags.extraEquivalentObjectId = oh->equivalentObjectId; -+ newTags.extraShadows = (oh->shadowsObject > 0) ? 1 : 0; -+ newTags.extraObjectType = in->variantType; ++/*------------------------ Short Operations Cache ---------------------------------------- ++ * In many situations where there is no high level buffering (eg WinCE) a lot of ++ * reads might be short sequential reads, and a lot of writes may be short ++ * sequential writes. eg. scanning/writing a jpeg file. ++ * In these cases, a short read/write cache can provide a huge perfomance benefit ++ * with dumb-as-a-rock code. ++ * In Linux, the page cache provides read buffering aand the short op cache provides write ++ * buffering. ++ * ++ * There are a limited number (~10) of cache chunks per device so that we don't ++ * need a very intelligent search. ++ */ -static int yaffs_DeleteDirectory(yaffs_Object *in) --{ ++static int yaffs_obj_cache_dirty(yaffs_obj_t *obj) + { - /* First check that the directory is empty. */ - if (ylist_empty(&in->variant.directoryVariant.children)) - return yaffs_DoGenericObjectDeletion(in); -+ yaffs_VerifyObjectHeader(in, oh, &newTags, 1); ++ yaffs_dev_t *dev = obj->my_dev; ++ int i; ++ yaffs_cache_t *cache; ++ int nCaches = obj->my_dev->param.n_caches; - return YAFFS_FAIL; -+ /* Create new chunk in NAND */ -+ newChunkId = -+ yaffs_WriteNewChunkWithTagsToNAND(dev, buffer, &newTags, -+ (prevChunkId > 0) ? 1 : 0); ++ for (i = 0; i < nCaches; i++) { ++ cache = &dev->cache[i]; ++ if (cache->object == obj && ++ cache->dirty) ++ return 1; ++ } --} -+ if (newChunkId >= 0) { ++ return 0; + } -static int yaffs_DeleteSymLink(yaffs_Object *in) -{ - YFREE(in->variant.symLinkVariant.alias); -+ in->hdrChunk = newChunkId; - +- - return yaffs_DoGenericObjectDeletion(in); -} -+ if (prevChunkId > 0) { -+ yaffs_DeleteChunk(dev, prevChunkId, 1, -+ __LINE__); -+ } -static int yaffs_DeleteHardLink(yaffs_Object *in) --{ ++static void yaffs_flush_file_cache(yaffs_obj_t *obj) + { - /* remove this hardlink from the list assocaited with the equivalent - * object - */ - ylist_del_init(&in->hardLinks); - return yaffs_DoGenericObjectDeletion(in); -} -+ if (!yaffs_ObjectHasCachedWriteData(in)) -+ in->dirty = 0; -+ -+ /* If this was a shrink, then mark the block that the chunk lives on */ -+ if (isShrink) { -+ bi = yaffs_GetBlockInfo(in->myDev, -+ newChunkId / in->myDev->param.nChunksPerBlock); -+ bi->hasShrinkHeader = 1; -+ } -+ -+ } -+ -+ retVal = newChunkId; ++ yaffs_dev_t *dev = obj->my_dev; ++ int lowest = -99; /* Stop compiler whining. */ ++ int i; ++ yaffs_cache_t *cache; ++ int chunkWritten = 0; ++ int nCaches = obj->my_dev->param.n_caches; -int yaffs_DeleteObject(yaffs_Object *obj) -{ @@ -11126,42 +11761,41 @@ - case YAFFS_OBJECT_TYPE_UNKNOWN: - retVal = 0; - break; /* should not happen. */ - } +- } ++ if (nCaches > 0) { ++ do { ++ cache = NULL; -+ if (buffer) -+ yaffs_ReleaseTempBuffer(dev, buffer, __LINE__); -+ - return retVal; - } +- return retVal; +-} ++ /* Find the dirty cache for this object with the lowest chunk id. */ ++ for (i = 0; i < nCaches; i++) { ++ if (dev->cache[i].object == obj && ++ dev->cache[i].dirty) { ++ if (!cache ++ || dev->cache[i].chunk_id < ++ lowest) { ++ cache = &dev->cache[i]; ++ lowest = cache->chunk_id; ++ } ++ } ++ } -static int yaffs_UnlinkWorker(yaffs_Object *obj) -+/*------------------------ Short Operations Cache ---------------------------------------- -+ * In many situations where there is no high level buffering (eg WinCE) a lot of -+ * reads might be short sequential reads, and a lot of writes may be short -+ * sequential writes. eg. scanning/writing a jpeg file. -+ * In these cases, a short read/write cache can provide a huge perfomance benefit -+ * with dumb-as-a-rock code. -+ * In Linux, the page cache provides read buffering aand the short op cache provides write -+ * buffering. -+ * -+ * There are a limited number (~10) of cache chunks per device so that we don't -+ * need a very intelligent search. -+ */ -+ -+static int yaffs_ObjectHasCachedWriteData(yaffs_Object *obj) - { -+ yaffs_Device *dev = obj->myDev; -+ int i; -+ yaffs_ChunkCache *cache; -+ int nCaches = obj->myDev->param.nShortOpCaches; +-{ ++ if (cache && !cache->locked) { ++ /* Write it out and free it up */ - int immediateDeletion = 0; -+ for (i = 0; i < nCaches; i++) { -+ cache = &dev->srCache[i]; -+ if (cache->object == obj && -+ cache->dirty) -+ return 1; -+ } ++ chunkWritten = ++ yaffs_wr_data_obj(cache->object, ++ cache->chunk_id, ++ cache->data, ++ cache->n_bytes, ++ 1); ++ cache->dirty = 0; ++ cache->object = NULL; ++ } -#ifdef __KERNEL__ - if (!obj->myInode) @@ -11170,8 +11804,7 @@ - if (obj->inUse <= 0) - immediateDeletion = 1; -#endif -+ return 0; -+} ++ } while (cache && chunkWritten > 0); - if (obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK) { - return yaffs_DeleteHardLink(obj); @@ -11189,63 +11822,53 @@ - * - Rename the object to the hardlink's name. - * - Delete the hardlink - */ ++ if (cache) { ++ /* Hoosterman, disk full while writing cache out. */ ++ T(YAFFS_TRACE_ERROR, ++ (TSTR("yaffs tragedy: no space during cache write" TENDSTR))); - yaffs_Object *hl; - int retVal; - YCHAR name[YAFFS_MAX_NAME_LENGTH + 1]; -+static void yaffs_FlushFilesChunkCache(yaffs_Object *obj) -+{ -+ yaffs_Device *dev = obj->myDev; -+ int lowest = -99; /* Stop compiler whining. */ -+ int i; -+ yaffs_ChunkCache *cache; -+ int chunkWritten = 0; -+ int nCaches = obj->myDev->param.nShortOpCaches; ++ } ++ } - hl = ylist_entry(obj->hardLinks.next, yaffs_Object, hardLinks); -+ if (nCaches > 0) { -+ do { -+ cache = NULL; ++} - ylist_del_init(&hl->hardLinks); - ylist_del_init(&hl->siblings); -+ /* Find the dirty cache for this object with the lowest chunk id. */ -+ for (i = 0; i < nCaches; i++) { -+ if (dev->srCache[i].object == obj && -+ dev->srCache[i].dirty) { -+ if (!cache -+ || dev->srCache[i].chunkId < -+ lowest) { -+ cache = &dev->srCache[i]; -+ lowest = cache->chunkId; -+ } -+ } -+ } ++/*yaffs_flush_whole_cache(dev) ++ * ++ * ++ */ - yaffs_GetObjectName(hl, name, YAFFS_MAX_NAME_LENGTH + 1); -+ if (cache && !cache->locked) { -+ /* Write it out and free it up */ ++void yaffs_flush_whole_cache(yaffs_dev_t *dev) ++{ ++ yaffs_obj_t *obj; ++ int nCaches = dev->param.n_caches; ++ int i; - retVal = yaffs_ChangeObjectName(obj, hl->parent, name, 0, 0); -+ chunkWritten = -+ yaffs_WriteChunkDataToObject(cache->object, -+ cache->chunkId, -+ cache->data, -+ cache->nBytes, -+ 1); -+ cache->dirty = 0; -+ cache->object = NULL; -+ } ++ /* Find a dirty object in the cache and flush it... ++ * until there are no further dirty objects. ++ */ ++ do { ++ obj = NULL; ++ for (i = 0; i < nCaches && !obj; i++) { ++ if (dev->cache[i].object && ++ dev->cache[i].dirty) ++ obj = dev->cache[i].object; - if (retVal == YAFFS_OK) - retVal = yaffs_DoGenericObjectDeletion(hl); -+ } while (cache && chunkWritten > 0); ++ } ++ if (obj) ++ yaffs_flush_file_cache(obj); - return retVal; -+ if (cache) { -+ /* Hoosterman, disk full while writing cache out. */ -+ T(YAFFS_TRACE_ERROR, -+ (TSTR("yaffs tragedy: no space during cache write" TENDSTR))); ++ } while (obj); - } else if (immediateDeletion) { - switch (obj->variantType) { @@ -11265,80 +11888,53 @@ - case YAFFS_OBJECT_TYPE_UNKNOWN: - default: - return YAFFS_FAIL; - } +- } - } else - return yaffs_ChangeObjectName(obj, obj->myDev->unlinkedDir, - _Y("unlinked"), 0, 0); -+ } -+ } -+/*yaffs_FlushEntireDeviceCache(dev) -+ * -+ * -+ */ -static int yaffs_UnlinkObject(yaffs_Object *obj) -+void yaffs_FlushEntireDeviceCache(yaffs_Device *dev) - { -+ yaffs_Object *obj; -+ int nCaches = dev->param.nShortOpCaches; -+ int i; - -- if (obj && obj->unlinkAllowed) -- return yaffs_UnlinkWorker(obj); -+ /* Find a dirty object in the cache and flush it... -+ * until there are no further dirty objects. -+ */ -+ do { -+ obj = NULL; -+ for (i = 0; i < nCaches && !obj; i++) { -+ if (dev->srCache[i].object && -+ dev->srCache[i].dirty) -+ obj = dev->srCache[i].object; - -- return YAFFS_FAIL; -+ } -+ if (obj) -+ yaffs_FlushFilesChunkCache(obj); -+ -+ } while (obj); - - } --int yaffs_Unlink(yaffs_Object *dir, const YCHAR *name) -+ -+ +/* Grab us a cache chunk for use. + * First look for an empty one. + * Then look for the least recently used non-dirty one. + * Then look for the least recently used dirty one...., flush and look again. + */ -+static yaffs_ChunkCache *yaffs_GrabChunkCacheWorker(yaffs_Device *dev) ++static yaffs_cache_t *yaffs_grab_chunk_worker(yaffs_dev_t *dev) { -- yaffs_Object *obj; + int i; -- obj = yaffs_FindObjectByName(dir, name); -- return yaffs_UnlinkObject(obj); +- if (obj && obj->unlinkAllowed) +- return yaffs_UnlinkWorker(obj); +- +- return YAFFS_FAIL; +- -} -+ if (dev->param.nShortOpCaches > 0) { -+ for (i = 0; i < dev->param.nShortOpCaches; i++) { -+ if (!dev->srCache[i].object) -+ return &dev->srCache[i]; +-int yaffs_Unlink(yaffs_Object *dir, const YCHAR *name) +-{ +- yaffs_Object *obj; ++ if (dev->param.n_caches > 0) { ++ for (i = 0; i < dev->param.n_caches; i++) { ++ if (!dev->cache[i].object) ++ return &dev->cache[i]; + } + } --/*----------------------- Initialisation Scanning ---------------------- */ +- obj = yaffs_FindObjectByName(dir, name); +- return yaffs_UnlinkObject(obj); + return NULL; -+} + } +-/*----------------------- Initialisation Scanning ---------------------- */ +- -static void yaffs_HandleShadowedObject(yaffs_Device *dev, int objId, - int backwardScanning) -+static yaffs_ChunkCache *yaffs_GrabChunkCache(yaffs_Device *dev) ++static yaffs_cache_t *yaffs_grab_chunk_cache(yaffs_dev_t *dev) { - yaffs_Object *obj; -+ yaffs_ChunkCache *cache; -+ yaffs_Object *theObj; ++ yaffs_cache_t *cache; ++ yaffs_obj_t *theObj; + int usage; + int i; + int pushout; @@ -11347,7 +11943,7 @@ - /* Handle YAFFS1 forward scanning case - * For YAFFS1 we always do the deletion - */ -+ if (dev->param.nShortOpCaches > 0) { ++ if (dev->param.n_caches > 0) { + /* Try find a non-dirty one... */ - } else { @@ -11357,7 +11953,7 @@ - if (yaffs_FindObjectByNumber(dev, objId)) - return; - } -+ cache = yaffs_GrabChunkCacheWorker(dev); ++ cache = yaffs_grab_chunk_worker(dev); - /* Let's create it (if it does not exist) assuming it is a file so that it can do shrinking etc. - * We put it in unlinked dir to be cleaned up after the scanning @@ -11389,13 +11985,13 @@ + cache = NULL; + pushout = -1; -+ for (i = 0; i < dev->param.nShortOpCaches; i++) { -+ if (dev->srCache[i].object && -+ !dev->srCache[i].locked && -+ (dev->srCache[i].lastUse < usage || !cache)) { -+ usage = dev->srCache[i].lastUse; -+ theObj = dev->srCache[i].object; -+ cache = &dev->srCache[i]; ++ for (i = 0; i < dev->param.n_caches; i++) { ++ if (dev->cache[i].object && ++ !dev->cache[i].locked && ++ (dev->cache[i].last_use < usage || !cache)) { ++ usage = dev->cache[i].last_use; ++ theObj = dev->cache[i].object; ++ cache = &dev->cache[i]; + pushout = i; + } + } @@ -11406,8 +12002,8 @@ - yaffs_Object *in; + if (!cache || cache->dirty) { + /* Flush and try again */ -+ yaffs_FlushFilesChunkCache(theObj); -+ cache = yaffs_GrabChunkCacheWorker(dev); ++ yaffs_flush_file_cache(theObj); ++ cache = yaffs_grab_chunk_worker(dev); + } - while (hardList) { @@ -11434,18 +12030,18 @@ - hl->variant.hardLinkVariant.equivalentObject = NULL; - YINIT_LIST_HEAD(&hl->hardLinks); +/* Find a cached chunk */ -+static yaffs_ChunkCache *yaffs_FindChunkCache(const yaffs_Object *obj, -+ int chunkId) ++static yaffs_cache_t *yaffs_find_chunk_cache(const yaffs_obj_t *obj, ++ int chunk_id) +{ -+ yaffs_Device *dev = obj->myDev; ++ yaffs_dev_t *dev = obj->my_dev; + int i; -+ if (dev->param.nShortOpCaches > 0) { -+ for (i = 0; i < dev->param.nShortOpCaches; i++) { -+ if (dev->srCache[i].object == obj && -+ dev->srCache[i].chunkId == chunkId) { -+ dev->cacheHits++; ++ if (dev->param.n_caches > 0) { ++ for (i = 0; i < dev->param.n_caches; i++) { ++ if (dev->cache[i].object == obj && ++ dev->cache[i].chunk_id == chunk_id) { ++ dev->cache_hits++; -+ return &dev->srCache[i]; ++ return &dev->cache[i]; + } } } @@ -11453,23 +12049,23 @@ } +/* Mark the chunk for the least recently used algorithym */ -+static void yaffs_UseChunkCache(yaffs_Device *dev, yaffs_ChunkCache *cache, ++static void yaffs_use_cache(yaffs_dev_t *dev, yaffs_cache_t *cache, + int isAWrite) +{ + -+ if (dev->param.nShortOpCaches > 0) { -+ if (dev->srLastUse < 0 || dev->srLastUse > 100000000) { ++ if (dev->param.n_caches > 0) { ++ if (dev->cache_last_use < 0 || dev->cache_last_use > 100000000) { + /* Reset the cache usages */ + int i; -+ for (i = 1; i < dev->param.nShortOpCaches; i++) -+ dev->srCache[i].lastUse = 0; ++ for (i = 1; i < dev->param.n_caches; i++) ++ dev->cache[i].last_use = 0; -+ dev->srLastUse = 0; ++ dev->cache_last_use = 0; + } -+ dev->srLastUse++; ++ dev->cache_last_use++; -+ cache->lastUse = dev->srLastUse; ++ cache->last_use = dev->cache_last_use; -static int ybicmp(const void *a, const void *b) -{ @@ -11490,10 +12086,10 @@ + * Do this when a whole page gets written, + * ie the short cache for this page is no longer valid. + */ -+static void yaffs_InvalidateChunkCache(yaffs_Object *object, int chunkId) ++static void yaffs_invalidate_chunk_cache(yaffs_obj_t *object, int chunk_id) +{ -+ if (object->myDev->param.nShortOpCaches > 0) { -+ yaffs_ChunkCache *cache = yaffs_FindChunkCache(object, chunkId); ++ if (object->my_dev->param.n_caches > 0) { ++ yaffs_cache_t *cache = yaffs_find_chunk_cache(object, chunk_id); -struct yaffs_ShadowFixerStruct { - int objectId; @@ -11510,7 +12106,7 @@ +/* Invalidate all the cache pages associated with this object + * Do this whenever ther file is deleted or resized. + */ -+static void yaffs_InvalidateWholeChunkCache(yaffs_Object *in) ++static void yaffs_invalidate_whole_cache(yaffs_obj_t *in) { - /* - * Sort out state of unlinked and deleted objects after scanning. @@ -11519,7 +12115,7 @@ - struct ylist_head *n; - yaffs_Object *l; + int i; -+ yaffs_Device *dev = in->myDev; ++ yaffs_dev_t *dev = in->my_dev; - /* Soft delete all the unlinked files */ - ylist_for_each_safe(i, n, @@ -11527,11 +12123,11 @@ - if (i) { - l = ylist_entry(i, yaffs_Object, siblings); - yaffs_DeleteObject(l); -+ if (dev->param.nShortOpCaches > 0) { ++ if (dev->param.n_caches > 0) { + /* Invalidate it. */ -+ for (i = 0; i < dev->param.nShortOpCaches; i++) { -+ if (dev->srCache[i].object == in) -+ dev->srCache[i].object = NULL; ++ for (i = 0; i < dev->param.n_caches; i++) { ++ if (dev->cache[i].object == in) ++ dev->cache[i].object = NULL; } } +} @@ -11556,8 +12152,8 @@ + */ -static int yaffs_Scan(yaffs_Device *dev) -+int yaffs_ReadDataFromFile(yaffs_Object *in, __u8 *buffer, loff_t offset, -+ int nBytes) ++int yaffs_file_rd(yaffs_obj_t *in, __u8 *buffer, loff_t offset, ++ int n_bytes) { - yaffs_ExtendedTags tags; - int blk; @@ -11576,82 +12172,90 @@ - yaffs_ObjectHeader *oh; - yaffs_Object *in; - yaffs_Object *parent; -- -- int alloc_failed = 0; + __u32 start; + int nToCopy; -+ int n = nBytes; ++ int n = n_bytes; + int nDone = 0; -+ yaffs_ChunkCache *cache; ++ yaffs_cache_t *cache; -- struct yaffs_ShadowFixerStruct *shadowFixerList = NULL; -+ yaffs_Device *dev; +- int alloc_failed = 0; ++ yaffs_dev_t *dev; -+ dev = in->myDev; +- struct yaffs_ShadowFixerStruct *shadowFixerList = NULL; ++ dev = in->my_dev; -- __u8 *chunkData; + while (n > 0) { -+ /* chunk = offset / dev->nDataBytesPerChunk + 1; */ -+ /* start = offset % dev->nDataBytesPerChunk; */ -+ yaffs_AddrToChunk(dev, offset, &chunk, &start); ++ /* chunk = offset / dev->data_bytes_per_chunk + 1; */ ++ /* start = offset % dev->data_bytes_per_chunk; */ ++ yaffs_addr_to_chunk(dev, offset, &chunk, &start); + chunk++; +- __u8 *chunkData; + /* OK now check for the curveball where the start and end are in + * the same chunk. + */ -+ if ((start + n) < dev->nDataBytesPerChunk) ++ if ((start + n) < dev->data_bytes_per_chunk) + nToCopy = n; + else -+ nToCopy = dev->nDataBytesPerChunk - start; ++ nToCopy = dev->data_bytes_per_chunk - start; + ++ cache = yaffs_find_chunk_cache(in, chunk); -+ cache = yaffs_FindChunkCache(in, chunk); ++ /* If the chunk is already in the cache or it is less than a whole chunk ++ * or we're using inband tags then use the cache (if there is caching) ++ * else bypass the cache. ++ */ ++ if (cache || nToCopy != dev->data_bytes_per_chunk || dev->param.inband_tags) { ++ if (dev->param.n_caches > 0) { - T(YAFFS_TRACE_SCAN, - (TSTR("yaffs_Scan starts intstartblk %d intendblk %d..." TENDSTR), - dev->internalStartBlock, dev->internalEndBlock)); -- ++ /* If we can't find the data in the cache, then load it up. */ + - chunkData = yaffs_GetTempBuffer(dev, __LINE__); -- ++ if (!cache) { ++ cache = yaffs_grab_chunk_cache(in->my_dev); ++ cache->object = in; ++ cache->chunk_id = chunk; ++ cache->dirty = 0; ++ cache->locked = 0; ++ yaffs_rd_data_obj(in, chunk, ++ cache-> ++ data); ++ cache->n_bytes = 0; ++ } + - dev->sequenceNumber = YAFFS_LOWEST_SEQUENCE_NUMBER; -- ++ yaffs_use_cache(dev, cache, 0); + - /* Scan all the blocks to determine their state */ - for (blk = dev->internalStartBlock; blk <= dev->internalEndBlock; blk++) { - bi = yaffs_GetBlockInfo(dev, blk); - yaffs_ClearChunkBits(dev, blk); - bi->pagesInUse = 0; - bi->softDeletions = 0; -+ /* If the chunk is already in the cache or it is less than a whole chunk -+ * or we're using inband tags then use the cache (if there is caching) -+ * else bypass the cache. -+ */ -+ if (cache || nToCopy != dev->nDataBytesPerChunk || dev->param.inbandTags) { -+ if (dev->param.nShortOpCaches > 0) { ++ cache->locked = 1; - yaffs_QueryInitialBlockState(dev, blk, &state, &sequenceNumber); -+ /* If we can't find the data in the cache, then load it up. */ - bi->blockState = state; - bi->sequenceNumber = sequenceNumber; -+ if (!cache) { -+ cache = yaffs_GrabChunkCache(in->myDev); -+ cache->object = in; -+ cache->chunkId = chunk; -+ cache->dirty = 0; -+ cache->locked = 0; -+ yaffs_ReadChunkDataFromObject(in, chunk, -+ cache-> -+ data); -+ cache->nBytes = 0; -+ } ++ memcpy(buffer, &cache->data[start], nToCopy); - if (bi->sequenceNumber == YAFFS_SEQUENCE_BAD_BLOCK) - bi->blockState = state = YAFFS_BLOCK_STATE_DEAD; -+ yaffs_UseChunkCache(dev, cache, 0); ++ cache->locked = 0; ++ } else { ++ /* Read into the local buffer then copy..*/ - T(YAFFS_TRACE_SCAN_DEBUG, - (TSTR("Block scanning block %d state %d seq %d" TENDSTR), blk, - state, sequenceNumber)); -+ cache->locked = 1; ++ __u8 *localBuffer = ++ yaffs_get_temp_buffer(dev, __LINE__); ++ yaffs_rd_data_obj(in, chunk, ++ localBuffer); - if (state == YAFFS_BLOCK_STATE_DEAD) { - T(YAFFS_TRACE_BAD_BLOCKS, @@ -11663,55 +12267,63 @@ - dev->nFreeChunks += dev->nChunksPerBlock; - } - } ++ memcpy(buffer, &localBuffer[start], nToCopy); - startIterator = dev->internalStartBlock; - endIterator = dev->internalEndBlock; -+ memcpy(buffer, &cache->data[start], nToCopy); - /* For each block.... */ - for (blockIterator = startIterator; !alloc_failed && blockIterator <= endIterator; - blockIterator++) { -+ cache->locked = 0; -+ } else { -+ /* Read into the local buffer then copy..*/ ++ yaffs_release_temp_buffer(dev, localBuffer, ++ __LINE__); ++ } - YYIELD(); -+ __u8 *localBuffer = -+ yaffs_GetTempBuffer(dev, __LINE__); -+ yaffs_ReadChunkDataFromObject(in, chunk, -+ localBuffer); ++ } else { - YYIELD(); -+ memcpy(buffer, &localBuffer[start], nToCopy); ++ /* A full chunk. Read directly into the supplied buffer. */ ++ yaffs_rd_data_obj(in, chunk, buffer); - blk = blockIterator; ++ } - bi = yaffs_GetBlockInfo(dev, blk); - state = bi->blockState; -+ yaffs_ReleaseTempBuffer(dev, localBuffer, -+ __LINE__); -+ } ++ n -= nToCopy; ++ offset += nToCopy; ++ buffer += nToCopy; ++ nDone += nToCopy; - deleted = 0; -+ } else { ++ } - /* For each chunk in each block that needs scanning....*/ - for (c = 0; !alloc_failed && c < dev->nChunksPerBlock && - state == YAFFS_BLOCK_STATE_NEEDS_SCANNING; c++) { - /* Read the tags and decide what to do */ - chunk = blk * dev->nChunksPerBlock + c; -+ /* A full chunk. Read directly into the supplied buffer. */ -+ yaffs_ReadChunkDataFromObject(in, chunk, buffer); ++ return nDone; ++} - result = yaffs_ReadChunkWithTagsFromNAND(dev, chunk, NULL, - &tags); -+ } ++int yaffs_do_file_wr(yaffs_obj_t *in, const __u8 *buffer, loff_t offset, ++ int n_bytes, int write_trhrough) ++{ - /* Let's have a good look at this chunk... */ -+ n -= nToCopy; -+ offset += nToCopy; -+ buffer += nToCopy; -+ nDone += nToCopy; ++ int chunk; ++ __u32 start; ++ int nToCopy; ++ int n = n_bytes; ++ int nDone = 0; ++ int nToWriteBack; ++ int startOfWrite = offset; ++ int chunkWritten = 0; ++ __u32 n_bytesRead; ++ __u32 chunkStart; - if (tags.eccResult == YAFFS_ECC_RESULT_UNFIXED || tags.chunkDeleted) { - /* YAFFS1 only... @@ -11725,7 +12337,7 @@ - * This means that either the block is empty or - * this is the one being allocated from - */ -+ } ++ yaffs_dev_t *dev; - if (c == 0) { - /* We're looking at the first chunk in the block so the block is unused */ @@ -11742,13 +12354,11 @@ - dev->allocationPage = c; - dev->allocationBlockFinder = blk; - /* Set it to here to encourage the allocator to go forth from here. */ -+ return nDone; -+} ++ dev = in->my_dev; - } -+int yaffs_DoWriteDataToFile(yaffs_Object *in, const __u8 *buffer, loff_t offset, -+ int nBytes, int writeThrough) -+{ ++ while (n > 0 && chunkWritten >= 0) { ++ yaffs_addr_to_chunk(dev, offset, &chunk, &start); - dev->nFreeChunks += (dev->nChunksPerBlock - c); - } else if (tags.chunkId > 0) { @@ -11765,26 +12375,27 @@ - /* PutChunkIntoFile checks for a clash (two data chunks with - * the same chunkId). - */ -+ int chunk; -+ __u32 start; -+ int nToCopy; -+ int n = nBytes; -+ int nDone = 0; -+ int nToWriteBack; -+ int startOfWrite = offset; -+ int chunkWritten = 0; -+ __u32 nBytesRead; -+ __u32 chunkStart; ++ if (chunk * dev->data_bytes_per_chunk + start != offset || ++ start >= dev->data_bytes_per_chunk) { ++ T(YAFFS_TRACE_ERROR, ( ++ TSTR("AddrToChunk of offset %d gives chunk %d start %d" ++ TENDSTR), ++ (int)offset, chunk, start)); ++ } ++ chunk++; /* File pos to chunk in file offset */ - if (!in) - alloc_failed = 1; -+ yaffs_Device *dev; ++ /* OK now check for the curveball where the start and end are in ++ * the same chunk. ++ */ - if (in) { - if (!yaffs_PutChunkIntoFile(in, tags.chunkId, chunk, 1)) - alloc_failed = 1; - } -+ dev = in->myDev; ++ if ((start + n) < dev->data_bytes_per_chunk) { ++ nToCopy = n; - endpos = - (tags.chunkId - 1) * dev->nDataBytesPerChunk + @@ -11801,8 +12412,10 @@ - in->variant.fileVariant. - scannedFileSize; - } -+ while (n > 0 && chunkWritten >= 0) { -+ yaffs_AddrToChunk(dev, offset, &chunk, &start); ++ /* Now folks, to calculate how many bytes to write back.... ++ * If we're overwriting and not writing to then end of file then ++ * we need to write back as much as was there before. ++ */ - } - /* T((" %d %d data %d %d\n",blk,c,tags.objectId,tags.chunkId)); */ @@ -11812,14 +12425,7 @@ - */ - yaffs_SetChunkBit(dev, blk, c); - bi->pagesInUse++; -+ if (chunk * dev->nDataBytesPerChunk + start != offset || -+ start >= dev->nDataBytesPerChunk) { -+ T(YAFFS_TRACE_ERROR, ( -+ TSTR("AddrToChunk of offset %d gives chunk %d start %d" -+ TENDSTR), -+ (int)offset, chunk, start)); -+ } -+ chunk++; /* File pos to chunk in file offset */ ++ chunkStart = ((chunk - 1) * dev->data_bytes_per_chunk); - result = yaffs_ReadChunkWithTagsFromNAND(dev, chunk, - chunkData, @@ -11834,20 +12440,20 @@ - * Wev'e ended up with an objectId that has been reused but not yet - * deleted, and worse still it has changed type. Delete the old object. - */ -+ /* OK now check for the curveball where the start and end are in -+ * the same chunk. -+ */ ++ if (chunkStart > in->variant.file_variant.file_size) ++ n_bytesRead = 0; /* Past end of file */ ++ else ++ n_bytesRead = in->variant.file_variant.file_size - chunkStart; - yaffs_DeleteObject(in); -+ if ((start + n) < dev->nDataBytesPerChunk) { -+ nToCopy = n; ++ if (n_bytesRead > dev->data_bytes_per_chunk) ++ n_bytesRead = dev->data_bytes_per_chunk; - in = 0; - } -+ /* Now folks, to calculate how many bytes to write back.... -+ * If we're overwriting and not writing to then end of file then -+ * we need to write back as much as was there before. -+ */ ++ nToWriteBack = ++ (n_bytesRead > ++ (start + n)) ? n_bytesRead : (start + n); - in = yaffs_FindOrCreateObjectByNumber(dev, - tags. @@ -11867,24 +12473,49 @@ - fixer->objectId = tags.objectId; - fixer->shadowedId = oh->shadowsObject; - } -+ chunkStart = ((chunk - 1) * dev->nDataBytesPerChunk); ++ if (nToWriteBack < 0 || nToWriteBack > dev->data_bytes_per_chunk) ++ YBUG(); ++ ++ } else { ++ nToCopy = dev->data_bytes_per_chunk - start; ++ nToWriteBack = dev->data_bytes_per_chunk; ++ } ++ ++ if (nToCopy != dev->data_bytes_per_chunk || dev->param.inband_tags) { ++ /* An incomplete start or end chunk (or maybe both start and end chunk), ++ * or we're using inband tags, so we want to use the cache buffers. ++ */ ++ if (dev->param.n_caches > 0) { ++ yaffs_cache_t *cache; ++ /* If we can't find the data in the cache, then load the cache */ ++ cache = yaffs_find_chunk_cache(in, chunk); -- } -+ if (chunkStart > in->variant.fileVariant.fileSize) -+ nBytesRead = 0; /* Past end of file */ -+ else -+ nBytesRead = in->variant.fileVariant.fileSize - chunkStart; ++ if (!cache ++ && yaffs_check_alloc_available(dev, 1)) { ++ cache = yaffs_grab_chunk_cache(dev); ++ cache->object = in; ++ cache->chunk_id = chunk; ++ cache->dirty = 0; ++ cache->locked = 0; ++ yaffs_rd_data_obj(in, chunk, ++ cache->data); ++ } else if (cache && ++ !cache->dirty && ++ !yaffs_check_alloc_available(dev, 1)) { ++ /* Drop the cache if it was a read cache item and ++ * no space check has been made for it. ++ */ ++ cache = NULL; + } - if (in && in->valid) { - /* We have already filled this one. We have a duplicate and need to resolve it. */ -+ if (nBytesRead > dev->nDataBytesPerChunk) -+ nBytesRead = dev->nDataBytesPerChunk; ++ if (cache) { ++ yaffs_use_cache(dev, cache, 1); ++ cache->locked = 1; - unsigned existingSerial = in->serial; - unsigned newSerial = tags.serialNumber; -+ nToWriteBack = -+ (nBytesRead > -+ (start + n)) ? nBytesRead : (start + n); - if (((existingSerial + 1) & 3) == newSerial) { - /* Use new one - destroy the exisiting one */ @@ -11896,10 +12527,30 @@ - /* Use existing - destroy this one. */ - yaffs_DeleteChunk(dev, chunk, 1, - __LINE__); -- } -- } -+ if (nToWriteBack < 0 || nToWriteBack > dev->nDataBytesPerChunk) -+ YBUG(); ++ memcpy(&cache->data[start], buffer, ++ nToCopy); ++ ++ ++ cache->locked = 0; ++ cache->n_bytes = nToWriteBack; ++ ++ if (write_trhrough) { ++ chunkWritten = ++ yaffs_wr_data_obj ++ (cache->object, ++ cache->chunk_id, ++ cache->data, cache->n_bytes, ++ 1); ++ cache->dirty = 0; + } ++ ++ } else { ++ chunkWritten = -1; /* fail the write */ + } ++ } else { ++ /* An incomplete start or end chunk (or maybe both start and end chunk) ++ * Read into the local buffer then copy, then copy over and write back. ++ */ - if (in && !in->valid && - (tags.objectId == YAFFS_OBJECTID_ROOT || @@ -11907,10 +12558,8 @@ - /* We only load some info, don't fiddle with directory structure */ - in->valid = 1; - in->variantType = oh->type; -+ } else { -+ nToCopy = dev->nDataBytesPerChunk - start; -+ nToWriteBack = dev->nDataBytesPerChunk; -+ } ++ __u8 *localBuffer = ++ yaffs_get_temp_buffer(dev, __LINE__); - in->yst_mode = oh->yst_mode; -#ifdef CONFIG_YAFFS_WINCE @@ -11930,40 +12579,14 @@ -#endif - in->hdrChunk = chunk; - in->serial = tags.serialNumber; -+ if (nToCopy != dev->nDataBytesPerChunk || dev->param.inbandTags) { -+ /* An incomplete start or end chunk (or maybe both start and end chunk), -+ * or we're using inband tags, so we want to use the cache buffers. -+ */ -+ if (dev->param.nShortOpCaches > 0) { -+ yaffs_ChunkCache *cache; -+ /* If we can't find the data in the cache, then load the cache */ -+ cache = yaffs_FindChunkCache(in, chunk); ++ yaffs_rd_data_obj(in, chunk, ++ localBuffer); - } else if (in && !in->valid) { - /* we need to load this info */ -+ if (!cache -+ && yaffs_CheckSpaceForAllocation(dev, 1)) { -+ cache = yaffs_GrabChunkCache(dev); -+ cache->object = in; -+ cache->chunkId = chunk; -+ cache->dirty = 0; -+ cache->locked = 0; -+ yaffs_ReadChunkDataFromObject(in, chunk, -+ cache->data); -+ } else if (cache && -+ !cache->dirty && -+ !yaffs_CheckSpaceForAllocation(dev, 1)) { -+ /* Drop the cache if it was a read cache item and -+ * no space check has been made for it. -+ */ -+ cache = NULL; -+ } - in->valid = 1; - in->variantType = oh->type; -+ if (cache) { -+ yaffs_UseChunkCache(dev, cache, 1); -+ cache->locked = 1; - in->yst_mode = oh->yst_mode; -#ifdef CONFIG_YAFFS_WINCE @@ -11983,15 +12606,21 @@ -#endif - in->hdrChunk = chunk; - in->serial = tags.serialNumber; ++ memcpy(&localBuffer[start], buffer, nToCopy); - yaffs_SetObjectName(in, oh->name); - in->dirty = 0; -+ memcpy(&cache->data[start], buffer, -+ nToCopy); ++ chunkWritten = ++ yaffs_wr_data_obj(in, chunk, ++ localBuffer, ++ nToWriteBack, ++ 0); - /* directory stuff... - * hook up to parent - */ ++ yaffs_release_temp_buffer(dev, localBuffer, ++ __LINE__); - parent = - yaffs_FindOrCreateObjectByNumber @@ -12012,32 +12641,18 @@ - /* Hoosterman, another problem.... - * We're trying to use a non-directory as a directory - */ -+ cache->locked = 0; -+ cache->nBytes = nToWriteBack; ++ } - T(YAFFS_TRACE_ERROR, - (TSTR - ("yaffs tragedy: attempting to use non-directory as a directory in scan. Put in lost+found." - TENDSTR))); - parent = dev->lostNFoundDir; -+ if (writeThrough) { -+ chunkWritten = -+ yaffs_WriteChunkDataToObject -+ (cache->object, -+ cache->chunkId, -+ cache->data, cache->nBytes, -+ 1); -+ cache->dirty = 0; - } +- } ++ } else { ++ /* A full chunk. Write directly from the supplied buffer. */ - yaffs_AddObjectToDirectory(parent, in); -+ } else { -+ chunkWritten = -1; /* fail the write */ -+ } -+ } else { -+ /* An incomplete start or end chunk (or maybe both start and end chunk) -+ * Read into the local buffer then copy, then copy over and write back. -+ */ - if (0 && (parent == dev->deletedDir || - parent == dev->unlinkedDir)) { @@ -12050,8 +12665,6 @@ - * After scanning is complete, we should have all the objects, so we run through this - * list and fix up all the chains. - */ -+ __u8 *localBuffer = -+ yaffs_GetTempBuffer(dev, __LINE__); - switch (in->variantType) { - case YAFFS_OBJECT_TYPE_UNKNOWN: @@ -12087,8 +12700,10 @@ - alloc_failed = 1; - break; - } -+ yaffs_ReadChunkDataFromObject(in, chunk, -+ localBuffer); ++ chunkWritten = ++ yaffs_wr_data_obj(in, chunk, buffer, ++ dev->data_bytes_per_chunk, ++ 0); -/* - if (parent == dev->deletedDir) { @@ -12098,15 +12713,22 @@ -*/ - } - } -- } ++ /* Since we've overwritten the cached data, we better invalidate it. */ ++ yaffs_invalidate_chunk_cache(in, chunk); + } - if (state == YAFFS_BLOCK_STATE_NEEDS_SCANNING) { - /* If we got this far while scanning, then the block is fully allocated.*/ - state = YAFFS_BLOCK_STATE_FULL; -- } ++ if (chunkWritten >= 0) { ++ n -= nToCopy; ++ offset += nToCopy; ++ buffer += nToCopy; ++ nDone += nToCopy; + } - bi->blockState = state; -+ memcpy(&localBuffer[start], buffer, nToCopy); ++ } - /* Now let's see if it was dirty */ - if (bi->pagesInUse == 0 && @@ -12114,27 +12736,29 @@ - bi->blockState == YAFFS_BLOCK_STATE_FULL) { - yaffs_BlockBecameDirty(dev, blk); - } -+ chunkWritten = -+ yaffs_WriteChunkDataToObject(in, chunk, -+ localBuffer, -+ nToWriteBack, -+ 0); ++ /* Update file object */ - } -+ yaffs_ReleaseTempBuffer(dev, localBuffer, -+ __LINE__); ++ if ((startOfWrite + nDone) > in->variant.file_variant.file_size) ++ in->variant.file_variant.file_size = (startOfWrite + nDone); -+ } ++ in->dirty = 1; - /* Ok, we've done all the scanning. - * Fix up the hard link chains. - * We should now have scanned all the objects, now it's time to add these - * hardlinks. - */ -+ } else { -+ /* A full chunk. Write directly from the supplied buffer. */ ++ return nDone; ++} - yaffs_HardlinkFixup(dev, hardList); ++int yaffs_wr_file(yaffs_obj_t *in, const __u8 *buffer, loff_t offset, ++ int n_bytes, int write_trhrough) ++{ ++ yaffs2_handle_hole(in,offset); ++ return yaffs_do_file_wr(in,buffer,offset,n_bytes,write_trhrough); ++} - /* Fix up any shadowed objects */ - { @@ -12152,79 +12776,100 @@ - yaffs_DeleteObject(obj); - obj = yaffs_FindObjectByNumber(dev, fixer->objectId); -+ chunkWritten = -+ yaffs_WriteChunkDataToObject(in, chunk, buffer, -+ dev->nDataBytesPerChunk, -+ 0); - if (obj) - yaffs_UpdateObjectHeader(obj, NULL, 1, 0, 0); -+ /* Since we've overwritten the cached data, we better invalidate it. */ -+ yaffs_InvalidateChunkCache(in, chunk); -+ } ++/* ---------------------- File resizing stuff ------------------ */ - YFREE(fixer); -+ if (chunkWritten >= 0) { -+ n -= nToCopy; -+ offset += nToCopy; -+ buffer += nToCopy; -+ nDone += nToCopy; - } +- } - } ++static void yaffs_prune_chunks(yaffs_obj_t *in, int new_size) ++{ - yaffs_ReleaseTempBuffer(dev, chunkData, __LINE__); -+ } ++ yaffs_dev_t *dev = in->my_dev; ++ int oldFileSize = in->variant.file_variant.file_size; - if (alloc_failed) - return YAFFS_FAIL; -+ /* Update file object */ ++ int lastDel = 1 + (oldFileSize - 1) / dev->data_bytes_per_chunk; ++ ++ int startDel = 1 + (new_size + dev->data_bytes_per_chunk - 1) / ++ dev->data_bytes_per_chunk; ++ int i; ++ int chunk_id; - T(YAFFS_TRACE_SCAN, (TSTR("yaffs_Scan ends" TENDSTR))); -+ if ((startOfWrite + nDone) > in->variant.fileVariant.fileSize) -+ in->variant.fileVariant.fileSize = (startOfWrite + nDone); ++ /* Delete backwards so that we don't end up with holes if ++ * power is lost part-way through the operation. ++ */ ++ for (i = lastDel; i >= startDel; i--) { ++ /* NB this could be optimised somewhat, ++ * eg. could retrieve the tags and write them without ++ * using yaffs_chunk_del ++ */ -+ in->dirty = 1; ++ chunk_id = yaffs_find_del_file_chunk(in, i, NULL); ++ if (chunk_id > 0) { ++ if (chunk_id < ++ (dev->internal_start_block * dev->param.chunks_per_block) ++ || chunk_id >= ++ ((dev->internal_end_block + ++ 1) * dev->param.chunks_per_block)) { ++ T(YAFFS_TRACE_ALWAYS, ++ (TSTR("Found daft chunk_id %d for %d" TENDSTR), ++ chunk_id, i)); ++ } else { ++ in->n_data_chunks--; ++ yaffs_chunk_del(dev, chunk_id, 1, __LINE__); ++ } ++ } ++ } - return YAFFS_OK; -+ return nDone; } -static void yaffs_CheckObjectDetailsLoaded(yaffs_Object *in) -+int yaffs_WriteDataToFile(yaffs_Object *in, const __u8 *buffer, loff_t offset, -+ int nBytes, int writeThrough) - { +-{ - __u8 *chunkData; - yaffs_ObjectHeader *oh; - yaffs_Device *dev; - yaffs_ExtendedTags tags; - int result; - int alloc_failed = 0; -+ yaffs2_HandleHole(in,offset); -+ return yaffs_DoWriteDataToFile(in,buffer,offset,nBytes,writeThrough); -+} - if (!in) - return; ++void yaffs_resize_file_down( yaffs_obj_t *obj, loff_t new_size) ++{ ++ int newFullChunks; ++ __u32 new_sizeOfPartialChunk; ++ yaffs_dev_t *dev = obj->my_dev; - dev = in->myDev; ++ yaffs_addr_to_chunk(dev, new_size, &newFullChunks, &new_sizeOfPartialChunk); -#if 0 - T(YAFFS_TRACE_SCAN, (TSTR("details for object %d %s loaded" TENDSTR), - in->objectId, - in->lazyLoaded ? "not yet" : "already")); -#endif -+/* ---------------------- File resizing stuff ------------------ */ ++ yaffs_prune_chunks(obj, new_size); - if (in->lazyLoaded && in->hdrChunk > 0) { - in->lazyLoaded = 0; - chunkData = yaffs_GetTempBuffer(dev, __LINE__); -+static void yaffs_PruneResizedChunks(yaffs_Object *in, int newSize) -+{ ++ if (new_sizeOfPartialChunk != 0) { ++ int lastChunk = 1 + newFullChunks; ++ __u8 *localBuffer = yaffs_get_temp_buffer(dev, __LINE__); - result = yaffs_ReadChunkWithTagsFromNAND(dev, in->hdrChunk, chunkData, &tags); - oh = (yaffs_ObjectHeader *) chunkData; -+ yaffs_Device *dev = in->myDev; -+ int oldFileSize = in->variant.fileVariant.fileSize; ++ /* Got to read and rewrite the last chunk with its new size and zero pad */ ++ yaffs_rd_data_obj(obj, lastChunk, localBuffer); ++ memset(localBuffer + new_sizeOfPartialChunk, 0, ++ dev->data_bytes_per_chunk - new_sizeOfPartialChunk); - in->yst_mode = oh->yst_mode; -#ifdef CONFIG_YAFFS_WINCE @@ -12241,14 +12886,13 @@ - in->yst_mtime = oh->yst_mtime; - in->yst_ctime = oh->yst_ctime; - in->yst_rdev = oh->yst_rdev; -+ int lastDel = 1 + (oldFileSize - 1) / dev->nDataBytesPerChunk; ++ yaffs_wr_data_obj(obj, lastChunk, localBuffer, ++ new_sizeOfPartialChunk, 1); -#endif - yaffs_SetObjectName(in, oh->name); -+ int startDel = 1 + (newSize + dev->nDataBytesPerChunk - 1) / -+ dev->nDataBytesPerChunk; -+ int i; -+ int chunkId; ++ yaffs_release_temp_buffer(dev, localBuffer, __LINE__); ++ } - if (in->variantType == YAFFS_OBJECT_TYPE_SYMLINK) { - in->variant.symLinkVariant.alias = @@ -12256,49 +12900,22 @@ - if (!in->variant.symLinkVariant.alias) - alloc_failed = 1; /* Not returned to caller */ - } -+ /* Delete backwards so that we don't end up with holes if -+ * power is lost part-way through the operation. -+ */ -+ for (i = lastDel; i >= startDel; i--) { -+ /* NB this could be optimised somewhat, -+ * eg. could retrieve the tags and write them without -+ * using yaffs_DeleteChunk -+ */ ++ obj->variant.file_variant.file_size = new_size; - yaffs_ReleaseTempBuffer(dev, chunkData, __LINE__); -+ chunkId = yaffs_FindAndDeleteChunkInFile(in, i, NULL); -+ if (chunkId > 0) { -+ if (chunkId < -+ (dev->internalStartBlock * dev->param.nChunksPerBlock) -+ || chunkId >= -+ ((dev->internalEndBlock + -+ 1) * dev->param.nChunksPerBlock)) { -+ T(YAFFS_TRACE_ALWAYS, -+ (TSTR("Found daft chunkId %d for %d" TENDSTR), -+ chunkId, i)); -+ } else { -+ in->nDataChunks--; -+ yaffs_DeleteChunk(dev, chunkId, 1, __LINE__); -+ } -+ } - } -+ +- } ++ yaffs_prune_tree(dev, &obj->variant.file_variant); } -static int yaffs_ScanBackwards(yaffs_Device *dev) -+ -+void yaffs_ResizeDown( yaffs_Object *obj, loff_t newSize) - { +-{ - yaffs_ExtendedTags tags; - int blk; - int blockIterator; - int startIterator; - int endIterator; - int nBlocksToScan = 0; -+ int newFullChunks; -+ __u32 newSizeOfPartialChunk; -+ yaffs_Device *dev = obj->myDev; - +- - int chunk; - int result; - int c; @@ -12313,121 +12930,100 @@ - int nBlocks = dev->internalEndBlock - dev->internalStartBlock + 1; - int itsUnlinked; - __u8 *chunkData; -+ yaffs_AddrToChunk(dev, newSize, &newFullChunks, &newSizeOfPartialChunk); - int fileSize; - int isShrink; - int foundChunksInBlock; - int equivalentObjectId; - int alloc_failed = 0; -+ yaffs_PruneResizedChunks(obj, newSize); ++int yaffs_resize_file(yaffs_obj_t *in, loff_t new_size) ++{ ++ yaffs_dev_t *dev = in->my_dev; ++ int oldFileSize = in->variant.file_variant.file_size; -+ if (newSizeOfPartialChunk != 0) { -+ int lastChunk = 1 + newFullChunks; -+ __u8 *localBuffer = yaffs_GetTempBuffer(dev, __LINE__); ++ yaffs_flush_file_cache(in); ++ yaffs_invalidate_whole_cache(in); - yaffs_BlockIndex *blockIndex = NULL; - int altBlockIndex = 0; -+ /* Got to read and rewrite the last chunk with its new size and zero pad */ -+ yaffs_ReadChunkDataFromObject(obj, lastChunk, localBuffer); -+ memset(localBuffer + newSizeOfPartialChunk, 0, -+ dev->nDataBytesPerChunk - newSizeOfPartialChunk); ++ yaffs_check_gc(dev,0); - if (!dev->isYaffs2) { - T(YAFFS_TRACE_SCAN, - (TSTR("yaffs_ScanBackwards is only for YAFFS2!" TENDSTR))); -- return YAFFS_FAIL; -+ yaffs_WriteChunkDataToObject(obj, lastChunk, localBuffer, -+ newSizeOfPartialChunk, 1); -+ -+ yaffs_ReleaseTempBuffer(dev, localBuffer, __LINE__); - } ++ if (in->variant_type != YAFFS_OBJECT_TYPE_FILE) + return YAFFS_FAIL; +- } - T(YAFFS_TRACE_SCAN, - (TSTR - ("yaffs_ScanBackwards starts intstartblk %d intendblk %d..." - TENDSTR), dev->internalStartBlock, dev->internalEndBlock)); -+ obj->variant.fileVariant.fileSize = newSize; -+ -+ yaffs_PruneFileStructure(dev, &obj->variant.fileVariant); -+} - - -- dev->sequenceNumber = YAFFS_LOWEST_SEQUENCE_NUMBER; -+int yaffs_ResizeFile(yaffs_Object *in, loff_t newSize) -+{ -+ yaffs_Device *dev = in->myDev; -+ int oldFileSize = in->variant.fileVariant.fileSize; - -- blockIndex = YMALLOC(nBlocks * sizeof(yaffs_BlockIndex)); -+ yaffs_FlushFilesChunkCache(in); -+ yaffs_InvalidateWholeChunkCache(in); - -- if (!blockIndex) { -- blockIndex = YMALLOC_ALT(nBlocks * sizeof(yaffs_BlockIndex)); -- altBlockIndex = 1; -- } -+ yaffs_CheckGarbageCollection(dev,0); - -- if (!blockIndex) { -- T(YAFFS_TRACE_SCAN, -- (TSTR("yaffs_Scan() could not allocate block index!" TENDSTR))); -+ if (in->variantType != YAFFS_OBJECT_TYPE_FILE) - return YAFFS_FAIL; -- } - -- dev->blocksInCheckpoint = 0; -+ if (newSize == oldFileSize) ++ if (new_size == oldFileSize) + return YAFFS_OK; + -+ if(newSize > oldFileSize){ -+ yaffs2_HandleHole(in,newSize); -+ in->variant.fileVariant.fileSize = newSize; ++ if(new_size > oldFileSize){ ++ yaffs2_handle_hole(in,new_size); ++ in->variant.file_variant.file_size = new_size; + } else { -+ /* newSize < oldFileSize */ -+ yaffs_ResizeDown(in, newSize); ++ /* new_size < oldFileSize */ ++ yaffs_resize_file_down(in, new_size); + } -+ + + /* Write a new object header to reflect the resize. + * show we've shrunk the file, if need be + * Do this only if the file is not in the deleted directories + * and is not shadowed. + */ + if (in->parent && -+ !in->isShadowed && -+ in->parent->objectId != YAFFS_OBJECTID_UNLINKED && -+ in->parent->objectId != YAFFS_OBJECTID_DELETED) -+ yaffs_UpdateObjectHeader(in, NULL, 0, 0, 0, NULL); -+ ++ !in->is_shadowed && ++ in->parent->obj_id != YAFFS_OBJECTID_UNLINKED && ++ in->parent->obj_id != YAFFS_OBJECTID_DELETED) ++ yaffs_update_oh(in, NULL, 0, 0, 0, NULL); -- chunkData = yaffs_GetTempBuffer(dev, __LINE__); +- dev->sequenceNumber = YAFFS_LOWEST_SEQUENCE_NUMBER; + +- blockIndex = YMALLOC(nBlocks * sizeof(yaffs_BlockIndex)); + return YAFFS_OK; +} -- /* Scan all the blocks to determine their state */ -- for (blk = dev->internalStartBlock; blk <= dev->internalEndBlock; blk++) { -- bi = yaffs_GetBlockInfo(dev, blk); -- yaffs_ClearChunkBits(dev, blk); -- bi->pagesInUse = 0; -- bi->softDeletions = 0; -+loff_t yaffs_GetFileSize(yaffs_Object *obj) +- if (!blockIndex) { +- blockIndex = YMALLOC_ALT(nBlocks * sizeof(yaffs_BlockIndex)); +- altBlockIndex = 1; +- } ++loff_t yaffs_get_file_size(yaffs_obj_t *obj) +{ + YCHAR *alias = NULL; -+ obj = yaffs_GetEquivalentObject(obj); -+ -+ switch (obj->variantType) { ++ obj = yaffs_get_equivalent_obj(obj); + +- if (!blockIndex) { +- T(YAFFS_TRACE_SCAN, +- (TSTR("yaffs_Scan() could not allocate block index!" TENDSTR))); +- return YAFFS_FAIL; ++ switch (obj->variant_type) { + case YAFFS_OBJECT_TYPE_FILE: -+ return obj->variant.fileVariant.fileSize; ++ return obj->variant.file_variant.file_size; + case YAFFS_OBJECT_TYPE_SYMLINK: -+ alias = obj->variant.symLinkVariant.alias; ++ alias = obj->variant.symlink_variant.alias; + if(!alias) + return 0; + return yaffs_strnlen(alias,YAFFS_MAX_ALIAS_LENGTH); + default: + return 0; -+ } + } +} +- dev->blocksInCheckpoint = 0; +- +- chunkData = yaffs_GetTempBuffer(dev, __LINE__); +- +- /* Scan all the blocks to determine their state */ +- for (blk = dev->internalStartBlock; blk <= dev->internalEndBlock; blk++) { +- bi = yaffs_GetBlockInfo(dev, blk); +- yaffs_ClearChunkBits(dev, blk); +- bi->pagesInUse = 0; +- bi->softDeletions = 0; +- - yaffs_QueryInitialBlockState(dev, blk, &state, &sequenceNumber); - bi->blockState = state; @@ -12437,17 +13033,17 @@ - bi->blockState = state = YAFFS_BLOCK_STATE_CHECKPOINT; - if (bi->sequenceNumber == YAFFS_SEQUENCE_BAD_BLOCK) - bi->blockState = state = YAFFS_BLOCK_STATE_DEAD; -+int yaffs_FlushFile(yaffs_Object *in, int updateTime, int dataSync) ++int yaffs_flush_file(yaffs_obj_t *in, int update_time, int data_sync) +{ + int retVal; + if (in->dirty) { -+ yaffs_FlushFilesChunkCache(in); -+ if(dataSync) /* Only sync data */ ++ yaffs_flush_file_cache(in); ++ if(data_sync) /* Only sync data */ + retVal=YAFFS_OK; + else { -+ if (updateTime) { ++ if (update_time) { +#ifdef CONFIG_YAFFS_WINCE -+ yfsd_WinFileTimeNow(in->win_mtime); ++ yfsd_win_file_time_now(in->win_mtime); +#else - T(YAFFS_TRACE_SCAN_DEBUG, @@ -12460,7 +13056,7 @@ - if (state == YAFFS_BLOCK_STATE_CHECKPOINT) { - dev->blocksInCheckpoint++; -+ retVal = (yaffs_UpdateObjectHeader(in, NULL, 0, 0, 0, NULL) >= ++ retVal = (yaffs_update_oh(in, NULL, 0, 0, 0, NULL) >= + 0) ? YAFFS_OK : YAFFS_FAIL; + } + } else { @@ -12485,12 +13081,12 @@ - blockIndex[nBlocksToScan].seq = sequenceNumber; - blockIndex[nBlocksToScan].block = blk; -+static int yaffs_DoGenericObjectDeletion(yaffs_Object *in) ++static int yaffs_generic_obj_del(yaffs_obj_t *in) +{ - nBlocksToScan++; + /* First off, invalidate the file's data in the cache, without flushing. */ -+ yaffs_InvalidateWholeChunkCache(in); ++ yaffs_invalidate_whole_cache(in); - if (sequenceNumber >= dev->sequenceNumber) - dev->sequenceNumber = sequenceNumber; @@ -12500,9 +13096,9 @@ - (TSTR - ("Block scanning block %d has bad sequence number %d" - TENDSTR), blk, sequenceNumber)); -+ if (in->myDev->param.isYaffs2 && (in->parent != in->myDev->deletedDir)) { ++ if (in->my_dev->param.is_yaffs2 && (in->parent != in->my_dev->del_dir)) { + /* Move to the unlinked directory so we have a record that it was deleted. */ -+ yaffs_ChangeObjectName(in, in->myDev->deletedDir, _Y("deleted"), 0, 0); ++ yaffs_change_obj_name(in, in->my_dev->del_dir, _Y("deleted"), 0, 0); - } - } @@ -12510,21 +13106,21 @@ - T(YAFFS_TRACE_SCAN, - (TSTR("%d blocks to be sorted..." TENDSTR), nBlocksToScan)); -+ yaffs_RemoveObjectFromDirectory(in); -+ yaffs_DeleteChunk(in->myDev, in->hdrChunk, 1, __LINE__); -+ in->hdrChunk = 0; ++ yaffs_remove_obj_from_dir(in); ++ yaffs_chunk_del(in->my_dev, in->hdr_chunk, 1, __LINE__); ++ in->hdr_chunk = 0; -+ yaffs_FreeObject(in); ++ yaffs_free_obj(in); + return YAFFS_OK; +} - YYIELD(); -+/* yaffs_DeleteFile deletes the whole file data ++/* yaffs_del_file deletes the whole file data + * and the inode associated with the file. + * It does not delete the links associated with the file. + */ -+static int yaffs_UnlinkFileIfNeeded(yaffs_Object *in) ++static int yaffs_unlink_file_if_needed(yaffs_obj_t *in) +{ - /* Sort the blocks */ @@ -12538,12 +13134,12 @@ - /* Dungy old bubble sort... */ + int retVal; + int immediateDeletion = 0; -+ yaffs_Device *dev = in->myDev; ++ yaffs_dev_t *dev = in->my_dev; - yaffs_BlockIndex temp; - int i; - int j; -+ if (!in->myInode) ++ if (!in->my_inode) + immediateDeletion = 1; - for (i = 0; i < nBlocksToScan; i++) @@ -12555,19 +13151,19 @@ - } + if (immediateDeletion) { + retVal = -+ yaffs_ChangeObjectName(in, in->myDev->deletedDir, ++ yaffs_change_obj_name(in, in->my_dev->del_dir, + _Y("deleted"), 0, 0); + T(YAFFS_TRACE_TRACING, + (TSTR("yaffs: immediate deletion of file %d" TENDSTR), -+ in->objectId)); ++ in->obj_id)); + in->deleted = 1; -+ in->myDev->nDeletedFiles++; -+ if (dev->param.disableSoftDelete || dev->param.isYaffs2) -+ yaffs_ResizeFile(in, 0); -+ yaffs_SoftDeleteFile(in); ++ in->my_dev->n_deleted_files++; ++ if (dev->param.disable_soft_del || dev->param.is_yaffs2) ++ yaffs_resize_file(in, 0); ++ yaffs_soft_del_file(in); + } else { + retVal = -+ yaffs_ChangeObjectName(in, in->myDev->unlinkedDir, ++ yaffs_change_obj_name(in, in->my_dev->unlinked_dir, + _Y("unlinked"), 0, 0); } -#endif @@ -12577,29 +13173,17 @@ - T(YAFFS_TRACE_SCAN, (TSTR("...done" TENDSTR))); + return retVal; +} -+ -+int yaffs_DeleteFile(yaffs_Object *in) -+{ -+ int retVal = YAFFS_OK; -+ int deleted; /* Need to cache value on stack if in is freed */ -+ yaffs_Device *dev = in->myDev; -+ -+ if (dev->param.disableSoftDelete || dev->param.isYaffs2) -+ yaffs_ResizeFile(in, 0); -+ -+ if (in->nDataChunks > 0) { -+ /* Use soft deletion if there is data in the file. -+ * That won't be the case if it has been resized to zero. -+ */ -+ if (!in->unlinked) -+ retVal = yaffs_UnlinkFileIfNeeded(in); - /* Now scan the blocks looking at the data. */ - startIterator = 0; - endIterator = nBlocksToScan - 1; - T(YAFFS_TRACE_SCAN_DEBUG, - (TSTR("%d blocks to be scanned" TENDSTR), nBlocksToScan)); -+ deleted = in->deleted; ++int yaffs_del_file(yaffs_obj_t *in) ++{ ++ int retVal = YAFFS_OK; ++ int deleted; /* Need to cache value on stack if in is freed */ ++ yaffs_dev_t *dev = in->my_dev; - /* For each block.... backwards */ - for (blockIterator = endIterator; !alloc_failed && blockIterator >= startIterator; @@ -12607,48 +13191,45 @@ - /* Cooperative multitasking! This loop can run for so - long that watchdog timers expire. */ - YYIELD(); ++ if (dev->param.disable_soft_del || dev->param.is_yaffs2) ++ yaffs_resize_file(in, 0); + +- /* get the block to scan in the correct order */ +- blk = blockIndex[blockIterator].block; ++ if (in->n_data_chunks > 0) { ++ /* Use soft deletion if there is data in the file. ++ * That won't be the case if it has been resized to zero. ++ */ ++ if (!in->unlinked) ++ retVal = yaffs_unlink_file_if_needed(in); + +- bi = yaffs_GetBlockInfo(dev, blk); ++ deleted = in->deleted; + + if (retVal == YAFFS_OK && in->unlinked && !in->deleted) { + in->deleted = 1; + deleted = 1; -+ in->myDev->nDeletedFiles++; -+ yaffs_SoftDeleteFile(in); ++ in->my_dev->n_deleted_files++; ++ yaffs_soft_del_file(in); + } + return deleted ? YAFFS_OK : YAFFS_FAIL; + } else { + /* The file has no data chunks so we toss it immediately */ -+ yaffs_FreeTnode(in->myDev, in->variant.fileVariant.top); -+ in->variant.fileVariant.top = NULL; -+ yaffs_DoGenericObjectDeletion(in); ++ yaffs_free_tnode(in->my_dev, in->variant.file_variant.top); ++ in->variant.file_variant.top = NULL; ++ yaffs_generic_obj_del(in); -- /* get the block to scan in the correct order */ -- blk = blockIndex[blockIterator].block; +- state = bi->blockState; + return YAFFS_OK; + } +} -- bi = yaffs_GetBlockInfo(dev, blk); -+static int yaffs_IsNonEmptyDirectory(yaffs_Object *obj) -+{ -+ return (obj->variantType == YAFFS_OBJECT_TYPE_DIRECTORY) && -+ !(ylist_empty(&obj->variant.directoryVariant.children)); -+} - -+static int yaffs_DeleteDirectory(yaffs_Object *obj) -+{ -+ /* First check that the directory is empty. */ -+ if (yaffs_IsNonEmptyDirectory(obj)) -+ return YAFFS_FAIL; - -- state = bi->blockState; -+ return yaffs_DoGenericObjectDeletion(obj); -+} - - deleted = 0; -+static int yaffs_DeleteSymLink(yaffs_Object *in) ++static int yaffs_is_non_empty_dir(yaffs_obj_t *obj) +{ -+ if(in->variant.symLinkVariant.alias) -+ YFREE(in->variant.symLinkVariant.alias); -+ in->variant.symLinkVariant.alias=NULL; ++ return (obj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY) && ++ !(ylist_empty(&obj->variant.dir_variant.children)); ++} - /* For each chunk in each block that needs scanning.... */ - foundChunksInBlock = 0; @@ -12659,51 +13240,26 @@ - /* Scan backwards... - * Read the tags and decide what to do - */ -+ return yaffs_DoGenericObjectDeletion(in); -+} ++static int yaffs_del_dir(yaffs_obj_t *obj) ++{ ++ /* First check that the directory is empty. */ ++ if (yaffs_is_non_empty_dir(obj)) ++ return YAFFS_FAIL; - chunk = blk * dev->nChunksPerBlock + c; -+static int yaffs_DeleteHardLink(yaffs_Object *in) -+{ -+ /* remove this hardlink from the list assocaited with the equivalent -+ * object -+ */ -+ ylist_del_init(&in->hardLinks); -+ return yaffs_DoGenericObjectDeletion(in); ++ return yaffs_generic_obj_del(obj); +} - result = yaffs_ReadChunkWithTagsFromNAND(dev, chunk, NULL, - &tags); -+int yaffs_DeleteObject(yaffs_Object *obj) ++static int yaffs_del_symlink(yaffs_obj_t *in) +{ -+int retVal = -1; -+ switch (obj->variantType) { -+ case YAFFS_OBJECT_TYPE_FILE: -+ retVal = yaffs_DeleteFile(obj); -+ break; -+ case YAFFS_OBJECT_TYPE_DIRECTORY: -+ if(!ylist_empty(&obj->variant.directoryVariant.dirty)){ -+ T(YAFFS_TRACE_BACKGROUND, (TSTR("Remove object %d from dirty directories" TENDSTR),obj->objectId)); -+ ylist_del_init(&obj->variant.directoryVariant.dirty); -+ } -+ return yaffs_DeleteDirectory(obj); -+ break; -+ case YAFFS_OBJECT_TYPE_SYMLINK: -+ retVal = yaffs_DeleteSymLink(obj); -+ break; -+ case YAFFS_OBJECT_TYPE_HARDLINK: -+ retVal = yaffs_DeleteHardLink(obj); -+ break; -+ case YAFFS_OBJECT_TYPE_SPECIAL: -+ retVal = yaffs_DoGenericObjectDeletion(obj); -+ break; -+ case YAFFS_OBJECT_TYPE_UNKNOWN: -+ retVal = 0; -+ break; /* should not happen. */ -+ } ++ if(in->variant.symlink_variant.alias) ++ YFREE(in->variant.symlink_variant.alias); ++ in->variant.symlink_variant.alias=NULL; - /* Let's have a good look at this chunk... */ -+ return retVal; ++ return yaffs_generic_obj_del(in); +} - if (!tags.chunkUsed) { @@ -12715,8 +13271,14 @@ - * chunk and his means that either the block is empty or - * this is the one being allocated from - */ -+static int yaffs_UnlinkWorker(yaffs_Object *obj) ++static int yaffs_del_link(yaffs_obj_t *in) +{ ++ /* remove this hardlink from the list assocaited with the equivalent ++ * object ++ */ ++ ylist_del_init(&in->hard_links); ++ return yaffs_generic_obj_del(in); ++} - if (foundChunksInBlock) { - /* This is a chunk that was skipped due to failing the erased check */ @@ -12754,11 +13316,37 @@ - } - } - } -+ int immediateDeletion = 0; ++int yaffs_del_obj(yaffs_obj_t *obj) ++{ ++int retVal = -1; ++ switch (obj->variant_type) { ++ case YAFFS_OBJECT_TYPE_FILE: ++ retVal = yaffs_del_file(obj); ++ break; ++ case YAFFS_OBJECT_TYPE_DIRECTORY: ++ if(!ylist_empty(&obj->variant.dir_variant.dirty)){ ++ T(YAFFS_TRACE_BACKGROUND, (TSTR("Remove object %d from dirty directories" TENDSTR),obj->obj_id)); ++ ylist_del_init(&obj->variant.dir_variant.dirty); ++ } ++ return yaffs_del_dir(obj); ++ break; ++ case YAFFS_OBJECT_TYPE_SYMLINK: ++ retVal = yaffs_del_symlink(obj); ++ break; ++ case YAFFS_OBJECT_TYPE_HARDLINK: ++ retVal = yaffs_del_link(obj); ++ break; ++ case YAFFS_OBJECT_TYPE_SPECIAL: ++ retVal = yaffs_generic_obj_del(obj); ++ break; ++ case YAFFS_OBJECT_TYPE_UNKNOWN: ++ retVal = 0; ++ break; /* should not happen. */ ++ } - dev->nFreeChunks++; -+ if (!obj->myInode) -+ immediateDeletion = 1; ++ return retVal; ++} - } else if (tags.eccResult == YAFFS_ECC_RESULT_UNFIXED) { - T(YAFFS_TRACE_SCAN, @@ -12787,8 +13375,8 @@ - /* Out of memory */ - alloc_failed = 1; - } -+ if(obj) -+ yaffs_UpdateParent(obj->parent); ++static int yaffs_unlink_worker(yaffs_obj_t *obj) ++{ - if (in && - in->variantType == YAFFS_OBJECT_TYPE_FILE @@ -12799,22 +13387,7 @@ - chunk, -1)) { - alloc_failed = 1; - } -+ if (obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK) { -+ return yaffs_DeleteHardLink(obj); -+ } else if (!ylist_empty(&obj->hardLinks)) { -+ /* Curve ball: We're unlinking an object that has a hardlink. -+ * -+ * This problem arises because we are not strictly following -+ * The Linux link/inode model. -+ * -+ * We can't really delete the object. -+ * Instead, we do the following: -+ * - Select a hardlink. -+ * - Unhook it from the hard links -+ * - Move it from its parent directory (so that the rename can work) -+ * - Rename the object to the hardlink's name. -+ * - Delete the hardlink -+ */ ++ int immediateDeletion = 0; - /* File size is calculated by looking at the data chunks if we have not - * seen an object header yet. Stop this practice once we find an object header. @@ -12834,15 +13407,14 @@ - in->variant.fileVariant. - scannedFileSize; - } -+ yaffs_Object *hl; -+ yaffs_Object *parent; -+ int retVal; -+ YCHAR name[YAFFS_MAX_NAME_LENGTH + 1]; ++ if (!obj->my_inode) ++ immediateDeletion = 1; - } else if (in) { - /* This chunk has been invalidated by a resize, so delete */ - yaffs_DeleteChunk(dev, chunk, 1, __LINE__); -+ hl = ylist_entry(obj->hardLinks.next, yaffs_Object, hardLinks); ++ if(obj) ++ yaffs_update_parent(obj->parent); - } - } else { @@ -12850,16 +13422,33 @@ - * Thus, we read in the object header and make the object - */ - foundChunksInBlock = 1; -+ yaffs_GetObjectName(hl, name, YAFFS_MAX_NAME_LENGTH + 1); -+ parent = hl->parent; ++ if (obj->variant_type == YAFFS_OBJECT_TYPE_HARDLINK) { ++ return yaffs_del_link(obj); ++ } else if (!ylist_empty(&obj->hard_links)) { ++ /* Curve ball: We're unlinking an object that has a hardlink. ++ * ++ * This problem arises because we are not strictly following ++ * The Linux link/inode model. ++ * ++ * We can't really delete the object. ++ * Instead, we do the following: ++ * - Select a hardlink. ++ * - Unhook it from the hard links ++ * - Move it from its parent directory (so that the rename can work) ++ * - Rename the object to the hardlink's name. ++ * - Delete the hardlink ++ */ - yaffs_SetChunkBit(dev, blk, c); - bi->pagesInUse++; -+ ylist_del_init(&hl->hardLinks); ++ yaffs_obj_t *hl; ++ yaffs_obj_t *parent; ++ int retVal; ++ YCHAR name[YAFFS_MAX_NAME_LENGTH + 1]; - oh = NULL; - in = NULL; -+ yaffs_AddObjectToDirectory(obj->myDev->unlinkedDir, hl); ++ hl = ylist_entry(obj->hard_links.next, yaffs_obj_t, hard_links); - if (tags.extraHeaderInfoAvailable) { - in = yaffs_FindOrCreateObjectByNumber @@ -12868,7 +13457,8 @@ - if (!in) - alloc_failed = 1; - } -+ retVal = yaffs_ChangeObjectName(obj,parent, name, 0, 0); ++ yaffs_get_obj_name(hl, name, YAFFS_MAX_NAME_LENGTH + 1); ++ parent = hl->parent; - if (!in || -#ifdef CONFIG_YAFFS_DISABLE_LAZY_LOAD @@ -12883,8 +13473,7 @@ - * TODO In future we can probably defer reading the chunk and - * living with invalid data until needed. - */ -+ if (retVal == YAFFS_OK) -+ retVal = yaffs_DoGenericObjectDeletion(hl); ++ ylist_del_init(&hl->hard_links); - result = yaffs_ReadChunkWithTagsFromNAND(dev, - chunk, @@ -12898,61 +13487,61 @@ - oh->shadowsObject = oh->inbandShadowsObject; - oh->isShrink = oh->inbandIsShrink; - } -+ return retVal; ++ yaffs_add_obj_to_dir(obj->my_dev->unlinked_dir, hl); - if (!in) { - in = yaffs_FindOrCreateObjectByNumber(dev, tags.objectId, oh->type); - if (!in) - alloc_failed = 1; - } ++ retVal = yaffs_change_obj_name(obj,parent, name, 0, 0); + +- } ++ if (retVal == YAFFS_OK) ++ retVal = yaffs_generic_obj_del(hl); + +- if (!in) { +- /* TODO Hoosterman we have a problem! */ +- T(YAFFS_TRACE_ERROR, +- (TSTR +- ("yaffs tragedy: Could not make object for object %d at chunk %d during scan" +- TENDSTR), tags.objectId, chunk)); +- continue; +- } ++ return retVal; + +- if (in->valid) { +- /* We have already filled this one. +- * We have a duplicate that will be discarded, but +- * we first have to suck out resize info if it is a file. +- */ + } else if (immediateDeletion) { -+ switch (obj->variantType) { ++ switch (obj->variant_type) { + case YAFFS_OBJECT_TYPE_FILE: -+ return yaffs_DeleteFile(obj); ++ return yaffs_del_file(obj); + break; + case YAFFS_OBJECT_TYPE_DIRECTORY: -+ ylist_del_init(&obj->variant.directoryVariant.dirty); -+ return yaffs_DeleteDirectory(obj); ++ ylist_del_init(&obj->variant.dir_variant.dirty); ++ return yaffs_del_dir(obj); + break; + case YAFFS_OBJECT_TYPE_SYMLINK: -+ return yaffs_DeleteSymLink(obj); ++ return yaffs_del_symlink(obj); + break; + case YAFFS_OBJECT_TYPE_SPECIAL: -+ return yaffs_DoGenericObjectDeletion(obj); ++ return yaffs_generic_obj_del(obj); + break; + case YAFFS_OBJECT_TYPE_HARDLINK: + case YAFFS_OBJECT_TYPE_UNKNOWN: + default: + return YAFFS_FAIL; + } -+ } else if(yaffs_IsNonEmptyDirectory(obj)) ++ } else if(yaffs_is_non_empty_dir(obj)) + return YAFFS_FAIL; + else -+ return yaffs_ChangeObjectName(obj, obj->myDev->unlinkedDir, ++ return yaffs_change_obj_name(obj, obj->my_dev->unlinked_dir, + _Y("unlinked"), 0, 0); +} -- } - -- if (!in) { -- /* TODO Hoosterman we have a problem! */ -- T(YAFFS_TRACE_ERROR, -- (TSTR -- ("yaffs tragedy: Could not make object for object %d at chunk %d during scan" -- TENDSTR), tags.objectId, chunk)); -- continue; -- } -+static int yaffs_UnlinkObject(yaffs_Object *obj) -+{ - -- if (in->valid) { -- /* We have already filled this one. -- * We have a duplicate that will be discarded, but -- * we first have to suck out resize info if it is a file. -- */ -+ if (obj && obj->unlinkAllowed) -+ return yaffs_UnlinkWorker(obj); - - if ((in->variantType == YAFFS_OBJECT_TYPE_FILE) && - ((oh && - oh->type == YAFFS_OBJECT_TYPE_FILE) || @@ -12970,7 +13559,6 @@ - isShrink = - (oh) ? oh->isShrink : tags. - extraIsShrinkHeader; -+ return YAFFS_FAIL; - /* If it is deleted (unlinked at start also means deleted) - * we treat the file size as being zeroed at this point. @@ -12982,10 +13570,8 @@ - thisSize = 0; - isShrink = 1; - } -+} -+int yaffs_Unlink(yaffs_Object *dir, const YCHAR *name) ++static int yaffs_unlink_obj(yaffs_obj_t *obj) +{ -+ yaffs_Object *obj; - if (isShrink && - in->variant.fileVariant. @@ -12994,27 +13580,25 @@ - shrinkSize = - thisSize; - } -+ obj = yaffs_FindObjectByName(dir, name); -+ return yaffs_UnlinkObject(obj); -+} ++ if (obj && obj->unlink_allowed) ++ return yaffs_unlink_worker(obj); - if (isShrink) - bi->hasShrinkHeader = 1; -+/*----------------------- Initialisation Scanning ---------------------- */ ++ return YAFFS_FAIL; - } - /* Use existing - destroy this one. */ - yaffs_DeleteChunk(dev, chunk, 1, __LINE__); -+void yaffs_HandleShadowedObject(yaffs_Device *dev, int objId, -+ int backwardScanning) ++} ++int yaffs_unlinker(yaffs_obj_t *dir, const YCHAR *name) +{ -+ yaffs_Object *obj; ++ yaffs_obj_t *obj; - } -+ if (!backwardScanning) { -+ /* Handle YAFFS1 forward scanning case -+ * For YAFFS1 we always do the deletion -+ */ ++ obj = yaffs_find_by_name(dir, name); ++ return yaffs_unlink_obj(obj); ++} - if (!in->valid && in->variantType != - (oh ? oh->type : tags.extraObjectType)) @@ -13033,29 +13617,14 @@ - YAFFS_OBJECTID_LOSTNFOUND)) { - /* We only load some info, don't fiddle with directory structure */ - in->valid = 1; -+ } else { -+ /* Handle YAFFS2 case (backward scanning) -+ * If the shadowed object exists then ignore. -+ */ -+ obj = yaffs_FindObjectByNumber(dev, objId); -+ if(obj) -+ return; -+ } ++/*----------------------- Initialisation Scanning ---------------------- */ - if (oh) { - in->variantType = oh->type; -+ /* Let's create it (if it does not exist) assuming it is a file so that it can do shrinking etc. -+ * We put it in unlinked dir to be cleaned up after the scanning -+ */ -+ obj = -+ yaffs_FindOrCreateObjectByNumber(dev, objId, -+ YAFFS_OBJECT_TYPE_FILE); -+ if (!obj) -+ return; -+ obj->isShadowed = 1; -+ yaffs_AddObjectToDirectory(dev->unlinkedDir, obj); -+ obj->variant.fileVariant.shrinkSize = 0; -+ obj->valid = 1; /* So that we don't read any other info for this file */ ++void yaffs_handle_shadowed_obj(yaffs_dev_t *dev, int obj_id, ++ int backward_scanning) ++{ ++ yaffs_obj_t *obj; - in->yst_mode = oh->yst_mode; -#ifdef CONFIG_YAFFS_WINCE @@ -13072,44 +13641,52 @@ - in->yst_mtime = oh->yst_mtime; - in->yst_ctime = oh->yst_ctime; - in->yst_rdev = oh->yst_rdev; -+} ++ if (!backward_scanning) { ++ /* Handle YAFFS1 forward scanning case ++ * For YAFFS1 we always do the deletion ++ */ -#endif - } else { - in->variantType = tags.extraObjectType; - in->lazyLoaded = 1; - } ++ } else { ++ /* Handle YAFFS2 case (backward scanning) ++ * If the shadowed object exists then ignore. ++ */ ++ obj = yaffs_find_by_number(dev, obj_id); ++ if(obj) ++ return; ++ } - in->hdrChunk = chunk; -+void yaffs_HardlinkFixup(yaffs_Device *dev, yaffs_Object *hardList) -+{ -+ yaffs_Object *hl; -+ yaffs_Object *in; ++ /* Let's create it (if it does not exist) assuming it is a file so that it can do shrinking etc. ++ * We put it in unlinked dir to be cleaned up after the scanning ++ */ ++ obj = ++ yaffs_find_or_create_by_number(dev, obj_id, ++ YAFFS_OBJECT_TYPE_FILE); ++ if (!obj) ++ return; ++ obj->is_shadowed = 1; ++ yaffs_add_obj_to_dir(dev->unlinked_dir, obj); ++ obj->variant.file_variant.shrink_size = 0; ++ obj->valid = 1; /* So that we don't read any other info for this file */ - } else if (!in->valid) { - /* we need to load this info */ -+ while (hardList) { -+ hl = hardList; -+ hardList = (yaffs_Object *) (hardList->hardLinks.next); ++} - in->valid = 1; - in->hdrChunk = chunk; -+ in = yaffs_FindObjectByNumber(dev, -+ hl->variant.hardLinkVariant. -+ equivalentObjectId); - if (oh) { - in->variantType = oh->type; -+ if (in) { -+ /* Add the hardlink pointers */ -+ hl->variant.hardLinkVariant.equivalentObject = in; -+ ylist_add(&hl->hardLinks, &in->hardLinks); -+ } else { -+ /* Todo Need to report/handle this better. -+ * Got a problem... hardlink to a non-existant object -+ */ -+ hl->variant.hardLinkVariant.equivalentObject = NULL; -+ YINIT_LIST_HEAD(&hl->hardLinks); ++void yaffs_link_fixup(yaffs_dev_t *dev, yaffs_obj_t *hard_list) ++{ ++ yaffs_obj_t *hl; ++ yaffs_obj_t *in; - in->yst_mode = oh->yst_mode; -#ifdef CONFIG_YAFFS_WINCE @@ -13127,9 +13704,13 @@ - in->yst_ctime = oh->yst_ctime; - in->yst_rdev = oh->yst_rdev; -#endif -+ } -+ } -+} ++ while (hard_list) { ++ hl = hard_list; ++ hard_list = (yaffs_obj_t *) (hard_list->hard_links.next); ++ ++ in = yaffs_find_by_number(dev, ++ hl->variant.hardlink_variant. ++ equiv_id); - if (oh->shadowsObject > 0) - yaffs_HandleShadowedObject(dev, @@ -13147,6 +13728,16 @@ - fileSize = oh->fileSize; - isShrink = oh->isShrink; - equivalentObjectId = oh->equivalentObjectId; ++ if (in) { ++ /* Add the hardlink pointers */ ++ hl->variant.hardlink_variant.equiv_obj = in; ++ ylist_add(&hl->hard_links, &in->hard_links); ++ } else { ++ /* Todo Need to report/handle this better. ++ * Got a problem... hardlink to a non-existant object ++ */ ++ hl->variant.hardlink_variant.equiv_obj = NULL; ++ YINIT_LIST_HEAD(&hl->hard_links); - } else { - in->variantType = tags.extraObjectType; @@ -13158,41 +13749,29 @@ - isShrink = tags.extraIsShrinkHeader; - equivalentObjectId = tags.extraEquivalentObjectId; - in->lazyLoaded = 1; -+static void yaffs_StripDeletedObjects(yaffs_Device *dev) -+{ -+ /* -+ * Sort out state of unlinked and deleted objects after scanning. -+ */ -+ struct ylist_head *i; -+ struct ylist_head *n; -+ yaffs_Object *l; ++ } ++ } ++} - } - in->dirty = 0; -+ if (dev->readOnly) -+ return; - if (!parent) - alloc_failed = 1; -+ /* Soft delete all the unlinked files */ -+ ylist_for_each_safe(i, n, -+ &dev->unlinkedDir->variant.directoryVariant.children) { -+ if (i) { -+ l = ylist_entry(i, yaffs_Object, siblings); -+ yaffs_DeleteObject(l); -+ } -+ } ++static void yaffs_strip_deleted_objs(yaffs_dev_t *dev) ++{ ++ /* ++ * Sort out state of unlinked and deleted objects after scanning. ++ */ ++ struct ylist_head *i; ++ struct ylist_head *n; ++ yaffs_obj_t *l; - /* directory stuff... - * hook up to parent - */ -+ ylist_for_each_safe(i, n, -+ &dev->deletedDir->variant.directoryVariant.children) { -+ if (i) { -+ l = ylist_entry(i, yaffs_Object, siblings); -+ yaffs_DeleteObject(l); -+ } -+ } ++ if (dev->read_only) ++ return; - if (parent && parent->variantType == - YAFFS_OBJECT_TYPE_UNKNOWN) { @@ -13207,7 +13786,14 @@ - /* Hoosterman, another problem.... - * We're trying to use a non-directory as a directory - */ -+} ++ /* Soft delete all the unlinked files */ ++ ylist_for_each_safe(i, n, ++ &dev->unlinked_dir->variant.dir_variant.children) { ++ if (i) { ++ l = ylist_entry(i, yaffs_obj_t, siblings); ++ yaffs_del_obj(l); ++ } ++ } - T(YAFFS_TRACE_ERROR, - (TSTR @@ -13215,6 +13801,19 @@ - TENDSTR))); - parent = dev->lostNFoundDir; - } ++ ylist_for_each_safe(i, n, ++ &dev->del_dir->variant.dir_variant.children) { ++ if (i) { ++ l = ylist_entry(i, yaffs_obj_t, siblings); ++ yaffs_del_obj(l); ++ } ++ } + +- yaffs_AddObjectToDirectory(parent, in); ++} + +- itsUnlinked = (parent == dev->deletedDir) || +- (parent == dev->unlinkedDir); +/* + * This code iterates through all the objects making sure that they are rooted. + * Any unrooted objects are re-rooted in lost+found. @@ -13225,70 +13824,42 @@ + * Note: + * This code assumes that we don't ever change the current relationships between + * directories: -+ * rootDir->parent == unlinkedDir->parent == deletedDir->parent == NULL -+ * lostNfound->parent == rootDir ++ * root_dir->parent == unlinked_dir->parent == del_dir->parent == NULL ++ * lostNfound->parent == root_dir + * + * This fixes the problem where directories might have inadvertently been deleted + * leaving the object "hanging" without being rooted in the directory tree. + */ + -+static int yaffs_HasNULLParent(yaffs_Device *dev, yaffs_Object *obj) ++static int yaffs_has_null_parent(yaffs_dev_t *dev, yaffs_obj_t *obj) +{ -+ return (obj == dev->deletedDir || -+ obj == dev->unlinkedDir|| -+ obj == dev->rootDir); ++ return (obj == dev->del_dir || ++ obj == dev->unlinked_dir|| ++ obj == dev->root_dir); +} -- yaffs_AddObjectToDirectory(parent, in); -+static void yaffs_FixHangingObjects(yaffs_Device *dev) +- if (isShrink) { +- /* Mark the block as having a shrinkHeader */ +- bi->hasShrinkHeader = 1; +- } ++static void yaffs_fix_hanging_objs(yaffs_dev_t *dev) +{ -+ yaffs_Object *obj; -+ yaffs_Object *parent; ++ yaffs_obj_t *obj; ++ yaffs_obj_t *parent; + int i; + struct ylist_head *lh; + struct ylist_head *n; + int depthLimit; + int hanging; -- itsUnlinked = (parent == dev->deletedDir) || -- (parent == dev->unlinkedDir); -+ if (dev->readOnly) -+ return; - -- if (isShrink) { -- /* Mark the block as having a shrinkHeader */ -- bi->hasShrinkHeader = 1; -- } -+ /* Iterate through the objects in each hash entry, -+ * looking at each object. -+ * Make sure it is rooted. -+ */ - - /* Note re hardlinks. - * Since we might scan a hardlink before its equivalent object is scanned - * we put them all in a list. - * After scanning is complete, we should have all the objects, so we run - * through this list and fix up all the chains. -+ for (i = 0; i < YAFFS_NOBJECT_BUCKETS; i++) { -+ ylist_for_each_safe(lh, n, &dev->objectBucket[i].list) { -+ if (lh) { -+ obj = ylist_entry(lh, yaffs_Object, hashLink); -+ parent= obj->parent; -+ -+ if(yaffs_HasNULLParent(dev,obj)){ -+ /* These directories are not hanging */ -+ hanging = 0; -+ } -+ else if(!parent || parent->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) -+ hanging = 1; -+ else if(yaffs_HasNULLParent(dev,parent)) -+ hanging = 0; -+ else { -+ /* -+ * Need to follow the parent chain to see if it is hanging. - */ -+ hanging = 0; -+ depthLimit=100; +- */ ++ if (dev->read_only) ++ return; - switch (in->variantType) { - case YAFFS_OBJECT_TYPE_UNKNOWN: @@ -13307,12 +13878,36 @@ - in->variant.fileVariant.scannedFileSize = - in->variant.fileVariant.fileSize; - } -- ++ /* Iterate through the objects in each hash entry, ++ * looking at each object. ++ * Make sure it is rooted. ++ */ + - if (isShrink && - in->variant.fileVariant.shrinkSize > fileSize) { - in->variant.fileVariant.shrinkSize = fileSize; - } -- ++ for (i = 0; i < YAFFS_NOBJECT_BUCKETS; i++) { ++ ylist_for_each_safe(lh, n, &dev->obj_bucket[i].list) { ++ if (lh) { ++ obj = ylist_entry(lh, yaffs_obj_t, hash_link); ++ parent= obj->parent; ++ ++ if(yaffs_has_null_parent(dev,obj)){ ++ /* These directories are not hanging */ ++ hanging = 0; ++ } ++ else if(!parent || parent->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) ++ hanging = 1; ++ else if(yaffs_has_null_parent(dev,parent)) ++ hanging = 0; ++ else { ++ /* ++ * Need to follow the parent chain to see if it is hanging. ++ */ ++ hanging = 0; ++ depthLimit=100; + - break; - case YAFFS_OBJECT_TYPE_HARDLINK: - if (!itsUnlinked) { @@ -13337,22 +13932,22 @@ - alloc_failed = 1; - } - break; -+ while(parent != dev->rootDir && ++ while(parent != dev->root_dir && + parent->parent && -+ parent->parent->variantType == YAFFS_OBJECT_TYPE_DIRECTORY && ++ parent->parent->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY && + depthLimit > 0){ + parent = parent->parent; + depthLimit--; } - -+ if(parent != dev->rootDir) ++ if(parent != dev->root_dir) + hanging = 1; + } + if(hanging){ + T(YAFFS_TRACE_SCAN, + (TSTR("Hanging object %d moved to lost and found" TENDSTR), -+ obj->objectId)); -+ yaffs_AddObjectToDirectory(dev->lostNFoundDir,obj); ++ obj->obj_id)); ++ yaffs_add_obj_to_dir(dev->lost_n_found,obj); } - } @@ -13369,25 +13964,25 @@ +/* + * Delete directory contents for cleaning up lost and found. + */ -+static void yaffs_DeleteDirectoryContents(yaffs_Object *dir) ++static void yaffs_del_dir_contents(yaffs_obj_t *dir) +{ -+ yaffs_Object *obj; ++ yaffs_obj_t *obj; + struct ylist_head *lh; + struct ylist_head *n; - bi->blockState = state; -+ if(dir->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) ++ if(dir->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) + YBUG(); + -+ ylist_for_each_safe(lh, n, &dir->variant.directoryVariant.children) { ++ ylist_for_each_safe(lh, n, &dir->variant.dir_variant.children) { + if (lh) { -+ obj = ylist_entry(lh, yaffs_Object, siblings); -+ if(obj->variantType == YAFFS_OBJECT_TYPE_DIRECTORY) -+ yaffs_DeleteDirectoryContents(obj); ++ obj = ylist_entry(lh, yaffs_obj_t, siblings); ++ if(obj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY) ++ yaffs_del_dir_contents(obj); + + T(YAFFS_TRACE_SCAN, + (TSTR("Deleting lost_found object %d" TENDSTR), -+ obj->objectId)); ++ obj->obj_id)); - /* Now let's see if it was dirty */ - if (bi->pagesInUse == 0 && @@ -13397,7 +13992,7 @@ + /* Need to use UnlinkObject since Delete would not handle + * hardlinked objects correctly. + */ -+ yaffs_UnlinkObject(obj); ++ yaffs_unlink_obj(obj); } - } @@ -13408,9 +14003,9 @@ - YFREE_ALT(blockIndex); - else - YFREE(blockIndex); -+static void yaffs_EmptyLostAndFound(yaffs_Device *dev) ++static void yaffs_empty_l_n_f(yaffs_dev_t *dev) +{ -+ yaffs_DeleteDirectoryContents(dev->lostNFoundDir); ++ yaffs_del_dir_contents(dev->lost_n_found); +} - /* Ok, we've done all the scanning. @@ -13419,12 +14014,12 @@ - * hardlinks. - */ - yaffs_HardlinkFixup(dev, hardList); -+static void yaffs_CheckObjectDetailsLoaded(yaffs_Object *in) ++static void yaffs_check_obj_details_loaded(yaffs_obj_t *in) +{ + __u8 *chunkData; -+ yaffs_ObjectHeader *oh; -+ yaffs_Device *dev; -+ yaffs_ExtendedTags tags; ++ yaffs_obj_header *oh; ++ yaffs_dev_t *dev; ++ yaffs_ext_tags tags; + int result; + int alloc_failed = 0; @@ -13432,25 +14027,25 @@ + return; - yaffs_ReleaseTempBuffer(dev, chunkData, __LINE__); -+ dev = in->myDev; ++ dev = in->my_dev; - if (alloc_failed) - return YAFFS_FAIL; +#if 0 + T(YAFFS_TRACE_SCAN, (TSTR("details for object %d %s loaded" TENDSTR), -+ in->objectId, -+ in->lazyLoaded ? "not yet" : "already")); ++ in->obj_id, ++ in->lazy_loaded ? "not yet" : "already")); +#endif - T(YAFFS_TRACE_SCAN, (TSTR("yaffs_ScanBackwards ends" TENDSTR))); -+ if (in->lazyLoaded && in->hdrChunk > 0) { -+ in->lazyLoaded = 0; -+ chunkData = yaffs_GetTempBuffer(dev, __LINE__); ++ if (in->lazy_loaded && in->hdr_chunk > 0) { ++ in->lazy_loaded = 0; ++ chunkData = yaffs_get_temp_buffer(dev, __LINE__); - return YAFFS_OK; -} -+ result = yaffs_ReadChunkWithTagsFromNAND(dev, in->hdrChunk, chunkData, &tags); -+ oh = (yaffs_ObjectHeader *) chunkData; ++ result = yaffs_rd_chunk_tags_nand(dev, in->hdr_chunk, chunkData, &tags); ++ oh = (yaffs_obj_header *) chunkData; -/*------------------------------ Directory Functions ----------------------------- */ + in->yst_mode = oh->yst_mode; @@ -13474,13 +14069,13 @@ - struct ylist_head *lh; - yaffs_Object *listObj; +#endif -+ yaffs_SetObjectNameFromOH(in, oh); ++ yaffs_set_obj_name_from_oh(in, oh); - int count = 0; -+ if (in->variantType == YAFFS_OBJECT_TYPE_SYMLINK) { -+ in->variant.symLinkVariant.alias = -+ yaffs_CloneString(oh->alias); -+ if (!in->variant.symLinkVariant.alias) ++ if (in->variant_type == YAFFS_OBJECT_TYPE_SYMLINK) { ++ in->variant.symlink_variant.alias = ++ yaffs_clone_str(oh->alias); ++ if (!in->variant.symlink_variant.alias) + alloc_failed = 1; /* Not returned to caller */ + } @@ -13488,7 +14083,7 @@ - T(YAFFS_TRACE_ALWAYS, (TSTR("No object to verify" TENDSTR))); - YBUG(); - return; -+ yaffs_ReleaseTempBuffer(dev, chunkData, __LINE__); ++ yaffs_release_temp_buffer(dev, chunkData, __LINE__); } +} @@ -13500,7 +14095,7 @@ - T(YAFFS_TRACE_ALWAYS, (TSTR("Object does not have parent" TENDSTR))); - YBUG(); +/* -+ *yaffs_UpdateParent() handles fixing a directories mtime and ctime when a new ++ *yaffs_update_parent() handles fixing a directories mtime and ctime when a new + * link (ie. name) is created or deleted in the directory. + * + * ie. @@ -13511,13 +14106,13 @@ + * This can be handled immediately or defered. Defering helps reduce the number + * of updates when many files in a directory are changed within a brief period. + * -+ * If the directory updating is defered then yaffs_UpdateDirtyDirecories must be ++ * If the directory updating is defered then yaffs_update_dirty_dirs must be + * called periodically. + */ + -+static void yaffs_UpdateParent(yaffs_Object *obj) ++static void yaffs_update_parent(yaffs_obj_t *obj) +{ -+ yaffs_Device *dev; ++ yaffs_dev_t *dev; + if(!obj) return; - } @@ -13536,15 +14131,15 @@ - yaffs_VerifyObject(listObj); - if (obj == listObj) - count++; -+ dev = obj->myDev; ++ dev = obj->my_dev; + obj->dirty = 1; + obj->yst_mtime = obj->yst_ctime = Y_CURRENT_TIME; -+ if(dev->param.deferDirectoryUpdate){ -+ struct ylist_head *link = &obj->variant.directoryVariant.dirty; ++ if(dev->param.defered_dir_update){ ++ struct ylist_head *link = &obj->variant.dir_variant.dirty; + + if(ylist_empty(link)){ -+ ylist_add(link,&dev->dirtyDirectories); -+ T(YAFFS_TRACE_BACKGROUND, (TSTR("Added object %d to dirty directories" TENDSTR),obj->objectId)); ++ ylist_add(link,&dev->dirty_dirs); ++ T(YAFFS_TRACE_BACKGROUND, (TSTR("Added object %d to dirty directories" TENDSTR),obj->obj_id)); } - } @@ -13553,12 +14148,12 @@ - YBUG(); - } + } else -+ yaffs_UpdateObjectHeader(obj, NULL, 0, 0, 0, NULL); ++ yaffs_update_oh(obj, NULL, 0, 0, 0, NULL); +#endif } -static void yaffs_VerifyDirectory(yaffs_Object *directory) -+void yaffs_UpdateDirtyDirectories(yaffs_Device *dev) ++void yaffs_update_dirty_dirs(yaffs_dev_t *dev) { - struct ylist_head *lh; - yaffs_Object *listObj; @@ -13568,9 +14163,9 @@ - return; - } + struct ylist_head *link; -+ yaffs_Object *obj; -+ yaffs_DirectoryStructure *dS; -+ yaffs_ObjectVariant *oV; ++ yaffs_obj_t *obj; ++ yaffs_dir_s *dS; ++ yaffs_obj_variant *oV; - if (yaffs_SkipFullVerification(directory->myDev)) - return; @@ -13580,16 +14175,16 @@ - T(YAFFS_TRACE_ALWAYS, (TSTR("Directory has wrong type: %d" TENDSTR), directory->variantType)); - YBUG(); - } -+ while(!ylist_empty(&dev->dirtyDirectories)){ -+ link = dev->dirtyDirectories.next; ++ while(!ylist_empty(&dev->dirty_dirs)){ ++ link = dev->dirty_dirs.next; + ylist_del_init(link); + -+ dS=ylist_entry(link,yaffs_DirectoryStructure,dirty); -+ oV = ylist_entry(dS,yaffs_ObjectVariant,directoryVariant); -+ obj = ylist_entry(oV,yaffs_Object,variant); ++ dS=ylist_entry(link,yaffs_dir_s,dirty); ++ oV = ylist_entry(dS,yaffs_obj_variant,dir_variant); ++ obj = ylist_entry(oV,yaffs_obj_t,variant); - /* Iterate through the objects in each hash entry */ -+ T(YAFFS_TRACE_BACKGROUND, (TSTR("Update directory %d" TENDSTR), obj->objectId)); ++ T(YAFFS_TRACE_BACKGROUND, (TSTR("Update directory %d" TENDSTR), obj->obj_id)); - ylist_for_each(lh, &directory->variant.directoryVariant.children) { - if (lh) { @@ -13601,47 +14196,211 @@ - yaffs_VerifyObjectInDirectory(listObj); - } + if(obj->dirty) -+ yaffs_UpdateObjectHeader(obj, NULL, 0, 0, 0, NULL); ++ yaffs_update_oh(obj, NULL, 0, 0, 0, NULL); } } - - static void yaffs_RemoveObjectFromDirectory(yaffs_Object *obj) +-static void yaffs_RemoveObjectFromDirectory(yaffs_Object *obj) ++static void yaffs_remove_obj_from_dir(yaffs_obj_t *obj) { - yaffs_Device *dev = obj->myDev; -@@ -6677,18 +4474,17 @@ static void yaffs_RemoveObjectFromDirect +- yaffs_Device *dev = obj->myDev; +- yaffs_Object *parent; ++ yaffs_dev_t *dev = obj->my_dev; ++ yaffs_obj_t *parent; - yaffs_VerifyDirectory(parent); +- yaffs_VerifyObjectInDirectory(obj); ++ yaffs_verify_obj_in_dir(obj); + parent = obj->parent; + +- yaffs_VerifyDirectory(parent); ++ yaffs_verify_dir(parent); - if (dev && dev->removeObjectCallback) - dev->removeObjectCallback(obj); -+ if (dev && dev->param.removeObjectCallback) -+ dev->param.removeObjectCallback(obj); ++ if (dev && dev->param.remove_obj_fn) ++ dev->param.remove_obj_fn(obj); ylist_del_init(&obj->siblings); obj->parent = NULL; - +- yaffs_VerifyDirectory(parent); + - yaffs_VerifyDirectory(parent); ++ yaffs_verify_dir(parent); } - -static void yaffs_AddObjectToDirectory(yaffs_Object *directory, -+void yaffs_AddObjectToDirectory(yaffs_Object *directory, - yaffs_Object *obj) +- yaffs_Object *obj) ++void yaffs_add_obj_to_dir(yaffs_obj_t *directory, ++ yaffs_obj_t *obj) + { + if (!directory) { + T(YAFFS_TRACE_ALWAYS, +@@ -6699,7 +4495,7 @@ static void yaffs_AddObjectToDirectory(y + YBUG(); + return; + } +- if (directory->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) { ++ if (directory->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) { + T(YAFFS_TRACE_ALWAYS, + (TSTR + ("tragedy: Trying to add an object to a non-directory" +@@ -6713,27 +4509,27 @@ static void yaffs_AddObjectToDirectory(y + } + + +- yaffs_VerifyDirectory(directory); ++ yaffs_verify_dir(directory); + +- yaffs_RemoveObjectFromDirectory(obj); ++ yaffs_remove_obj_from_dir(obj); + + + /* Now add it */ +- ylist_add(&obj->siblings, &directory->variant.directoryVariant.children); ++ ylist_add(&obj->siblings, &directory->variant.dir_variant.children); + obj->parent = directory; + +- if (directory == obj->myDev->unlinkedDir +- || directory == obj->myDev->deletedDir) { ++ if (directory == obj->my_dev->unlinked_dir ++ || directory == obj->my_dev->del_dir) { + obj->unlinked = 1; +- obj->myDev->nUnlinkedFiles++; +- obj->renameAllowed = 0; ++ obj->my_dev->n_unlinked_files++; ++ obj->rename_allowed = 0; + } + +- yaffs_VerifyDirectory(directory); +- yaffs_VerifyObjectInDirectory(obj); ++ yaffs_verify_dir(directory); ++ yaffs_verify_obj_in_dir(obj); + } + +-yaffs_Object *yaffs_FindObjectByName(yaffs_Object *directory, ++yaffs_obj_t *yaffs_find_by_name(yaffs_obj_t *directory, + const YCHAR *name) { + int sum; +@@ -6741,7 +4537,7 @@ yaffs_Object *yaffs_FindObjectByName(yaf + struct ylist_head *i; + YCHAR buffer[YAFFS_MAX_NAME_LENGTH + 1]; + +- yaffs_Object *l; ++ yaffs_obj_t *l; + + if (!name) + return NULL; +@@ -6749,39 +4545,39 @@ yaffs_Object *yaffs_FindObjectByName(yaf if (!directory) { -@@ -6781,7 +4577,7 @@ yaffs_Object *yaffs_FindObjectByName(yaf + T(YAFFS_TRACE_ALWAYS, + (TSTR +- ("tragedy: yaffs_FindObjectByName: null pointer directory" ++ ("tragedy: yaffs_find_by_name: null pointer directory" + TENDSTR))); + YBUG(); + return NULL; + } +- if (directory->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) { ++ if (directory->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) { + T(YAFFS_TRACE_ALWAYS, + (TSTR +- ("tragedy: yaffs_FindObjectByName: non-directory" TENDSTR))); ++ ("tragedy: yaffs_find_by_name: non-directory" TENDSTR))); + YBUG(); + } + +- sum = yaffs_CalcNameSum(name); ++ sum = yaffs_calc_name_sum(name); + +- ylist_for_each(i, &directory->variant.directoryVariant.children) { ++ ylist_for_each(i, &directory->variant.dir_variant.children) { + if (i) { +- l = ylist_entry(i, yaffs_Object, siblings); ++ l = ylist_entry(i, yaffs_obj_t, siblings); + + if (l->parent != directory) + YBUG(); + +- yaffs_CheckObjectDetailsLoaded(l); ++ yaffs_check_obj_details_loaded(l); + + /* Special case for lost-n-found */ +- if (l->objectId == YAFFS_OBJECTID_LOSTNFOUND) { ++ if (l->obj_id == YAFFS_OBJECTID_LOSTNFOUND) { + if (yaffs_strcmp(name, YAFFS_LOSTNFOUND_NAME) == 0) + return l; +- } else if (yaffs_SumCompare(l->sum, sum) || l->hdrChunk <= 0) { ++ } else if (yaffs_sum_cmp(l->sum, sum) || l->hdr_chunk <= 0) { + /* LostnFound chunk called Objxxx * Do a real check */ - yaffs_GetObjectName(l, buffer, +- yaffs_GetObjectName(l, buffer, - YAFFS_MAX_NAME_LENGTH); ++ yaffs_get_obj_name(l, buffer, + YAFFS_MAX_NAME_LENGTH + 1); if (yaffs_strncmp(name, buffer, YAFFS_MAX_NAME_LENGTH) == 0) return l; } -@@ -6842,36 +4638,124 @@ yaffs_Object *yaffs_GetEquivalentObject( +@@ -6793,31 +4589,31 @@ yaffs_Object *yaffs_FindObjectByName(yaf + + + #if 0 +-int yaffs_ApplyToDirectoryChildren(yaffs_Object *theDir, +- int (*fn) (yaffs_Object *)) ++int yaffs_ApplyToDirectoryChildren(yaffs_obj_t *the_dir, ++ int (*fn) (yaffs_obj_t *)) + { + struct ylist_head *i; +- yaffs_Object *l; ++ yaffs_obj_t *l; + +- if (!theDir) { ++ if (!the_dir) { + T(YAFFS_TRACE_ALWAYS, + (TSTR +- ("tragedy: yaffs_FindObjectByName: null pointer directory" ++ ("tragedy: yaffs_find_by_name: null pointer directory" + TENDSTR))); + YBUG(); + return YAFFS_FAIL; + } +- if (theDir->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) { ++ if (the_dir->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) { + T(YAFFS_TRACE_ALWAYS, + (TSTR +- ("tragedy: yaffs_FindObjectByName: non-directory" TENDSTR))); ++ ("tragedy: yaffs_find_by_name: non-directory" TENDSTR))); + YBUG(); + return YAFFS_FAIL; + } + +- ylist_for_each(i, &theDir->variant.directoryVariant.children) { ++ ylist_for_each(i, &the_dir->variant.dir_variant.children) { + if (i) { +- l = ylist_entry(i, yaffs_Object, siblings); ++ l = ylist_entry(i, yaffs_obj_t, siblings); + if (l && !fn(l)) + return YAFFS_FAIL; + } +@@ -6832,82 +4628,175 @@ int yaffs_ApplyToDirectoryChildren(yaffs + * actual object. + */ + +-yaffs_Object *yaffs_GetEquivalentObject(yaffs_Object *obj) ++yaffs_obj_t *yaffs_get_equivalent_obj(yaffs_obj_t *obj) + { +- if (obj && obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK) { ++ if (obj && obj->variant_type == YAFFS_OBJECT_TYPE_HARDLINK) { + /* We want the object id of the equivalent object, not this one */ +- obj = obj->variant.hardLinkVariant.equivalentObject; +- yaffs_CheckObjectDetailsLoaded(obj); ++ obj = obj->variant.hardlink_variant.equiv_obj; ++ yaffs_check_obj_details_loaded(obj); + } return obj; } @@ -13672,14 +14431,15 @@ - yaffs_strncpy(name, YAFFS_LOSTNFOUND_NAME, buffSize - 1); - } else if (obj->hdrChunk <= 0) { + */ -+static void yaffs_FixNullName(yaffs_Object * obj,YCHAR * name, int buffSize) ++static void yaffs_fix_null_name(yaffs_obj_t * obj,YCHAR * name, int buffer_size) +{ + /* Create an object name if we could not find one. */ + if(yaffs_strnlen(name,YAFFS_MAX_NAME_LENGTH) == 0){ YCHAR locName[20]; YCHAR numString[20]; YCHAR *x = &numString[19]; - unsigned v = obj->objectId; +- unsigned v = obj->objectId; ++ unsigned v = obj->obj_id; numString[19] = 0; - while (v > 0) { + while(v>0){ @@ -13690,15 +14450,16 @@ /* make up a name */ yaffs_strcpy(locName, YAFFS_LOSTNFOUND_PREFIX); - yaffs_strcat(locName, x); +- yaffs_strncpy(name, locName, buffSize - 1); + yaffs_strcat(locName,x); - yaffs_strncpy(name, locName, buffSize - 1); ++ yaffs_strncpy(name, locName, buffer_size - 1); + } +} + -+static void yaffs_LoadNameFromObjectHeader(yaffs_Device *dev,YCHAR *name, const YCHAR *ohName, int bufferSize) ++static void yaffs_load_name_from_oh(yaffs_dev_t *dev,YCHAR *name, const YCHAR *ohName, int bufferSize) +{ +#ifdef CONFIG_YAFFS_AUTO_UNICODE -+ if(dev->param.autoUnicode){ ++ if(dev->param.auto_unicode){ + if(*ohName){ + /* It is an ASCII name, so do an ASCII to unicode conversion */ + const char *asciiOhName = (const char *)ohName; @@ -13717,14 +14478,14 @@ +} + + -+static void yaffs_LoadObjectHeaderFromName(yaffs_Device *dev, YCHAR *ohName, const YCHAR *name) ++static void yaffs_load_oh_from_name(yaffs_dev_t *dev, YCHAR *ohName, const YCHAR *name) +{ +#ifdef CONFIG_YAFFS_AUTO_UNICODE + + int isAscii; + YCHAR *w; - -+ if(dev->param.autoUnicode){ ++ ++ if(dev->param.auto_unicode){ + + isAscii = 1; + w = name; @@ -13735,7 +14496,7 @@ + isAscii = 0; + w++; + } -+ + + if(isAscii){ + /* It is an ASCII name, so do a unicode to ascii conversion */ + char *asciiOhName = (char *)ohName; @@ -13758,78 +14519,178 @@ + +} + -+int yaffs_GetObjectName(yaffs_Object * obj, YCHAR * name, int buffSize) ++int yaffs_get_obj_name(yaffs_obj_t * obj, YCHAR * name, int buffer_size) +{ -+ memset(name, 0, buffSize * sizeof(YCHAR)); ++ memset(name, 0, buffer_size * sizeof(YCHAR)); + -+ yaffs_CheckObjectDetailsLoaded(obj); ++ yaffs_check_obj_details_loaded(obj); + -+ if (obj->objectId == YAFFS_OBJECTID_LOSTNFOUND) { -+ yaffs_strncpy(name, YAFFS_LOSTNFOUND_NAME, buffSize - 1); ++ if (obj->obj_id == YAFFS_OBJECTID_LOSTNFOUND) { ++ yaffs_strncpy(name, YAFFS_LOSTNFOUND_NAME, buffer_size - 1); + } #ifdef CONFIG_YAFFS_SHORT_NAMES_IN_RAM - else if (obj->shortName[0]) -+ else if (obj->shortName[0]) { - yaffs_strcpy(name, obj->shortName); +- yaffs_strcpy(name, obj->shortName); ++ else if (obj->short_name[0]) { ++ yaffs_strcpy(name, obj->short_name); + } #endif - else { -+ else if(obj->hdrChunk > 0) { ++ else if(obj->hdr_chunk > 0) { int result; - __u8 *buffer = yaffs_GetTempBuffer(obj->myDev, __LINE__); +- __u8 *buffer = yaffs_GetTempBuffer(obj->myDev, __LINE__); ++ __u8 *buffer = yaffs_get_temp_buffer(obj->my_dev, __LINE__); + +- yaffs_ObjectHeader *oh = (yaffs_ObjectHeader *) buffer; ++ yaffs_obj_header *oh = (yaffs_obj_header *) buffer; -@@ -6884,14 +4768,17 @@ int yaffs_GetObjectName(yaffs_Object *ob - obj->hdrChunk, buffer, +- memset(buffer, 0, obj->myDev->nDataBytesPerChunk); ++ memset(buffer, 0, obj->my_dev->data_bytes_per_chunk); + +- if (obj->hdrChunk > 0) { +- result = yaffs_ReadChunkWithTagsFromNAND(obj->myDev, +- obj->hdrChunk, buffer, ++ if (obj->hdr_chunk > 0) { ++ result = yaffs_rd_chunk_tags_nand(obj->my_dev, ++ obj->hdr_chunk, buffer, NULL); } - yaffs_strncpy(name, oh->name, buffSize - 1); -+ yaffs_LoadNameFromObjectHeader(obj->myDev,name,oh->name,buffSize); ++ yaffs_load_name_from_oh(obj->my_dev,name,oh->name,buffer_size); - yaffs_ReleaseTempBuffer(obj->myDev, buffer, __LINE__); +- yaffs_ReleaseTempBuffer(obj->myDev, buffer, __LINE__); ++ yaffs_release_temp_buffer(obj->my_dev, buffer, __LINE__); } - return yaffs_strlen(name); -+ yaffs_FixNullName(obj,name,buffSize); ++ yaffs_fix_null_name(obj,name,buffer_size); + + return yaffs_strnlen(name,YAFFS_MAX_NAME_LENGTH); } +-int yaffs_GetObjectFileLength(yaffs_Object *obj) + - int yaffs_GetObjectFileLength(yaffs_Object *obj) ++int yaffs_get_obj_length(yaffs_obj_t *obj) { /* Dereference any hard linking */ -@@ -6899,9 +4786,11 @@ int yaffs_GetObjectFileLength(yaffs_Obje +- obj = yaffs_GetEquivalentObject(obj); ++ obj = yaffs_get_equivalent_obj(obj); - if (obj->variantType == YAFFS_OBJECT_TYPE_FILE) - return obj->variant.fileVariant.fileSize; +- if (obj->variantType == YAFFS_OBJECT_TYPE_FILE) +- return obj->variant.fileVariant.fileSize; - if (obj->variantType == YAFFS_OBJECT_TYPE_SYMLINK) - return yaffs_strlen(obj->variant.symLinkVariant.alias); - else { -+ if (obj->variantType == YAFFS_OBJECT_TYPE_SYMLINK){ -+ if(!obj->variant.symLinkVariant.alias) ++ if (obj->variant_type == YAFFS_OBJECT_TYPE_FILE) ++ return obj->variant.file_variant.file_size; ++ if (obj->variant_type == YAFFS_OBJECT_TYPE_SYMLINK){ ++ if(!obj->variant.symlink_variant.alias) + return 0; -+ return yaffs_strnlen(obj->variant.symLinkVariant.alias,YAFFS_MAX_ALIAS_LENGTH); ++ return yaffs_strnlen(obj->variant.symlink_variant.alias,YAFFS_MAX_ALIAS_LENGTH); + } else { /* Only a directory should drop through to here */ - return obj->myDev->nDataBytesPerChunk; +- return obj->myDev->nDataBytesPerChunk; ++ return obj->my_dev->data_bytes_per_chunk; + } + } + +-int yaffs_GetObjectLinkCount(yaffs_Object *obj) ++int yaffs_get_obj_link_count(yaffs_obj_t *obj) + { + int count = 0; + struct ylist_head *i; +@@ -6915,24 +4804,24 @@ int yaffs_GetObjectLinkCount(yaffs_Objec + if (!obj->unlinked) + count++; /* the object itself */ + +- ylist_for_each(i, &obj->hardLinks) ++ ylist_for_each(i, &obj->hard_links) + count++; /* add the hard links; */ + + return count; + } + +-int yaffs_GetObjectInode(yaffs_Object *obj) ++int yaffs_get_obj_inode(yaffs_obj_t *obj) + { +- obj = yaffs_GetEquivalentObject(obj); ++ obj = yaffs_get_equivalent_obj(obj); + +- return obj->objectId; ++ return obj->obj_id; + } + +-unsigned yaffs_GetObjectType(yaffs_Object *obj) ++unsigned yaffs_get_obj_type(yaffs_obj_t *obj) + { +- obj = yaffs_GetEquivalentObject(obj); ++ obj = yaffs_get_equivalent_obj(obj); + +- switch (obj->variantType) { ++ switch (obj->variant_type) { + case YAFFS_OBJECT_TYPE_FILE: + return DT_REG; + break; +@@ -6960,18 +4849,18 @@ unsigned yaffs_GetObjectType(yaffs_Objec } -@@ -6992,7 +4881,7 @@ int yaffs_SetAttributes(yaffs_Object *ob + } + +-YCHAR *yaffs_GetSymlinkAlias(yaffs_Object *obj) ++YCHAR *yaffs_get_symlink_alias(yaffs_obj_t *obj) + { +- obj = yaffs_GetEquivalentObject(obj); +- if (obj->variantType == YAFFS_OBJECT_TYPE_SYMLINK) +- return yaffs_CloneString(obj->variant.symLinkVariant.alias); ++ obj = yaffs_get_equivalent_obj(obj); ++ if (obj->variant_type == YAFFS_OBJECT_TYPE_SYMLINK) ++ return yaffs_clone_str(obj->variant.symlink_variant.alias); + else +- return yaffs_CloneString(_Y("")); ++ return yaffs_clone_str(_Y("")); + } + + #ifndef CONFIG_YAFFS_WINCE + +-int yaffs_SetAttributes(yaffs_Object *obj, struct iattr *attr) ++int yaffs_set_attribs(yaffs_obj_t *obj, struct iattr *attr) + { + unsigned int valid = attr->ia_valid; + +@@ -6990,14 +4879,14 @@ int yaffs_SetAttributes(yaffs_Object *ob + obj->yst_mtime = Y_TIME_CONVERT(attr->ia_mtime); + if (valid & ATTR_SIZE) - yaffs_ResizeFile(obj, attr->ia_size); +- yaffs_ResizeFile(obj, attr->ia_size); ++ yaffs_resize_file(obj, attr->ia_size); - yaffs_UpdateObjectHeader(obj, NULL, 1, 0, 0); -+ yaffs_UpdateObjectHeader(obj, NULL, 1, 0, 0, NULL); ++ yaffs_update_oh(obj, NULL, 1, 0, 0, NULL); return YAFFS_OK; -@@ -7025,12 +4914,129 @@ int yaffs_GetAttributes(yaffs_Object *ob + } +-int yaffs_GetAttributes(yaffs_Object *obj, struct iattr *attr) ++int yaffs_get_attribs(yaffs_obj_t *obj, struct iattr *attr) + { + unsigned int valid = 0; + +@@ -7015,7 +4904,7 @@ int yaffs_GetAttributes(yaffs_Object *ob + Y_TIME_CONVERT(attr->ia_mtime) = obj->yst_mtime; + valid |= ATTR_MTIME; + +- attr->ia_size = yaffs_GetFileSize(obj); ++ attr->ia_size = yaffs_get_file_size(obj); + valid |= ATTR_SIZE; + + attr->ia_valid = valid; +@@ -7025,20 +4914,137 @@ int yaffs_GetAttributes(yaffs_Object *ob #endif + -+static int yaffs_DoXMod(yaffs_Object *obj, int set, const YCHAR *name, const void *value, int size, int flags) ++static int yaffs_do_xattrib_mod(yaffs_obj_t *obj, int set, const YCHAR *name, const void *value, int size, int flags) +{ -+ yaffs_XAttrMod xmod; ++ yaffs_xattr_mod xmod; + + int result; + @@ -13840,7 +14701,7 @@ + xmod.flags = flags; + xmod.result = -ENOSPC; + -+ result = yaffs_UpdateObjectHeader(obj, NULL, 0, 0, 0, &xmod); ++ result = yaffs_update_oh(obj, NULL, 0, 0, 0, &xmod); + + if(result > 0) + return xmod.result; @@ -13848,12 +14709,12 @@ + return -ENOSPC; +} + -+static int yaffs_ApplyXMod(yaffs_Object *obj, char *buffer, yaffs_XAttrMod *xmod) ++static int yaffs_apply_xattrib_mod(yaffs_obj_t *obj, char *buffer, yaffs_xattr_mod *xmod) +{ + int retval = 0; -+ int x_offs = sizeof(yaffs_ObjectHeader); -+ yaffs_Device *dev = obj->myDev; -+ int x_size = dev->nDataBytesPerChunk - sizeof(yaffs_ObjectHeader); ++ int x_offs = sizeof(yaffs_obj_header); ++ yaffs_dev_t *dev = obj->my_dev; ++ int x_size = dev->data_bytes_per_chunk - sizeof(yaffs_obj_header); + + char * x_buffer = buffer + x_offs; + @@ -13862,54 +14723,54 @@ + else + retval = nval_del(x_buffer, x_size, xmod->name); + -+ obj->hasXattr = nval_hasvalues(x_buffer, x_size); -+ obj->xattrKnown = 1; ++ obj->has_xattr = nval_hasvalues(x_buffer, x_size); ++ obj->xattr_known = 1; + + xmod->result = retval; + + return retval; +} + -+static int yaffs_DoXFetch(yaffs_Object *obj, const YCHAR *name, void *value, int size) ++static int yaffs_do_xattrib_fetch(yaffs_obj_t *obj, const YCHAR *name, void *value, int size) +{ + char *buffer = NULL; + int result; -+ yaffs_ExtendedTags tags; -+ yaffs_Device *dev = obj->myDev; -+ int x_offs = sizeof(yaffs_ObjectHeader); -+ int x_size = dev->nDataBytesPerChunk - sizeof(yaffs_ObjectHeader); ++ yaffs_ext_tags tags; ++ yaffs_dev_t *dev = obj->my_dev; ++ int x_offs = sizeof(yaffs_obj_header); ++ int x_size = dev->data_bytes_per_chunk - sizeof(yaffs_obj_header); + + char * x_buffer; + + int retval = 0; + -+ if(obj->hdrChunk < 1) ++ if(obj->hdr_chunk < 1) + return -ENODATA; + + /* If we know that the object has no xattribs then don't do all the + * reading and parsing. + */ -+ if(obj->xattrKnown && !obj->hasXattr){ ++ if(obj->xattr_known && !obj->has_xattr){ + if(name) + return -ENODATA; + else + return 0; + } + -+ buffer = (char *) yaffs_GetTempBuffer(dev, __LINE__); ++ buffer = (char *) yaffs_get_temp_buffer(dev, __LINE__); + if(!buffer) + return -ENOMEM; + -+ result = yaffs_ReadChunkWithTagsFromNAND(dev,obj->hdrChunk, (__u8 *)buffer, &tags); ++ result = yaffs_rd_chunk_tags_nand(dev,obj->hdr_chunk, (__u8 *)buffer, &tags); + + if(result != YAFFS_OK) + retval = -ENOENT; + else{ + x_buffer = buffer + x_offs; + -+ if (!obj->xattrKnown){ -+ obj->hasXattr = nval_hasvalues(x_buffer, x_size); -+ obj->xattrKnown = 1; ++ if (!obj->xattr_known){ ++ obj->has_xattr = nval_hasvalues(x_buffer, x_size); ++ obj->xattr_known = 1; + } + + if(name) @@ -13917,48 +14778,65 @@ + else + retval = nval_list(x_buffer, x_size, value,size); + } -+ yaffs_ReleaseTempBuffer(dev,(__u8 *)buffer,__LINE__); ++ yaffs_release_temp_buffer(dev,(__u8 *)buffer,__LINE__); + return retval; +} + -+int yaffs_SetXAttribute(yaffs_Object *obj, const YCHAR *name, const void * value, int size, int flags) ++int yaffs_set_xattrib(yaffs_obj_t *obj, const YCHAR *name, const void * value, int size, int flags) +{ -+ return yaffs_DoXMod(obj, 1, name, value, size, flags); ++ return yaffs_do_xattrib_mod(obj, 1, name, value, size, flags); +} + -+int yaffs_RemoveXAttribute(yaffs_Object *obj, const YCHAR *name) ++int yaffs_remove_xattrib(yaffs_obj_t *obj, const YCHAR *name) +{ -+ return yaffs_DoXMod(obj, 0, name, NULL, 0, 0); ++ return yaffs_do_xattrib_mod(obj, 0, name, NULL, 0, 0); +} + -+int yaffs_GetXAttribute(yaffs_Object *obj, const YCHAR *name, void *value, int size) ++int yaffs_get_xattrib(yaffs_obj_t *obj, const YCHAR *name, void *value, int size) +{ -+ return yaffs_DoXFetch(obj, name, value, size); ++ return yaffs_do_xattrib_fetch(obj, name, value, size); +} + -+int yaffs_ListXAttributes(yaffs_Object *obj, char *buffer, int size) ++int yaffs_list_xattrib(yaffs_obj_t *obj, char *buffer, int size) +{ -+ return yaffs_DoXFetch(obj, NULL, buffer,size); ++ return yaffs_do_xattrib_fetch(obj, NULL, buffer,size); +} + + + #if 0 - int yaffs_DumpObject(yaffs_Object *obj) +-int yaffs_DumpObject(yaffs_Object *obj) ++int yaffs_dump_obj(yaffs_obj_t *obj) { YCHAR name[257]; - yaffs_GetObjectName(obj, name, 256); -+ yaffs_GetObjectName(obj, name, YAFFS_MAX_NAME_LENGTH + 1); ++ yaffs_get_obj_name(obj, name, YAFFS_MAX_NAME_LENGTH + 1); T(YAFFS_TRACE_ALWAYS, (TSTR -@@ -7050,30 +5056,32 @@ static int yaffs_CheckDevFunctions(const + ("Object %d, inode %d \"%s\"\n dirty %d valid %d serial %d sum %d" + " chunk %d type %d size %d\n" +- TENDSTR), obj->objectId, yaffs_GetObjectInode(obj), name, +- obj->dirty, obj->valid, obj->serial, obj->sum, obj->hdrChunk, +- yaffs_GetObjectType(obj), yaffs_GetObjectFileLength(obj))); ++ TENDSTR), obj->obj_id, yaffs_get_obj_inode(obj), name, ++ obj->dirty, obj->valid, obj->serial, obj->sum, obj->hdr_chunk, ++ yaffs_get_obj_type(obj), yaffs_get_obj_length(obj))); + + return YAFFS_OK; + } +@@ -7046,72 +5052,74 @@ int yaffs_DumpObject(yaffs_Object *obj) + + /*---------------------------- Initialisation code -------------------------------------- */ + +-static int yaffs_CheckDevFunctions(const yaffs_Device *dev) ++static int yaffs_cehck_dev_fns(const yaffs_dev_t *dev) { /* Common functions, gotta have */ - if (!dev->eraseBlockInNAND || !dev->initialiseNAND) -+ if (!dev->param.eraseBlockInNAND || !dev->param.initialiseNAND) ++ if (!dev->param.erase_fn || !dev->param.initialise_flash_fn) return 0; #ifdef CONFIG_YAFFS_YAFFS2 @@ -13969,12 +14847,12 @@ - !dev->writeChunkToNAND && - !dev->readChunkFromNAND && - dev->markNANDBlockBad && dev->queryNANDBlock) -+ if (dev->param.writeChunkWithTagsToNAND && -+ dev->param.readChunkWithTagsFromNAND && -+ !dev->param.writeChunkToNAND && -+ !dev->param.readChunkFromNAND && -+ dev->param.markNANDBlockBad && -+ dev->param.queryNANDBlock) ++ if (dev->param.write_chunk_tags_fn && ++ dev->param.read_chunk_tags_fn && ++ !dev->param.write_chunk_fn && ++ !dev->param.read_chunk_fn && ++ dev->param.bad_block_fn && ++ dev->param.query_block_fn) return 1; #endif @@ -13985,13 +14863,13 @@ - dev->writeChunkToNAND && - dev->readChunkFromNAND && - !dev->markNANDBlockBad && !dev->queryNANDBlock) -+ if (!dev->param.isYaffs2 && -+ !dev->param.writeChunkWithTagsToNAND && -+ !dev->param.readChunkWithTagsFromNAND && -+ dev->param.writeChunkToNAND && -+ dev->param.readChunkFromNAND && -+ !dev->param.markNANDBlockBad && -+ !dev->param.queryNANDBlock) ++ if (!dev->param.is_yaffs2 && ++ !dev->param.write_chunk_tags_fn && ++ !dev->param.read_chunk_tags_fn && ++ dev->param.write_chunk_fn && ++ dev->param.read_chunk_fn && ++ !dev->param.bad_block_fn && ++ !dev->param.query_block_fn) return 1; - return 0; /* bad */ @@ -13999,30 +14877,89 @@ } -@@ -7120,35 +5128,35 @@ int yaffs_GutsInitialise(yaffs_Device *d +-static int yaffs_CreateInitialDirectories(yaffs_Device *dev) ++static int yaffs_create_initial_dir(yaffs_dev_t *dev) + { + /* Initialise the unlinked, deleted, root and lost and found directories */ + +- dev->lostNFoundDir = dev->rootDir = NULL; +- dev->unlinkedDir = dev->deletedDir = NULL; ++ dev->lost_n_found = dev->root_dir = NULL; ++ dev->unlinked_dir = dev->del_dir = NULL; + +- dev->unlinkedDir = +- yaffs_CreateFakeDirectory(dev, YAFFS_OBJECTID_UNLINKED, S_IFDIR); ++ dev->unlinked_dir = ++ yaffs_create_fake_dir(dev, YAFFS_OBJECTID_UNLINKED, S_IFDIR); + +- dev->deletedDir = +- yaffs_CreateFakeDirectory(dev, YAFFS_OBJECTID_DELETED, S_IFDIR); ++ dev->del_dir = ++ yaffs_create_fake_dir(dev, YAFFS_OBJECTID_DELETED, S_IFDIR); + +- dev->rootDir = +- yaffs_CreateFakeDirectory(dev, YAFFS_OBJECTID_ROOT, ++ dev->root_dir = ++ yaffs_create_fake_dir(dev, YAFFS_OBJECTID_ROOT, + YAFFS_ROOT_MODE | S_IFDIR); +- dev->lostNFoundDir = +- yaffs_CreateFakeDirectory(dev, YAFFS_OBJECTID_LOSTNFOUND, ++ dev->lost_n_found = ++ yaffs_create_fake_dir(dev, YAFFS_OBJECTID_LOSTNFOUND, + YAFFS_LOSTNFOUND_MODE | S_IFDIR); + +- if (dev->lostNFoundDir && dev->rootDir && dev->unlinkedDir && dev->deletedDir) { +- yaffs_AddObjectToDirectory(dev->rootDir, dev->lostNFoundDir); ++ if (dev->lost_n_found && dev->root_dir && dev->unlinked_dir && dev->del_dir) { ++ yaffs_add_obj_to_dir(dev->root_dir, dev->lost_n_found); + return YAFFS_OK; + } + + return YAFFS_FAIL; + } + +-int yaffs_GutsInitialise(yaffs_Device *dev) ++int yaffs_guts_initialise(yaffs_dev_t *dev) + { + int init_failed = 0; + unsigned x; + int bits; + +- T(YAFFS_TRACE_TRACING, (TSTR("yaffs: yaffs_GutsInitialise()" TENDSTR))); ++ T(YAFFS_TRACE_TRACING, (TSTR("yaffs: yaffs_guts_initialise()" TENDSTR))); + + /* Check stuff that must be set */ + +@@ -7120,52 +5128,52 @@ int yaffs_GutsInitialise(yaffs_Device *d return YAFFS_FAIL; } - dev->internalStartBlock = dev->startBlock; - dev->internalEndBlock = dev->endBlock; -+ dev->internalStartBlock = dev->param.startBlock; -+ dev->internalEndBlock = dev->param.endBlock; - dev->blockOffset = 0; - dev->chunkOffset = 0; - dev->nFreeChunks = 0; - +- dev->blockOffset = 0; +- dev->chunkOffset = 0; +- dev->nFreeChunks = 0; +- - dev->gcBlock = -1; -+ dev->gcBlock = 0; - +- - if (dev->startBlock == 0) { - dev->internalStartBlock = dev->startBlock + 1; - dev->internalEndBlock = dev->endBlock + 1; -+ if (dev->param.startBlock == 0) { -+ dev->internalStartBlock = dev->param.startBlock + 1; -+ dev->internalEndBlock = dev->param.endBlock + 1; - dev->blockOffset = 1; +- dev->blockOffset = 1; - dev->chunkOffset = dev->nChunksPerBlock; -+ dev->chunkOffset = dev->param.nChunksPerBlock; ++ dev->internal_start_block = dev->param.start_block; ++ dev->internal_end_block = dev->param.end_block; ++ dev->block_offset = 0; ++ dev->chunk_offset = 0; ++ dev->n_free_chunks = 0; ++ ++ dev->gc_block = 0; ++ ++ if (dev->param.start_block == 0) { ++ dev->internal_start_block = dev->param.start_block + 1; ++ dev->internal_end_block = dev->param.end_block + 1; ++ dev->block_offset = 1; ++ dev->chunk_offset = dev->param.chunks_per_block; } /* Check geometry parameters. */ @@ -14032,265 +14969,461 @@ - (dev->inbandTags && !dev->isYaffs2) || - dev->nChunksPerBlock < 2 || - dev->nReservedBlocks < 2 || -+ if ((!dev->param.inbandTags && dev->param.isYaffs2 && dev->param.totalBytesPerChunk < 1024) || -+ (!dev->param.isYaffs2 && dev->param.totalBytesPerChunk < 512) || -+ (dev->param.inbandTags && !dev->param.isYaffs2) || -+ dev->param.nChunksPerBlock < 2 || -+ dev->param.nReservedBlocks < 2 || - dev->internalStartBlock <= 0 || - dev->internalEndBlock <= 0 || +- dev->internalStartBlock <= 0 || +- dev->internalEndBlock <= 0 || - dev->internalEndBlock <= (dev->internalStartBlock + dev->nReservedBlocks + 2)) { /* otherwise it is too small */ -+ dev->internalEndBlock <= (dev->internalStartBlock + dev->param.nReservedBlocks + 2)) { /* otherwise it is too small */ ++ if ((!dev->param.inband_tags && dev->param.is_yaffs2 && dev->param.total_bytes_per_chunk < 1024) || ++ (!dev->param.is_yaffs2 && dev->param.total_bytes_per_chunk < 512) || ++ (dev->param.inband_tags && !dev->param.is_yaffs2) || ++ dev->param.chunks_per_block < 2 || ++ dev->param.n_reserved_blocks < 2 || ++ dev->internal_start_block <= 0 || ++ dev->internal_end_block <= 0 || ++ dev->internal_end_block <= (dev->internal_start_block + dev->param.n_reserved_blocks + 2)) { /* otherwise it is too small */ T(YAFFS_TRACE_ALWAYS, (TSTR - ("yaffs: NAND geometry problems: chunk size %d, type is yaffs%s, inbandTags %d " +- ("yaffs: NAND geometry problems: chunk size %d, type is yaffs%s, inbandTags %d " - TENDSTR), dev->totalBytesPerChunk, dev->isYaffs2 ? "2" : "", dev->inbandTags)); -+ TENDSTR), dev->param.totalBytesPerChunk, dev->param.isYaffs2 ? "2" : "", dev->param.inbandTags)); ++ ("yaffs: NAND geometry problems: chunk size %d, type is yaffs%s, inband_tags %d " ++ TENDSTR), dev->param.total_bytes_per_chunk, dev->param.is_yaffs2 ? "2" : "", dev->param.inband_tags)); return YAFFS_FAIL; } -@@ -7159,10 +5167,10 @@ int yaffs_GutsInitialise(yaffs_Device *d +- if (yaffs_InitialiseNAND(dev) != YAFFS_OK) { ++ if (yaffs_init_nand(dev) != YAFFS_OK) { + T(YAFFS_TRACE_ALWAYS, + (TSTR("yaffs: InitialiseNAND failed" TENDSTR))); + return YAFFS_FAIL; } /* Sort out space for inband tags, if required */ - if (dev->inbandTags) - dev->nDataBytesPerChunk = dev->totalBytesPerChunk - sizeof(yaffs_PackedTags2TagsPart); -+ if (dev->param.inbandTags) -+ dev->nDataBytesPerChunk = dev->param.totalBytesPerChunk - sizeof(yaffs_PackedTags2TagsPart); ++ if (dev->param.inband_tags) ++ dev->data_bytes_per_chunk = dev->param.total_bytes_per_chunk - sizeof(yaffs_PackedTags2TagsPart); else - dev->nDataBytesPerChunk = dev->totalBytesPerChunk; -+ dev->nDataBytesPerChunk = dev->param.totalBytesPerChunk; ++ dev->data_bytes_per_chunk = dev->param.total_bytes_per_chunk; /* Got the right mix of functions? */ - if (!yaffs_CheckDevFunctions(dev)) { -@@ -7209,12 +5217,12 @@ int yaffs_GutsInitialise(yaffs_Device *d - * We need to find the next power of 2 > than internalEndBlock +- if (!yaffs_CheckDevFunctions(dev)) { ++ if (!yaffs_cehck_dev_fns(dev)) { + /* Function missing */ + T(YAFFS_TRACE_ALWAYS, + (TSTR +@@ -7175,13 +5183,13 @@ int yaffs_GutsInitialise(yaffs_Device *d + } + + /* This is really a compilation check. */ +- if (!yaffs_CheckStructures()) { ++ if (!yaffs_check_structures()) { + T(YAFFS_TRACE_ALWAYS, +- (TSTR("yaffs_CheckStructures failed\n" TENDSTR))); ++ (TSTR("yaffs_check_structures failed\n" TENDSTR))); + return YAFFS_FAIL; + } + +- if (dev->isMounted) { ++ if (dev->is_mounted) { + T(YAFFS_TRACE_ALWAYS, + (TSTR("yaffs: device already mounted\n" TENDSTR))); + return YAFFS_FAIL; +@@ -7189,59 +5197,62 @@ int yaffs_GutsInitialise(yaffs_Device *d + + /* Finished with most checks. One or two more checks happen later on too. */ + +- dev->isMounted = 1; ++ dev->is_mounted = 1; + + /* OK now calculate a few things for the device */ + + /* + * Calculate all the chunk size manipulation numbers: + */ +- x = dev->nDataBytesPerChunk; +- /* We always use dev->chunkShift and dev->chunkDiv */ +- dev->chunkShift = Shifts(x); +- x >>= dev->chunkShift; +- dev->chunkDiv = x; +- /* We only use chunk mask if chunkDiv is 1 */ +- dev->chunkMask = (1<<dev->chunkShift) - 1; ++ x = dev->data_bytes_per_chunk; ++ /* We always use dev->chunk_shift and dev->chunk_div */ ++ dev->chunk_shift = Shifts(x); ++ x >>= dev->chunk_shift; ++ dev->chunk_div = x; ++ /* We only use chunk mask if chunk_div is 1 */ ++ dev->chunk_mask = (1<<dev->chunk_shift) - 1; + + /* +- * Calculate chunkGroupBits. +- * We need to find the next power of 2 > than internalEndBlock ++ * Calculate chunk_grp_bits. ++ * We need to find the next power of 2 > than internal_end_block */ - x = dev->nChunksPerBlock * (dev->internalEndBlock + 1); -+ x = dev->param.nChunksPerBlock * (dev->internalEndBlock + 1); ++ x = dev->param.chunks_per_block * (dev->internal_end_block + 1); bits = ShiftsGE(x); /* Set up tnode width if wide tnodes are enabled. */ - if (!dev->wideTnodesDisabled) { -+ if (!dev->param.wideTnodesDisabled) { ++ if (!dev->param.wide_tnodes_disabled) { /* bits must be even so that we end up with 32-bit words */ if (bits & 1) bits++; -@@ -7238,10 +5246,13 @@ int yaffs_GutsInitialise(yaffs_Device *d + if (bits < 16) +- dev->tnodeWidth = 16; ++ dev->tnode_width = 16; + else +- dev->tnodeWidth = bits; ++ dev->tnode_width = bits; + } else +- dev->tnodeWidth = 16; ++ dev->tnode_width = 16; + +- dev->tnodeMask = (1<<dev->tnodeWidth)-1; ++ dev->tnode_mask = (1<<dev->tnode_width)-1; + + /* Level0 Tnodes are 16 bits or wider (if wide tnodes are enabled), + * so if the bitwidth of the + * chunk range we're using is greater than 16 we need +- * to figure out chunk shift and chunkGroupSize ++ * to figure out chunk shift and chunk_grp_size + */ + +- if (bits <= dev->tnodeWidth) +- dev->chunkGroupBits = 0; ++ if (bits <= dev->tnode_width) ++ dev->chunk_grp_bits = 0; else - dev->chunkGroupBits = bits - dev->tnodeWidth; +- dev->chunkGroupBits = bits - dev->tnodeWidth; ++ dev->chunk_grp_bits = bits - dev->tnode_width; -+ dev->tnodeSize = (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8; -+ if(dev->tnodeSize < sizeof(yaffs_Tnode)) -+ dev->tnodeSize = sizeof(yaffs_Tnode); ++ dev->tnode_size = (dev->tnode_width * YAFFS_NTNODES_LEVEL0)/8; ++ if(dev->tnode_size < sizeof(yaffs_tnode_t)) ++ dev->tnode_size = sizeof(yaffs_tnode_t); - dev->chunkGroupSize = 1 << dev->chunkGroupBits; +- dev->chunkGroupSize = 1 << dev->chunkGroupBits; ++ dev->chunk_grp_size = 1 << dev->chunk_grp_bits; - if (dev->nChunksPerBlock < dev->chunkGroupSize) { -+ if (dev->param.nChunksPerBlock < dev->chunkGroupSize) { ++ if (dev->param.chunks_per_block < dev->chunk_grp_size) { /* We have a problem because the soft delete won't work if * the chunk group size > chunks per block. * This can be remedied by using larger "virtual blocks". -@@ -7255,9 +5266,11 @@ int yaffs_GutsInitialise(yaffs_Device *d +@@ -7255,85 +5266,89 @@ int yaffs_GutsInitialise(yaffs_Device *d /* OK, we've finished verifying the device, lets continue with initialisation */ /* More device initialisation */ - dev->garbageCollections = 0; - dev->passiveGarbageCollections = 0; - dev->currentDirtyChecker = 0; -+ dev->allGCs = 0; -+ dev->passiveGCs = 0; -+ dev->oldestDirtyGCs = 0; -+ dev->backgroundGCs = 0; -+ dev->gcBlockFinder = 0; - dev->bufferedBlock = -1; - dev->doingBufferedBlockRewrite = 0; - dev->nDeletedFiles = 0; -@@ -7269,8 +5282,11 @@ int yaffs_GutsInitialise(yaffs_Device *d - dev->tagsEccUnfixed = 0; - dev->nErasureFailures = 0; - dev->nErasedBlocks = 0; +- dev->bufferedBlock = -1; +- dev->doingBufferedBlockRewrite = 0; +- dev->nDeletedFiles = 0; +- dev->nBackgroundDeletions = 0; +- dev->nUnlinkedFiles = 0; +- dev->eccFixed = 0; +- dev->eccUnfixed = 0; +- dev->tagsEccFixed = 0; +- dev->tagsEccUnfixed = 0; +- dev->nErasureFailures = 0; +- dev->nErasedBlocks = 0; - dev->isDoingGC = 0; -+ dev->gcDisable= 0; - dev->hasPendingPrioritisedGCs = 1; /* Assume the worst for now, will get fixed on first GC */ -+ YINIT_LIST_HEAD(&dev->dirtyDirectories); -+ dev->oldestDirtySequence = 0; -+ dev->oldestDirtyBlock = 0; +- dev->hasPendingPrioritisedGCs = 1; /* Assume the worst for now, will get fixed on first GC */ ++ dev->all_gcs = 0; ++ dev->passive_gc_count = 0; ++ dev->oldest_dirty_gc_count = 0; ++ dev->bg_gcs = 0; ++ dev->gc_block_finder = 0; ++ dev->buffered_block = -1; ++ dev->doing_buffered_block_rewrite = 0; ++ dev->n_deleted_files = 0; ++ dev->n_bg_deletions = 0; ++ dev->n_unlinked_files = 0; ++ dev->n_ecc_fixed = 0; ++ dev->n_ecc_unfixed = 0; ++ dev->n_tags_ecc_fixed = 0; ++ dev->n_tags_ecc_unfixed = 0; ++ dev->n_erase_failures = 0; ++ dev->n_erased_blocks = 0; ++ dev->gc_disable= 0; ++ dev->has_pending_prioritised_gc = 1; /* Assume the worst for now, will get fixed on first GC */ ++ YINIT_LIST_HEAD(&dev->dirty_dirs); ++ dev->oldest_dirty_seq = 0; ++ dev->oldest_dirty_block = 0; /* Initialise temporary buffers and caches. */ - if (!yaffs_InitialiseTempBuffers(dev)) -@@ -7281,13 +5297,13 @@ int yaffs_GutsInitialise(yaffs_Device *d +- if (!yaffs_InitialiseTempBuffers(dev)) ++ if (!yaffs_init_tmp_buffers(dev)) + init_failed = 1; + +- dev->srCache = NULL; +- dev->gcCleanupList = NULL; ++ dev->cache = NULL; ++ dev->gc_cleanup_list = NULL; if (!init_failed && - dev->nShortOpCaches > 0) { -+ dev->param.nShortOpCaches > 0) { ++ dev->param.n_caches > 0) { int i; void *buf; - int srCacheBytes = dev->nShortOpCaches * sizeof(yaffs_ChunkCache); -+ int srCacheBytes = dev->param.nShortOpCaches * sizeof(yaffs_ChunkCache); ++ int cacheBytes = dev->param.n_caches * sizeof(yaffs_cache_t); - if (dev->nShortOpCaches > YAFFS_MAX_SHORT_OP_CACHES) - dev->nShortOpCaches = YAFFS_MAX_SHORT_OP_CACHES; -+ if (dev->param.nShortOpCaches > YAFFS_MAX_SHORT_OP_CACHES) -+ dev->param.nShortOpCaches = YAFFS_MAX_SHORT_OP_CACHES; ++ if (dev->param.n_caches > YAFFS_MAX_SHORT_OP_CACHES) ++ dev->param.n_caches = YAFFS_MAX_SHORT_OP_CACHES; - dev->srCache = YMALLOC(srCacheBytes); +- dev->srCache = YMALLOC(srCacheBytes); ++ dev->cache = YMALLOC(cacheBytes); -@@ -7296,11 +5312,11 @@ int yaffs_GutsInitialise(yaffs_Device *d - if (dev->srCache) - memset(dev->srCache, 0, srCacheBytes); +- buf = (__u8 *) dev->srCache; ++ buf = (__u8 *) dev->cache; + +- if (dev->srCache) +- memset(dev->srCache, 0, srCacheBytes); ++ if (dev->cache) ++ memset(dev->cache, 0, cacheBytes); - for (i = 0; i < dev->nShortOpCaches && buf; i++) { -+ for (i = 0; i < dev->param.nShortOpCaches && buf; i++) { - dev->srCache[i].object = NULL; - dev->srCache[i].lastUse = 0; - dev->srCache[i].dirty = 0; +- dev->srCache[i].object = NULL; +- dev->srCache[i].lastUse = 0; +- dev->srCache[i].dirty = 0; - dev->srCache[i].data = buf = YMALLOC_DMA(dev->totalBytesPerChunk); -+ dev->srCache[i].data = buf = YMALLOC_DMA(dev->param.totalBytesPerChunk); ++ for (i = 0; i < dev->param.n_caches && buf; i++) { ++ dev->cache[i].object = NULL; ++ dev->cache[i].last_use = 0; ++ dev->cache[i].dirty = 0; ++ dev->cache[i].data = buf = YMALLOC_DMA(dev->param.total_bytes_per_chunk); } if (!buf) init_failed = 1; -@@ -7311,19 +5327,18 @@ int yaffs_GutsInitialise(yaffs_Device *d - dev->cacheHits = 0; + +- dev->srLastUse = 0; ++ dev->cache_last_use = 0; + } + +- dev->cacheHits = 0; ++ dev->cache_hits = 0; if (!init_failed) { - dev->gcCleanupList = YMALLOC(dev->nChunksPerBlock * sizeof(__u32)); -+ dev->gcCleanupList = YMALLOC(dev->param.nChunksPerBlock * sizeof(__u32)); - if (!dev->gcCleanupList) +- if (!dev->gcCleanupList) ++ dev->gc_cleanup_list = YMALLOC(dev->param.chunks_per_block * sizeof(__u32)); ++ if (!dev->gc_cleanup_list) init_failed = 1; } - if (dev->isYaffs2) - dev->useHeaderFileSize = 1; -+ if (dev->param.isYaffs2) -+ dev->param.useHeaderFileSize = 1; ++ if (dev->param.is_yaffs2) ++ dev->param.use_header_file_size = 1; - if (!init_failed && !yaffs_InitialiseBlocks(dev)) +- if (!init_failed && !yaffs_InitialiseBlocks(dev)) ++ if (!init_failed && !yaffs_init_blocks(dev)) init_failed = 1; - yaffs_InitialiseTnodes(dev); - yaffs_InitialiseObjects(dev); -+ yaffs_InitialiseTnodesAndObjects(dev); ++ yaffs_init_tnodes_and_objs(dev); - if (!init_failed && !yaffs_CreateInitialDirectories(dev)) +- if (!init_failed && !yaffs_CreateInitialDirectories(dev)) ++ if (!init_failed && !yaffs_create_initial_dir(dev)) init_failed = 1; -@@ -7331,8 +5346,8 @@ int yaffs_GutsInitialise(yaffs_Device *d + if (!init_failed) { /* Now scan the flash. */ - if (dev->isYaffs2) { - if (yaffs_CheckpointRestore(dev)) { -+ if (dev->param.isYaffs2) { -+ if (yaffs2_CheckpointRestore(dev)) { - yaffs_CheckObjectDetailsLoaded(dev->rootDir); +- yaffs_CheckObjectDetailsLoaded(dev->rootDir); ++ if (dev->param.is_yaffs2) { ++ if (yaffs2_checkpt_restore(dev)) { ++ yaffs_check_obj_details_loaded(dev->root_dir); T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: restored from checkpoint" TENDSTR))); -@@ -7342,9 +5357,8 @@ int yaffs_GutsInitialise(yaffs_Device *d + } else { +@@ -7341,128 +5356,129 @@ int yaffs_GutsInitialise(yaffs_Device *d + /* Clean up the mess caused by an aborted checkpoint load * and scan backwards. */ - yaffs_DeinitialiseBlocks(dev); +- yaffs_DeinitialiseBlocks(dev); - yaffs_DeinitialiseTnodes(dev); - yaffs_DeinitialiseObjects(dev); ++ yaffs_deinit_blocks(dev); -+ yaffs_DeinitialiseTnodesAndObjects(dev); ++ yaffs_deinit_tnodes_and_objs(dev); - dev->nErasedBlocks = 0; - dev->nFreeChunks = 0; -@@ -7353,24 +5367,25 @@ int yaffs_GutsInitialise(yaffs_Device *d - dev->nDeletedFiles = 0; - dev->nUnlinkedFiles = 0; - dev->nBackgroundDeletions = 0; +- dev->nErasedBlocks = 0; +- dev->nFreeChunks = 0; +- dev->allocationBlock = -1; +- dev->allocationPage = -1; +- dev->nDeletedFiles = 0; +- dev->nUnlinkedFiles = 0; +- dev->nBackgroundDeletions = 0; - dev->oldestDirtySequence = 0; - - if (!init_failed && !yaffs_InitialiseBlocks(dev)) ++ dev->n_erased_blocks = 0; ++ dev->n_free_chunks = 0; ++ dev->alloc_block = -1; ++ dev->alloc_page = -1; ++ dev->n_deleted_files = 0; ++ dev->n_unlinked_files = 0; ++ dev->n_bg_deletions = 0; + +- if (!init_failed && !yaffs_InitialiseBlocks(dev)) ++ if (!init_failed && !yaffs_init_blocks(dev)) init_failed = 1; - yaffs_InitialiseTnodes(dev); - yaffs_InitialiseObjects(dev); -+ yaffs_InitialiseTnodesAndObjects(dev); ++ yaffs_init_tnodes_and_objs(dev); - if (!init_failed && !yaffs_CreateInitialDirectories(dev)) +- if (!init_failed && !yaffs_CreateInitialDirectories(dev)) ++ if (!init_failed && !yaffs_create_initial_dir(dev)) init_failed = 1; - if (!init_failed && !yaffs_ScanBackwards(dev)) -+ if (!init_failed && !yaffs2_ScanBackwards(dev)) ++ if (!init_failed && !yaffs2_scan_backwards(dev)) init_failed = 1; } - } else if (!yaffs_Scan(dev)) -+ } else if (!yaffs1_Scan(dev)) ++ } else if (!yaffs1_scan(dev)) init_failed = 1; - yaffs_StripDeletedObjects(dev); -+ yaffs_FixHangingObjects(dev); -+ if(dev->param.emptyLostAndFound) -+ yaffs_EmptyLostAndFound(dev); +- yaffs_StripDeletedObjects(dev); ++ yaffs_strip_deleted_objs(dev); ++ yaffs_fix_hanging_objs(dev); ++ if(dev->param.empty_lost_n_found) ++ yaffs_empty_l_n_f(dev); } if (init_failed) { -@@ -7394,6 +5409,9 @@ int yaffs_GutsInitialise(yaffs_Device *d - yaffs_VerifyFreeChunks(dev); - yaffs_VerifyBlocks(dev); + /* Clean up the mess */ + T(YAFFS_TRACE_TRACING, +- (TSTR("yaffs: yaffs_GutsInitialise() aborted.\n" TENDSTR))); ++ (TSTR("yaffs: yaffs_guts_initialise() aborted.\n" TENDSTR))); +- yaffs_Deinitialise(dev); ++ yaffs_deinitialise(dev); + return YAFFS_FAIL; + } + + /* Zero out stats */ +- dev->nPageReads = 0; +- dev->nPageWrites = 0; +- dev->nBlockErasures = 0; +- dev->nGCCopies = 0; +- dev->nRetriedWrites = 0; +- +- dev->nRetiredBlocks = 0; +- +- yaffs_VerifyFreeChunks(dev); +- yaffs_VerifyBlocks(dev); +- ++ dev->n_page_reads = 0; ++ dev->n_page_writes = 0; ++ dev->n_erasures = 0; ++ dev->n_gc_copies = 0; ++ dev->n_retired_writes = 0; ++ ++ dev->n_retired_blocks = 0; ++ ++ yaffs_verify_free_chunks(dev); ++ yaffs_verify_blocks(dev); ++ + /* Clean up any aborted checkpoint data */ -+ if(!dev->isCheckpointed && dev->blocksInCheckpoint > 0) -+ yaffs2_InvalidateCheckpoint(dev); ++ if(!dev->is_checkpointed && dev->blocks_in_checkpt > 0) ++ yaffs2_checkpt_invalidate(dev); T(YAFFS_TRACE_TRACING, - (TSTR("yaffs: yaffs_GutsInitialise() done.\n" TENDSTR))); -@@ -7407,12 +5425,11 @@ void yaffs_Deinitialise(yaffs_Device *de +- (TSTR("yaffs: yaffs_GutsInitialise() done.\n" TENDSTR))); ++ (TSTR("yaffs: yaffs_guts_initialise() done.\n" TENDSTR))); + return YAFFS_OK; + + } + +-void yaffs_Deinitialise(yaffs_Device *dev) ++void yaffs_deinitialise(yaffs_dev_t *dev) + { +- if (dev->isMounted) { ++ if (dev->is_mounted) { int i; - yaffs_DeinitialiseBlocks(dev); +- yaffs_DeinitialiseBlocks(dev); - yaffs_DeinitialiseTnodes(dev); - yaffs_DeinitialiseObjects(dev); - if (dev->nShortOpCaches > 0 && -+ yaffs_DeinitialiseTnodesAndObjects(dev); -+ if (dev->param.nShortOpCaches > 0 && - dev->srCache) { +- dev->srCache) { ++ yaffs_deinit_blocks(dev); ++ yaffs_deinit_tnodes_and_objs(dev); ++ if (dev->param.n_caches > 0 && ++ dev->cache) { - for (i = 0; i < dev->nShortOpCaches; i++) { -+ for (i = 0; i < dev->param.nShortOpCaches; i++) { - if (dev->srCache[i].data) - YFREE(dev->srCache[i].data); - dev->srCache[i].data = NULL; -@@ -7429,34 +5446,33 @@ void yaffs_Deinitialise(yaffs_Device *de +- if (dev->srCache[i].data) +- YFREE(dev->srCache[i].data); +- dev->srCache[i].data = NULL; ++ for (i = 0; i < dev->param.n_caches; i++) { ++ if (dev->cache[i].data) ++ YFREE(dev->cache[i].data); ++ dev->cache[i].data = NULL; + } + +- YFREE(dev->srCache); +- dev->srCache = NULL; ++ YFREE(dev->cache); ++ dev->cache = NULL; + } + +- YFREE(dev->gcCleanupList); ++ YFREE(dev->gc_cleanup_list); + + for (i = 0; i < YAFFS_N_TEMP_BUFFERS; i++) +- YFREE(dev->tempBuffer[i].buffer); ++ YFREE(dev->temp_buffer[i].buffer); - dev->isMounted = 0; +- dev->isMounted = 0; ++ dev->is_mounted = 0; - if (dev->deinitialiseNAND) - dev->deinitialiseNAND(dev); -+ if (dev->param.deinitialiseNAND) -+ dev->param.deinitialiseNAND(dev); ++ if (dev->param.deinitialise_flash_fn) ++ dev->param.deinitialise_flash_fn(dev); } } -static int yaffs_CountFreeChunks(yaffs_Device *dev) -+int yaffs_CountFreeChunks(yaffs_Device *dev) ++int yaffs_count_free_chunks(yaffs_dev_t *dev) { - int nFree; + int nFree=0; int b; - yaffs_BlockInfo *blk; - +- yaffs_BlockInfo *blk; +- - for (nFree = 0, b = dev->internalStartBlock; b <= dev->internalEndBlock; - b++) { - blk = yaffs_GetBlockInfo(dev, b); -- -+ blk = dev->blockInfo; -+ for (b = dev->internalStartBlock; b <= dev->internalEndBlock; b++) { - switch (blk->blockState) { ++ yaffs_block_info_t *blk; + +- switch (blk->blockState) { ++ blk = dev->block_info; ++ for (b = dev->internal_start_block; b <= dev->internal_end_block; b++) { ++ switch (blk->block_state) { case YAFFS_BLOCK_STATE_EMPTY: case YAFFS_BLOCK_STATE_ALLOCATING: case YAFFS_BLOCK_STATE_COLLECTING: case YAFFS_BLOCK_STATE_FULL: nFree += - (dev->nChunksPerBlock - blk->pagesInUse + -+ (dev->param.nChunksPerBlock - blk->pagesInUse + - blk->softDeletions); +- blk->softDeletions); ++ (dev->param.chunks_per_block - blk->pages_in_use + ++ blk->soft_del_pages); break; default: break; @@ -14299,33 +15432,53 @@ } return nFree; -@@ -7481,21 +5497,19 @@ int yaffs_GetNumberOfFreeChunks(yaffs_De + } + +-int yaffs_GetNumberOfFreeChunks(yaffs_Device *dev) ++int yaffs_get_n_free_chunks(yaffs_dev_t *dev) + { + /* This is what we report to the outside world */ + +@@ -7472,30 +5488,28 @@ int yaffs_GetNumberOfFreeChunks(yaffs_De + int i; + + #if 1 +- nFree = dev->nFreeChunks; ++ nFree = dev->n_free_chunks; + #else +- nFree = yaffs_CountFreeChunks(dev); ++ nFree = yaffs_count_free_chunks(dev); + #endif + +- nFree += dev->nDeletedFiles; ++ nFree += dev->n_deleted_files; /* Now count the number of dirty chunks in the cache and subtract those */ - for (nDirtyCacheChunks = 0, i = 0; i < dev->nShortOpCaches; i++) { -+ for (nDirtyCacheChunks = 0, i = 0; i < dev->param.nShortOpCaches; i++) { - if (dev->srCache[i].dirty) +- if (dev->srCache[i].dirty) ++ for (nDirtyCacheChunks = 0, i = 0; i < dev->param.n_caches; i++) { ++ if (dev->cache[i].dirty) nDirtyCacheChunks++; } nFree -= nDirtyCacheChunks; - nFree -= ((dev->nReservedBlocks + 1) * dev->nChunksPerBlock); -+ nFree -= ((dev->param.nReservedBlocks + 1) * dev->param.nChunksPerBlock); ++ nFree -= ((dev->param.n_reserved_blocks + 1) * dev->param.chunks_per_block); /* Now we figure out how much to reserve for the checkpoint and report that... */ - blocksForCheckpoint = yaffs_CalcCheckpointBlocksRequired(dev) - dev->blocksInCheckpoint; - if (blocksForCheckpoint < 0) - blocksForCheckpoint = 0; -+ blocksForCheckpoint = yaffs2_CalcCheckpointBlocksRequired(dev); ++ blocksForCheckpoint = yaffs_calc_checkpt_blocks_required(dev); - nFree -= (blocksForCheckpoint * dev->nChunksPerBlock); -+ nFree -= (blocksForCheckpoint * dev->param.nChunksPerBlock); ++ nFree -= (blocksForCheckpoint * dev->param.chunks_per_block); if (nFree < 0) nFree = 0; -@@ -7504,27 +5518,6 @@ int yaffs_GetNumberOfFreeChunks(yaffs_De +@@ -7504,49 +5518,27 @@ int yaffs_GetNumberOfFreeChunks(yaffs_De } @@ -14353,7 +15506,8 @@ /*---------------------------------------- YAFFS test code ----------------------*/ -@@ -7532,7 +5525,7 @@ static void yaffs_VerifyFreeChunks(yaffs +-#define yaffs_CheckStruct(structure, syze, name) \ ++#define yaffs_check_struct(structure, syze, name) \ do { \ if (sizeof(structure) != syze) { \ T(YAFFS_TRACE_ALWAYS, (TSTR("%s should be %d but is %d\n" TENDSTR),\ @@ -14362,20 +15516,30 @@ return YAFFS_FAIL; \ } \ } while (0) -@@ -7542,9 +5535,8 @@ static int yaffs_CheckStructures(void) - /* yaffs_CheckStruct(yaffs_Tags,8,"yaffs_Tags"); */ - /* yaffs_CheckStruct(yaffs_TagsUnion,8,"yaffs_TagsUnion"); */ - /* yaffs_CheckStruct(yaffs_Spare,16,"yaffs_Spare"); */ + +-static int yaffs_CheckStructures(void) ++static int yaffs_check_structures(void) + { +-/* yaffs_CheckStruct(yaffs_Tags,8,"yaffs_Tags"); */ +-/* yaffs_CheckStruct(yaffs_TagsUnion,8,"yaffs_TagsUnion"); */ +-/* yaffs_CheckStruct(yaffs_Spare,16,"yaffs_Spare"); */ -#ifndef CONFIG_YAFFS_TNODE_LIST_DEBUG - yaffs_CheckStruct(yaffs_Tnode, 2 * YAFFS_NTNODES_LEVEL0, "yaffs_Tnode"); -#endif -+/* yaffs_CheckStruct(yaffs_Tnode, 2 * YAFFS_NTNODES_LEVEL0, "yaffs_Tnode"); */ ++/* yaffs_check_struct(yaffs_tags_t,8,"yaffs_tags_t"); */ ++/* yaffs_check_struct(yaffs_tags_union_t,8,"yaffs_tags_union_t"); */ ++/* yaffs_check_struct(yaffs_spare,16,"yaffs_spare"); */ ++/* yaffs_check_struct(yaffs_tnode_t, 2 * YAFFS_NTNODES_LEVEL0, "yaffs_tnode_t"); */ + #ifndef CONFIG_YAFFS_WINCE - yaffs_CheckStruct(yaffs_ObjectHeader, 512, "yaffs_ObjectHeader"); +- yaffs_CheckStruct(yaffs_ObjectHeader, 512, "yaffs_ObjectHeader"); ++ yaffs_check_struct(yaffs_obj_header, 512, "yaffs_obj_header"); #endif ---- a/fs/yaffs2/yaffs_guts.h -+++ b/fs/yaffs2/yaffs_guts.h + return YAFFS_OK; + } +diff -Nrup linux-2.6.36-rc8/fs/yaffs2/yaffs_guts.h linux-2.6.36-rc8.new/fs/yaffs2/yaffs_guts.h +--- linux-2.6.36-rc8/fs/yaffs2/yaffs_guts.h 2010-10-20 13:17:58.954000294 +0300 ++++ linux-2.6.36-rc8.new/fs/yaffs2/yaffs_guts.h 2010-10-20 13:28:16.061000294 +0300 @@ -1,7 +1,7 @@ /* * YAFFS: Yet another Flash File System . A NAND-flash specific file system. @@ -14429,18 +15593,165 @@ #define YAFFS_MAX_SHORT_OP_CACHES 20 -@@ -119,11 +119,7 @@ typedef struct { +@@ -113,18 +113,14 @@ + + /* ChunkCache is used for short read/write operations.*/ + typedef struct { +- struct yaffs_ObjectStruct *object; +- int chunkId; +- int lastUse; ++ struct yaffs_obj_s *object; ++ int chunk_id; ++ int last_use; int dirty; - int nBytes; /* Only valid if the cache is dirty */ +- int nBytes; /* Only valid if the cache is dirty */ ++ int n_bytes; /* Only valid if the cache is dirty */ int locked; /* Can't push out or flush while locked. */ -#ifdef CONFIG_YAFFS_YAFFS2 __u8 *data; -#else - __u8 data[YAFFS_BYTES_PER_CHUNK]; -#endif - } yaffs_ChunkCache; +-} yaffs_ChunkCache; ++} yaffs_cache_t; + +@@ -135,18 +131,18 @@ typedef struct { + + #ifndef CONFIG_YAFFS_NO_YAFFS1 + typedef struct { +- unsigned chunkId:20; +- unsigned serialNumber:2; +- unsigned byteCountLSB:10; +- unsigned objectId:18; ++ unsigned chunk_id:20; ++ unsigned serial_number:2; ++ unsigned n_bytes_lsb:10; ++ unsigned obj_id:18; + unsigned ecc:12; +- unsigned byteCountMSB:2; +-} yaffs_Tags; ++ unsigned n_bytes_msb:2; ++} yaffs_tags_t; + + typedef union { +- yaffs_Tags asTags; +- __u8 asBytes[8]; +-} yaffs_TagsUnion; ++ yaffs_tags_t as_tags; ++ __u8 as_bytes[8]; ++} yaffs_tags_union_t; + + #endif + +@@ -157,7 +153,7 @@ typedef enum { + YAFFS_ECC_RESULT_NO_ERROR, + YAFFS_ECC_RESULT_FIXED, + YAFFS_ECC_RESULT_UNFIXED +-} yaffs_ECCResult; ++} yaffs_ecc_result; + + typedef enum { + YAFFS_OBJECT_TYPE_UNKNOWN, +@@ -166,64 +162,64 @@ typedef enum { + YAFFS_OBJECT_TYPE_DIRECTORY, + YAFFS_OBJECT_TYPE_HARDLINK, + YAFFS_OBJECT_TYPE_SPECIAL +-} yaffs_ObjectType; ++} yaffs_obj_type; + + #define YAFFS_OBJECT_TYPE_MAX YAFFS_OBJECT_TYPE_SPECIAL + + typedef struct { + +- unsigned validMarker0; +- unsigned chunkUsed; /* Status of the chunk: used or unused */ +- unsigned objectId; /* If 0 then this is not part of an object (unused) */ +- unsigned chunkId; /* If 0 then this is a header, else a data chunk */ +- unsigned byteCount; /* Only valid for data chunks */ ++ unsigned validity1; ++ unsigned chunk_used; /* Status of the chunk: used or unused */ ++ unsigned obj_id; /* If 0 then this is not part of an object (unused) */ ++ unsigned chunk_id; /* If 0 then this is a header, else a data chunk */ ++ unsigned n_bytes; /* Only valid for data chunks */ + + /* The following stuff only has meaning when we read */ +- yaffs_ECCResult eccResult; +- unsigned blockBad; ++ yaffs_ecc_result ecc_result; ++ unsigned block_bad; + + /* YAFFS 1 stuff */ +- unsigned chunkDeleted; /* The chunk is marked deleted */ +- unsigned serialNumber; /* Yaffs1 2-bit serial number */ ++ unsigned is_deleted; /* The chunk is marked deleted */ ++ unsigned serial_number; /* Yaffs1 2-bit serial number */ + + /* YAFFS2 stuff */ +- unsigned sequenceNumber; /* The sequence number of this block */ ++ unsigned seq_number; /* The sequence number of this block */ + + /* Extra info if this is an object header (YAFFS2 only) */ + +- unsigned extraHeaderInfoAvailable; /* There is extra info available if this is not zero */ +- unsigned extraParentObjectId; /* The parent object */ +- unsigned extraIsShrinkHeader; /* Is it a shrink header? */ +- unsigned extraShadows; /* Does this shadow another object? */ ++ unsigned extra_available; /* There is extra info available if this is not zero */ ++ unsigned extra_parent_id; /* The parent object */ ++ unsigned extra_is_shrink; /* Is it a shrink header? */ ++ unsigned extra_shadows; /* Does this shadow another object? */ + +- yaffs_ObjectType extraObjectType; /* What object type? */ ++ yaffs_obj_type extra_obj_type; /* What object type? */ + +- unsigned extraFileLength; /* Length if it is a file */ +- unsigned extraEquivalentObjectId; /* Equivalent object Id if it is a hard link */ ++ unsigned extra_length; /* Length if it is a file */ ++ unsigned extra_equiv_id; /* Equivalent object Id if it is a hard link */ + +- unsigned validMarker1; ++ unsigned validty1; + +-} yaffs_ExtendedTags; ++} yaffs_ext_tags; + + /* Spare structure for YAFFS1 */ + typedef struct { +- __u8 tagByte0; +- __u8 tagByte1; +- __u8 tagByte2; +- __u8 tagByte3; +- __u8 pageStatus; /* set to 0 to delete the chunk */ +- __u8 blockStatus; +- __u8 tagByte4; +- __u8 tagByte5; ++ __u8 tb0; ++ __u8 tb1; ++ __u8 tb2; ++ __u8 tb3; ++ __u8 page_status; /* set to 0 to delete the chunk */ ++ __u8 block_status; ++ __u8 tb4; ++ __u8 tb5; + __u8 ecc1[3]; +- __u8 tagByte6; +- __u8 tagByte7; ++ __u8 tb6; ++ __u8 tb7; + __u8 ecc2[3]; +-} yaffs_Spare; ++} yaffs_spare; + + /*Special structure for passing through to mtd */ +-struct yaffs_NANDSpare { +- yaffs_Spare spare; ++struct yaffs_nand_spare { ++ yaffs_spare spare; + int eccres1; + int eccres2; + }; @@ -234,6 +230,8 @@ typedef enum { YAFFS_BLOCK_STATE_UNKNOWN = 0, @@ -14450,7 +15761,7 @@ YAFFS_BLOCK_STATE_NEEDS_SCANNING, /* The block might have something on it (ie it is allocating or full, perhaps empty) * but it needs to be scanned to determine its true state. -@@ -249,21 +247,23 @@ typedef enum { +@@ -249,67 +247,69 @@ typedef enum { /* This block is partially allocated. * At least one page holds valid data. * This is the one currently being used for page @@ -14478,20 +15789,122 @@ YAFFS_BLOCK_STATE_COLLECTING, /* This block is being garbage collected */ -@@ -351,23 +351,12 @@ typedef struct { + + YAFFS_BLOCK_STATE_DEAD + /* This block has failed and is not in use */ +-} yaffs_BlockState; ++} yaffs_block_state_t; + + #define YAFFS_NUMBER_OF_BLOCK_STATES (YAFFS_BLOCK_STATE_DEAD + 1) + + + typedef struct { + +- int softDeletions:10; /* number of soft deleted pages */ +- int pagesInUse:10; /* number of pages in use */ +- unsigned blockState:4; /* One of the above block states. NB use unsigned because enum is sometimes an int */ +- __u32 needsRetiring:1; /* Data has failed on this block, need to get valid data off */ ++ int soft_del_pages:10; /* number of soft deleted pages */ ++ int pages_in_use:10; /* number of pages in use */ ++ unsigned block_state:4; /* One of the above block states. NB use unsigned because enum is sometimes an int */ ++ __u32 needs_retiring:1; /* Data has failed on this block, need to get valid data off */ + /* and retire the block. */ +- __u32 skipErasedCheck:1; /* If this is set we can skip the erased check on this block */ +- __u32 gcPrioritise:1; /* An ECC check or blank check has failed on this block. ++ __u32 skip_erased_check:1; /* If this is set we can skip the erased check on this block */ ++ __u32 gc_prioritise:1; /* An ECC check or blank check has failed on this block. + It should be prioritised for GC */ +- __u32 chunkErrorStrikes:3; /* How many times we've had ecc etc failures on this block and tried to reuse it */ ++ __u32 chunk_error_strikes:3; /* How many times we've had ecc etc failures on this block and tried to reuse it */ + + #ifdef CONFIG_YAFFS_YAFFS2 +- __u32 hasShrinkHeader:1; /* This block has at least one shrink object header */ +- __u32 sequenceNumber; /* block sequence number for yaffs2 */ ++ __u32 has_shrink_hdr:1; /* This block has at least one shrink object header */ ++ __u32 seq_number; /* block sequence number for yaffs2 */ + #endif + +-} yaffs_BlockInfo; ++} yaffs_block_info_t; + + /* -------------------------- Object structure -------------------------------*/ + /* This is the object structure as stored on NAND */ + + typedef struct { +- yaffs_ObjectType type; ++ yaffs_obj_type type; + + /* Apply to everything */ +- int parentObjectId; +- __u16 sum__NoLongerUsed; /* checksum of name. No longer used */ ++ int parent_obj_id; ++ __u16 sum_no_longer_used; /* checksum of name. No longer used */ + YCHAR name[YAFFS_MAX_NAME_LENGTH + 1]; + + /* The following apply to directories, files, symlinks - not hard links */ + __u32 yst_mode; /* protection */ + + #ifdef CONFIG_YAFFS_WINCE +- __u32 notForWinCE[5]; ++ __u32 not_for_wince[5]; + #else + __u32 yst_uid; + __u32 yst_gid; +@@ -319,10 +319,10 @@ typedef struct { + #endif + + /* File size applies to files only */ +- int fileSize; ++ int file_size; + + /* Equivalent object id applies to hard links only. */ +- int equivalentObjectId; ++ int equiv_id; + + /* Alias is for symlinks only. */ + YCHAR alias[YAFFS_MAX_ALIAS_LENGTH + 1]; +@@ -334,40 +334,29 @@ typedef struct { + __u32 win_atime[2]; + __u32 win_mtime[2]; + #else +- __u32 roomToGrow[6]; ++ __u32 room_to_grow[6]; + + #endif +- __u32 inbandShadowsObject; +- __u32 inbandIsShrink; ++ __u32 inband_shadowed_obj_id; ++ __u32 inband_is_shrink; + +- __u32 reservedSpace[2]; +- int shadowsObject; /* This object header shadows the specified object if > 0 */ ++ __u32 reserved[2]; ++ int shadows_obj; /* This object header shadows the specified object if > 0 */ + +- /* isShrink applies to object headers written when we shrink the file (ie resize) */ +- __u32 isShrink; ++ /* is_shrink applies to object headers written when we shrink the file (ie resize) */ ++ __u32 is_shrink; + +-} yaffs_ObjectHeader; ++} yaffs_obj_header; + /*--------------------------- Tnode -------------------------- */ - union yaffs_Tnode_union { +-union yaffs_Tnode_union { -#ifdef CONFIG_YAFFS_TNODE_LIST_DEBUG - union yaffs_Tnode_union *internal[YAFFS_NTNODES_INTERNAL + 1]; -#else - union yaffs_Tnode_union *internal[YAFFS_NTNODES_INTERNAL]; +- union yaffs_Tnode_union *internal[YAFFS_NTNODES_INTERNAL]; -#endif -/* __u16 level0[YAFFS_NTNODES_LEVEL0]; */ ++union yaffs_tnode_union { ++ union yaffs_tnode_union *internal[YAFFS_NTNODES_INTERNAL]; }; - typedef union yaffs_Tnode_union yaffs_Tnode; +-typedef union yaffs_Tnode_union yaffs_Tnode; ++typedef union yaffs_tnode_union yaffs_tnode_t; -struct yaffs_TnodeList_struct { - struct yaffs_TnodeList_struct *next; @@ -14502,175 +15915,359 @@ /*------------------------ Object -----------------------------*/ /* An object can be one of: -@@ -387,6 +376,7 @@ typedef struct { +@@ -378,82 +367,85 @@ typedef struct yaffs_TnodeList_struct ya + */ + + typedef struct { +- __u32 fileSize; +- __u32 scannedFileSize; +- __u32 shrinkSize; +- int topLevel; +- yaffs_Tnode *top; +-} yaffs_FileStructure; ++ __u32 file_size; ++ __u32 scanned_size; ++ __u32 shrink_size; ++ int top_level; ++ yaffs_tnode_t *top; ++} yaffs_file_s; typedef struct { struct ylist_head children; /* list of child links */ +-} yaffs_DirectoryStructure; + struct ylist_head dirty; /* Entry for list of dirty directories */ - } yaffs_DirectoryStructure; ++} yaffs_dir_s; typedef struct { -@@ -405,6 +395,8 @@ typedef union { - yaffs_HardLinkStructure hardLinkVariant; - } yaffs_ObjectVariant; + YCHAR *alias; +-} yaffs_SymLinkStructure; ++} yaffs_symlink_t; -+ -+ - struct yaffs_ObjectStruct { + typedef struct { +- struct yaffs_ObjectStruct *equivalentObject; +- __u32 equivalentObjectId; +-} yaffs_HardLinkStructure; ++ struct yaffs_obj_s *equiv_obj; ++ __u32 equiv_id; ++} yaffs_hard_link_s; + + typedef union { +- yaffs_FileStructure fileVariant; +- yaffs_DirectoryStructure directoryVariant; +- yaffs_SymLinkStructure symLinkVariant; +- yaffs_HardLinkStructure hardLinkVariant; +-} yaffs_ObjectVariant; ++ yaffs_file_s file_variant; ++ yaffs_dir_s dir_variant; ++ yaffs_symlink_t symlink_variant; ++ yaffs_hard_link_s hardlink_variant; ++} yaffs_obj_variant; ++ ++ + +-struct yaffs_ObjectStruct { ++struct yaffs_obj_s { __u8 deleted:1; /* This should only apply to unlinked files. */ - __u8 softDeleted:1; /* it has also been soft deleted */ -@@ -424,6 +416,10 @@ struct yaffs_ObjectStruct { +- __u8 softDeleted:1; /* it has also been soft deleted */ ++ __u8 soft_del:1; /* it has also been soft deleted */ + __u8 unlinked:1; /* An unlinked file. The file should be in the unlinked directory.*/ + __u8 fake:1; /* A fake object has no presence on NAND. */ +- __u8 renameAllowed:1; /* Some objects are not allowed to be renamed. */ +- __u8 unlinkAllowed:1; ++ __u8 rename_allowed:1; /* Some objects are not allowed to be renamed. */ ++ __u8 unlink_allowed:1; + __u8 dirty:1; /* the object needs to be written to flash */ + __u8 valid:1; /* When the file system is being loaded up, this + * object might be created before the data + * is available (ie. file data records appear before the header). + */ +- __u8 lazyLoaded:1; /* This object has been lazy loaded and is missing some detail */ ++ __u8 lazy_loaded:1; /* This object has been lazy loaded and is missing some detail */ + +- __u8 deferedFree:1; /* For Linux kernel. Object is removed from NAND, but is ++ __u8 defered_free:1; /* For Linux kernel. Object is removed from NAND, but is + * still in the inode cache. Free of object is defered. * until the inode is released. */ - __u8 beingCreated:1; /* This object is still being created so skip some checks. */ -+ __u8 isShadowed:1; /* This object is shadowed on the way to being renamed. */ +- __u8 beingCreated:1; /* This object is still being created so skip some checks. */ ++ __u8 being_created:1; /* This object is still being created so skip some checks. */ ++ __u8 is_shadowed:1; /* This object is shadowed on the way to being renamed. */ + -+ __u8 xattrKnown:1; /* We know if this has object has xattribs or not. */ -+ __u8 hasXattr:1; /* This object has xattribs. Valid if xattrKnown. */ ++ __u8 xattr_known:1; /* We know if this has object has xattribs or not. */ ++ __u8 has_xattr:1; /* This object has xattribs. Valid if xattr_known. */ __u8 serial; /* serial number of chunk in NAND. Cached here */ __u16 sum; /* sum of the name to speed searching */ -@@ -452,10 +448,6 @@ struct yaffs_ObjectStruct { - YCHAR shortName[YAFFS_SHORT_NAME_LENGTH + 1]; - #endif --#ifndef __KERNEL__ -- __u32 inUse; +- struct yaffs_DeviceStruct *myDev; /* The device I'm on */ ++ struct yaffs_dev_s *my_dev; /* The device I'm on */ + +- struct ylist_head hashLink; /* list of objects in this hash bucket */ ++ struct ylist_head hash_link; /* list of objects in this hash bucket */ + +- struct ylist_head hardLinks; /* all the equivalent hard linked objects */ ++ struct ylist_head hard_links; /* all the equivalent hard linked objects */ + + /* directory structure stuff */ + /* also used for linking up the free list */ +- struct yaffs_ObjectStruct *parent; ++ struct yaffs_obj_s *parent; + struct ylist_head siblings; + + /* Where's my object header in NAND? */ +- int hdrChunk; ++ int hdr_chunk; + +- int nDataChunks; /* Number of data chunks attached to the file. */ ++ int n_data_chunks; /* Number of data chunks attached to the file. */ + +- __u32 objectId; /* the object id value */ ++ __u32 obj_id; /* the object id value */ + + __u32 yst_mode; + + #ifdef CONFIG_YAFFS_SHORT_NAMES_IN_RAM +- YCHAR shortName[YAFFS_SHORT_NAME_LENGTH + 1]; -#endif - +-#ifndef __KERNEL__ +- __u32 inUse; ++ YCHAR short_name[YAFFS_SHORT_NAME_LENGTH + 1]; + #endif + #ifdef CONFIG_YAFFS_WINCE - __u32 win_ctime[2]; - __u32 win_mtime[2]; -@@ -470,10 +462,7 @@ struct yaffs_ObjectStruct { +@@ -470,53 +462,43 @@ struct yaffs_ObjectStruct { __u32 yst_rdev; -#ifdef __KERNEL__ - struct inode *myInode; -- --#endif -+ void *myInode; - - yaffs_ObjectType variantType; ++ void *my_inode; -@@ -483,13 +472,6 @@ struct yaffs_ObjectStruct { +-#endif ++ yaffs_obj_type variant_type; - typedef struct yaffs_ObjectStruct yaffs_Object; +- yaffs_ObjectType variantType; ++ yaffs_obj_variant variant; +- yaffs_ObjectVariant variant; +- +-}; +- +-typedef struct yaffs_ObjectStruct yaffs_Object; +- -struct yaffs_ObjectList_struct { - yaffs_Object *objects; - struct yaffs_ObjectList_struct *next; --}; -- + }; + -typedef struct yaffs_ObjectList_struct yaffs_ObjectList; -- ++typedef struct yaffs_obj_s yaffs_obj_t; + typedef struct { struct ylist_head list; int count; -@@ -531,12 +513,18 @@ typedef struct { +-} yaffs_ObjectBucket; ++} yaffs_obj_bucket; + + +-/* yaffs_CheckpointObject holds the definition of an object as dumped ++/* yaffs_checkpt_obj_t holds the definition of an object as dumped + * by checkpointing. + */ + + typedef struct { +- int structType; +- __u32 objectId; +- __u32 parentId; +- int hdrChunk; +- yaffs_ObjectType variantType:3; ++ int struct_type; ++ __u32 obj_id; ++ __u32 parent_id; ++ int hdr_chunk; ++ yaffs_obj_type variant_type:3; + __u8 deleted:1; +- __u8 softDeleted:1; ++ __u8 soft_del:1; + __u8 unlinked:1; + __u8 fake:1; +- __u8 renameAllowed:1; +- __u8 unlinkAllowed:1; ++ __u8 rename_allowed:1; ++ __u8 unlink_allowed:1; + __u8 serial; + +- int nDataChunks; +- __u32 fileSizeOrEquivalentObjectId; +-} yaffs_CheckpointObject; ++ int n_data_chunks; ++ __u32 size_or_equiv_obj; ++} yaffs_checkpt_obj_t; + + /*--------------------- Temporary buffers ---------------- + * +@@ -526,379 +508,462 @@ typedef struct { + typedef struct { + __u8 *buffer; + int line; /* track from whence this buffer was allocated */ +- int maxLine; +-} yaffs_TempBuffer; ++ int max_line; ++} yaffs_buffer_t; /*----------------- Device ---------------------------------*/ -struct yaffs_DeviceStruct { - struct ylist_head devList; - const char *name; - +- - /* Entry parameters set up way early. Yaffs sets up the rest.*/ - int nDataBytesPerChunk; /* Should be a power of 2 >= 512 */ -+struct yaffs_DeviceParamStruct { +- int nChunksPerBlock; /* does not need to be a power of 2 */ +- int spareBytesPerChunk; /* spare area size */ +- int startBlock; /* Start block we're allowed to use */ +- int endBlock; /* End block we're allowed to use */ +- int nReservedBlocks; /* We want this tuneable so that we can reduce */ +- /* reserved blocks on NOR and RAM. */ +- + +- /* Stuff used by the shared space checkpointing mechanism */ +- /* If this value is zero, then this mechanism is disabled */ ++struct yaffs_param_s { + const YCHAR *name; -+ + +-/* int nCheckpointReservedBlocks; */ /* Blocks to reserve for checkpoint data */ + /* + * Entry parameters set up way early. Yaffs sets up the rest. + * The structure should be zeroed out before use so that unused + * and defualt values are zero. + */ + -+ int inbandTags; /* Use unband tags */ -+ __u32 totalBytesPerChunk; /* Should be >= 512, does not need to be a power of 2 */ - int nChunksPerBlock; /* does not need to be a power of 2 */ - int spareBytesPerChunk; /* spare area size */ - int startBlock; /* Start block we're allowed to use */ -@@ -545,24 +533,24 @@ struct yaffs_DeviceStruct { - /* reserved blocks on NOR and RAM. */ ++ int inband_tags; /* Use unband tags */ ++ __u32 total_bytes_per_chunk; /* Should be >= 512, does not need to be a power of 2 */ ++ int chunks_per_block; /* does not need to be a power of 2 */ ++ int spare_bytes_per_chunk; /* spare area size */ ++ int start_block; /* Start block we're allowed to use */ ++ int end_block; /* End block we're allowed to use */ ++ int n_reserved_blocks; /* We want this tuneable so that we can reduce */ ++ /* reserved blocks on NOR and RAM. */ -- /* Stuff used by the shared space checkpointing mechanism */ -- /* If this value is zero, then this mechanism is disabled */ -- --/* int nCheckpointReservedBlocks; */ /* Blocks to reserve for checkpoint data */ -- -- - int nShortOpCaches; /* If <= 0, then short op caching is disabled, else +- int nShortOpCaches; /* If <= 0, then short op caching is disabled, else - * the number of short op caches (don't use too many) ++ int n_caches; /* If <= 0, then short op caching is disabled, else + * the number of short op caches (don't use too many). + * 10 to 20 is a good bet. */ -+ int useNANDECC; /* Flag to decide whether or not to use NANDECC on data (yaffs1) */ -+ int noTagsECC; /* Flag to decide whether or not to do ECC on packed tags (yaffs2) */ ++ int use_nand_ecc; /* Flag to decide whether or not to use NANDECC on data (yaffs1) */ ++ int no_tags_ecc; /* Flag to decide whether or not to do ECC on packed tags (yaffs2) */ - int useHeaderFileSize; /* Flag to determine if we should use file sizes from the header */ -+ int isYaffs2; /* Use yaffs2 mode on this device */ ++ int is_yaffs2; /* Use yaffs2 mode on this device */ - int useNANDECC; /* Flag to decide whether or not to use NANDECC */ -+ int emptyLostAndFound; /* Auto-empty lost+found directory on mount */ ++ int empty_lost_n_found; /* Auto-empty lost+found directory on mount */ - void *genericDevice; /* Pointer to device context - * On an mtd this holds the mtd pointer. - */ - void *superBlock; -+ int refreshPeriod; /* How often we should check to do a block refresh */ ++ int refresh_period; /* How often we should check to do a block refresh */ + + /* Checkpoint control. Can be set before or after initialisation */ -+ __u8 skipCheckpointRead; -+ __u8 skipCheckpointWrite; ++ __u8 skip_checkpt_rd; ++ __u8 skip_checkpt_wr; + -+ int enableXattr; /* Enable xattribs */ ++ int enable_xattr; /* Enable xattribs */ /* NAND access functions (Must be set before calling YAFFS)*/ -@@ -589,58 +577,68 @@ struct yaffs_DeviceStruct { - yaffs_BlockState *state, __u32 *sequenceNumber); - #endif +- int (*writeChunkToNAND) (struct yaffs_DeviceStruct *dev, +- int chunkInNAND, const __u8 *data, +- const yaffs_Spare *spare); +- int (*readChunkFromNAND) (struct yaffs_DeviceStruct *dev, +- int chunkInNAND, __u8 *data, +- yaffs_Spare *spare); +- int (*eraseBlockInNAND) (struct yaffs_DeviceStruct *dev, +- int blockInNAND); +- int (*initialiseNAND) (struct yaffs_DeviceStruct *dev); +- int (*deinitialiseNAND) (struct yaffs_DeviceStruct *dev); ++ int (*write_chunk_fn) (struct yaffs_dev_s *dev, ++ int nand_chunk, const __u8 *data, ++ const yaffs_spare *spare); ++ int (*read_chunk_fn) (struct yaffs_dev_s *dev, ++ int nand_chunk, __u8 *data, ++ yaffs_spare *spare); ++ int (*erase_fn) (struct yaffs_dev_s *dev, ++ int flash_block); ++ int (*initialise_flash_fn) (struct yaffs_dev_s *dev); ++ int (*deinitialise_flash_fn) (struct yaffs_dev_s *dev); + #ifdef CONFIG_YAFFS_YAFFS2 +- int (*writeChunkWithTagsToNAND) (struct yaffs_DeviceStruct *dev, +- int chunkInNAND, const __u8 *data, +- const yaffs_ExtendedTags *tags); +- int (*readChunkWithTagsFromNAND) (struct yaffs_DeviceStruct *dev, +- int chunkInNAND, __u8 *data, +- yaffs_ExtendedTags *tags); +- int (*markNANDBlockBad) (struct yaffs_DeviceStruct *dev, int blockNo); +- int (*queryNANDBlock) (struct yaffs_DeviceStruct *dev, int blockNo, +- yaffs_BlockState *state, __u32 *sequenceNumber); +-#endif +- - int isYaffs2; - - /* The removeObjectCallback function must be supplied by OS flavours that +- /* The removeObjectCallback function must be supplied by OS flavours that - * need it. The Linux kernel does not use this, but yaffs direct does use - * it to implement the faster readdir ++ int (*write_chunk_tags_fn) (struct yaffs_dev_s *dev, ++ int nand_chunk, const __u8 *data, ++ const yaffs_ext_tags *tags); ++ int (*read_chunk_tags_fn) (struct yaffs_dev_s *dev, ++ int nand_chunk, __u8 *data, ++ yaffs_ext_tags *tags); ++ int (*bad_block_fn) (struct yaffs_dev_s *dev, int block_no); ++ int (*query_block_fn) (struct yaffs_dev_s *dev, int block_no, ++ yaffs_block_state_t *state, __u32 *seq_number); ++#endif ++ ++ /* The remove_obj_fn function must be supplied by OS flavours that + * need it. + * yaffs direct uses it to implement the faster readdir. + * Linux uses it to protect the directory during unlocking. */ - void (*removeObjectCallback)(struct yaffs_ObjectStruct *obj); +- void (*removeObjectCallback)(struct yaffs_ObjectStruct *obj); ++ void (*remove_obj_fn)(struct yaffs_obj_s *obj); - /* Callback to mark the superblock dirsty */ - void (*markSuperBlockDirty)(void *superblock); + /* Callback to mark the superblock dirty */ -+ void (*markSuperBlockDirty)(struct yaffs_DeviceStruct *dev); ++ void (*sb_dirty_fn)(struct yaffs_dev_s *dev); + + /* Callback to control garbage collection. */ -+ unsigned (*gcControl)(struct yaffs_DeviceStruct *dev); - ++ unsigned (*gc_control)(struct yaffs_dev_s *dev); ++ + /* Debug control flags. Don't use unless you know what you're doing */ -+ int useHeaderFileSize; /* Flag to determine if we should use file sizes from the header */ -+ int disableLazyLoad; /* Disable lazy loading on this device */ - int wideTnodesDisabled; /* Set to disable wide tnodes */ -+ int disableSoftDelete; /* yaffs 1 only: Set to disable the use of softdeletion. */ ++ int use_header_file_size; /* Flag to determine if we should use file sizes from the header */ ++ int disable_lazy_load; /* Disable lazy loading on this device */ ++ int wide_tnodes_disabled; /* Set to disable wide tnodes */ ++ int disable_soft_del; /* yaffs 1 only: Set to disable the use of softdeletion. */ + -+ int deferDirectoryUpdate; /* Set to defer directory updates */ -+ ++ int defered_dir_update; /* Set to defer directory updates */ + +- int wideTnodesDisabled; /* Set to disable wide tnodes */ +#ifdef CONFIG_YAFFS_AUTO_UNICODE -+ int autoUnicode; ++ int auto_unicode; +#endif -+ int alwaysCheckErased; /* Force chunk erased check always on */ ++ int always_check_erased; /* Force chunk erased check always on */ +}; - YCHAR *pathDividers; /* String of legal path dividers */ -+typedef struct yaffs_DeviceParamStruct yaffs_DeviceParam; ++typedef struct yaffs_param_s yaffs_param_t; -+struct yaffs_DeviceStruct { -+ struct yaffs_DeviceParamStruct param; ++struct yaffs_dev_s { ++ struct yaffs_param_s param; - /* End of stuff that must be set before initialisation. */ + /* Context storage. Holds extra OS specific data for this device */ @@ -14678,31 +16275,34 @@ - /* Checkpoint control. Can be set before or after initialisation */ - __u8 skipCheckpointRead; - __u8 skipCheckpointWrite; -+ void *osContext; -+ void *driverContext; ++ void *os_context; ++ void *driver_context; + -+ struct ylist_head devList; ++ struct ylist_head dev_list; /* Runtime parameters. Set up by YAFFS. */ -+ int nDataBytesPerChunk; ++ int data_bytes_per_chunk; - __u16 chunkGroupBits; /* 0 for devices <= 32MB. else log2(nchunks) - 16 */ +- __u16 chunkGroupSize; /* == 2^^chunkGroupBits */ + /* Non-wide tnode stuff */ -+ __u16 chunkGroupBits; /* Number of bits that need to be resolved if ++ __u16 chunk_grp_bits; /* Number of bits that need to be resolved if + * the tnodes are not wide enough. + */ - __u16 chunkGroupSize; /* == 2^^chunkGroupBits */ ++ __u16 chunk_grp_size; /* == 2^^chunk_grp_bits */ /* Stuff to support wide tnodes */ - __u32 tnodeWidth; - __u32 tnodeMask; -+ __u32 tnodeSize; +- __u32 tnodeWidth; +- __u32 tnodeMask; ++ __u32 tnode_width; ++ __u32 tnode_mask; ++ __u32 tnode_size; /* Stuff for figuring out file offset to chunk conversions */ - __u32 chunkShift; /* Shift value */ - __u32 chunkDiv; /* Divisor after shifting: 1 for power-of-2 sizes */ - __u32 chunkMask; /* Mask to use for power-of-2 case */ - +- __u32 chunkShift; /* Shift value */ +- __u32 chunkDiv; /* Divisor after shifting: 1 for power-of-2 sizes */ +- __u32 chunkMask; /* Mask to use for power-of-2 case */ +- - /* Stuff to handle inband tags */ - int inbandTags; - __u32 totalBytesPerChunk; @@ -14716,18 +16316,81 @@ - */ - void (*putSuperFunc) (struct super_block *sb); -#endif ++ __u32 chunk_shift; /* Shift value */ ++ __u32 chunk_div; /* Divisor after shifting: 1 for power-of-2 sizes */ ++ __u32 chunk_mask; /* Mask to use for power-of-2 case */ - int isMounted; -+ int isMounted; -+ int readOnly; - int isCheckpointed; - - -@@ -682,51 +680,31 @@ struct yaffs_DeviceStruct { - __u32 allocationPage; - int allocationBlockFinder; /* Used to search for next allocation block */ +- int isCheckpointed; ++ ++ int is_mounted; ++ int read_only; ++ int is_checkpointed; + + + /* Stuff to support block offsetting to support start block zero */ +- int internalStartBlock; +- int internalEndBlock; +- int blockOffset; +- int chunkOffset; ++ int internal_start_block; ++ int internal_end_block; ++ int block_offset; ++ int chunk_offset; + + + /* Runtime checkpointing stuff */ +- int checkpointPageSequence; /* running sequence number of checkpoint pages */ +- int checkpointByteCount; +- int checkpointByteOffset; +- __u8 *checkpointBuffer; +- int checkpointOpenForWrite; +- int blocksInCheckpoint; +- int checkpointCurrentChunk; +- int checkpointCurrentBlock; +- int checkpointNextBlock; +- int *checkpointBlockList; +- int checkpointMaxBlocks; +- __u32 checkpointSum; +- __u32 checkpointXor; ++ int checkpt_page_seq; /* running sequence number of checkpoint pages */ ++ int checkpt_byte_count; ++ int checkpt_byte_offs; ++ __u8 *checkpt_buffer; ++ int checkpt_open_write; ++ int blocks_in_checkpt; ++ int checkpt_cur_chunk; ++ int checkpt_cur_block; ++ int checkpt_next_block; ++ int *checkpt_block_list; ++ int checkpt_max_blocks; ++ __u32 checkpt_sum; ++ __u32 checkpt_xor; + +- int nCheckpointBlocksRequired; /* Number of blocks needed to store current checkpoint set */ ++ int checkpoint_blocks_required; /* Number of blocks needed to store current checkpoint set */ + + /* Block Info */ +- yaffs_BlockInfo *blockInfo; +- __u8 *chunkBits; /* bitmap of chunks in use */ +- unsigned blockInfoAlt:1; /* was allocated using alternative strategy */ +- unsigned chunkBitsAlt:1; /* was allocated using alternative strategy */ +- int chunkBitmapStride; /* Number of bytes of chunkBits per block. +- * Must be consistent with nChunksPerBlock. ++ yaffs_block_info_t *block_info; ++ __u8 *chunk_bits; /* bitmap of chunks in use */ ++ unsigned block_info_alt:1; /* was allocated using alternative strategy */ ++ unsigned chunk_bits_alt:1; /* was allocated using alternative strategy */ ++ int chunk_bit_stride; /* Number of bytes of chunk_bits per block. ++ * Must be consistent with chunks_per_block. + */ +- int nErasedBlocks; +- int allocationBlock; /* Current block being allocated off */ +- __u32 allocationPage; +- int allocationBlockFinder; /* Used to search for next allocation block */ +- - /* Runtime state */ - int nTnodesCreated; - yaffs_Tnode *freeTnodes; @@ -14741,27 +16404,20 @@ - int nObjectsCreated; - yaffs_Object *freeObjects; - int nFreeObjects; -+ /* Object and Tnode memory management */ -+ void *allocator; -+ int nObjects; -+ int nTnodes; - - int nHardLinks; - +- +- int nHardLinks; +- - yaffs_ObjectList *allocatedObjectList; - - yaffs_ObjectBucket objectBucket[YAFFS_NOBJECT_BUCKETS]; -+ __u32 bucketFinder; - - int nFreeChunks; - +- yaffs_ObjectBucket objectBucket[YAFFS_NOBJECT_BUCKETS]; +- +- int nFreeChunks; +- - int currentDirtyChecker; /* Used to find current dirtiest block */ - -+ /* Garbage collection control */ - __u32 *gcCleanupList; /* objects to delete at the end of a GC. */ +- __u32 *gcCleanupList; /* objects to delete at the end of a GC. */ - int nonAggressiveSkip; /* GC state/mode */ -+ __u32 nCleanups; - +- - /* Statistcs */ - int nPageWrites; - int nPageReads; @@ -14780,88 +16436,192 @@ - int nUnmarkedDeletions; - - int hasPendingPrioritisedGCs; /* We think this device might have pending prioritised gcs */ -+ unsigned hasPendingPrioritisedGCs; /* We think this device might have pending prioritised gcs */ -+ unsigned gcDisable; -+ unsigned gcBlockFinder; -+ unsigned gcDirtiest; -+ unsigned gcPagesInUse; -+ unsigned gcNotDone; -+ unsigned gcBlock; -+ unsigned gcChunk; -+ unsigned gcSkip; ++ int n_erased_blocks; ++ int alloc_block; /* Current block being allocated off */ ++ __u32 alloc_page; ++ int alloc_block_finder; /* Used to search for next allocation block */ ++ ++ /* Object and Tnode memory management */ ++ void *allocator; ++ int n_obj; ++ int n_tnodes; ++ ++ int n_hardlinks; ++ ++ yaffs_obj_bucket obj_bucket[YAFFS_NOBJECT_BUCKETS]; ++ __u32 bucket_finder; ++ ++ int n_free_chunks; ++ ++ /* Garbage collection control */ ++ __u32 *gc_cleanup_list; /* objects to delete at the end of a GC. */ ++ __u32 n_clean_ups; ++ ++ unsigned has_pending_prioritised_gc; /* We think this device might have pending prioritised gcs */ ++ unsigned gc_disable; ++ unsigned gc_block_finder; ++ unsigned gc_dirtiest; ++ unsigned gc_pages_in_use; ++ unsigned gc_not_done; ++ unsigned gc_block; ++ unsigned gc_chunk; ++ unsigned gc_skip; /* Special directories */ - yaffs_Object *rootDir; -@@ -743,8 +721,6 @@ struct yaffs_DeviceStruct { - yaffs_ChunkCache *srCache; - int srLastUse; +- yaffs_Object *rootDir; +- yaffs_Object *lostNFoundDir; ++ yaffs_obj_t *root_dir; ++ yaffs_obj_t *lost_n_found; + + /* Buffer areas for storing data to recover from write failures TODO +- * __u8 bufferedData[YAFFS_CHUNKS_PER_BLOCK][YAFFS_BYTES_PER_CHUNK]; +- * yaffs_Spare bufferedSpare[YAFFS_CHUNKS_PER_BLOCK]; ++ * __u8 buffered_data[YAFFS_CHUNKS_PER_BLOCK][YAFFS_BYTES_PER_CHUNK]; ++ * yaffs_spare buffered_spare[YAFFS_CHUNKS_PER_BLOCK]; + */ -- int cacheHits; +- int bufferedBlock; /* Which block is buffered here? */ +- int doingBufferedBlockRewrite; - +- yaffs_ChunkCache *srCache; +- int srLastUse; ++ int buffered_block; /* Which block is buffered here? */ ++ int doing_buffered_block_rewrite; + +- int cacheHits; ++ yaffs_cache_t *cache; ++ int cache_last_use; + /* Stuff for background deletion and unlinked files.*/ - yaffs_Object *unlinkedDir; /* Directory where unlinked and deleted files live. */ - yaffs_Object *deletedDir; /* Directory where deleted objects are sent to disappear. */ -@@ -753,7 +729,6 @@ struct yaffs_DeviceStruct { - int nUnlinkedFiles; /* Count of unlinked files. */ - int nBackgroundDeletions; /* Count of background deletions. */ +- yaffs_Object *unlinkedDir; /* Directory where unlinked and deleted files live. */ +- yaffs_Object *deletedDir; /* Directory where deleted objects are sent to disappear. */ +- yaffs_Object *unlinkedDeletion; /* Current file being background deleted.*/ +- int nDeletedFiles; /* Count of files awaiting deletion;*/ +- int nUnlinkedFiles; /* Count of unlinked files. */ +- int nBackgroundDeletions; /* Count of background deletions. */ +- ++ yaffs_obj_t *unlinked_dir; /* Directory where unlinked and deleted files live. */ ++ yaffs_obj_t *del_dir; /* Directory where deleted objects are sent to disappear. */ ++ yaffs_obj_t *unlinked_deletion; /* Current file being background deleted.*/ ++ int n_deleted_files; /* Count of files awaiting deletion;*/ ++ int n_unlinked_files; /* Count of unlinked files. */ ++ int n_bg_deletions; /* Count of background deletions. */ -- /* Temporary buffer management */ - yaffs_TempBuffer tempBuffer[YAFFS_N_TEMP_BUFFERS]; - int maxTemp; -@@ -764,6 +739,36 @@ struct yaffs_DeviceStruct { +- yaffs_TempBuffer tempBuffer[YAFFS_N_TEMP_BUFFERS]; +- int maxTemp; +- int tempInUse; +- int unmanagedTempAllocations; +- int unmanagedTempDeallocations; ++ yaffs_buffer_t temp_buffer[YAFFS_N_TEMP_BUFFERS]; ++ int max_temp; ++ int temp_in_use; ++ int unmanaged_buffer_allocs; ++ int unmanaged_buffer_deallocs; + /* yaffs2 runtime stuff */ - unsigned sequenceNumber; /* Sequence number of currently allocating block */ - unsigned oldestDirtySequence; -+ unsigned oldestDirtyBlock; +- unsigned sequenceNumber; /* Sequence number of currently allocating block */ +- unsigned oldestDirtySequence; ++ unsigned seq_number; /* Sequence number of currently allocating block */ ++ unsigned oldest_dirty_seq; ++ unsigned oldest_dirty_block; + + /* Block refreshing */ -+ int refreshSkip; /* A skip down counter. Refresh happens when this gets to zero. */ ++ int refresh_skip; /* A skip down counter. Refresh happens when this gets to zero. */ + + /* Dirty directory handling */ -+ struct ylist_head dirtyDirectories; /* List of dirty directories */ ++ struct ylist_head dirty_dirs; /* List of dirty directories */ + + + /* Statistcs */ -+ __u32 nPageWrites; -+ __u32 nPageReads; -+ __u32 nBlockErasures; -+ __u32 nErasureFailures; -+ __u32 nGCCopies; -+ __u32 allGCs; -+ __u32 passiveGCs; -+ __u32 oldestDirtyGCs; -+ __u32 nGCBlocks; -+ __u32 backgroundGCs; -+ __u32 nRetriedWrites; -+ __u32 nRetiredBlocks; -+ __u32 eccFixed; -+ __u32 eccUnfixed; -+ __u32 tagsEccFixed; -+ __u32 tagsEccUnfixed; -+ __u32 nDeletions; -+ __u32 nUnmarkedDeletions; -+ __u32 refreshCount; -+ __u32 cacheHits; ++ __u32 n_page_writes; ++ __u32 n_page_reads; ++ __u32 n_erasures; ++ __u32 n_erase_failures; ++ __u32 n_gc_copies; ++ __u32 all_gcs; ++ __u32 passive_gc_count; ++ __u32 oldest_dirty_gc_count; ++ __u32 n_gc_blocks; ++ __u32 bg_gcs; ++ __u32 n_retired_writes; ++ __u32 n_retired_blocks; ++ __u32 n_ecc_fixed; ++ __u32 n_ecc_unfixed; ++ __u32 n_tags_ecc_fixed; ++ __u32 n_tags_ecc_unfixed; ++ __u32 n_deletions; ++ __u32 n_unmarked_deletions; ++ __u32 refresh_count; ++ __u32 cache_hits; }; -@@ -796,7 +801,6 @@ typedef struct { +-typedef struct yaffs_DeviceStruct yaffs_Device; ++typedef struct yaffs_dev_s yaffs_dev_t; + + /* The static layout of block usage etc is stored in the super block header */ + typedef struct { + int StructType; + int version; +- int checkpointStartBlock; +- int checkpointEndBlock; +- int startBlock; +- int endBlock; ++ int checkpt_start_block; ++ int checkpt_end_block; ++ int start_block; ++ int end_block; + int rfu[100]; +-} yaffs_SuperBlockHeader; ++} yaffs_sb_header; + + /* The CheckpointDevice structure holds the device information that changes at runtime and + * must be preserved over unmount/mount cycles. + */ + typedef struct { +- int structType; +- int nErasedBlocks; +- int allocationBlock; /* Current block being allocated off */ +- __u32 allocationPage; +- int nFreeChunks; +- +- int nDeletedFiles; /* Count of files awaiting deletion;*/ +- int nUnlinkedFiles; /* Count of unlinked files. */ +- int nBackgroundDeletions; /* Count of background deletions. */ ++ int struct_type; ++ int n_erased_blocks; ++ int alloc_block; /* Current block being allocated off */ ++ __u32 alloc_page; ++ int n_free_chunks; ++ ++ int n_deleted_files; /* Count of files awaiting deletion;*/ ++ int n_unlinked_files; /* Count of unlinked files. */ ++ int n_bg_deletions; /* Count of background deletions. */ /* yaffs2 runtime stuff */ - unsigned sequenceNumber; /* Sequence number of currently allocating block */ +- unsigned sequenceNumber; /* Sequence number of currently allocating block */ - unsigned oldestDirtySequence; ++ unsigned seq_number; /* Sequence number of currently allocating block */ - } yaffs_CheckpointDevice; +-} yaffs_CheckpointDevice; ++} yaffs_checkpt_dev_t; -@@ -809,6 +813,23 @@ typedef struct { - } yaffs_CheckpointValidity; - -+struct yaffs_ShadowFixerStruct { -+ int objectId; -+ int shadowedId; -+ struct yaffs_ShadowFixerStruct *next; + typedef struct { +- int structType; ++ int struct_type; + __u32 magic; + __u32 version; + __u32 head; +-} yaffs_CheckpointValidity; ++} yaffs_checkpt_validty_t; ++ ++ ++struct yaffs_shadow_fixer_s { ++ int obj_id; ++ int shadowed_id; ++ struct yaffs_shadow_fixer_s *next; +}; + +/* Structure for doing xattr modifications */ @@ -14872,103 +16632,199 @@ + int size; + int flags; + int result; -+}yaffs_XAttrMod; -+ -+ ++}yaffs_xattr_mod; + + /*----------------------- YAFFS Functions -----------------------*/ - int yaffs_GutsInitialise(yaffs_Device *dev); -@@ -840,7 +861,8 @@ int yaffs_ResizeFile(yaffs_Object *obj, +-int yaffs_GutsInitialise(yaffs_Device *dev); +-void yaffs_Deinitialise(yaffs_Device *dev); ++int yaffs_guts_initialise(yaffs_dev_t *dev); ++void yaffs_deinitialise(yaffs_dev_t *dev); + +-int yaffs_GetNumberOfFreeChunks(yaffs_Device *dev); ++int yaffs_get_n_free_chunks(yaffs_dev_t *dev); + +-int yaffs_RenameObject(yaffs_Object *oldDir, const YCHAR *oldName, +- yaffs_Object *newDir, const YCHAR *newName); ++int yaffs_rename_obj(yaffs_obj_t *old_dir, const YCHAR *old_name, ++ yaffs_obj_t *new_dir, const YCHAR *new_name); + +-int yaffs_Unlink(yaffs_Object *dir, const YCHAR *name); +-int yaffs_DeleteObject(yaffs_Object *obj); ++int yaffs_unlinker(yaffs_obj_t *dir, const YCHAR *name); ++int yaffs_del_obj(yaffs_obj_t *obj); + +-int yaffs_GetObjectName(yaffs_Object *obj, YCHAR *name, int buffSize); +-int yaffs_GetObjectFileLength(yaffs_Object *obj); +-int yaffs_GetObjectInode(yaffs_Object *obj); +-unsigned yaffs_GetObjectType(yaffs_Object *obj); +-int yaffs_GetObjectLinkCount(yaffs_Object *obj); ++int yaffs_get_obj_name(yaffs_obj_t *obj, YCHAR *name, int buffer_size); ++int yaffs_get_obj_length(yaffs_obj_t *obj); ++int yaffs_get_obj_inode(yaffs_obj_t *obj); ++unsigned yaffs_get_obj_type(yaffs_obj_t *obj); ++int yaffs_get_obj_link_count(yaffs_obj_t *obj); + +-int yaffs_SetAttributes(yaffs_Object *obj, struct iattr *attr); +-int yaffs_GetAttributes(yaffs_Object *obj, struct iattr *attr); ++int yaffs_set_attribs(yaffs_obj_t *obj, struct iattr *attr); ++int yaffs_get_attribs(yaffs_obj_t *obj, struct iattr *attr); + + /* File operations */ +-int yaffs_ReadDataFromFile(yaffs_Object *obj, __u8 *buffer, loff_t offset, +- int nBytes); +-int yaffs_WriteDataToFile(yaffs_Object *obj, const __u8 *buffer, loff_t offset, +- int nBytes, int writeThrough); +-int yaffs_ResizeFile(yaffs_Object *obj, loff_t newSize); ++int yaffs_file_rd(yaffs_obj_t *obj, __u8 *buffer, loff_t offset, ++ int n_bytes); ++int yaffs_wr_file(yaffs_obj_t *obj, const __u8 *buffer, loff_t offset, ++ int n_bytes, int write_trhrough); ++int yaffs_resize_file(yaffs_obj_t *obj, loff_t new_size); - yaffs_Object *yaffs_MknodFile(yaffs_Object *parent, const YCHAR *name, +-yaffs_Object *yaffs_MknodFile(yaffs_Object *parent, const YCHAR *name, ++yaffs_obj_t *yaffs_create_file(yaffs_obj_t *parent, const YCHAR *name, __u32 mode, __u32 uid, __u32 gid); -int yaffs_FlushFile(yaffs_Object *obj, int updateTime); + -+int yaffs_FlushFile(yaffs_Object *obj, int updateTime, int dataSync); ++int yaffs_flush_file(yaffs_obj_t *obj, int update_time, int data_sync); /* Flushing and checkpointing */ - void yaffs_FlushEntireDeviceCache(yaffs_Device *dev); -@@ -873,6 +895,12 @@ YCHAR *yaffs_GetSymlinkAlias(yaffs_Objec - yaffs_Object *yaffs_MknodSpecial(yaffs_Object *parent, const YCHAR *name, +-void yaffs_FlushEntireDeviceCache(yaffs_Device *dev); ++void yaffs_flush_whole_cache(yaffs_dev_t *dev); + +-int yaffs_CheckpointSave(yaffs_Device *dev); +-int yaffs_CheckpointRestore(yaffs_Device *dev); ++int yaffs_checkpoint_save(yaffs_dev_t *dev); ++int yaffs_checkpoint_restore(yaffs_dev_t *dev); + + /* Directory operations */ +-yaffs_Object *yaffs_MknodDirectory(yaffs_Object *parent, const YCHAR *name, ++yaffs_obj_t *yaffs_create_dir(yaffs_obj_t *parent, const YCHAR *name, + __u32 mode, __u32 uid, __u32 gid); +-yaffs_Object *yaffs_FindObjectByName(yaffs_Object *theDir, const YCHAR *name); +-int yaffs_ApplyToDirectoryChildren(yaffs_Object *theDir, +- int (*fn) (yaffs_Object *)); ++yaffs_obj_t *yaffs_find_by_name(yaffs_obj_t *the_dir, const YCHAR *name); ++int yaffs_ApplyToDirectoryChildren(yaffs_obj_t *the_dir, ++ int (*fn) (yaffs_obj_t *)); + +-yaffs_Object *yaffs_FindObjectByNumber(yaffs_Device *dev, __u32 number); ++yaffs_obj_t *yaffs_find_by_number(yaffs_dev_t *dev, __u32 number); + + /* Link operations */ +-yaffs_Object *yaffs_Link(yaffs_Object *parent, const YCHAR *name, +- yaffs_Object *equivalentObject); ++yaffs_obj_t *yaffs_link_obj(yaffs_obj_t *parent, const YCHAR *name, ++ yaffs_obj_t *equiv_obj); + +-yaffs_Object *yaffs_GetEquivalentObject(yaffs_Object *obj); ++yaffs_obj_t *yaffs_get_equivalent_obj(yaffs_obj_t *obj); + + /* Symlink operations */ +-yaffs_Object *yaffs_MknodSymLink(yaffs_Object *parent, const YCHAR *name, ++yaffs_obj_t *yaffs_create_symlink(yaffs_obj_t *parent, const YCHAR *name, + __u32 mode, __u32 uid, __u32 gid, + const YCHAR *alias); +-YCHAR *yaffs_GetSymlinkAlias(yaffs_Object *obj); ++YCHAR *yaffs_get_symlink_alias(yaffs_obj_t *obj); + + /* Special inodes (fifos, sockets and devices) */ +-yaffs_Object *yaffs_MknodSpecial(yaffs_Object *parent, const YCHAR *name, ++yaffs_obj_t *yaffs_create_special(yaffs_obj_t *parent, const YCHAR *name, __u32 mode, __u32 uid, __u32 gid, __u32 rdev); + -+int yaffs_SetXAttribute(yaffs_Object *obj, const YCHAR *name, const void * value, int size, int flags); -+int yaffs_GetXAttribute(yaffs_Object *obj, const YCHAR *name, void *value, int size); -+int yaffs_ListXAttributes(yaffs_Object *obj, char *buffer, int size); -+int yaffs_RemoveXAttribute(yaffs_Object *obj, const YCHAR *name); ++int yaffs_set_xattrib(yaffs_obj_t *obj, const YCHAR *name, const void * value, int size, int flags); ++int yaffs_get_xattrib(yaffs_obj_t *obj, const YCHAR *name, void *value, int size); ++int yaffs_list_xattrib(yaffs_obj_t *obj, char *buffer, int size); ++int yaffs_remove_xattrib(yaffs_obj_t *obj, const YCHAR *name); + /* Special directories */ - yaffs_Object *yaffs_Root(yaffs_Device *dev); - yaffs_Object *yaffs_LostNFound(yaffs_Device *dev); -@@ -882,18 +910,18 @@ yaffs_Object *yaffs_LostNFound(yaffs_Dev - void yfsd_WinFileTimeNow(__u32 target[2]); +-yaffs_Object *yaffs_Root(yaffs_Device *dev); +-yaffs_Object *yaffs_LostNFound(yaffs_Device *dev); ++yaffs_obj_t *yaffs_root(yaffs_dev_t *dev); ++yaffs_obj_t *yaffs_lost_n_found(yaffs_dev_t *dev); + + #ifdef CONFIG_YAFFS_WINCE + /* CONFIG_YAFFS_WINCE special stuff */ +-void yfsd_WinFileTimeNow(__u32 target[2]); ++void yfsd_win_file_time_now(__u32 target[2]); #endif -#ifdef __KERNEL__ -- - void yaffs_HandleDeferedFree(yaffs_Object *obj); ++void yaffs_handle_defered_free(yaffs_obj_t *obj); + +-void yaffs_HandleDeferedFree(yaffs_Object *obj); -#endif ++void yaffs_update_dirty_dirs(yaffs_dev_t *dev); + -+void yaffs_UpdateDirtyDirectories(yaffs_Device *dev); -+ -+int yaffs_BackgroundGarbageCollect(yaffs_Device *dev, unsigned urgency); ++int yaffs_bg_gc(yaffs_dev_t *dev, unsigned urgency); /* Debug dump */ - int yaffs_DumpObject(yaffs_Object *obj); +-int yaffs_DumpObject(yaffs_Object *obj); ++int yaffs_dump_obj(yaffs_obj_t *obj); - void yaffs_GutsTest(yaffs_Device *dev); +-void yaffs_GutsTest(yaffs_Device *dev); ++void yaffs_guts_test(yaffs_dev_t *dev); -/* A few useful functions */ -void yaffs_InitialiseTags(yaffs_ExtendedTags *tags); +-void yaffs_DeleteChunk(yaffs_Device *dev, int chunkId, int markNAND, int lyn); +-int yaffs_CheckFF(__u8 *buffer, int nBytes); +-void yaffs_HandleChunkError(yaffs_Device *dev, yaffs_BlockInfo *bi); +/* A few useful functions to be used within the core files*/ - void yaffs_DeleteChunk(yaffs_Device *dev, int chunkId, int markNAND, int lyn); - int yaffs_CheckFF(__u8 *buffer, int nBytes); - void yaffs_HandleChunkError(yaffs_Device *dev, yaffs_BlockInfo *bi); -@@ -901,4 +929,41 @@ void yaffs_HandleChunkError(yaffs_Device - __u8 *yaffs_GetTempBuffer(yaffs_Device *dev, int lineNo); - void yaffs_ReleaseTempBuffer(yaffs_Device *dev, __u8 *buffer, int lineNo); - -+yaffs_Object *yaffs_FindOrCreateObjectByNumber(yaffs_Device *dev, -+ int number, -+ yaffs_ObjectType type); -+int yaffs_PutChunkIntoFile(yaffs_Object *in, int chunkInInode, -+ int chunkInNAND, int inScan); -+void yaffs_SetObjectName(yaffs_Object *obj, const YCHAR *name); -+void yaffs_SetObjectNameFromOH(yaffs_Object *obj, const yaffs_ObjectHeader *oh); -+void yaffs_AddObjectToDirectory(yaffs_Object *directory, -+ yaffs_Object *obj); -+YCHAR *yaffs_CloneString(const YCHAR *str); -+void yaffs_HardlinkFixup(yaffs_Device *dev, yaffs_Object *hardList); -+void yaffs_BlockBecameDirty(yaffs_Device *dev, int blockNo); -+int yaffs_UpdateObjectHeader(yaffs_Object *in, const YCHAR *name, -+ int force, int isShrink, int shadows, -+ yaffs_XAttrMod *xop); -+void yaffs_HandleShadowedObject(yaffs_Device *dev, int objId, -+ int backwardScanning); -+int yaffs_CheckSpaceForAllocation(yaffs_Device *dev, int nChunks); -+yaffs_Tnode *yaffs_GetTnode(yaffs_Device *dev); -+yaffs_Tnode *yaffs_AddOrFindLevel0Tnode(yaffs_Device *dev, -+ yaffs_FileStructure *fStruct, -+ __u32 chunkId, -+ yaffs_Tnode *passedTn); -+ -+int yaffs_DoWriteDataToFile(yaffs_Object *in, const __u8 *buffer, loff_t offset, -+ int nBytes, int writeThrough); -+void yaffs_ResizeDown( yaffs_Object *obj, loff_t newSize); -+void yaffs_SkipRestOfBlock(yaffs_Device *dev); -+ -+int yaffs_CountFreeChunks(yaffs_Device *dev); -+ -+yaffs_Tnode *yaffs_FindLevel0Tnode(yaffs_Device *dev, -+ yaffs_FileStructure *fStruct, -+ __u32 chunkId); -+ -+__u32 yaffs_GetChunkGroupBase(yaffs_Device *dev, yaffs_Tnode *tn, unsigned pos); ++void yaffs_chunk_del(yaffs_dev_t *dev, int chunk_id, int mark_flash, int lyn); ++int yaffs_check_ff(__u8 *buffer, int n_bytes); ++void yaffs_handle_chunk_error(yaffs_dev_t *dev, yaffs_block_info_t *bi); ++ ++__u8 *yaffs_get_temp_buffer(yaffs_dev_t *dev, int line_no); ++void yaffs_release_temp_buffer(yaffs_dev_t *dev, __u8 *buffer, int line_no); + ++yaffs_obj_t *yaffs_find_or_create_by_number(yaffs_dev_t *dev, ++ int number, ++ yaffs_obj_type type); ++int yaffs_put_chunk_in_file(yaffs_obj_t *in, int inode_chunk, ++ int nand_chunk, int in_scan); ++void yaffs_set_obj_name(yaffs_obj_t *obj, const YCHAR *name); ++void yaffs_set_obj_name_from_oh(yaffs_obj_t *obj, const yaffs_obj_header *oh); ++void yaffs_add_obj_to_dir(yaffs_obj_t *directory, ++ yaffs_obj_t *obj); ++YCHAR *yaffs_clone_str(const YCHAR *str); ++void yaffs_link_fixup(yaffs_dev_t *dev, yaffs_obj_t *hard_list); ++void yaffs_block_became_dirty(yaffs_dev_t *dev, int block_no); ++int yaffs_update_oh(yaffs_obj_t *in, const YCHAR *name, ++ int force, int is_shrink, int shadows, ++ yaffs_xattr_mod *xop); ++void yaffs_handle_shadowed_obj(yaffs_dev_t *dev, int obj_id, ++ int backward_scanning); ++int yaffs_check_alloc_available(yaffs_dev_t *dev, int n_chunks); ++yaffs_tnode_t *yaffs_get_tnode(yaffs_dev_t *dev); ++yaffs_tnode_t *yaffs_add_find_tnode_0(yaffs_dev_t *dev, ++ yaffs_file_s *file_struct, ++ __u32 chunk_id, ++ yaffs_tnode_t *passed_tn); ++ ++int yaffs_do_file_wr(yaffs_obj_t *in, const __u8 *buffer, loff_t offset, ++ int n_bytes, int write_trhrough); ++void yaffs_resize_file_down( yaffs_obj_t *obj, loff_t new_size); ++void yaffs_skip_rest_of_block(yaffs_dev_t *dev); ++ ++int yaffs_count_free_chunks(yaffs_dev_t *dev); ++ ++yaffs_tnode_t *yaffs_find_tnode_0(yaffs_dev_t *dev, ++ yaffs_file_s *file_struct, ++ __u32 chunk_id); + +-__u8 *yaffs_GetTempBuffer(yaffs_Device *dev, int lineNo); +-void yaffs_ReleaseTempBuffer(yaffs_Device *dev, __u8 *buffer, int lineNo); ++__u32 yaffs_get_group_base(yaffs_dev_t *dev, yaffs_tnode_t *tn, unsigned pos); + #endif ---- a/fs/yaffs2/yaffsinterface.h -+++ b/fs/yaffs2/yaffsinterface.h +diff -Nrup linux-2.6.36-rc8/fs/yaffs2/yaffsinterface.h linux-2.6.36-rc8.new/fs/yaffs2/yaffsinterface.h +--- linux-2.6.36-rc8/fs/yaffs2/yaffsinterface.h 2010-10-20 13:17:58.955000294 +0300 ++++ linux-2.6.36-rc8.new/fs/yaffs2/yaffsinterface.h 2010-10-20 13:28:16.061000294 +0300 @@ -1,7 +1,7 @@ /* * YAFFS: Yet another Flash File System . A NAND-flash specific file system. @@ -14978,8 +16834,17 @@ * for Toby Churchill Ltd and Brightstar Engineering * * Created by Charles Manning <charles@aleph1.co.uk> ---- /dev/null -+++ b/fs/yaffs2/yaffs_linux_allocator.c +@@ -16,6 +16,6 @@ + #ifndef __YAFFSINTERFACE_H__ + #define __YAFFSINTERFACE_H__ + +-int yaffs_Initialise(unsigned nBlocks); ++int yaffs_initialise(unsigned nBlocks); + + #endif +diff -Nrup linux-2.6.36-rc8/fs/yaffs2/yaffs_linux_allocator.c linux-2.6.36-rc8.new/fs/yaffs2/yaffs_linux_allocator.c +--- linux-2.6.36-rc8/fs/yaffs2/yaffs_linux_allocator.c 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.36-rc8.new/fs/yaffs2/yaffs_linux_allocator.c 2010-10-20 13:28:16.028000294 +0300 @@ -0,0 +1,200 @@ +/* + * YAFFS: Yet another Flash File System . A NAND-flash specific file system. @@ -15023,7 +16888,7 @@ + +int mount_id; + -+void yaffs_DeinitialiseRawTnodesAndObjects(yaffs_Device *dev) ++void yaffs_deinit_raw_tnodes_and_objs(yaffs_dev_t *dev) +{ + yaffs_Allocator *allocator = (yaffs_Allocator *)dev->allocator; + @@ -15083,10 +16948,10 @@ + fake_ctor9, +}; + -+void yaffs_InitialiseRawTnodesAndObjects(yaffs_Device *dev) ++void yaffs_init_raw_tnodes_and_objs(yaffs_dev_t *dev) +{ + yaffs_Allocator *allocator; -+ unsigned mount_id = yaffs_DeviceToLC(dev)->mount_id; ++ unsigned mount_id = yaffs_dev_to_lc(dev)->mount_id; + + T(YAFFS_TRACE_ALLOCATE,(TSTR("Initialising yaffs allocator\n"))); + @@ -15112,7 +16977,7 @@ + + allocator->tnode_cache = + kmem_cache_create(allocator->tnode_name, -+ dev->tnodeSize, ++ dev->tnode_size, + 0, 0, + fake_ctor_list[mount_id]); + if(allocator->tnode_cache) @@ -15128,7 +16993,7 @@ + + allocator->object_cache = + kmem_cache_create(allocator->object_name, -+ sizeof(yaffs_Object), ++ sizeof(yaffs_obj_t), + 0, 0, + fake_ctor_list[mount_id]); + @@ -15146,7 +17011,7 @@ +} + + -+yaffs_Tnode *yaffs_AllocateRawTnode(yaffs_Device *dev) ++yaffs_tnode_t *yaffs_alloc_raw_tnode(yaffs_dev_t *dev) +{ + yaffs_Allocator *allocator = dev->allocator; + if(!allocator || !allocator->tnode_cache){ @@ -15156,13 +17021,13 @@ + return kmem_cache_alloc(allocator->tnode_cache, GFP_NOFS); +} + -+void yaffs_FreeRawTnode(yaffs_Device *dev, yaffs_Tnode *tn) ++void yaffs_free_raw_tnode(yaffs_dev_t *dev, yaffs_tnode_t *tn) +{ + yaffs_Allocator *allocator = dev->allocator; + kmem_cache_free(allocator->tnode_cache,tn); +} + -+yaffs_Object *yaffs_AllocateRawObject(yaffs_Device *dev) ++yaffs_obj_t *yaffs_alloc_raw_obj(yaffs_dev_t *dev) +{ + yaffs_Allocator *allocator = dev->allocator; + if(!allocator){ @@ -15176,13 +17041,14 @@ + return kmem_cache_alloc(allocator->object_cache, GFP_NOFS); +} + -+void yaffs_FreeRawObject(yaffs_Device *dev, yaffs_Object *obj) ++void yaffs_free_raw_obj(yaffs_dev_t *dev, yaffs_obj_t *obj) +{ + yaffs_Allocator *allocator = dev->allocator; + kmem_cache_free(allocator->object_cache,obj); +} ---- /dev/null -+++ b/fs/yaffs2/yaffs_linux.h +diff -Nrup linux-2.6.36-rc8/fs/yaffs2/yaffs_linux.h linux-2.6.36-rc8.new/fs/yaffs2/yaffs_linux.h +--- linux-2.6.36-rc8/fs/yaffs2/yaffs_linux.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.36-rc8.new/fs/yaffs2/yaffs_linux.h 2010-10-20 13:28:16.061000294 +0300 @@ -0,0 +1,43 @@ +/* + * YAFFS: Yet another Flash File System . A NAND-flash specific file system. @@ -15207,7 +17073,7 @@ + +struct yaffs_LinuxContext { + struct ylist_head contextList; /* List of these we have mounted */ -+ struct yaffs_DeviceStruct *dev; ++ struct yaffs_dev_s *dev; + struct super_block * superBlock; + struct task_struct *bgThread; /* Background thread for this device */ + int bgRunning; @@ -15222,13 +17088,14 @@ + unsigned mount_id; +}; + -+#define yaffs_DeviceToLC(dev) ((struct yaffs_LinuxContext *)((dev)->osContext)) -+#define yaffs_DeviceToMtd(dev) ((struct mtd_info *)((dev)->driverContext)) ++#define yaffs_dev_to_lc(dev) ((struct yaffs_LinuxContext *)((dev)->os_context)) ++#define yaffs_dev_to_mtd(dev) ((struct mtd_info *)((dev)->driver_context)) + +#endif + ---- /dev/null -+++ b/fs/yaffs2/yaffs_list.h +diff -Nrup linux-2.6.36-rc8/fs/yaffs2/yaffs_list.h linux-2.6.36-rc8.new/fs/yaffs2/yaffs_list.h +--- linux-2.6.36-rc8/fs/yaffs2/yaffs_list.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.36-rc8.new/fs/yaffs2/yaffs_list.h 2010-10-20 13:28:16.062000294 +0300 @@ -0,0 +1,127 @@ +/* + * YAFFS: Yet another Flash File System . A NAND-flash specific file system. @@ -15357,8 +17224,9 @@ + + +#endif ---- a/fs/yaffs2/yaffs_mtdif1.c -+++ b/fs/yaffs2/yaffs_mtdif1.c +diff -Nrup linux-2.6.36-rc8/fs/yaffs2/yaffs_mtdif1.c linux-2.6.36-rc8.new/fs/yaffs2/yaffs_mtdif1.c +--- linux-2.6.36-rc8/fs/yaffs2/yaffs_mtdif1.c 2010-10-20 13:17:58.956000294 +0300 ++++ linux-2.6.36-rc8.new/fs/yaffs2/yaffs_mtdif1.c 2010-10-20 13:28:16.028000294 +0300 @@ -2,7 +2,7 @@ * YAFFS: Yet another FFS. A NAND-flash specific file system. * yaffs_mtdif1.c NAND mtd interface functions for small-page NAND. @@ -15368,14 +17236,23 @@ * for Toby Churchill Ltd and Brightstar Engineering * * This program is free software; you can redistribute it and/or modify -@@ -24,9 +24,11 @@ +@@ -18,15 +18,17 @@ + * + * These functions are invoked via function pointers in yaffs_nand.c. + * This replaces functionality provided by functions in yaffs_mtdif.c +- * and the yaffs_TagsCompatability functions in yaffs_tagscompat.c that are ++ * and the yaffs_tags_tCompatability functions in yaffs_tagscompat.c that are + * called in yaffs_mtdif.c when the function pointers are NULL. +- * We assume the MTD layer is performing ECC (useNANDECC is true). ++ * We assume the MTD layer is performing ECC (use_nand_ecc is true). */ #include "yportenv.h" +#include "yaffs_trace.h" #include "yaffs_guts.h" #include "yaffs_packedtags1.h" - #include "yaffs_tagscompat.h" /* for yaffs_CalcTagsECC */ +-#include "yaffs_tagscompat.h" /* for yaffs_CalcTagsECC */ ++#include "yaffs_tagscompat.h" /* for yaffs_calc_tags_ecc */ +#include "yaffs_linux.h" #include "linux/kernel.h" @@ -15389,25 +17266,78 @@ #ifndef CONFIG_YAFFS_9BYTE_TAGS # define YTAG1_SIZE 8 #else -@@ -91,7 +91,7 @@ static struct nand_ecclayout nand_oob_16 - int nandmtd1_WriteChunkWithTagsToNAND(yaffs_Device *dev, - int chunkInNAND, const __u8 *data, const yaffs_ExtendedTags *etags) +@@ -51,12 +51,12 @@ const char *yaffs_mtdif1_c_version = "$I + * adjust 'oobfree' to match your existing Yaffs data. + * + * This nand_ecclayout scatters/gathers to/from the old-yaffs layout with the +- * pageStatus byte (at NAND spare offset 4) scattered/gathered from/to ++ * page_status byte (at NAND spare offset 4) scattered/gathered from/to + * the 9th byte. + * + * Old-style on-NAND format: T0,T1,T2,T3,P,B,T4,T5,E0,E1,E2,T6,T7,E3,E4,E5 +- * We have/need PackedTags1 plus pageStatus: T0,T1,T2,T3,T4,T5,T6,T7,P +- * where Tn are the tag bytes, En are MTD's ECC bytes, P is the pageStatus ++ * We have/need PackedTags1 plus page_status: T0,T1,T2,T3,T4,T5,T6,T7,P ++ * where Tn are the tag bytes, En are MTD's ECC bytes, P is the page_status + * byte and B is the small-page bad-block indicator byte. + */ + static struct nand_ecclayout nand_oob_16 = { +@@ -88,42 +88,40 @@ static struct nand_ecclayout nand_oob_16 + * Any underlying MTD error results in YAFFS_FAIL. + * Returns YAFFS_OK or YAFFS_FAIL. + */ +-int nandmtd1_WriteChunkWithTagsToNAND(yaffs_Device *dev, +- int chunkInNAND, const __u8 *data, const yaffs_ExtendedTags *etags) ++int nandmtd1_WriteChunkWithTagsToNAND(yaffs_dev_t *dev, ++ int nand_chunk, const __u8 *data, const yaffs_ext_tags *etags) { - struct mtd_info *mtd = dev->genericDevice; -+ struct mtd_info *mtd = yaffs_DeviceToMtd(dev); - int chunkBytes = dev->nDataBytesPerChunk; - loff_t addr = ((loff_t)chunkInNAND) * chunkBytes; +- int chunkBytes = dev->nDataBytesPerChunk; +- loff_t addr = ((loff_t)chunkInNAND) * chunkBytes; ++ struct mtd_info *mtd = yaffs_dev_to_mtd(dev); ++ int chunkBytes = dev->data_bytes_per_chunk; ++ loff_t addr = ((loff_t)nand_chunk) * chunkBytes; struct mtd_oob_ops ops; -@@ -102,8 +102,6 @@ int nandmtd1_WriteChunkWithTagsToNAND(ya - compile_time_assertion(sizeof(yaffs_PackedTags1) == 12); - compile_time_assertion(sizeof(yaffs_Tags) == 8); + yaffs_PackedTags1 pt1; + int retval; -- dev->nPageWrites++; +- /* we assume that PackedTags1 and yaffs_Tags are compatible */ ++ /* we assume that PackedTags1 and yaffs_tags_t are compatible */ + compile_time_assertion(sizeof(yaffs_PackedTags1) == 12); +- compile_time_assertion(sizeof(yaffs_Tags) == 8); - +- dev->nPageWrites++; ++ compile_time_assertion(sizeof(yaffs_tags_t) == 8); + yaffs_PackTags1(&pt1, etags); - yaffs_CalcTagsECC((yaffs_Tags *)&pt1); +- yaffs_CalcTagsECC((yaffs_Tags *)&pt1); ++ yaffs_calc_tags_ecc((yaffs_tags_t *)&pt1); -@@ -137,9 +135,9 @@ int nandmtd1_WriteChunkWithTagsToNAND(ya + /* When deleting a chunk, the upper layer provides only skeletal +- * etags, one with chunkDeleted set. However, we need to update the ++ * etags, one with is_deleted set. However, we need to update the + * tags, not erase them completely. So we use the NAND write property + * that only zeroed-bits stick and set tag bytes to all-ones and + * zero just the (not) deleted bit. + */ + #ifndef CONFIG_YAFFS_9BYTE_TAGS +- if (etags->chunkDeleted) { ++ if (etags->is_deleted) { + memset(&pt1, 0xff, 8); + /* clear delete status bit to indicate deleted */ + pt1.deleted = 0; + } + #else + ((__u8 *)&pt1)[8] = 0xff; +- if (etags->chunkDeleted) { ++ if (etags->is_deleted) { + memset(&pt1, 0xff, 8); +- /* zero pageStatus byte to indicate deleted */ ++ /* zero page_status byte to indicate deleted */ + ((__u8 *)&pt1)[8] = 0; + } + #endif +@@ -137,20 +135,20 @@ int nandmtd1_WriteChunkWithTagsToNAND(ya retval = mtd->write_oob(mtd, addr, &ops); if (retval) { @@ -15416,20 +17346,54 @@ - chunkInNAND, retval); + T(YAFFS_TRACE_MTD, + (TSTR("write_oob failed, chunk %d, mtd error %d"TENDSTR), -+ chunkInNAND, retval)); ++ nand_chunk, retval)); } return retval ? YAFFS_FAIL : YAFFS_OK; } -@@ -171,7 +169,7 @@ static int rettags(yaffs_ExtendedTags *e - int nandmtd1_ReadChunkWithTagsFromNAND(yaffs_Device *dev, - int chunkInNAND, __u8 *data, yaffs_ExtendedTags *etags) + +-/* Return with empty ExtendedTags but add eccResult. ++/* Return with empty ExtendedTags but add ecc_result. + */ +-static int rettags(yaffs_ExtendedTags *etags, int eccResult, int retval) ++static int rettags(yaffs_ext_tags *etags, int ecc_result, int retval) + { + if (etags) { + memset(etags, 0, sizeof(*etags)); +- etags->eccResult = eccResult; ++ etags->ecc_result = ecc_result; + } + return retval; + } +@@ -158,30 +156,28 @@ static int rettags(yaffs_ExtendedTags *e + /* Read a chunk (page) from NAND. + * + * Caller expects ExtendedTags data to be usable even on error; that is, +- * all members except eccResult and blockBad are zeroed. ++ * all members except ecc_result and block_bad are zeroed. + * + * - Check ECC results for data (if applicable) + * - Check for blank/erased block (return empty ExtendedTags if blank) + * - Check the PackedTags1 mini-ECC (correct if necessary/possible) + * - Convert PackedTags1 to ExtendedTags +- * - Update eccResult and blockBad members to refect state. ++ * - Update ecc_result and block_bad members to refect state. + * + * Returns YAFFS_OK or YAFFS_FAIL. + */ +-int nandmtd1_ReadChunkWithTagsFromNAND(yaffs_Device *dev, +- int chunkInNAND, __u8 *data, yaffs_ExtendedTags *etags) ++int nandmtd1_ReadChunkWithTagsFromNAND(yaffs_dev_t *dev, ++ int nand_chunk, __u8 *data, yaffs_ext_tags *etags) { - struct mtd_info *mtd = dev->genericDevice; -+ struct mtd_info *mtd = yaffs_DeviceToMtd(dev); - int chunkBytes = dev->nDataBytesPerChunk; - loff_t addr = ((loff_t)chunkInNAND) * chunkBytes; +- int chunkBytes = dev->nDataBytesPerChunk; +- loff_t addr = ((loff_t)chunkInNAND) * chunkBytes; ++ struct mtd_info *mtd = yaffs_dev_to_mtd(dev); ++ int chunkBytes = dev->data_bytes_per_chunk; ++ loff_t addr = ((loff_t)nand_chunk) * chunkBytes; int eccres = YAFFS_ECC_RESULT_NO_ERROR; -@@ -180,8 +178,6 @@ int nandmtd1_ReadChunkWithTagsFromNAND(y + struct mtd_oob_ops ops; + yaffs_PackedTags1 pt1; int retval; int deleted; @@ -15447,25 +17411,106 @@ - chunkInNAND, retval); + T(YAFFS_TRACE_MTD, + (TSTR("read_oob failed, chunk %d, mtd error %d"TENDSTR), -+ chunkInNAND, retval)); ++ nand_chunk, retval)); + } + + switch (retval) { +@@ -213,23 +209,23 @@ int nandmtd1_ReadChunkWithTagsFromNAND(y + case -EUCLEAN: + /* MTD's ECC fixed the data */ + eccres = YAFFS_ECC_RESULT_FIXED; +- dev->eccFixed++; ++ dev->n_ecc_fixed++; + break; + + case -EBADMSG: + /* MTD's ECC could not fix the data */ +- dev->eccUnfixed++; ++ dev->n_ecc_unfixed++; + /* fall into... */ + default: + rettags(etags, YAFFS_ECC_RESULT_UNFIXED, 0); +- etags->blockBad = (mtd->block_isbad)(mtd, addr); ++ etags->block_bad = (mtd->block_isbad)(mtd, addr); + return YAFFS_FAIL; } + /* Check for a blank/erased chunk. + */ +- if (yaffs_CheckFF((__u8 *)&pt1, 8)) { +- /* when blank, upper layers want eccResult to be <= NO_ERROR */ ++ if (yaffs_check_ff((__u8 *)&pt1, 8)) { ++ /* when blank, upper layers want ecc_result to be <= NO_ERROR */ + return rettags(etags, YAFFS_ECC_RESULT_NO_ERROR, YAFFS_OK); + } + +@@ -241,37 +237,37 @@ int nandmtd1_ReadChunkWithTagsFromNAND(y + deleted = !pt1.deleted; + pt1.deleted = 1; + #else +- deleted = (yaffs_CountBits(((__u8 *)&pt1)[8]) < 7); ++ deleted = (yaffs_count_bits(((__u8 *)&pt1)[8]) < 7); + #endif + + /* Check the packed tags mini-ECC and correct if necessary/possible. + */ +- retval = yaffs_CheckECCOnTags((yaffs_Tags *)&pt1); ++ retval = yaffs_check_tags_ecc((yaffs_tags_t *)&pt1); switch (retval) { -@@ -284,11 +280,11 @@ int nandmtd1_ReadChunkWithTagsFromNAND(y + case 0: + /* no tags error, use MTD result */ + break; + case 1: + /* recovered tags-ECC error */ +- dev->tagsEccFixed++; ++ dev->n_tags_ecc_fixed++; + if (eccres == YAFFS_ECC_RESULT_NO_ERROR) + eccres = YAFFS_ECC_RESULT_FIXED; + break; + default: + /* unrecovered tags-ECC error */ +- dev->tagsEccUnfixed++; ++ dev->n_tags_ecc_unfixed++; + return rettags(etags, YAFFS_ECC_RESULT_UNFIXED, YAFFS_FAIL); + } + + /* Unpack the tags to extended form and set ECC result. +- * [set shouldBeFF just to keep yaffs_UnpackTags1 happy] ++ * [set shouldBeFF just to keep yaffs_unpack_tags1 happy] + */ + pt1.shouldBeFF = 0xFFFFFFFF; +- yaffs_UnpackTags1(etags, &pt1); +- etags->eccResult = eccres; ++ yaffs_unpack_tags1(etags, &pt1); ++ etags->ecc_result = eccres; + + /* Set deleted state */ +- etags->chunkDeleted = deleted; ++ etags->is_deleted = deleted; + return YAFFS_OK; + } + +@@ -282,15 +278,15 @@ int nandmtd1_ReadChunkWithTagsFromNAND(y + * + * Returns YAFFS_OK or YAFFS_FAIL. */ - int nandmtd1_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo) +-int nandmtd1_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo) ++int nandmtd1_MarkNANDBlockBad(struct yaffs_dev_s *dev, int block_no) { - struct mtd_info *mtd = dev->genericDevice; - int blocksize = dev->nChunksPerBlock * dev->nDataBytesPerChunk; -+ struct mtd_info *mtd = yaffs_DeviceToMtd(dev); -+ int blocksize = dev->param.nChunksPerBlock * dev->nDataBytesPerChunk; ++ struct mtd_info *mtd = yaffs_dev_to_mtd(dev); ++ int blocksize = dev->param.chunks_per_block * dev->data_bytes_per_chunk; int retval; - yaffs_trace(YAFFS_TRACE_BAD_BLOCKS, "marking block %d bad\n", blockNo); -+ T(YAFFS_TRACE_BAD_BLOCKS,(TSTR("marking block %d bad"TENDSTR), blockNo)); ++ T(YAFFS_TRACE_BAD_BLOCKS,(TSTR("marking block %d bad"TENDSTR), block_no)); - retval = mtd->block_markbad(mtd, (loff_t)blocksize * blockNo); +- retval = mtd->block_markbad(mtd, (loff_t)blocksize * blockNo); ++ retval = mtd->block_markbad(mtd, (loff_t)blocksize * block_no); return (retval) ? YAFFS_FAIL : YAFFS_OK; + } + @@ -305,9 +301,9 @@ static int nandmtd1_TestPrerequists(stru int oobavail = mtd->ecclayout->oobavail; @@ -15479,30 +17524,54 @@ return YAFFS_FAIL; } return YAFFS_OK; -@@ -325,8 +321,8 @@ static int nandmtd1_TestPrerequists(stru - int nandmtd1_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockNo, - yaffs_BlockState *pState, __u32 *pSequenceNumber) +@@ -322,13 +318,13 @@ static int nandmtd1_TestPrerequists(stru + * + * Always returns YAFFS_OK. + */ +-int nandmtd1_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockNo, +- yaffs_BlockState *pState, __u32 *pSequenceNumber) ++int nandmtd1_QueryNANDBlock(struct yaffs_dev_s *dev, int block_no, ++ yaffs_block_state_t *pState, __u32 *pSequenceNumber) { - struct mtd_info *mtd = dev->genericDevice; - int chunkNo = blockNo * dev->nChunksPerBlock; -+ struct mtd_info *mtd = yaffs_DeviceToMtd(dev); -+ int chunkNo = blockNo * dev->param.nChunksPerBlock; - loff_t addr = (loff_t)chunkNo * dev->nDataBytesPerChunk; - yaffs_ExtendedTags etags; +- loff_t addr = (loff_t)chunkNo * dev->nDataBytesPerChunk; +- yaffs_ExtendedTags etags; ++ struct mtd_info *mtd = yaffs_dev_to_mtd(dev); ++ int chunkNo = block_no * dev->param.chunks_per_block; ++ loff_t addr = (loff_t)chunkNo * dev->data_bytes_per_chunk; ++ yaffs_ext_tags etags; int state = YAFFS_BLOCK_STATE_DEAD; -@@ -342,8 +338,8 @@ int nandmtd1_QueryNANDBlock(struct yaffs + int seqnum = 0; + int retval; +@@ -340,17 +336,17 @@ int nandmtd1_QueryNANDBlock(struct yaffs + return YAFFS_FAIL; + retval = nandmtd1_ReadChunkWithTagsFromNAND(dev, chunkNo, NULL, &etags); - etags.blockBad = (mtd->block_isbad)(mtd, addr); - if (etags.blockBad) { +- etags.blockBad = (mtd->block_isbad)(mtd, addr); +- if (etags.blockBad) { - yaffs_trace(YAFFS_TRACE_BAD_BLOCKS, - "block %d is marked bad\n", blockNo); ++ etags.block_bad = (mtd->block_isbad)(mtd, addr); ++ if (etags.block_bad) { + T(YAFFS_TRACE_BAD_BLOCKS, -+ (TSTR("block %d is marked bad"TENDSTR), blockNo)); ++ (TSTR("block %d is marked bad"TENDSTR), block_no)); state = YAFFS_BLOCK_STATE_DEAD; - } else if (etags.eccResult != YAFFS_ECC_RESULT_NO_ERROR) { +- } else if (etags.eccResult != YAFFS_ECC_RESULT_NO_ERROR) { ++ } else if (etags.ecc_result != YAFFS_ECC_RESULT_NO_ERROR) { /* bad tags, need to look more closely */ ---- a/fs/yaffs2/yaffs_mtdif1-compat.c -+++ /dev/null + state = YAFFS_BLOCK_STATE_NEEDS_SCANNING; +- } else if (etags.chunkUsed) { ++ } else if (etags.chunk_used) { + state = YAFFS_BLOCK_STATE_NEEDS_SCANNING; +- seqnum = etags.sequenceNumber; ++ seqnum = etags.seq_number; + } else { + state = YAFFS_BLOCK_STATE_EMPTY; + } +diff -Nrup linux-2.6.36-rc8/fs/yaffs2/yaffs_mtdif1-compat.c linux-2.6.36-rc8.new/fs/yaffs2/yaffs_mtdif1-compat.c +--- linux-2.6.36-rc8/fs/yaffs2/yaffs_mtdif1-compat.c 2010-10-20 13:17:58.956000294 +0300 ++++ linux-2.6.36-rc8.new/fs/yaffs2/yaffs_mtdif1-compat.c 1970-01-01 02:00:00.000000000 +0200 @@ -1,434 +0,0 @@ -From ian@brightstareng.com Fri May 18 15:06:49 2007 -From ian@brightstareng.com Fri May 18 15:08:21 2007 @@ -15938,8 +18007,9 @@ - - - ---- a/fs/yaffs2/yaffs_mtdif1.h -+++ b/fs/yaffs2/yaffs_mtdif1.h +diff -Nrup linux-2.6.36-rc8/fs/yaffs2/yaffs_mtdif1.h linux-2.6.36-rc8.new/fs/yaffs2/yaffs_mtdif1.h +--- linux-2.6.36-rc8/fs/yaffs2/yaffs_mtdif1.h 2010-10-20 13:17:58.957000294 +0300 ++++ linux-2.6.36-rc8.new/fs/yaffs2/yaffs_mtdif1.h 2010-10-20 13:28:16.062000294 +0300 @@ -1,7 +1,7 @@ /* * YAFFS: Yet another Flash File System. A NAND-flash specific file system. @@ -15949,8 +18019,32 @@ * for Toby Churchill Ltd and Brightstar Engineering * * This program is free software; you can redistribute it and/or modify ---- a/fs/yaffs2/yaffs_mtdif2.c -+++ b/fs/yaffs2/yaffs_mtdif2.c +@@ -14,15 +14,15 @@ + #ifndef __YAFFS_MTDIF1_H__ + #define __YAFFS_MTDIF1_H__ + +-int nandmtd1_WriteChunkWithTagsToNAND(yaffs_Device *dev, int chunkInNAND, +- const __u8 *data, const yaffs_ExtendedTags *tags); ++int nandmtd1_WriteChunkWithTagsToNAND(yaffs_dev_t *dev, int nand_chunk, ++ const __u8 *data, const yaffs_ext_tags *tags); + +-int nandmtd1_ReadChunkWithTagsFromNAND(yaffs_Device *dev, int chunkInNAND, +- __u8 *data, yaffs_ExtendedTags *tags); ++int nandmtd1_ReadChunkWithTagsFromNAND(yaffs_dev_t *dev, int nand_chunk, ++ __u8 *data, yaffs_ext_tags *tags); + +-int nandmtd1_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo); ++int nandmtd1_MarkNANDBlockBad(struct yaffs_dev_s *dev, int block_no); + +-int nandmtd1_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockNo, +- yaffs_BlockState *state, __u32 *sequenceNumber); ++int nandmtd1_QueryNANDBlock(struct yaffs_dev_s *dev, int block_no, ++ yaffs_block_state_t *state, __u32 *seq_number); + + #endif +diff -Nrup linux-2.6.36-rc8/fs/yaffs2/yaffs_mtdif2.c linux-2.6.36-rc8.new/fs/yaffs2/yaffs_mtdif2.c +--- linux-2.6.36-rc8/fs/yaffs2/yaffs_mtdif2.c 2010-10-20 13:17:58.957000294 +0300 ++++ linux-2.6.36-rc8.new/fs/yaffs2/yaffs_mtdif2.c 2010-10-20 13:28:16.028000294 +0300 @@ -1,7 +1,7 @@ /* * YAFFS: Yet Another Flash File System. A NAND-flash specific file system. @@ -15973,7 +18067,7 @@ #include "yaffs_mtdif2.h" -@@ -27,6 +24,8 @@ const char *yaffs_mtdif2_c_version = +@@ -27,15 +24,17 @@ const char *yaffs_mtdif2_c_version = #include "yaffs_packedtags2.h" @@ -15982,12 +18076,15 @@ /* NB For use with inband tags.... * We assume that the data buffer is of size totalBytersPerChunk so that we can also * use it to load the tags. -@@ -35,7 +34,7 @@ int nandmtd2_WriteChunkWithTagsToNAND(ya + */ +-int nandmtd2_WriteChunkWithTagsToNAND(yaffs_Device *dev, int chunkInNAND, ++int nandmtd2_WriteChunkWithTagsToNAND(yaffs_dev_t *dev, int nand_chunk, const __u8 *data, - const yaffs_ExtendedTags *tags) +- const yaffs_ExtendedTags *tags) ++ const yaffs_ext_tags *tags) { - struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice); -+ struct mtd_info *mtd = yaffs_DeviceToMtd(dev); ++ struct mtd_info *mtd = yaffs_dev_to_mtd(dev); #if (MTD_VERSION_CODE > MTD_VERSION(2, 6, 17)) struct mtd_oob_ops ops; #else @@ -15995,17 +18092,18 @@ yaffs_PackedTags2 pt; -+ int packed_tags_size = dev->param.noTagsECC ? sizeof(pt.t) : sizeof(pt); -+ void * packed_tags_ptr = dev->param.noTagsECC ? (void *) &pt.t : (void *)&pt; ++ int packed_tags_size = dev->param.no_tags_ecc ? sizeof(pt.t) : sizeof(pt); ++ void * packed_tags_ptr = dev->param.no_tags_ecc ? (void *) &pt.t : (void *)&pt; + T(YAFFS_TRACE_MTD, (TSTR ("nandmtd2_WriteChunkWithTagsToNAND chunk %d data %p tags %p" - TENDSTR), chunkInNAND, data, tags)); +- TENDSTR), chunkInNAND, data, tags)); ++ TENDSTR), nand_chunk, data, tags)); - addr = ((loff_t) chunkInNAND) * dev->totalBytesPerChunk; -+ addr = ((loff_t) chunkInNAND) * dev->param.totalBytesPerChunk; ++ addr = ((loff_t) nand_chunk) * dev->param.total_bytes_per_chunk; /* For yaffs2 writing there must be both data and tags. * If we're using inband tags, then the tags are stuffed into @@ -16014,191 +18112,244 @@ if (!data || !tags) BUG(); - else if (dev->inbandTags) { -+ else if (dev->param.inbandTags) { ++ else if (dev->param.inband_tags) { yaffs_PackedTags2TagsPart *pt2tp; - pt2tp = (yaffs_PackedTags2TagsPart *)(data + dev->nDataBytesPerChunk); +- pt2tp = (yaffs_PackedTags2TagsPart *)(data + dev->nDataBytesPerChunk); ++ pt2tp = (yaffs_PackedTags2TagsPart *)(data + dev->data_bytes_per_chunk); yaffs_PackTags2TagsPart(pt2tp, tags); } else - yaffs_PackTags2(&pt, tags); -+ yaffs_PackTags2(&pt, tags, !dev->param.noTagsECC); ++ yaffs_PackTags2(&pt, tags, !dev->param.no_tags_ecc); #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17)) ops.mode = MTD_OOB_AUTO; - ops.ooblen = (dev->inbandTags) ? 0 : sizeof(pt); - ops.len = dev->totalBytesPerChunk; -+ ops.ooblen = (dev->param.inbandTags) ? 0 : packed_tags_size; -+ ops.len = dev->param.totalBytesPerChunk; ++ ops.ooblen = (dev->param.inband_tags) ? 0 : packed_tags_size; ++ ops.len = dev->param.total_bytes_per_chunk; ops.ooboffs = 0; ops.datbuf = (__u8 *)data; - ops.oobbuf = (dev->inbandTags) ? NULL : (void *)&pt; -+ ops.oobbuf = (dev->param.inbandTags) ? NULL : packed_tags_ptr; ++ ops.oobbuf = (dev->param.inband_tags) ? NULL : packed_tags_ptr; retval = mtd->write_oob(mtd, addr, &ops); #else - if (!dev->inbandTags) { -+ if (!dev->param.inbandTags) { ++ if (!dev->param.inband_tags) { retval = - mtd->write_ecc(mtd, addr, dev->nDataBytesPerChunk, +- mtd->write_ecc(mtd, addr, dev->nDataBytesPerChunk, - &dummy, data, (__u8 *) &pt, NULL); ++ mtd->write_ecc(mtd, addr, dev->data_bytes_per_chunk, + &dummy, data, (__u8 *) packed_tags_ptr, NULL); } else { retval = - mtd->write(mtd, addr, dev->totalBytesPerChunk, &dummy, -+ mtd->write(mtd, addr, dev->param.totalBytesPerChunk, &dummy, ++ mtd->write(mtd, addr, dev->param.total_bytes_per_chunk, &dummy, data); } #endif -@@ -98,7 +100,7 @@ int nandmtd2_WriteChunkWithTagsToNAND(ya - int nandmtd2_ReadChunkWithTagsFromNAND(yaffs_Device *dev, int chunkInNAND, - __u8 *data, yaffs_ExtendedTags *tags) +@@ -95,10 +97,10 @@ int nandmtd2_WriteChunkWithTagsToNAND(ya + return YAFFS_FAIL; + } + +-int nandmtd2_ReadChunkWithTagsFromNAND(yaffs_Device *dev, int chunkInNAND, +- __u8 *data, yaffs_ExtendedTags *tags) ++int nandmtd2_ReadChunkWithTagsFromNAND(yaffs_dev_t *dev, int nand_chunk, ++ __u8 *data, yaffs_ext_tags *tags) { - struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice); -+ struct mtd_info *mtd = yaffs_DeviceToMtd(dev); ++ struct mtd_info *mtd = yaffs_dev_to_mtd(dev); #if (MTD_VERSION_CODE > MTD_VERSION(2, 6, 17)) struct mtd_oob_ops ops; #endif -@@ -106,16 +108,19 @@ int nandmtd2_ReadChunkWithTagsFromNAND(y +@@ -106,20 +108,23 @@ int nandmtd2_ReadChunkWithTagsFromNAND(y int retval = 0; int localData = 0; - loff_t addr = ((loff_t) chunkInNAND) * dev->totalBytesPerChunk; -+ loff_t addr = ((loff_t) chunkInNAND) * dev->param.totalBytesPerChunk; ++ loff_t addr = ((loff_t) nand_chunk) * dev->param.total_bytes_per_chunk; yaffs_PackedTags2 pt; -+ int packed_tags_size = dev->param.noTagsECC ? sizeof(pt.t) : sizeof(pt); -+ void * packed_tags_ptr = dev->param.noTagsECC ? (void *) &pt.t: (void *)&pt; ++ int packed_tags_size = dev->param.no_tags_ecc ? sizeof(pt.t) : sizeof(pt); ++ void * packed_tags_ptr = dev->param.no_tags_ecc ? (void *) &pt.t: (void *)&pt; + T(YAFFS_TRACE_MTD, (TSTR ("nandmtd2_ReadChunkWithTagsFromNAND chunk %d data %p tags %p" - TENDSTR), chunkInNAND, data, tags)); +- TENDSTR), chunkInNAND, data, tags)); ++ TENDSTR), nand_chunk, data, tags)); - if (dev->inbandTags) { -+ if (dev->param.inbandTags) { ++ if (dev->param.inband_tags) { if (!data) { localData = 1; -@@ -127,20 +132,20 @@ int nandmtd2_ReadChunkWithTagsFromNAND(y +- data = yaffs_GetTempBuffer(dev, __LINE__); ++ data = yaffs_get_temp_buffer(dev, __LINE__); + } + + +@@ -127,30 +132,30 @@ int nandmtd2_ReadChunkWithTagsFromNAND(y #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17)) - if (dev->inbandTags || (data && !tags)) - retval = mtd->read(mtd, addr, dev->totalBytesPerChunk, -+ if (dev->param.inbandTags || (data && !tags)) -+ retval = mtd->read(mtd, addr, dev->param.totalBytesPerChunk, ++ if (dev->param.inband_tags || (data && !tags)) ++ retval = mtd->read(mtd, addr, dev->param.total_bytes_per_chunk, &dummy, data); else if (tags) { ops.mode = MTD_OOB_AUTO; - ops.ooblen = sizeof(pt); - ops.len = data ? dev->nDataBytesPerChunk : sizeof(pt); + ops.ooblen = packed_tags_size; -+ ops.len = data ? dev->nDataBytesPerChunk : packed_tags_size; ++ ops.len = data ? dev->data_bytes_per_chunk : packed_tags_size; ops.ooboffs = 0; ops.datbuf = data; - ops.oobbuf = dev->spareBuffer; -+ ops.oobbuf = yaffs_DeviceToLC(dev)->spareBuffer; ++ ops.oobbuf = yaffs_dev_to_lc(dev)->spareBuffer; retval = mtd->read_oob(mtd, addr, &ops); } #else - if (!dev->inbandTags && data && tags) { -+ if (!dev->param.inbandTags && data && tags) { ++ if (!dev->param.inband_tags && data && tags) { - retval = mtd->read_ecc(mtd, addr, dev->nDataBytesPerChunk, +- retval = mtd->read_ecc(mtd, addr, dev->nDataBytesPerChunk, ++ retval = mtd->read_ecc(mtd, addr, dev->data_bytes_per_chunk, &dummy, data, dev->spareBuffer, -@@ -150,7 +155,7 @@ int nandmtd2_ReadChunkWithTagsFromNAND(y + NULL); + } else { + if (data) retval = - mtd->read(mtd, addr, dev->nDataBytesPerChunk, &dummy, +- mtd->read(mtd, addr, dev->nDataBytesPerChunk, &dummy, ++ mtd->read(mtd, addr, dev->data_bytes_per_chunk, &dummy, data); - if (!dev->inbandTags && tags) -+ if (!dev->param.inbandTags && tags) ++ if (!dev->param.inband_tags && tags) retval = mtd->read_oob(mtd, addr, mtd->oobsize, &dummy, dev->spareBuffer); -@@ -158,7 +163,7 @@ int nandmtd2_ReadChunkWithTagsFromNAND(y +@@ -158,41 +163,47 @@ int nandmtd2_ReadChunkWithTagsFromNAND(y #endif - if (dev->inbandTags) { -+ if (dev->param.inbandTags) { ++ if (dev->param.inband_tags) { if (tags) { yaffs_PackedTags2TagsPart *pt2tp; - pt2tp = (yaffs_PackedTags2TagsPart *)&data[dev->nDataBytesPerChunk]; -@@ -166,16 +171,22 @@ int nandmtd2_ReadChunkWithTagsFromNAND(y +- pt2tp = (yaffs_PackedTags2TagsPart *)&data[dev->nDataBytesPerChunk]; +- yaffs_UnpackTags2TagsPart(tags, pt2tp); ++ pt2tp = (yaffs_PackedTags2TagsPart *)&data[dev->data_bytes_per_chunk]; ++ yaffs_unpack_tags2tags_part(tags, pt2tp); } } else { if (tags) { - memcpy(&pt, dev->spareBuffer, sizeof(pt)); - yaffs_UnpackTags2(tags, &pt); -+ memcpy(packed_tags_ptr, yaffs_DeviceToLC(dev)->spareBuffer, packed_tags_size); -+ yaffs_UnpackTags2(tags, &pt, !dev->param.noTagsECC); ++ memcpy(packed_tags_ptr, yaffs_dev_to_lc(dev)->spareBuffer, packed_tags_size); ++ yaffs_unpack_tags2(tags, &pt, !dev->param.no_tags_ecc); } } if (localData) - yaffs_ReleaseTempBuffer(dev, data, __LINE__); +- yaffs_ReleaseTempBuffer(dev, data, __LINE__); ++ yaffs_release_temp_buffer(dev, data, __LINE__); - if (tags && retval == -EBADMSG && tags->eccResult == YAFFS_ECC_RESULT_NO_ERROR) -+ if (tags && retval == -EBADMSG && tags->eccResult == YAFFS_ECC_RESULT_NO_ERROR) { - tags->eccResult = YAFFS_ECC_RESULT_UNFIXED; -+ dev->eccUnfixed++; +- tags->eccResult = YAFFS_ECC_RESULT_UNFIXED; ++ if (tags && retval == -EBADMSG && tags->ecc_result == YAFFS_ECC_RESULT_NO_ERROR) { ++ tags->ecc_result = YAFFS_ECC_RESULT_UNFIXED; ++ dev->n_ecc_unfixed++; + } -+ if(tags && retval == -EUCLEAN && tags->eccResult == YAFFS_ECC_RESULT_NO_ERROR) { -+ tags->eccResult = YAFFS_ECC_RESULT_FIXED; -+ dev->eccFixed++; ++ if(tags && retval == -EUCLEAN && tags->ecc_result == YAFFS_ECC_RESULT_NO_ERROR) { ++ tags->ecc_result = YAFFS_ECC_RESULT_FIXED; ++ dev->n_ecc_fixed++; + } if (retval == 0) return YAFFS_OK; else -@@ -184,15 +195,15 @@ int nandmtd2_ReadChunkWithTagsFromNAND(y + return YAFFS_FAIL; + } - int nandmtd2_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo) +-int nandmtd2_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo) ++int nandmtd2_MarkNANDBlockBad(struct yaffs_dev_s *dev, int block_no) { - struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice); -+ struct mtd_info *mtd = yaffs_DeviceToMtd(dev); ++ struct mtd_info *mtd = yaffs_dev_to_mtd(dev); int retval; T(YAFFS_TRACE_MTD, - (TSTR("nandmtd2_MarkNANDBlockBad %d" TENDSTR), blockNo)); +- (TSTR("nandmtd2_MarkNANDBlockBad %d" TENDSTR), blockNo)); ++ (TSTR("nandmtd2_MarkNANDBlockBad %d" TENDSTR), block_no)); retval = mtd->block_markbad(mtd, - blockNo * dev->nChunksPerBlock * - dev->totalBytesPerChunk); -+ blockNo * dev->param.nChunksPerBlock * -+ dev->param.totalBytesPerChunk); ++ block_no * dev->param.chunks_per_block * ++ dev->param.total_bytes_per_chunk); if (retval == 0) return YAFFS_OK; -@@ -204,15 +215,15 @@ int nandmtd2_MarkNANDBlockBad(struct yaf - int nandmtd2_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockNo, - yaffs_BlockState *state, __u32 *sequenceNumber) +@@ -201,41 +212,41 @@ int nandmtd2_MarkNANDBlockBad(struct yaf + + } + +-int nandmtd2_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockNo, +- yaffs_BlockState *state, __u32 *sequenceNumber) ++int nandmtd2_QueryNANDBlock(struct yaffs_dev_s *dev, int block_no, ++ yaffs_block_state_t *state, __u32 *seq_number) { - struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice); -+ struct mtd_info *mtd = yaffs_DeviceToMtd(dev); ++ struct mtd_info *mtd = yaffs_dev_to_mtd(dev); int retval; T(YAFFS_TRACE_MTD, - (TSTR("nandmtd2_QueryNANDBlock %d" TENDSTR), blockNo)); +- (TSTR("nandmtd2_QueryNANDBlock %d" TENDSTR), blockNo)); ++ (TSTR("nandmtd2_QueryNANDBlock %d" TENDSTR), block_no)); retval = mtd->block_isbad(mtd, - blockNo * dev->nChunksPerBlock * - dev->totalBytesPerChunk); -+ blockNo * dev->param.nChunksPerBlock * -+ dev->param.totalBytesPerChunk); ++ block_no * dev->param.chunks_per_block * ++ dev->param.total_bytes_per_chunk); if (retval) { T(YAFFS_TRACE_MTD, (TSTR("block is bad" TENDSTR))); -@@ -223,7 +234,7 @@ int nandmtd2_QueryNANDBlock(struct yaffs - yaffs_ExtendedTags t; + + *state = YAFFS_BLOCK_STATE_DEAD; +- *sequenceNumber = 0; ++ *seq_number = 0; + } else { +- yaffs_ExtendedTags t; ++ yaffs_ext_tags t; nandmtd2_ReadChunkWithTagsFromNAND(dev, - blockNo * +- blockNo * - dev->nChunksPerBlock, NULL, -+ dev->param.nChunksPerBlock, NULL, ++ block_no * ++ dev->param.chunks_per_block, NULL, &t); - if (t.chunkUsed) { ---- a/fs/yaffs2/yaffs_mtdif2.h -+++ b/fs/yaffs2/yaffs_mtdif2.h +- if (t.chunkUsed) { +- *sequenceNumber = t.sequenceNumber; ++ if (t.chunk_used) { ++ *seq_number = t.seq_number; + *state = YAFFS_BLOCK_STATE_NEEDS_SCANNING; + } else { +- *sequenceNumber = 0; ++ *seq_number = 0; + *state = YAFFS_BLOCK_STATE_EMPTY; + } + } + T(YAFFS_TRACE_MTD, +- (TSTR("block is bad seq %d state %d" TENDSTR), *sequenceNumber, ++ (TSTR("block is bad seq %d state %d" TENDSTR), *seq_number, + *state)); + + if (retval == 0) +diff -Nrup linux-2.6.36-rc8/fs/yaffs2/yaffs_mtdif2.h linux-2.6.36-rc8.new/fs/yaffs2/yaffs_mtdif2.h +--- linux-2.6.36-rc8/fs/yaffs2/yaffs_mtdif2.h 2010-10-20 13:17:58.957000294 +0300 ++++ linux-2.6.36-rc8.new/fs/yaffs2/yaffs_mtdif2.h 2010-10-20 13:28:16.062000294 +0300 @@ -1,7 +1,7 @@ /* * YAFFS: Yet another Flash File System . A NAND-flash specific file system. @@ -16208,8 +18359,30 @@ * for Toby Churchill Ltd and Brightstar Engineering * * Created by Charles Manning <charles@aleph1.co.uk> ---- a/fs/yaffs2/yaffs_mtdif.c -+++ b/fs/yaffs2/yaffs_mtdif.c +@@ -17,13 +17,13 @@ + #define __YAFFS_MTDIF2_H__ + + #include "yaffs_guts.h" +-int nandmtd2_WriteChunkWithTagsToNAND(yaffs_Device *dev, int chunkInNAND, ++int nandmtd2_WriteChunkWithTagsToNAND(yaffs_dev_t *dev, int nand_chunk, + const __u8 *data, +- const yaffs_ExtendedTags *tags); +-int nandmtd2_ReadChunkWithTagsFromNAND(yaffs_Device *dev, int chunkInNAND, +- __u8 *data, yaffs_ExtendedTags *tags); +-int nandmtd2_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo); +-int nandmtd2_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockNo, +- yaffs_BlockState *state, __u32 *sequenceNumber); ++ const yaffs_ext_tags *tags); ++int nandmtd2_ReadChunkWithTagsFromNAND(yaffs_dev_t *dev, int nand_chunk, ++ __u8 *data, yaffs_ext_tags *tags); ++int nandmtd2_MarkNANDBlockBad(struct yaffs_dev_s *dev, int block_no); ++int nandmtd2_QueryNANDBlock(struct yaffs_dev_s *dev, int block_no, ++ yaffs_block_state_t *state, __u32 *seq_number); + + #endif +diff -Nrup linux-2.6.36-rc8/fs/yaffs2/yaffs_mtdif.c linux-2.6.36-rc8.new/fs/yaffs2/yaffs_mtdif.c +--- linux-2.6.36-rc8/fs/yaffs2/yaffs_mtdif.c 2010-10-20 13:17:58.958000294 +0300 ++++ linux-2.6.36-rc8.new/fs/yaffs2/yaffs_mtdif.c 2010-10-20 13:28:16.029000294 +0300 @@ -1,7 +1,7 @@ /* * YAFFS: Yet Another Flash File System. A NAND-flash specific file system. @@ -16353,7 +18526,8 @@ -#endif - size_t dummy; - int retval = 0; -- ++#include "yaffs_linux.h" + - loff_t addr = ((loff_t) chunkInNAND) * dev->nDataBytesPerChunk; -#if (MTD_VERSION_CODE > MTD_VERSION(2, 6, 17)) - __u8 spareAsBytes[8]; /* OOB */ @@ -16413,17 +18587,17 @@ - else - return YAFFS_FAIL; -} -+#include "yaffs_linux.h" - - int nandmtd_EraseBlockInNAND(yaffs_Device *dev, int blockNumber) +- +-int nandmtd_EraseBlockInNAND(yaffs_Device *dev, int blockNumber) ++int nandmtd_EraseBlockInNAND(yaffs_dev_t *dev, int blockNumber) { - struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice); -+ struct mtd_info *mtd = yaffs_DeviceToMtd(dev); ++ struct mtd_info *mtd = yaffs_dev_to_mtd(dev); __u32 addr = - ((loff_t) blockNumber) * dev->nDataBytesPerChunk - * dev->nChunksPerBlock; -+ ((loff_t) blockNumber) * dev->param.totalBytesPerChunk -+ * dev->param.nChunksPerBlock; ++ ((loff_t) blockNumber) * dev->param.total_bytes_per_chunk ++ * dev->param.chunks_per_block; struct erase_info ei; + int retval = 0; @@ -16431,7 +18605,7 @@ ei.mtd = mtd; ei.addr = addr; - ei.len = dev->nDataBytesPerChunk * dev->nChunksPerBlock; -+ ei.len = dev->param.totalBytesPerChunk * dev->param.nChunksPerBlock; ++ ei.len = dev->param.total_bytes_per_chunk * dev->param.chunks_per_block; ei.time = 1000; ei.retries = 2; ei.callback = NULL; @@ -16444,8 +18618,18 @@ retval = mtd->erase(mtd, &ei); if (retval == 0) ---- a/fs/yaffs2/yaffs_mtdif.h -+++ b/fs/yaffs2/yaffs_mtdif.h +@@ -234,7 +49,7 @@ int nandmtd_EraseBlockInNAND(yaffs_Devic + return YAFFS_FAIL; + } + +-int nandmtd_InitialiseNAND(yaffs_Device *dev) ++int nandmtd_InitialiseNAND(yaffs_dev_t *dev) + { + return YAFFS_OK; + } +diff -Nrup linux-2.6.36-rc8/fs/yaffs2/yaffs_mtdif.h linux-2.6.36-rc8.new/fs/yaffs2/yaffs_mtdif.h +--- linux-2.6.36-rc8/fs/yaffs2/yaffs_mtdif.h 2010-10-20 13:17:58.958000294 +0300 ++++ linux-2.6.36-rc8.new/fs/yaffs2/yaffs_mtdif.h 2010-10-20 13:28:16.062000294 +0300 @@ -1,7 +1,7 @@ /* * YAFFS: Yet another Flash File System . A NAND-flash specific file system. @@ -16464,11 +18648,14 @@ - const __u8 *data, const yaffs_Spare *spare); -int nandmtd_ReadChunkFromNAND(yaffs_Device *dev, int chunkInNAND, __u8 *data, - yaffs_Spare *spare); - int nandmtd_EraseBlockInNAND(yaffs_Device *dev, int blockNumber); - int nandmtd_InitialiseNAND(yaffs_Device *dev); +-int nandmtd_EraseBlockInNAND(yaffs_Device *dev, int blockNumber); +-int nandmtd_InitialiseNAND(yaffs_Device *dev); ++int nandmtd_EraseBlockInNAND(yaffs_dev_t *dev, int blockNumber); ++int nandmtd_InitialiseNAND(yaffs_dev_t *dev); #endif ---- /dev/null -+++ b/fs/yaffs2/yaffs_nameval.c +diff -Nrup linux-2.6.36-rc8/fs/yaffs2/yaffs_nameval.c linux-2.6.36-rc8.new/fs/yaffs2/yaffs_nameval.c +--- linux-2.6.36-rc8/fs/yaffs2/yaffs_nameval.c 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.36-rc8.new/fs/yaffs2/yaffs_nameval.c 2010-10-20 13:28:16.029000294 +0300 @@ -0,0 +1,197 @@ +/* + * YAFFS: Yet Another Flash File System. A NAND-flash specific file system. @@ -16667,8 +18854,9 @@ +{ + return nval_used(xb, xb_size) > 0; +} ---- /dev/null -+++ b/fs/yaffs2/yaffs_nameval.h +diff -Nrup linux-2.6.36-rc8/fs/yaffs2/yaffs_nameval.h linux-2.6.36-rc8.new/fs/yaffs2/yaffs_nameval.h +--- linux-2.6.36-rc8/fs/yaffs2/yaffs_nameval.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.36-rc8.new/fs/yaffs2/yaffs_nameval.h 2010-10-20 13:28:16.062000294 +0300 @@ -0,0 +1,25 @@ +/* + * YAFFS: Yet another Flash File System . A NAND-flash specific file system. @@ -16695,8 +18883,9 @@ +int nval_list(const char *xb, int xb_size, char *buf, int bsize); +int nval_hasvalues(const char *xb, int xb_size); +#endif ---- a/fs/yaffs2/yaffs_nand.c -+++ b/fs/yaffs2/yaffs_nand.c +diff -Nrup linux-2.6.36-rc8/fs/yaffs2/yaffs_nand.c linux-2.6.36-rc8.new/fs/yaffs2/yaffs_nand.c +--- linux-2.6.36-rc8/fs/yaffs2/yaffs_nand.c 2010-10-20 13:17:58.959000294 +0300 ++++ linux-2.6.36-rc8.new/fs/yaffs2/yaffs_nand.c 2010-10-20 13:28:16.029000294 +0300 @@ -1,7 +1,7 @@ /* * YAFFS: Yet Another Flash File System. A NAND-flash specific file system. @@ -16706,7 +18895,7 @@ * for Toby Churchill Ltd and Brightstar Engineering * * Created by Charles Manning <charles@aleph1.co.uk> -@@ -11,9 +11,6 @@ +@@ -11,124 +11,129 @@ * published by the Free Software Foundation. */ @@ -16716,102 +18905,177 @@ #include "yaffs_nand.h" #include "yaffs_tagscompat.h" #include "yaffs_tagsvalidity.h" -@@ -29,12 +26,14 @@ int yaffs_ReadChunkWithTagsFromNAND(yaff - int realignedChunkInNAND = chunkInNAND - dev->chunkOffset; + #include "yaffs_getblockinfo.h" -+ dev->nPageReads++; +-int yaffs_ReadChunkWithTagsFromNAND(yaffs_Device *dev, int chunkInNAND, ++int yaffs_rd_chunk_tags_nand(yaffs_dev_t *dev, int nand_chunk, + __u8 *buffer, +- yaffs_ExtendedTags *tags) ++ yaffs_ext_tags *tags) + { + int result; +- yaffs_ExtendedTags localTags; ++ yaffs_ext_tags localTags; + ++ int realignedChunkInNAND = nand_chunk - dev->chunk_offset; + +- int realignedChunkInNAND = chunkInNAND - dev->chunkOffset; ++ dev->n_page_reads++; + /* If there are no tags provided, use local tags to get prioritised gc working */ if (!tags) tags = &localTags; - if (dev->readChunkWithTagsFromNAND) - result = dev->readChunkWithTagsFromNAND(dev, realignedChunkInNAND, buffer, -+ if (dev->param.readChunkWithTagsFromNAND) -+ result = dev->param.readChunkWithTagsFromNAND(dev, realignedChunkInNAND, buffer, ++ if (dev->param.read_chunk_tags_fn) ++ result = dev->param.read_chunk_tags_fn(dev, realignedChunkInNAND, buffer, tags); else - result = yaffs_TagsCompatabilityReadChunkWithTagsFromNAND(dev, -@@ -44,7 +43,8 @@ int yaffs_ReadChunkWithTagsFromNAND(yaff +- result = yaffs_TagsCompatabilityReadChunkWithTagsFromNAND(dev, ++ result = yaffs_tags_compat_rd(dev, + realignedChunkInNAND, + buffer, + tags); if (tags && - tags->eccResult > YAFFS_ECC_RESULT_NO_ERROR) { +- tags->eccResult > YAFFS_ECC_RESULT_NO_ERROR) { ++ tags->ecc_result > YAFFS_ECC_RESULT_NO_ERROR) { - yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, chunkInNAND/dev->nChunksPerBlock); -+ yaffs_BlockInfo *bi; -+ bi = yaffs_GetBlockInfo(dev, chunkInNAND/dev->param.nChunksPerBlock); - yaffs_HandleChunkError(dev, bi); +- yaffs_HandleChunkError(dev, bi); ++ yaffs_block_info_t *bi; ++ bi = yaffs_get_block_info(dev, nand_chunk/dev->param.chunks_per_block); ++ yaffs_handle_chunk_error(dev, bi); } -@@ -56,6 +56,9 @@ int yaffs_WriteChunkWithTagsToNAND(yaffs + return result; + } + +-int yaffs_WriteChunkWithTagsToNAND(yaffs_Device *dev, +- int chunkInNAND, ++int yaffs_wr_chunk_tags_nand(yaffs_dev_t *dev, ++ int nand_chunk, const __u8 *buffer, - yaffs_ExtendedTags *tags) +- yaffs_ExtendedTags *tags) ++ yaffs_ext_tags *tags) { +- chunkInNAND -= dev->chunkOffset; + -+ dev->nPageWrites++; ++ dev->n_page_writes++; + - chunkInNAND -= dev->chunkOffset; ++ nand_chunk -= dev->chunk_offset; -@@ -75,8 +78,8 @@ int yaffs_WriteChunkWithTagsToNAND(yaffs + if (tags) { +- tags->sequenceNumber = dev->sequenceNumber; +- tags->chunkUsed = 1; +- if (!yaffs_ValidateTags(tags)) { ++ tags->seq_number = dev->seq_number; ++ tags->chunk_used = 1; ++ if (!yaffs_validate_tags(tags)) { + T(YAFFS_TRACE_ERROR, + (TSTR("Writing uninitialised tags" TENDSTR))); + YBUG(); + } + T(YAFFS_TRACE_WRITE, +- (TSTR("Writing chunk %d tags %d %d" TENDSTR), chunkInNAND, +- tags->objectId, tags->chunkId)); ++ (TSTR("Writing chunk %d tags %d %d" TENDSTR), nand_chunk, ++ tags->obj_id, tags->chunk_id)); + } else { + T(YAFFS_TRACE_ERROR, (TSTR("Writing with no tags" TENDSTR))); YBUG(); } - if (dev->writeChunkWithTagsToNAND) - return dev->writeChunkWithTagsToNAND(dev, chunkInNAND, buffer, -+ if (dev->param.writeChunkWithTagsToNAND) -+ return dev->param.writeChunkWithTagsToNAND(dev, chunkInNAND, buffer, ++ if (dev->param.write_chunk_tags_fn) ++ return dev->param.write_chunk_tags_fn(dev, nand_chunk, buffer, tags); else - return yaffs_TagsCompatabilityWriteChunkWithTagsToNAND(dev, -@@ -89,9 +92,9 @@ int yaffs_MarkBlockBad(yaffs_Device *dev +- return yaffs_TagsCompatabilityWriteChunkWithTagsToNAND(dev, +- chunkInNAND, ++ return yaffs_tags_compat_wr(dev, ++ nand_chunk, + buffer, + tags); + } + +-int yaffs_MarkBlockBad(yaffs_Device *dev, int blockNo) ++int yaffs_mark_bad(yaffs_dev_t *dev, int block_no) { - blockNo -= dev->blockOffset; +- blockNo -= dev->blockOffset; ++ block_no -= dev->block_offset; ++ -; - if (dev->markNANDBlockBad) - return dev->markNANDBlockBad(dev, blockNo); -+ -+ if (dev->param.markNANDBlockBad) -+ return dev->param.markNANDBlockBad(dev, blockNo); ++ if (dev->param.bad_block_fn) ++ return dev->param.bad_block_fn(dev, block_no); else - return yaffs_TagsCompatabilityMarkNANDBlockBad(dev, blockNo); +- return yaffs_TagsCompatabilityMarkNANDBlockBad(dev, blockNo); ++ return yaffs_tags_compat_mark_bad(dev, block_no); } -@@ -103,8 +106,8 @@ int yaffs_QueryInitialBlockState(yaffs_D + +-int yaffs_QueryInitialBlockState(yaffs_Device *dev, +- int blockNo, +- yaffs_BlockState *state, +- __u32 *sequenceNumber) ++int yaffs_query_init_block_state(yaffs_dev_t *dev, ++ int block_no, ++ yaffs_block_state_t *state, ++ __u32 *seq_number) { - blockNo -= dev->blockOffset; +- blockNo -= dev->blockOffset; ++ block_no -= dev->block_offset; - if (dev->queryNANDBlock) - return dev->queryNANDBlock(dev, blockNo, state, sequenceNumber); -+ if (dev->param.queryNANDBlock) -+ return dev->param.queryNANDBlock(dev, blockNo, state, sequenceNumber); ++ if (dev->param.query_block_fn) ++ return dev->param.query_block_fn(dev, block_no, state, seq_number); else - return yaffs_TagsCompatabilityQueryNANDBlock(dev, blockNo, +- return yaffs_TagsCompatabilityQueryNANDBlock(dev, blockNo, ++ return yaffs_tags_compat_query_block(dev, block_no, state, -@@ -119,16 +122,18 @@ int yaffs_EraseBlockInNAND(struct yaffs_ +- sequenceNumber); ++ seq_number); + } - blockInNAND -= dev->blockOffset; -- - dev->nBlockErasures++; +-int yaffs_EraseBlockInNAND(struct yaffs_DeviceStruct *dev, +- int blockInNAND) ++int yaffs_erase_block(struct yaffs_dev_s *dev, ++ int flash_block) + { + int result; + +- blockInNAND -= dev->blockOffset; ++ flash_block -= dev->block_offset; + ++ dev->n_erasures++; + +- dev->nBlockErasures++; - result = dev->eraseBlockInNAND(dev, blockInNAND); -+ -+ result = dev->param.eraseBlockInNAND(dev, blockInNAND); ++ result = dev->param.erase_fn(dev, flash_block); return result; } - int yaffs_InitialiseNAND(struct yaffs_DeviceStruct *dev) +-int yaffs_InitialiseNAND(struct yaffs_DeviceStruct *dev) ++int yaffs_init_nand(struct yaffs_dev_s *dev) { - return dev->initialiseNAND(dev); -+ if(dev->param.initialiseNAND) -+ return dev->param.initialiseNAND(dev); ++ if(dev->param.initialise_flash_fn) ++ return dev->param.initialise_flash_fn(dev); + return YAFFS_OK; } ---- a/fs/yaffs2/yaffs_nandemul2k.h -+++ b/fs/yaffs2/yaffs_nandemul2k.h +diff -Nrup linux-2.6.36-rc8/fs/yaffs2/yaffs_nandemul2k.h linux-2.6.36-rc8.new/fs/yaffs2/yaffs_nandemul2k.h +--- linux-2.6.36-rc8/fs/yaffs2/yaffs_nandemul2k.h 2010-10-20 13:17:58.959000294 +0300 ++++ linux-2.6.36-rc8.new/fs/yaffs2/yaffs_nandemul2k.h 2010-10-20 13:28:16.063000294 +0300 @@ -1,7 +1,7 @@ /* * YAFFS: Yet another Flash File System . A NAND-flash specific file system. @@ -16821,8 +19085,40 @@ * for Toby Churchill Ltd and Brightstar Engineering * * Created by Charles Manning <charles@aleph1.co.uk> ---- a/fs/yaffs2/yaffs_nand.h -+++ b/fs/yaffs2/yaffs_nand.h +@@ -20,18 +20,18 @@ + + #include "yaffs_guts.h" + +-int nandemul2k_WriteChunkWithTagsToNAND(struct yaffs_DeviceStruct *dev, +- int chunkInNAND, const __u8 *data, +- const yaffs_ExtendedTags *tags); +-int nandemul2k_ReadChunkWithTagsFromNAND(struct yaffs_DeviceStruct *dev, +- int chunkInNAND, __u8 *data, +- yaffs_ExtendedTags *tags); +-int nandemul2k_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo); +-int nandemul2k_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockNo, +- yaffs_BlockState *state, __u32 *sequenceNumber); +-int nandemul2k_EraseBlockInNAND(struct yaffs_DeviceStruct *dev, +- int blockInNAND); +-int nandemul2k_InitialiseNAND(struct yaffs_DeviceStruct *dev); ++int nandemul2k_WriteChunkWithTagsToNAND(struct yaffs_dev_s *dev, ++ int nand_chunk, const __u8 *data, ++ const yaffs_ext_tags *tags); ++int nandemul2k_ReadChunkWithTagsFromNAND(struct yaffs_dev_s *dev, ++ int nand_chunk, __u8 *data, ++ yaffs_ext_tags *tags); ++int nandemul2k_MarkNANDBlockBad(struct yaffs_dev_s *dev, int block_no); ++int nandemul2k_QueryNANDBlock(struct yaffs_dev_s *dev, int block_no, ++ yaffs_block_state_t *state, __u32 *seq_number); ++int nandemul2k_EraseBlockInNAND(struct yaffs_dev_s *dev, ++ int flash_block); ++int nandemul2k_InitialiseNAND(struct yaffs_dev_s *dev); + int nandemul2k_GetBytesPerChunk(void); + int nandemul2k_GetChunksPerBlock(void); + int nandemul2k_GetNumberOfBlocks(void); +diff -Nrup linux-2.6.36-rc8/fs/yaffs2/yaffs_nand.h linux-2.6.36-rc8.new/fs/yaffs2/yaffs_nand.h +--- linux-2.6.36-rc8/fs/yaffs2/yaffs_nand.h 2010-10-20 13:17:58.959000294 +0300 ++++ linux-2.6.36-rc8.new/fs/yaffs2/yaffs_nand.h 2010-10-20 13:28:16.063000294 +0300 @@ -1,7 +1,7 @@ /* * YAFFS: Yet another Flash File System . A NAND-flash specific file system. @@ -16832,8 +19128,49 @@ * for Toby Churchill Ltd and Brightstar Engineering * * Created by Charles Manning <charles@aleph1.co.uk> ---- a/fs/yaffs2/yaffs_packedtags1.c -+++ b/fs/yaffs2/yaffs_packedtags1.c +@@ -19,26 +19,26 @@ + + + +-int yaffs_ReadChunkWithTagsFromNAND(yaffs_Device *dev, int chunkInNAND, ++int yaffs_rd_chunk_tags_nand(yaffs_dev_t *dev, int nand_chunk, + __u8 *buffer, +- yaffs_ExtendedTags *tags); ++ yaffs_ext_tags *tags); + +-int yaffs_WriteChunkWithTagsToNAND(yaffs_Device *dev, +- int chunkInNAND, ++int yaffs_wr_chunk_tags_nand(yaffs_dev_t *dev, ++ int nand_chunk, + const __u8 *buffer, +- yaffs_ExtendedTags *tags); ++ yaffs_ext_tags *tags); + +-int yaffs_MarkBlockBad(yaffs_Device *dev, int blockNo); ++int yaffs_mark_bad(yaffs_dev_t *dev, int block_no); + +-int yaffs_QueryInitialBlockState(yaffs_Device *dev, +- int blockNo, +- yaffs_BlockState *state, +- unsigned *sequenceNumber); ++int yaffs_query_init_block_state(yaffs_dev_t *dev, ++ int block_no, ++ yaffs_block_state_t *state, ++ unsigned *seq_number); + +-int yaffs_EraseBlockInNAND(struct yaffs_DeviceStruct *dev, +- int blockInNAND); ++int yaffs_erase_block(struct yaffs_dev_s *dev, ++ int flash_block); + +-int yaffs_InitialiseNAND(struct yaffs_DeviceStruct *dev); ++int yaffs_init_nand(struct yaffs_dev_s *dev); + + #endif + +diff -Nrup linux-2.6.36-rc8/fs/yaffs2/yaffs_packedtags1.c linux-2.6.36-rc8.new/fs/yaffs2/yaffs_packedtags1.c +--- linux-2.6.36-rc8/fs/yaffs2/yaffs_packedtags1.c 2010-10-20 13:17:58.959000294 +0300 ++++ linux-2.6.36-rc8.new/fs/yaffs2/yaffs_packedtags1.c 2010-10-20 13:28:16.029000294 +0300 @@ -1,7 +1,7 @@ /* * YAFFS: Yet Another Flash File System. A NAND-flash specific file system. @@ -16843,8 +19180,64 @@ * for Toby Churchill Ltd and Brightstar Engineering * * Created by Charles Manning <charles@aleph1.co.uk> ---- a/fs/yaffs2/yaffs_packedtags1.h -+++ b/fs/yaffs2/yaffs_packedtags1.h +@@ -14,37 +14,37 @@ + #include "yaffs_packedtags1.h" + #include "yportenv.h" + +-void yaffs_PackTags1(yaffs_PackedTags1 *pt, const yaffs_ExtendedTags *t) ++void yaffs_PackTags1(yaffs_PackedTags1 *pt, const yaffs_ext_tags *t) + { +- pt->chunkId = t->chunkId; +- pt->serialNumber = t->serialNumber; +- pt->byteCount = t->byteCount; +- pt->objectId = t->objectId; ++ pt->chunk_id = t->chunk_id; ++ pt->serial_number = t->serial_number; ++ pt->n_bytes = t->n_bytes; ++ pt->obj_id = t->obj_id; + pt->ecc = 0; +- pt->deleted = (t->chunkDeleted) ? 0 : 1; ++ pt->deleted = (t->is_deleted) ? 0 : 1; + pt->unusedStuff = 0; + pt->shouldBeFF = 0xFFFFFFFF; + + } + +-void yaffs_UnpackTags1(yaffs_ExtendedTags *t, const yaffs_PackedTags1 *pt) ++void yaffs_unpack_tags1(yaffs_ext_tags *t, const yaffs_PackedTags1 *pt) + { + static const __u8 allFF[] = + { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff }; + + if (memcmp(allFF, pt, sizeof(yaffs_PackedTags1))) { +- t->blockBad = 0; ++ t->block_bad = 0; + if (pt->shouldBeFF != 0xFFFFFFFF) +- t->blockBad = 1; +- t->chunkUsed = 1; +- t->objectId = pt->objectId; +- t->chunkId = pt->chunkId; +- t->byteCount = pt->byteCount; +- t->eccResult = YAFFS_ECC_RESULT_NO_ERROR; +- t->chunkDeleted = (pt->deleted) ? 0 : 1; +- t->serialNumber = pt->serialNumber; ++ t->block_bad = 1; ++ t->chunk_used = 1; ++ t->obj_id = pt->obj_id; ++ t->chunk_id = pt->chunk_id; ++ t->n_bytes = pt->n_bytes; ++ t->ecc_result = YAFFS_ECC_RESULT_NO_ERROR; ++ t->is_deleted = (pt->deleted) ? 0 : 1; ++ t->serial_number = pt->serial_number; + } else { +- memset(t, 0, sizeof(yaffs_ExtendedTags)); ++ memset(t, 0, sizeof(yaffs_ext_tags)); + } + } +diff -Nrup linux-2.6.36-rc8/fs/yaffs2/yaffs_packedtags1.h linux-2.6.36-rc8.new/fs/yaffs2/yaffs_packedtags1.h +--- linux-2.6.36-rc8/fs/yaffs2/yaffs_packedtags1.h 2010-10-20 13:17:58.960000294 +0300 ++++ linux-2.6.36-rc8.new/fs/yaffs2/yaffs_packedtags1.h 2010-10-20 13:28:16.063000294 +0300 @@ -1,7 +1,7 @@ /* * YAFFS: Yet another Flash File System . A NAND-flash specific file system. @@ -16854,8 +19247,33 @@ * for Toby Churchill Ltd and Brightstar Engineering * * Created by Charles Manning <charles@aleph1.co.uk> ---- a/fs/yaffs2/yaffs_packedtags2.c -+++ b/fs/yaffs2/yaffs_packedtags2.c +@@ -21,10 +21,10 @@ + #include "yaffs_guts.h" + + typedef struct { +- unsigned chunkId:20; +- unsigned serialNumber:2; +- unsigned byteCount:10; +- unsigned objectId:18; ++ unsigned chunk_id:20; ++ unsigned serial_number:2; ++ unsigned n_bytes:10; ++ unsigned obj_id:18; + unsigned ecc:12; + unsigned deleted:1; + unsigned unusedStuff:1; +@@ -32,6 +32,6 @@ typedef struct { + + } yaffs_PackedTags1; + +-void yaffs_PackTags1(yaffs_PackedTags1 *pt, const yaffs_ExtendedTags *t); +-void yaffs_UnpackTags1(yaffs_ExtendedTags *t, const yaffs_PackedTags1 *pt); ++void yaffs_PackTags1(yaffs_PackedTags1 *pt, const yaffs_ext_tags *t); ++void yaffs_unpack_tags1(yaffs_ext_tags *t, const yaffs_PackedTags1 *pt); + #endif +diff -Nrup linux-2.6.36-rc8/fs/yaffs2/yaffs_packedtags2.c linux-2.6.36-rc8.new/fs/yaffs2/yaffs_packedtags2.c +--- linux-2.6.36-rc8/fs/yaffs2/yaffs_packedtags2.c 2010-10-20 13:17:58.960000294 +0300 ++++ linux-2.6.36-rc8.new/fs/yaffs2/yaffs_packedtags2.c 2010-10-20 13:28:16.029000294 +0300 @@ -1,7 +1,7 @@ /* * YAFFS: Yet Another Flash File System. A NAND-flash specific file system. @@ -16873,19 +19291,112 @@ #include "yaffs_tagsvalidity.h" /* This code packs a set of extended tags into a binary structure for -@@ -96,17 +97,14 @@ void yaffs_PackTags2TagsPart(yaffs_Packe +@@ -24,7 +25,7 @@ + * This is defined by having the EXTRA_HEADER_INFO_FLAG set. + */ + +-/* Extra flags applied to chunkId */ ++/* Extra flags applied to chunk_id */ + + #define EXTRA_HEADER_INFO_FLAG 0x80000000 + #define EXTRA_SHRINK_FLAG 0x40000000 +@@ -42,53 +43,53 @@ static void yaffs_DumpPackedTags2TagsPar + { + T(YAFFS_TRACE_MTD, + (TSTR("packed tags obj %d chunk %d byte %d seq %d" TENDSTR), +- ptt->objectId, ptt->chunkId, ptt->byteCount, +- ptt->sequenceNumber)); ++ ptt->obj_id, ptt->chunk_id, ptt->n_bytes, ++ ptt->seq_number)); + } + static void yaffs_DumpPackedTags2(const yaffs_PackedTags2 *pt) + { + yaffs_DumpPackedTags2TagsPart(&pt->t); + } + +-static void yaffs_DumpTags2(const yaffs_ExtendedTags *t) ++static void yaffs_DumpTags2(const yaffs_ext_tags *t) + { + T(YAFFS_TRACE_MTD, + (TSTR + ("ext.tags eccres %d blkbad %d chused %d obj %d chunk%d byte %d del %d ser %d seq %d" +- TENDSTR), t->eccResult, t->blockBad, t->chunkUsed, t->objectId, +- t->chunkId, t->byteCount, t->chunkDeleted, t->serialNumber, +- t->sequenceNumber)); ++ TENDSTR), t->ecc_result, t->block_bad, t->chunk_used, t->obj_id, ++ t->chunk_id, t->n_bytes, t->is_deleted, t->serial_number, ++ t->seq_number)); + + } + + void yaffs_PackTags2TagsPart(yaffs_PackedTags2TagsPart *ptt, +- const yaffs_ExtendedTags *t) ++ const yaffs_ext_tags *t) + { +- ptt->chunkId = t->chunkId; +- ptt->sequenceNumber = t->sequenceNumber; +- ptt->byteCount = t->byteCount; +- ptt->objectId = t->objectId; ++ ptt->chunk_id = t->chunk_id; ++ ptt->seq_number = t->seq_number; ++ ptt->n_bytes = t->n_bytes; ++ ptt->obj_id = t->obj_id; + +- if (t->chunkId == 0 && t->extraHeaderInfoAvailable) { ++ if (t->chunk_id == 0 && t->extra_available) { + /* Store the extra header info instead */ +- /* We save the parent object in the chunkId */ +- ptt->chunkId = EXTRA_HEADER_INFO_FLAG +- | t->extraParentObjectId; +- if (t->extraIsShrinkHeader) +- ptt->chunkId |= EXTRA_SHRINK_FLAG; +- if (t->extraShadows) +- ptt->chunkId |= EXTRA_SHADOWS_FLAG; +- +- ptt->objectId &= ~EXTRA_OBJECT_TYPE_MASK; +- ptt->objectId |= +- (t->extraObjectType << EXTRA_OBJECT_TYPE_SHIFT); +- +- if (t->extraObjectType == YAFFS_OBJECT_TYPE_HARDLINK) +- ptt->byteCount = t->extraEquivalentObjectId; +- else if (t->extraObjectType == YAFFS_OBJECT_TYPE_FILE) +- ptt->byteCount = t->extraFileLength; ++ /* We save the parent object in the chunk_id */ ++ ptt->chunk_id = EXTRA_HEADER_INFO_FLAG ++ | t->extra_parent_id; ++ if (t->extra_is_shrink) ++ ptt->chunk_id |= EXTRA_SHRINK_FLAG; ++ if (t->extra_shadows) ++ ptt->chunk_id |= EXTRA_SHADOWS_FLAG; ++ ++ ptt->obj_id &= ~EXTRA_OBJECT_TYPE_MASK; ++ ptt->obj_id |= ++ (t->extra_obj_type << EXTRA_OBJECT_TYPE_SHIFT); ++ ++ if (t->extra_obj_type == YAFFS_OBJECT_TYPE_HARDLINK) ++ ptt->n_bytes = t->extra_equiv_id; ++ else if (t->extra_obj_type == YAFFS_OBJECT_TYPE_FILE) ++ ptt->n_bytes = t->extra_length; + else +- ptt->byteCount = 0; ++ ptt->n_bytes = 0; + } + + yaffs_DumpPackedTags2TagsPart(ptt); +@@ -96,59 +97,56 @@ void yaffs_PackTags2TagsPart(yaffs_Packe } -void yaffs_PackTags2(yaffs_PackedTags2 *pt, const yaffs_ExtendedTags *t) -+void yaffs_PackTags2(yaffs_PackedTags2 *pt, const yaffs_ExtendedTags *t, int tagsECC) ++void yaffs_PackTags2(yaffs_PackedTags2 *pt, const yaffs_ext_tags *t, int tagsECC) { yaffs_PackTags2TagsPart(&pt->t, t); -#ifndef YAFFS_IGNORE_TAGS_ECC - { +- yaffs_ECCCalculateOther((unsigned char *)&pt->t, + if(tagsECC) - yaffs_ECCCalculateOther((unsigned char *)&pt->t, ++ yaffs_ecc_calc_other((unsigned char *)&pt->t, sizeof(yaffs_PackedTags2TagsPart), &pt->ecc); - } @@ -16893,15 +19404,87 @@ } -@@ -158,27 +156,24 @@ void yaffs_UnpackTags2TagsPart(yaffs_Ext +-void yaffs_UnpackTags2TagsPart(yaffs_ExtendedTags *t, ++void yaffs_unpack_tags2tags_part(yaffs_ext_tags *t, + yaffs_PackedTags2TagsPart *ptt) + { + +- memset(t, 0, sizeof(yaffs_ExtendedTags)); ++ memset(t, 0, sizeof(yaffs_ext_tags)); + +- yaffs_InitialiseTags(t); ++ yaffs_init_tags(t); + +- if (ptt->sequenceNumber != 0xFFFFFFFF) { +- t->blockBad = 0; +- t->chunkUsed = 1; +- t->objectId = ptt->objectId; +- t->chunkId = ptt->chunkId; +- t->byteCount = ptt->byteCount; +- t->chunkDeleted = 0; +- t->serialNumber = 0; +- t->sequenceNumber = ptt->sequenceNumber; ++ if (ptt->seq_number != 0xFFFFFFFF) { ++ t->block_bad = 0; ++ t->chunk_used = 1; ++ t->obj_id = ptt->obj_id; ++ t->chunk_id = ptt->chunk_id; ++ t->n_bytes = ptt->n_bytes; ++ t->is_deleted = 0; ++ t->serial_number = 0; ++ t->seq_number = ptt->seq_number; + + /* Do extra header info stuff */ + +- if (ptt->chunkId & EXTRA_HEADER_INFO_FLAG) { +- t->chunkId = 0; +- t->byteCount = 0; +- +- t->extraHeaderInfoAvailable = 1; +- t->extraParentObjectId = +- ptt->chunkId & (~(ALL_EXTRA_FLAGS)); +- t->extraIsShrinkHeader = +- (ptt->chunkId & EXTRA_SHRINK_FLAG) ? 1 : 0; +- t->extraShadows = +- (ptt->chunkId & EXTRA_SHADOWS_FLAG) ? 1 : 0; +- t->extraObjectType = +- ptt->objectId >> EXTRA_OBJECT_TYPE_SHIFT; +- t->objectId &= ~EXTRA_OBJECT_TYPE_MASK; ++ if (ptt->chunk_id & EXTRA_HEADER_INFO_FLAG) { ++ t->chunk_id = 0; ++ t->n_bytes = 0; ++ ++ t->extra_available = 1; ++ t->extra_parent_id = ++ ptt->chunk_id & (~(ALL_EXTRA_FLAGS)); ++ t->extra_is_shrink = ++ (ptt->chunk_id & EXTRA_SHRINK_FLAG) ? 1 : 0; ++ t->extra_shadows = ++ (ptt->chunk_id & EXTRA_SHADOWS_FLAG) ? 1 : 0; ++ t->extra_obj_type = ++ ptt->obj_id >> EXTRA_OBJECT_TYPE_SHIFT; ++ t->obj_id &= ~EXTRA_OBJECT_TYPE_MASK; + +- if (t->extraObjectType == YAFFS_OBJECT_TYPE_HARDLINK) +- t->extraEquivalentObjectId = ptt->byteCount; ++ if (t->extra_obj_type == YAFFS_OBJECT_TYPE_HARDLINK) ++ t->extra_equiv_id = ptt->n_bytes; + else +- t->extraFileLength = ptt->byteCount; ++ t->extra_length = ptt->n_bytes; + } + } + +@@ -158,49 +156,43 @@ void yaffs_UnpackTags2TagsPart(yaffs_Ext } -void yaffs_UnpackTags2(yaffs_ExtendedTags *t, yaffs_PackedTags2 *pt) -+void yaffs_UnpackTags2(yaffs_ExtendedTags *t, yaffs_PackedTags2 *pt, int tagsECC) ++void yaffs_unpack_tags2(yaffs_ext_tags *t, yaffs_PackedTags2 *pt, int tagsECC) { - yaffs_ECCResult eccResult = YAFFS_ECC_RESULT_NO_ERROR; +- yaffs_ECCResult eccResult = YAFFS_ECC_RESULT_NO_ERROR; ++ yaffs_ecc_result ecc_result = YAFFS_ECC_RESULT_NO_ERROR; - if (pt->t.sequenceNumber != 0xFFFFFFFF) { - /* Page is in use */ @@ -16919,41 +19502,53 @@ - (yaffs_PackedTags2TagsPart), - &pt->ecc, &ecc); - switch (result) { -+ if (pt->t.sequenceNumber != 0xFFFFFFFF && ++ if (pt->t.seq_number != 0xFFFFFFFF && + tagsECC){ + /* Chunk is in use and we need to do ECC */ + + yaffs_ECCOther ecc; + int result; -+ yaffs_ECCCalculateOther((unsigned char *)&pt->t, ++ yaffs_ecc_calc_other((unsigned char *)&pt->t, + sizeof(yaffs_PackedTags2TagsPart), + &ecc); -+ result = yaffs_ECCCorrectOther((unsigned char *)&pt->t, ++ result = yaffs_ecc_correct_other((unsigned char *)&pt->t, + sizeof(yaffs_PackedTags2TagsPart), + &pt->ecc, &ecc); + switch (result) { case 0: - eccResult = YAFFS_ECC_RESULT_NO_ERROR; +- eccResult = YAFFS_ECC_RESULT_NO_ERROR; ++ ecc_result = YAFFS_ECC_RESULT_NO_ERROR; + break; + case 1: +- eccResult = YAFFS_ECC_RESULT_FIXED; ++ ecc_result = YAFFS_ECC_RESULT_FIXED; break; -@@ -190,9 +185,7 @@ void yaffs_UnpackTags2(yaffs_ExtendedTag + case -1: +- eccResult = YAFFS_ECC_RESULT_UNFIXED; ++ ecc_result = YAFFS_ECC_RESULT_UNFIXED; break; default: - eccResult = YAFFS_ECC_RESULT_UNKNOWN; +- eccResult = YAFFS_ECC_RESULT_UNKNOWN; - } ++ ecc_result = YAFFS_ECC_RESULT_UNKNOWN; } -#endif } - yaffs_UnpackTags2TagsPart(t, &pt->t); -@@ -201,6 +194,5 @@ void yaffs_UnpackTags2(yaffs_ExtendedTag +- yaffs_UnpackTags2TagsPart(t, &pt->t); ++ yaffs_unpack_tags2tags_part(t, &pt->t); + +- t->eccResult = eccResult; ++ t->ecc_result = ecc_result; yaffs_DumpPackedTags2(pt); yaffs_DumpTags2(t); - } ---- a/fs/yaffs2/yaffs_packedtags2.h -+++ b/fs/yaffs2/yaffs_packedtags2.h +diff -Nrup linux-2.6.36-rc8/fs/yaffs2/yaffs_packedtags2.h linux-2.6.36-rc8.new/fs/yaffs2/yaffs_packedtags2.h +--- linux-2.6.36-rc8/fs/yaffs2/yaffs_packedtags2.h 2010-10-20 13:17:58.960000294 +0300 ++++ linux-2.6.36-rc8.new/fs/yaffs2/yaffs_packedtags2.h 2010-10-20 13:28:16.063000294 +0300 @@ -1,7 +1,7 @@ /* * YAFFS: Yet another Flash File System . A NAND-flash specific file system. @@ -16963,19 +19558,39 @@ * for Toby Churchill Ltd and Brightstar Engineering * * Created by Charles Manning <charles@aleph1.co.uk> -@@ -34,8 +34,8 @@ typedef struct { +@@ -22,10 +22,10 @@ + #include "yaffs_ecc.h" + + typedef struct { +- unsigned sequenceNumber; +- unsigned objectId; +- unsigned chunkId; +- unsigned byteCount; ++ unsigned seq_number; ++ unsigned obj_id; ++ unsigned chunk_id; ++ unsigned n_bytes; + } yaffs_PackedTags2TagsPart; + + typedef struct { +@@ -34,10 +34,10 @@ typedef struct { } yaffs_PackedTags2; /* Full packed tags with ECC, used for oob tags */ -void yaffs_PackTags2(yaffs_PackedTags2 *pt, const yaffs_ExtendedTags *t); -void yaffs_UnpackTags2(yaffs_ExtendedTags *t, yaffs_PackedTags2 *pt); -+void yaffs_PackTags2(yaffs_PackedTags2 *pt, const yaffs_ExtendedTags *t, int tagsECC); -+void yaffs_UnpackTags2(yaffs_ExtendedTags *t, yaffs_PackedTags2 *pt, int tagsECC); ++void yaffs_PackTags2(yaffs_PackedTags2 *pt, const yaffs_ext_tags *t, int tagsECC); ++void yaffs_unpack_tags2(yaffs_ext_tags *t, yaffs_PackedTags2 *pt, int tagsECC); /* Only the tags part (no ECC for use with inband tags */ - void yaffs_PackTags2TagsPart(yaffs_PackedTags2TagsPart *pt, const yaffs_ExtendedTags *t); ---- a/fs/yaffs2/yaffs_qsort.h -+++ b/fs/yaffs2/yaffs_qsort.h +-void yaffs_PackTags2TagsPart(yaffs_PackedTags2TagsPart *pt, const yaffs_ExtendedTags *t); +-void yaffs_UnpackTags2TagsPart(yaffs_ExtendedTags *t, yaffs_PackedTags2TagsPart *pt); ++void yaffs_PackTags2TagsPart(yaffs_PackedTags2TagsPart *pt, const yaffs_ext_tags *t); ++void yaffs_unpack_tags2tags_part(yaffs_ext_tags *t, yaffs_PackedTags2TagsPart *pt); + #endif +diff -Nrup linux-2.6.36-rc8/fs/yaffs2/yaffs_qsort.h linux-2.6.36-rc8.new/fs/yaffs2/yaffs_qsort.h +--- linux-2.6.36-rc8/fs/yaffs2/yaffs_qsort.h 2010-10-20 13:17:58.961000294 +0300 ++++ linux-2.6.36-rc8.new/fs/yaffs2/yaffs_qsort.h 2010-10-20 13:28:16.063000294 +0300 @@ -1,7 +1,7 @@ /* * YAFFS: Yet another Flash File System . A NAND-flash specific file system. @@ -17004,8 +19619,9 @@ #endif +#endif ---- a/fs/yaffs2/yaffs_tagscompat.c -+++ b/fs/yaffs2/yaffs_tagscompat.c +diff -Nrup linux-2.6.36-rc8/fs/yaffs2/yaffs_tagscompat.c linux-2.6.36-rc8.new/fs/yaffs2/yaffs_tagscompat.c +--- linux-2.6.36-rc8/fs/yaffs2/yaffs_tagscompat.c 2010-10-20 13:17:58.961000294 +0300 ++++ linux-2.6.36-rc8.new/fs/yaffs2/yaffs_tagscompat.c 2010-10-20 13:28:16.030000294 +0300 @@ -1,7 +1,7 @@ /* * YAFFS: Yet Another Flash File System. A NAND-flash specific file system. @@ -17015,126 +19631,668 @@ * for Toby Churchill Ltd and Brightstar Engineering * * Created by Charles Manning <charles@aleph1.co.uk> -@@ -15,6 +15,7 @@ +@@ -15,19 +15,20 @@ #include "yaffs_tagscompat.h" #include "yaffs_ecc.h" #include "yaffs_getblockinfo.h" +#include "yaffs_trace.h" - static void yaffs_HandleReadDataError(yaffs_Device *dev, int chunkInNAND); +-static void yaffs_HandleReadDataError(yaffs_Device *dev, int chunkInNAND); ++static void yaffs_handle_rd_data_error(yaffs_dev_t *dev, int nand_chunk); #ifdef NOTYET -@@ -163,15 +164,14 @@ static int yaffs_WriteChunkToNAND(struct - int chunkInNAND, const __u8 *data, - yaffs_Spare *spare) +-static void yaffs_CheckWrittenBlock(yaffs_Device *dev, int chunkInNAND); +-static void yaffs_HandleWriteChunkOk(yaffs_Device *dev, int chunkInNAND, ++static void yaffs_check_written_block(yaffs_dev_t *dev, int nand_chunk); ++static void yaffs_handle_chunk_wr_ok(yaffs_dev_t *dev, int nand_chunk, + const __u8 *data, +- const yaffs_Spare *spare); +-static void yaffs_HandleUpdateChunk(yaffs_Device *dev, int chunkInNAND, +- const yaffs_Spare *spare); +-static void yaffs_HandleWriteChunkError(yaffs_Device *dev, int chunkInNAND); ++ const yaffs_spare *spare); ++static void yaffs_handle_chunk_update(yaffs_dev_t *dev, int nand_chunk, ++ const yaffs_spare *spare); ++static void yaffs_handle_chunk_wr_error(yaffs_dev_t *dev, int nand_chunk); + #endif + +-static const char yaffs_countBitsTable[256] = { ++static const char yaffs_count_bits_table[256] = { + 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, + 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, + 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, +@@ -46,26 +47,26 @@ static const char yaffs_countBitsTable[2 + 4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8 + }; + +-int yaffs_CountBits(__u8 x) ++int yaffs_count_bits(__u8 x) + { + int retVal; +- retVal = yaffs_countBitsTable[x]; ++ retVal = yaffs_count_bits_table[x]; + return retVal; + } + + /********** Tags ECC calculations *********/ + +-void yaffs_CalcECC(const __u8 *data, yaffs_Spare *spare) ++void yaffs_calc_ecc(const __u8 *data, yaffs_spare *spare) + { +- yaffs_ECCCalculate(data, spare->ecc1); +- yaffs_ECCCalculate(&data[256], spare->ecc2); ++ yaffs_ecc_cacl(data, spare->ecc1); ++ yaffs_ecc_cacl(&data[256], spare->ecc2); + } + +-void yaffs_CalcTagsECC(yaffs_Tags *tags) ++void yaffs_calc_tags_ecc(yaffs_tags_t *tags) + { + /* Calculate an ecc */ + +- unsigned char *b = ((yaffs_TagsUnion *) tags)->asBytes; ++ unsigned char *b = ((yaffs_tags_union_t *) tags)->as_bytes; + unsigned i, j; + unsigned ecc = 0; + unsigned bit = 0; +@@ -84,24 +85,24 @@ void yaffs_CalcTagsECC(yaffs_Tags *tags) + + } + +-int yaffs_CheckECCOnTags(yaffs_Tags *tags) ++int yaffs_check_tags_ecc(yaffs_tags_t *tags) + { + unsigned ecc = tags->ecc; + +- yaffs_CalcTagsECC(tags); ++ yaffs_calc_tags_ecc(tags); + + ecc ^= tags->ecc; + + if (ecc && ecc <= 64) { + /* TODO: Handle the failure better. Retire? */ +- unsigned char *b = ((yaffs_TagsUnion *) tags)->asBytes; ++ unsigned char *b = ((yaffs_tags_union_t *) tags)->as_bytes; + + ecc--; + + b[ecc / 8] ^= (1 << (ecc & 7)); + + /* Now recvalc the ecc */ +- yaffs_CalcTagsECC(tags); ++ yaffs_calc_tags_ecc(tags); + + return 1; /* recovered error */ + } else if (ecc) { +@@ -115,76 +116,73 @@ int yaffs_CheckECCOnTags(yaffs_Tags *tag + + /********** Tags **********/ + +-static void yaffs_LoadTagsIntoSpare(yaffs_Spare *sparePtr, +- yaffs_Tags *tagsPtr) ++static void yaffs_load_tags_to_spare(yaffs_spare *sparePtr, ++ yaffs_tags_t *tagsPtr) + { +- yaffs_TagsUnion *tu = (yaffs_TagsUnion *) tagsPtr; ++ yaffs_tags_union_t *tu = (yaffs_tags_union_t *) tagsPtr; + +- yaffs_CalcTagsECC(tagsPtr); ++ yaffs_calc_tags_ecc(tagsPtr); + +- sparePtr->tagByte0 = tu->asBytes[0]; +- sparePtr->tagByte1 = tu->asBytes[1]; +- sparePtr->tagByte2 = tu->asBytes[2]; +- sparePtr->tagByte3 = tu->asBytes[3]; +- sparePtr->tagByte4 = tu->asBytes[4]; +- sparePtr->tagByte5 = tu->asBytes[5]; +- sparePtr->tagByte6 = tu->asBytes[6]; +- sparePtr->tagByte7 = tu->asBytes[7]; ++ sparePtr->tb0 = tu->as_bytes[0]; ++ sparePtr->tb1 = tu->as_bytes[1]; ++ sparePtr->tb2 = tu->as_bytes[2]; ++ sparePtr->tb3 = tu->as_bytes[3]; ++ sparePtr->tb4 = tu->as_bytes[4]; ++ sparePtr->tb5 = tu->as_bytes[5]; ++ sparePtr->tb6 = tu->as_bytes[6]; ++ sparePtr->tb7 = tu->as_bytes[7]; + } + +-static void yaffs_GetTagsFromSpare(yaffs_Device *dev, yaffs_Spare *sparePtr, +- yaffs_Tags *tagsPtr) ++static void yaffs_get_tags_from_spare(yaffs_dev_t *dev, yaffs_spare *sparePtr, ++ yaffs_tags_t *tagsPtr) + { +- yaffs_TagsUnion *tu = (yaffs_TagsUnion *) tagsPtr; ++ yaffs_tags_union_t *tu = (yaffs_tags_union_t *) tagsPtr; + int result; + +- tu->asBytes[0] = sparePtr->tagByte0; +- tu->asBytes[1] = sparePtr->tagByte1; +- tu->asBytes[2] = sparePtr->tagByte2; +- tu->asBytes[3] = sparePtr->tagByte3; +- tu->asBytes[4] = sparePtr->tagByte4; +- tu->asBytes[5] = sparePtr->tagByte5; +- tu->asBytes[6] = sparePtr->tagByte6; +- tu->asBytes[7] = sparePtr->tagByte7; ++ tu->as_bytes[0] = sparePtr->tb0; ++ tu->as_bytes[1] = sparePtr->tb1; ++ tu->as_bytes[2] = sparePtr->tb2; ++ tu->as_bytes[3] = sparePtr->tb3; ++ tu->as_bytes[4] = sparePtr->tb4; ++ tu->as_bytes[5] = sparePtr->tb5; ++ tu->as_bytes[6] = sparePtr->tb6; ++ tu->as_bytes[7] = sparePtr->tb7; + +- result = yaffs_CheckECCOnTags(tagsPtr); ++ result = yaffs_check_tags_ecc(tagsPtr); + if (result > 0) +- dev->tagsEccFixed++; ++ dev->n_tags_ecc_fixed++; + else if (result < 0) +- dev->tagsEccUnfixed++; ++ dev->n_tags_ecc_unfixed++; + } + +-static void yaffs_SpareInitialise(yaffs_Spare *spare) ++static void yaffs_spare_init(yaffs_spare *spare) + { +- memset(spare, 0xFF, sizeof(yaffs_Spare)); ++ memset(spare, 0xFF, sizeof(yaffs_spare)); + } + +-static int yaffs_WriteChunkToNAND(struct yaffs_DeviceStruct *dev, +- int chunkInNAND, const __u8 *data, +- yaffs_Spare *spare) ++static int yaffs_wr_nand(struct yaffs_dev_s *dev, ++ int nand_chunk, const __u8 *data, ++ yaffs_spare *spare) { - if (chunkInNAND < dev->startBlock * dev->nChunksPerBlock) { -+ if (chunkInNAND < dev->param.startBlock * dev->param.nChunksPerBlock) { ++ if (nand_chunk < dev->param.start_block * dev->param.chunks_per_block) { T(YAFFS_TRACE_ERROR, (TSTR("**>> yaffs chunk %d is not valid" TENDSTR), - chunkInNAND)); +- chunkInNAND)); ++ nand_chunk)); return YAFFS_FAIL; } - dev->nPageWrites++; - return dev->writeChunkToNAND(dev, chunkInNAND, data, spare); -+ return dev->param.writeChunkToNAND(dev, chunkInNAND, data, spare); ++ return dev->param.write_chunk_fn(dev, nand_chunk, data, spare); } - static int yaffs_ReadChunkFromNAND(struct yaffs_DeviceStruct *dev, -@@ -184,16 +184,14 @@ static int yaffs_ReadChunkFromNAND(struc +-static int yaffs_ReadChunkFromNAND(struct yaffs_DeviceStruct *dev, +- int chunkInNAND, ++static int yaffs_rd_chunk_nand(struct yaffs_dev_s *dev, ++ int nand_chunk, + __u8 *data, +- yaffs_Spare *spare, +- yaffs_ECCResult *eccResult, ++ yaffs_spare *spare, ++ yaffs_ecc_result *ecc_result, + int doErrorCorrection) + { int retVal; - yaffs_Spare localSpare; - -- dev->nPageReads++; +- yaffs_Spare localSpare; - +- dev->nPageReads++; ++ yaffs_spare localSpare; + if (!spare && data) { /* If we don't have a real spare, then we use a local one. */ - /* Need this for the calculation of the ecc */ +@@ -192,107 +190,107 @@ static int yaffs_ReadChunkFromNAND(struc spare = &localSpare; } - if (!dev->useNANDECC) { - retVal = dev->readChunkFromNAND(dev, chunkInNAND, data, spare); -+ if (!dev->param.useNANDECC) { -+ retVal = dev->param.readChunkFromNAND(dev, chunkInNAND, data, spare); ++ if (!dev->param.use_nand_ecc) { ++ retVal = dev->param.read_chunk_fn(dev, nand_chunk, data, spare); if (data && doErrorCorrection) { /* Do ECC correction */ /* Todo handle any errors */ -@@ -254,7 +252,7 @@ static int yaffs_ReadChunkFromNAND(struc +- int eccResult1, eccResult2; ++ int ecc_result1, ecc_result2; + __u8 calcEcc[3]; + +- yaffs_ECCCalculate(data, calcEcc); +- eccResult1 = +- yaffs_ECCCorrect(data, spare->ecc1, calcEcc); +- yaffs_ECCCalculate(&data[256], calcEcc); +- eccResult2 = +- yaffs_ECCCorrect(&data[256], spare->ecc2, calcEcc); ++ yaffs_ecc_cacl(data, calcEcc); ++ ecc_result1 = ++ yaffs_ecc_correct(data, spare->ecc1, calcEcc); ++ yaffs_ecc_cacl(&data[256], calcEcc); ++ ecc_result2 = ++ yaffs_ecc_correct(&data[256], spare->ecc2, calcEcc); + +- if (eccResult1 > 0) { ++ if (ecc_result1 > 0) { + T(YAFFS_TRACE_ERROR, + (TSTR + ("**>>yaffs ecc error fix performed on chunk %d:0" +- TENDSTR), chunkInNAND)); +- dev->eccFixed++; +- } else if (eccResult1 < 0) { ++ TENDSTR), nand_chunk)); ++ dev->n_ecc_fixed++; ++ } else if (ecc_result1 < 0) { + T(YAFFS_TRACE_ERROR, + (TSTR + ("**>>yaffs ecc error unfixed on chunk %d:0" +- TENDSTR), chunkInNAND)); +- dev->eccUnfixed++; ++ TENDSTR), nand_chunk)); ++ dev->n_ecc_unfixed++; + } + +- if (eccResult2 > 0) { ++ if (ecc_result2 > 0) { + T(YAFFS_TRACE_ERROR, + (TSTR + ("**>>yaffs ecc error fix performed on chunk %d:1" +- TENDSTR), chunkInNAND)); +- dev->eccFixed++; +- } else if (eccResult2 < 0) { ++ TENDSTR), nand_chunk)); ++ dev->n_ecc_fixed++; ++ } else if (ecc_result2 < 0) { + T(YAFFS_TRACE_ERROR, + (TSTR + ("**>>yaffs ecc error unfixed on chunk %d:1" +- TENDSTR), chunkInNAND)); +- dev->eccUnfixed++; ++ TENDSTR), nand_chunk)); ++ dev->n_ecc_unfixed++; + } + +- if (eccResult1 || eccResult2) { ++ if (ecc_result1 || ecc_result2) { + /* We had a data problem on this page */ +- yaffs_HandleReadDataError(dev, chunkInNAND); ++ yaffs_handle_rd_data_error(dev, nand_chunk); + } + +- if (eccResult1 < 0 || eccResult2 < 0) +- *eccResult = YAFFS_ECC_RESULT_UNFIXED; +- else if (eccResult1 > 0 || eccResult2 > 0) +- *eccResult = YAFFS_ECC_RESULT_FIXED; ++ if (ecc_result1 < 0 || ecc_result2 < 0) ++ *ecc_result = YAFFS_ECC_RESULT_UNFIXED; ++ else if (ecc_result1 > 0 || ecc_result2 > 0) ++ *ecc_result = YAFFS_ECC_RESULT_FIXED; + else +- *eccResult = YAFFS_ECC_RESULT_NO_ERROR; ++ *ecc_result = YAFFS_ECC_RESULT_NO_ERROR; + } + } else { + /* Must allocate enough memory for spare+2*sizeof(int) */ + /* for ecc results from device. */ +- struct yaffs_NANDSpare nspare; ++ struct yaffs_nand_spare nspare; memset(&nspare, 0, sizeof(nspare)); - retVal = dev->readChunkFromNAND(dev, chunkInNAND, data, -+ retVal = dev->param.readChunkFromNAND(dev, chunkInNAND, data, - (yaffs_Spare *) &nspare); - memcpy(spare, &nspare, sizeof(yaffs_Spare)); +- (yaffs_Spare *) &nspare); +- memcpy(spare, &nspare, sizeof(yaffs_Spare)); ++ retVal = dev->param.read_chunk_fn(dev, nand_chunk, data, ++ (yaffs_spare *) &nspare); ++ memcpy(spare, &nspare, sizeof(yaffs_spare)); if (data && doErrorCorrection) { -@@ -307,10 +305,10 @@ static int yaffs_CheckChunkErased(struct + if (nspare.eccres1 > 0) { + T(YAFFS_TRACE_ERROR, + (TSTR + ("**>>mtd ecc error fix performed on chunk %d:0" +- TENDSTR), chunkInNAND)); ++ TENDSTR), nand_chunk)); + } else if (nspare.eccres1 < 0) { + T(YAFFS_TRACE_ERROR, + (TSTR + ("**>>mtd ecc error unfixed on chunk %d:0" +- TENDSTR), chunkInNAND)); ++ TENDSTR), nand_chunk)); + } + + if (nspare.eccres2 > 0) { + T(YAFFS_TRACE_ERROR, + (TSTR + ("**>>mtd ecc error fix performed on chunk %d:1" +- TENDSTR), chunkInNAND)); ++ TENDSTR), nand_chunk)); + } else if (nspare.eccres2 < 0) { + T(YAFFS_TRACE_ERROR, + (TSTR + ("**>>mtd ecc error unfixed on chunk %d:1" +- TENDSTR), chunkInNAND)); ++ TENDSTR), nand_chunk)); + } + + if (nspare.eccres1 || nspare.eccres2) { + /* We had a data problem on this page */ +- yaffs_HandleReadDataError(dev, chunkInNAND); ++ yaffs_handle_rd_data_error(dev, nand_chunk); + } + + if (nspare.eccres1 < 0 || nspare.eccres2 < 0) +- *eccResult = YAFFS_ECC_RESULT_UNFIXED; ++ *ecc_result = YAFFS_ECC_RESULT_UNFIXED; + else if (nspare.eccres1 > 0 || nspare.eccres2 > 0) +- *eccResult = YAFFS_ECC_RESULT_FIXED; ++ *ecc_result = YAFFS_ECC_RESULT_FIXED; + else +- *eccResult = YAFFS_ECC_RESULT_NO_ERROR; ++ *ecc_result = YAFFS_ECC_RESULT_NO_ERROR; + + } + } +@@ -300,17 +298,17 @@ static int yaffs_ReadChunkFromNAND(struc + } + + #ifdef NOTYET +-static int yaffs_CheckChunkErased(struct yaffs_DeviceStruct *dev, +- int chunkInNAND) ++static int yaffs_check_chunk_erased(struct yaffs_dev_s *dev, ++ int nand_chunk) + { + static int init; static __u8 cmpbuf[YAFFS_BYTES_PER_CHUNK]; static __u8 data[YAFFS_BYTES_PER_CHUNK]; /* Might as well always allocate the larger size for */ - /* dev->useNANDECC == true; */ -+ /* dev->param.useNANDECC == true; */ - static __u8 spare[sizeof(struct yaffs_NANDSpare)]; +- static __u8 spare[sizeof(struct yaffs_NANDSpare)]; ++ /* dev->param.use_nand_ecc == true; */ ++ static __u8 spare[sizeof(struct yaffs_nand_spare)]; - dev->readChunkFromNAND(dev, chunkInNAND, data, (yaffs_Spare *) spare); -+ dev->param.readChunkFromNAND(dev, chunkInNAND, data, (yaffs_Spare *) spare); ++ dev->param.read_chunk_fn(dev, nand_chunk, data, (yaffs_spare *) spare); if (!init) { memset(cmpbuf, 0xff, YAFFS_BYTES_PER_CHUNK); -@@ -333,7 +331,7 @@ static int yaffs_CheckChunkErased(struct +@@ -331,14 +329,14 @@ static int yaffs_CheckChunkErased(struct + * Functions for robustisizing + */ - static void yaffs_HandleReadDataError(yaffs_Device *dev, int chunkInNAND) +-static void yaffs_HandleReadDataError(yaffs_Device *dev, int chunkInNAND) ++static void yaffs_handle_rd_data_error(yaffs_dev_t *dev, int nand_chunk) { - int blockInNAND = chunkInNAND / dev->nChunksPerBlock; -+ int blockInNAND = chunkInNAND / dev->param.nChunksPerBlock; ++ int flash_block = nand_chunk / dev->param.chunks_per_block; /* Mark the block for retirement */ - yaffs_GetBlockInfo(dev, blockInNAND + dev->blockOffset)->needsRetiring = 1; -@@ -365,7 +363,7 @@ static void yaffs_HandleUpdateChunk(yaff +- yaffs_GetBlockInfo(dev, blockInNAND + dev->blockOffset)->needsRetiring = 1; ++ yaffs_get_block_info(dev, flash_block + dev->block_offset)->needs_retiring = 1; + T(YAFFS_TRACE_ERROR | YAFFS_TRACE_BAD_BLOCKS, +- (TSTR("**>>Block %d marked for retirement" TENDSTR), blockInNAND)); ++ (TSTR("**>>Block %d marked for retirement" TENDSTR), flash_block)); + + /* TODO: + * Just do a garbage collection on the affected block +@@ -348,44 +346,44 @@ static void yaffs_HandleReadDataError(ya + } - static void yaffs_HandleWriteChunkError(yaffs_Device *dev, int chunkInNAND) + #ifdef NOTYET +-static void yaffs_CheckWrittenBlock(yaffs_Device *dev, int chunkInNAND) ++static void yaffs_check_written_block(yaffs_dev_t *dev, int nand_chunk) + { + } + +-static void yaffs_HandleWriteChunkOk(yaffs_Device *dev, int chunkInNAND, ++static void yaffs_handle_chunk_wr_ok(yaffs_dev_t *dev, int nand_chunk, + const __u8 *data, +- const yaffs_Spare *spare) ++ const yaffs_spare *spare) + { + } + +-static void yaffs_HandleUpdateChunk(yaffs_Device *dev, int chunkInNAND, +- const yaffs_Spare *spare) ++static void yaffs_handle_chunk_update(yaffs_dev_t *dev, int nand_chunk, ++ const yaffs_spare *spare) + { + } + +-static void yaffs_HandleWriteChunkError(yaffs_Device *dev, int chunkInNAND) ++static void yaffs_handle_chunk_wr_error(yaffs_dev_t *dev, int nand_chunk) { - int blockInNAND = chunkInNAND / dev->nChunksPerBlock; -+ int blockInNAND = chunkInNAND / dev->param.nChunksPerBlock; ++ int flash_block = nand_chunk / dev->param.chunks_per_block; /* Mark the block for retirement */ - yaffs_GetBlockInfo(dev, blockInNAND)->needsRetiring = 1; -@@ -424,7 +422,7 @@ int yaffs_TagsCompatabilityWriteChunkWit +- yaffs_GetBlockInfo(dev, blockInNAND)->needsRetiring = 1; ++ yaffs_get_block_info(dev, flash_block)->needs_retiring = 1; + /* Delete the chunk */ +- yaffs_DeleteChunk(dev, chunkInNAND, 1, __LINE__); ++ yaffs_chunk_del(dev, nand_chunk, 1, __LINE__); + } + +-static int yaffs_VerifyCompare(const __u8 *d0, const __u8 *d1, +- const yaffs_Spare *s0, const yaffs_Spare *s1) ++static int yaffs_verify_cmp(const __u8 *d0, const __u8 *d1, ++ const yaffs_spare *s0, const yaffs_spare *s1) + { - tags.serialNumber = eTags->serialNumber; + if (memcmp(d0, d1, YAFFS_BYTES_PER_CHUNK) != 0 || +- s0->tagByte0 != s1->tagByte0 || +- s0->tagByte1 != s1->tagByte1 || +- s0->tagByte2 != s1->tagByte2 || +- s0->tagByte3 != s1->tagByte3 || +- s0->tagByte4 != s1->tagByte4 || +- s0->tagByte5 != s1->tagByte5 || +- s0->tagByte6 != s1->tagByte6 || +- s0->tagByte7 != s1->tagByte7 || ++ s0->tb0 != s1->tb0 || ++ s0->tb1 != s1->tb1 || ++ s0->tb2 != s1->tb2 || ++ s0->tb3 != s1->tb3 || ++ s0->tb4 != s1->tb4 || ++ s0->tb5 != s1->tb5 || ++ s0->tb6 != s1->tb6 || ++ s0->tb7 != s1->tb7 || + s0->ecc1[0] != s1->ecc1[0] || + s0->ecc1[1] != s1->ecc1[1] || + s0->ecc1[2] != s1->ecc1[2] || +@@ -398,53 +396,53 @@ static int yaffs_VerifyCompare(const __u + } + #endif /* NOTYET */ + +-int yaffs_TagsCompatabilityWriteChunkWithTagsToNAND(yaffs_Device *dev, +- int chunkInNAND, ++int yaffs_tags_compat_wr(yaffs_dev_t *dev, ++ int nand_chunk, + const __u8 *data, +- const yaffs_ExtendedTags *eTags) ++ const yaffs_ext_tags *eTags) + { +- yaffs_Spare spare; +- yaffs_Tags tags; ++ yaffs_spare spare; ++ yaffs_tags_t tags; + +- yaffs_SpareInitialise(&spare); ++ yaffs_spare_init(&spare); + +- if (eTags->chunkDeleted) +- spare.pageStatus = 0; ++ if (eTags->is_deleted) ++ spare.page_status = 0; + else { +- tags.objectId = eTags->objectId; +- tags.chunkId = eTags->chunkId; ++ tags.obj_id = eTags->obj_id; ++ tags.chunk_id = eTags->chunk_id; + +- tags.byteCountLSB = eTags->byteCount & 0x3ff; ++ tags.n_bytes_lsb = eTags->n_bytes & 0x3ff; + +- if (dev->nDataBytesPerChunk >= 1024) +- tags.byteCountMSB = (eTags->byteCount >> 10) & 3; ++ if (dev->data_bytes_per_chunk >= 1024) ++ tags.n_bytes_msb = (eTags->n_bytes >> 10) & 3; + else +- tags.byteCountMSB = 3; ++ tags.n_bytes_msb = 3; + + +- tags.serialNumber = eTags->serialNumber; ++ tags.serial_number = eTags->serial_number; - if (!dev->useNANDECC && data) -+ if (!dev->param.useNANDECC && data) - yaffs_CalcECC(data, &spare); +- yaffs_CalcECC(data, &spare); ++ if (!dev->param.use_nand_ecc && data) ++ yaffs_calc_ecc(data, &spare); - yaffs_LoadTagsIntoSpare(&spare, &tags); -@@ -498,9 +496,9 @@ int yaffs_TagsCompatabilityMarkNANDBlock +- yaffs_LoadTagsIntoSpare(&spare, &tags); ++ yaffs_load_tags_to_spare(&spare, &tags); - spare.blockStatus = 'Y'; + } + +- return yaffs_WriteChunkToNAND(dev, chunkInNAND, data, &spare); ++ return yaffs_wr_nand(dev, nand_chunk, data, &spare); + } + +-int yaffs_TagsCompatabilityReadChunkWithTagsFromNAND(yaffs_Device *dev, +- int chunkInNAND, ++int yaffs_tags_compat_rd(yaffs_dev_t *dev, ++ int nand_chunk, + __u8 *data, +- yaffs_ExtendedTags *eTags) ++ yaffs_ext_tags *eTags) + { + +- yaffs_Spare spare; +- yaffs_Tags tags; +- yaffs_ECCResult eccResult = YAFFS_ECC_RESULT_UNKNOWN; ++ yaffs_spare spare; ++ yaffs_tags_t tags; ++ yaffs_ecc_result ecc_result = YAFFS_ECC_RESULT_UNKNOWN; + +- static yaffs_Spare spareFF; ++ static yaffs_spare spareFF; + static int init; + + if (!init) { +@@ -452,33 +450,33 @@ int yaffs_TagsCompatabilityReadChunkWith + init = 1; + } + +- if (yaffs_ReadChunkFromNAND +- (dev, chunkInNAND, data, &spare, &eccResult, 1)) { ++ if (yaffs_rd_chunk_nand ++ (dev, nand_chunk, data, &spare, &ecc_result, 1)) { + /* eTags may be NULL */ + if (eTags) { + + int deleted = +- (yaffs_CountBits(spare.pageStatus) < 7) ? 1 : 0; ++ (yaffs_count_bits(spare.page_status) < 7) ? 1 : 0; + +- eTags->chunkDeleted = deleted; +- eTags->eccResult = eccResult; +- eTags->blockBad = 0; /* We're reading it */ ++ eTags->is_deleted = deleted; ++ eTags->ecc_result = ecc_result; ++ eTags->block_bad = 0; /* We're reading it */ + /* therefore it is not a bad block */ +- eTags->chunkUsed = ++ eTags->chunk_used = + (memcmp(&spareFF, &spare, sizeof(spareFF)) != + 0) ? 1 : 0; + +- if (eTags->chunkUsed) { +- yaffs_GetTagsFromSpare(dev, &spare, &tags); ++ if (eTags->chunk_used) { ++ yaffs_get_tags_from_spare(dev, &spare, &tags); + +- eTags->objectId = tags.objectId; +- eTags->chunkId = tags.chunkId; +- eTags->byteCount = tags.byteCountLSB; ++ eTags->obj_id = tags.obj_id; ++ eTags->chunk_id = tags.chunk_id; ++ eTags->n_bytes = tags.n_bytes_lsb; + +- if (dev->nDataBytesPerChunk >= 1024) +- eTags->byteCount |= (((unsigned) tags.byteCountMSB) << 10); ++ if (dev->data_bytes_per_chunk >= 1024) ++ eTags->n_bytes |= (((unsigned) tags.n_bytes_msb) << 10); + +- eTags->serialNumber = tags.serialNumber; ++ eTags->serial_number = tags.serial_number; + } + } + +@@ -488,49 +486,49 @@ int yaffs_TagsCompatabilityReadChunkWith + } + } + +-int yaffs_TagsCompatabilityMarkNANDBlockBad(struct yaffs_DeviceStruct *dev, +- int blockInNAND) ++int yaffs_tags_compat_mark_bad(struct yaffs_dev_s *dev, ++ int flash_block) + { + +- yaffs_Spare spare; ++ yaffs_spare spare; + +- memset(&spare, 0xff, sizeof(yaffs_Spare)); ++ memset(&spare, 0xff, sizeof(yaffs_spare)); + +- spare.blockStatus = 'Y'; ++ spare.block_status = 'Y'; - yaffs_WriteChunkToNAND(dev, blockInNAND * dev->nChunksPerBlock, NULL, -+ yaffs_WriteChunkToNAND(dev, blockInNAND * dev->param.nChunksPerBlock, NULL, ++ yaffs_wr_nand(dev, flash_block * dev->param.chunks_per_block, NULL, &spare); - yaffs_WriteChunkToNAND(dev, blockInNAND * dev->nChunksPerBlock + 1, -+ yaffs_WriteChunkToNAND(dev, blockInNAND * dev->param.nChunksPerBlock + 1, ++ yaffs_wr_nand(dev, flash_block * dev->param.chunks_per_block + 1, NULL, &spare); return YAFFS_OK; -@@ -525,9 +523,9 @@ int yaffs_TagsCompatabilityQueryNANDBloc - *sequenceNumber = 0; + } + +-int yaffs_TagsCompatabilityQueryNANDBlock(struct yaffs_DeviceStruct *dev, +- int blockNo, +- yaffs_BlockState *state, +- __u32 *sequenceNumber) ++int yaffs_tags_compat_query_block(struct yaffs_dev_s *dev, ++ int block_no, ++ yaffs_block_state_t *state, ++ __u32 *seq_number) + { + +- yaffs_Spare spare0, spare1; +- static yaffs_Spare spareFF; ++ yaffs_spare spare0, spare1; ++ static yaffs_spare spareFF; + static int init; +- yaffs_ECCResult dummy; ++ yaffs_ecc_result dummy; + + if (!init) { + memset(&spareFF, 0xFF, sizeof(spareFF)); + init = 1; + } + +- *sequenceNumber = 0; ++ *seq_number = 0; - yaffs_ReadChunkFromNAND(dev, blockNo * dev->nChunksPerBlock, NULL, -+ yaffs_ReadChunkFromNAND(dev, blockNo * dev->param.nChunksPerBlock, NULL, ++ yaffs_rd_chunk_nand(dev, block_no * dev->param.chunks_per_block, NULL, &spare0, &dummy, 1); - yaffs_ReadChunkFromNAND(dev, blockNo * dev->nChunksPerBlock + 1, NULL, -+ yaffs_ReadChunkFromNAND(dev, blockNo * dev->param.nChunksPerBlock + 1, NULL, ++ yaffs_rd_chunk_nand(dev, block_no * dev->param.chunks_per_block + 1, NULL, &spare1, &dummy, 1); - if (yaffs_CountBits(spare0.blockStatus & spare1.blockStatus) < 7) ---- a/fs/yaffs2/yaffs_tagscompat.h -+++ b/fs/yaffs2/yaffs_tagscompat.h +- if (yaffs_CountBits(spare0.blockStatus & spare1.blockStatus) < 7) ++ if (yaffs_count_bits(spare0.block_status & spare1.block_status) < 7) + *state = YAFFS_BLOCK_STATE_DEAD; + else if (memcmp(&spareFF, &spare0, sizeof(spareFF)) == 0) + *state = YAFFS_BLOCK_STATE_EMPTY; +diff -Nrup linux-2.6.36-rc8/fs/yaffs2/yaffs_tagscompat.h linux-2.6.36-rc8.new/fs/yaffs2/yaffs_tagscompat.h +--- linux-2.6.36-rc8/fs/yaffs2/yaffs_tagscompat.h 2010-10-20 13:17:58.961000294 +0300 ++++ linux-2.6.36-rc8.new/fs/yaffs2/yaffs_tagscompat.h 2010-10-20 13:28:16.064000294 +0300 @@ -1,7 +1,7 @@ /* * YAFFS: Yet another Flash File System . A NAND-flash specific file system. @@ -17144,8 +20302,48 @@ * for Toby Churchill Ltd and Brightstar Engineering * * Created by Charles Manning <charles@aleph1.co.uk> ---- a/fs/yaffs2/yaffs_tagsvalidity.c -+++ b/fs/yaffs2/yaffs_tagsvalidity.c +@@ -17,23 +17,23 @@ + #define __YAFFS_TAGSCOMPAT_H__ + + #include "yaffs_guts.h" +-int yaffs_TagsCompatabilityWriteChunkWithTagsToNAND(yaffs_Device *dev, +- int chunkInNAND, ++int yaffs_tags_compat_wr(yaffs_dev_t *dev, ++ int nand_chunk, + const __u8 *data, +- const yaffs_ExtendedTags *tags); +-int yaffs_TagsCompatabilityReadChunkWithTagsFromNAND(yaffs_Device *dev, +- int chunkInNAND, ++ const yaffs_ext_tags *tags); ++int yaffs_tags_compat_rd(yaffs_dev_t *dev, ++ int nand_chunk, + __u8 *data, +- yaffs_ExtendedTags *tags); +-int yaffs_TagsCompatabilityMarkNANDBlockBad(struct yaffs_DeviceStruct *dev, +- int blockNo); +-int yaffs_TagsCompatabilityQueryNANDBlock(struct yaffs_DeviceStruct *dev, +- int blockNo, +- yaffs_BlockState *state, +- __u32 *sequenceNumber); ++ yaffs_ext_tags *tags); ++int yaffs_tags_compat_mark_bad(struct yaffs_dev_s *dev, ++ int block_no); ++int yaffs_tags_compat_query_block(struct yaffs_dev_s *dev, ++ int block_no, ++ yaffs_block_state_t *state, ++ __u32 *seq_number); + +-void yaffs_CalcTagsECC(yaffs_Tags *tags); +-int yaffs_CheckECCOnTags(yaffs_Tags *tags); +-int yaffs_CountBits(__u8 byte); ++void yaffs_calc_tags_ecc(yaffs_tags_t *tags); ++int yaffs_check_tags_ecc(yaffs_tags_t *tags); ++int yaffs_count_bits(__u8 byte); + + #endif +diff -Nrup linux-2.6.36-rc8/fs/yaffs2/yaffs_tagsvalidity.c linux-2.6.36-rc8.new/fs/yaffs2/yaffs_tagsvalidity.c +--- linux-2.6.36-rc8/fs/yaffs2/yaffs_tagsvalidity.c 2010-10-20 13:17:58.962000294 +0300 ++++ linux-2.6.36-rc8.new/fs/yaffs2/yaffs_tagsvalidity.c 2010-10-20 13:28:16.030000294 +0300 @@ -1,7 +1,7 @@ /* * YAFFS: Yet Another Flash File System. A NAND-flash specific file system. @@ -17155,8 +20353,33 @@ * for Toby Churchill Ltd and Brightstar Engineering * * Created by Charles Manning <charles@aleph1.co.uk> ---- a/fs/yaffs2/yaffs_tagsvalidity.h -+++ b/fs/yaffs2/yaffs_tagsvalidity.h +@@ -13,16 +13,16 @@ + + #include "yaffs_tagsvalidity.h" + +-void yaffs_InitialiseTags(yaffs_ExtendedTags *tags) ++void yaffs_init_tags(yaffs_ext_tags *tags) + { +- memset(tags, 0, sizeof(yaffs_ExtendedTags)); +- tags->validMarker0 = 0xAAAAAAAA; +- tags->validMarker1 = 0x55555555; ++ memset(tags, 0, sizeof(yaffs_ext_tags)); ++ tags->validity1 = 0xAAAAAAAA; ++ tags->validty1 = 0x55555555; + } + +-int yaffs_ValidateTags(yaffs_ExtendedTags *tags) ++int yaffs_validate_tags(yaffs_ext_tags *tags) + { +- return (tags->validMarker0 == 0xAAAAAAAA && +- tags->validMarker1 == 0x55555555); ++ return (tags->validity1 == 0xAAAAAAAA && ++ tags->validty1 == 0x55555555); + + } +diff -Nrup linux-2.6.36-rc8/fs/yaffs2/yaffs_tagsvalidity.h linux-2.6.36-rc8.new/fs/yaffs2/yaffs_tagsvalidity.h +--- linux-2.6.36-rc8/fs/yaffs2/yaffs_tagsvalidity.h 2010-10-20 13:17:58.962000294 +0300 ++++ linux-2.6.36-rc8.new/fs/yaffs2/yaffs_tagsvalidity.h 2010-10-20 13:28:16.064000294 +0300 @@ -1,7 +1,7 @@ /* * YAFFS: Yet another Flash File System . A NAND-flash specific file system. @@ -17166,8 +20389,18 @@ * for Toby Churchill Ltd and Brightstar Engineering * * Created by Charles Manning <charles@aleph1.co.uk> ---- /dev/null -+++ b/fs/yaffs2/yaffs_trace.h +@@ -19,6 +19,6 @@ + + #include "yaffs_guts.h" + +-void yaffs_InitialiseTags(yaffs_ExtendedTags *tags); +-int yaffs_ValidateTags(yaffs_ExtendedTags *tags); ++void yaffs_init_tags(yaffs_ext_tags *tags); ++int yaffs_validate_tags(yaffs_ext_tags *tags); + #endif +diff -Nrup linux-2.6.36-rc8/fs/yaffs2/yaffs_trace.h linux-2.6.36-rc8.new/fs/yaffs2/yaffs_trace.h +--- linux-2.6.36-rc8/fs/yaffs2/yaffs_trace.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.36-rc8.new/fs/yaffs2/yaffs_trace.h 2010-10-20 13:28:16.064000294 +0300 @@ -0,0 +1,60 @@ +/* + * YAFFS: Yet another Flash File System . A NAND-flash specific file system. @@ -17188,7 +20421,7 @@ +#ifndef __YTRACE_H__ +#define __YTRACE_H__ + -+extern unsigned int yaffs_traceMask; ++extern unsigned int yaffs_trace_mask; +extern unsigned int yaffs_wr_attempts; + +/* @@ -17226,11 +20459,12 @@ +#define YAFFS_TRACE_ALWAYS 0xF0000000 + + -+#define T(mask, p) do { if ((mask) & (yaffs_traceMask | YAFFS_TRACE_ALWAYS)) TOUT(p); } while (0) ++#define T(mask, p) do { if ((mask) & (yaffs_trace_mask | YAFFS_TRACE_ALWAYS)) TOUT(p); } while (0) + +#endif ---- /dev/null -+++ b/fs/yaffs2/yaffs_verify.c +diff -Nrup linux-2.6.36-rc8/fs/yaffs2/yaffs_verify.c linux-2.6.36-rc8.new/fs/yaffs2/yaffs_verify.c +--- linux-2.6.36-rc8/fs/yaffs2/yaffs_verify.c 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.36-rc8.new/fs/yaffs2/yaffs_verify.c 2010-10-20 13:28:16.031000294 +0300 @@ -0,0 +1,626 @@ +/* + * YAFFS: Yet Another Flash File System. A NAND-flash specific file system. @@ -17252,26 +20486,26 @@ +#include "yaffs_getblockinfo.h" +#include "yaffs_nand.h" + -+int yaffs_SkipVerification(yaffs_Device *dev) ++int yaffs_skip_verification(yaffs_dev_t *dev) +{ + dev=dev; -+ return !(yaffs_traceMask & (YAFFS_TRACE_VERIFY | YAFFS_TRACE_VERIFY_FULL)); ++ return !(yaffs_trace_mask & (YAFFS_TRACE_VERIFY | YAFFS_TRACE_VERIFY_FULL)); +} + -+static int yaffs_SkipFullVerification(yaffs_Device *dev) ++static int yaffs_skip_full_verification(yaffs_dev_t *dev) +{ + dev=dev; -+ return !(yaffs_traceMask & (YAFFS_TRACE_VERIFY_FULL)); ++ return !(yaffs_trace_mask & (YAFFS_TRACE_VERIFY_FULL)); +} + -+static int yaffs_SkipNANDVerification(yaffs_Device *dev) ++static int yaffs_skip_nand_verification(yaffs_dev_t *dev) +{ + dev=dev; -+ return !(yaffs_traceMask & (YAFFS_TRACE_VERIFY_NAND)); ++ return !(yaffs_trace_mask & (YAFFS_TRACE_VERIFY_NAND)); +} + + -+static const char *blockStateName[] = { ++static const char *block_stateName[] = { +"Unknown", +"Needs scanning", +"Scanning", @@ -17285,77 +20519,77 @@ +}; + + -+void yaffs_VerifyBlock(yaffs_Device *dev, yaffs_BlockInfo *bi, int n) ++void yaffs_verify_blk(yaffs_dev_t *dev, yaffs_block_info_t *bi, int n) +{ + int actuallyUsed; + int inUse; + -+ if (yaffs_SkipVerification(dev)) ++ if (yaffs_skip_verification(dev)) + return; + + /* Report illegal runtime states */ -+ if (bi->blockState >= YAFFS_NUMBER_OF_BLOCK_STATES) -+ T(YAFFS_TRACE_VERIFY, (TSTR("Block %d has undefined state %d"TENDSTR), n, bi->blockState)); ++ if (bi->block_state >= YAFFS_NUMBER_OF_BLOCK_STATES) ++ T(YAFFS_TRACE_VERIFY, (TSTR("Block %d has undefined state %d"TENDSTR), n, bi->block_state)); + -+ switch (bi->blockState) { ++ switch (bi->block_state) { + case YAFFS_BLOCK_STATE_UNKNOWN: + case YAFFS_BLOCK_STATE_SCANNING: + case YAFFS_BLOCK_STATE_NEEDS_SCANNING: + T(YAFFS_TRACE_VERIFY, (TSTR("Block %d has bad run-state %s"TENDSTR), -+ n, blockStateName[bi->blockState])); ++ n, block_stateName[bi->block_state])); + } + + /* Check pages in use and soft deletions are legal */ + -+ actuallyUsed = bi->pagesInUse - bi->softDeletions; ++ actuallyUsed = bi->pages_in_use - bi->soft_del_pages; + -+ if (bi->pagesInUse < 0 || bi->pagesInUse > dev->param.nChunksPerBlock || -+ bi->softDeletions < 0 || bi->softDeletions > dev->param.nChunksPerBlock || -+ actuallyUsed < 0 || actuallyUsed > dev->param.nChunksPerBlock) -+ T(YAFFS_TRACE_VERIFY, (TSTR("Block %d has illegal values pagesInUsed %d softDeletions %d"TENDSTR), -+ n, bi->pagesInUse, bi->softDeletions)); ++ if (bi->pages_in_use < 0 || bi->pages_in_use > dev->param.chunks_per_block || ++ bi->soft_del_pages < 0 || bi->soft_del_pages > dev->param.chunks_per_block || ++ actuallyUsed < 0 || actuallyUsed > dev->param.chunks_per_block) ++ T(YAFFS_TRACE_VERIFY, (TSTR("Block %d has illegal values pages_in_used %d soft_del_pages %d"TENDSTR), ++ n, bi->pages_in_use, bi->soft_del_pages)); + + + /* Check chunk bitmap legal */ -+ inUse = yaffs_CountChunkBits(dev, n); -+ if (inUse != bi->pagesInUse) -+ T(YAFFS_TRACE_VERIFY, (TSTR("Block %d has inconsistent values pagesInUse %d counted chunk bits %d"TENDSTR), -+ n, bi->pagesInUse, inUse)); ++ inUse = yaffs_count_chunk_bits(dev, n); ++ if (inUse != bi->pages_in_use) ++ T(YAFFS_TRACE_VERIFY, (TSTR("Block %d has inconsistent values pages_in_use %d counted chunk bits %d"TENDSTR), ++ n, bi->pages_in_use, inUse)); + +} + + + -+void yaffs_VerifyCollectedBlock(yaffs_Device *dev, yaffs_BlockInfo *bi, int n) ++void yaffs_verify_collected_blk(yaffs_dev_t *dev, yaffs_block_info_t *bi, int n) +{ -+ yaffs_VerifyBlock(dev, bi, n); ++ yaffs_verify_blk(dev, bi, n); + + /* After collection the block should be in the erased state */ + -+ if (bi->blockState != YAFFS_BLOCK_STATE_COLLECTING && -+ bi->blockState != YAFFS_BLOCK_STATE_EMPTY) { ++ if (bi->block_state != YAFFS_BLOCK_STATE_COLLECTING && ++ bi->block_state != YAFFS_BLOCK_STATE_EMPTY) { + T(YAFFS_TRACE_ERROR, (TSTR("Block %d is in state %d after gc, should be erased"TENDSTR), -+ n, bi->blockState)); ++ n, bi->block_state)); + } +} + -+void yaffs_VerifyBlocks(yaffs_Device *dev) ++void yaffs_verify_blocks(yaffs_dev_t *dev) +{ + int i; + int nBlocksPerState[YAFFS_NUMBER_OF_BLOCK_STATES]; + int nIllegalBlockStates = 0; + -+ if (yaffs_SkipVerification(dev)) ++ if (yaffs_skip_verification(dev)) + return; + + memset(nBlocksPerState, 0, sizeof(nBlocksPerState)); + -+ for (i = dev->internalStartBlock; i <= dev->internalEndBlock; i++) { -+ yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, i); -+ yaffs_VerifyBlock(dev, bi, i); ++ for (i = dev->internal_start_block; i <= dev->internal_end_block; i++) { ++ yaffs_block_info_t *bi = yaffs_get_block_info(dev, i); ++ yaffs_verify_blk(dev, bi, i); + -+ if (bi->blockState < YAFFS_NUMBER_OF_BLOCK_STATES) -+ nBlocksPerState[bi->blockState]++; ++ if (bi->block_state < YAFFS_NUMBER_OF_BLOCK_STATES) ++ nBlocksPerState[bi->block_state]++; + else + nIllegalBlockStates++; + } @@ -17370,17 +20604,17 @@ + for (i = 0; i < YAFFS_NUMBER_OF_BLOCK_STATES; i++) + T(YAFFS_TRACE_VERIFY, + (TSTR("%s %d blocks"TENDSTR), -+ blockStateName[i], nBlocksPerState[i])); ++ block_stateName[i], nBlocksPerState[i])); + -+ if (dev->blocksInCheckpoint != nBlocksPerState[YAFFS_BLOCK_STATE_CHECKPOINT]) ++ if (dev->blocks_in_checkpt != nBlocksPerState[YAFFS_BLOCK_STATE_CHECKPOINT]) + T(YAFFS_TRACE_VERIFY, + (TSTR("Checkpoint block count wrong dev %d count %d"TENDSTR), -+ dev->blocksInCheckpoint, nBlocksPerState[YAFFS_BLOCK_STATE_CHECKPOINT])); ++ dev->blocks_in_checkpt, nBlocksPerState[YAFFS_BLOCK_STATE_CHECKPOINT])); + -+ if (dev->nErasedBlocks != nBlocksPerState[YAFFS_BLOCK_STATE_EMPTY]) ++ if (dev->n_erased_blocks != nBlocksPerState[YAFFS_BLOCK_STATE_EMPTY]) + T(YAFFS_TRACE_VERIFY, + (TSTR("Erased block count wrong dev %d count %d"TENDSTR), -+ dev->nErasedBlocks, nBlocksPerState[YAFFS_BLOCK_STATE_EMPTY])); ++ dev->n_erased_blocks, nBlocksPerState[YAFFS_BLOCK_STATE_EMPTY])); + + if (nBlocksPerState[YAFFS_BLOCK_STATE_COLLECTING] > 1) + T(YAFFS_TRACE_VERIFY, @@ -17395,9 +20629,9 @@ + * Verify the object header. oh must be valid, but obj and tags may be NULL in which + * case those tests will not be performed. + */ -+void yaffs_VerifyObjectHeader(yaffs_Object *obj, yaffs_ObjectHeader *oh, yaffs_ExtendedTags *tags, int parentCheck) ++void yaffs_verify_oh(yaffs_obj_t *obj, yaffs_obj_header *oh, yaffs_ext_tags *tags, int parentCheck) +{ -+ if (obj && yaffs_SkipVerification(obj->myDev)) ++ if (obj && yaffs_skip_verification(obj->my_dev)) + return; + + if (!(tags && obj && oh)) { @@ -17411,12 +20645,12 @@ + oh->type > YAFFS_OBJECT_TYPE_MAX) + T(YAFFS_TRACE_VERIFY, + (TSTR("Obj %d header type is illegal value 0x%x"TENDSTR), -+ tags->objectId, oh->type)); ++ tags->obj_id, oh->type)); + -+ if (tags->objectId != obj->objectId) ++ if (tags->obj_id != obj->obj_id) + T(YAFFS_TRACE_VERIFY, -+ (TSTR("Obj %d header mismatch objectId %d"TENDSTR), -+ tags->objectId, obj->objectId)); ++ (TSTR("Obj %d header mismatch obj_id %d"TENDSTR), ++ tags->obj_id, obj->obj_id)); + + + /* @@ -17425,38 +20659,38 @@ + * Tests do not apply to the root object. + */ + -+ if (parentCheck && tags->objectId > 1 && !obj->parent) ++ if (parentCheck && tags->obj_id > 1 && !obj->parent) + T(YAFFS_TRACE_VERIFY, -+ (TSTR("Obj %d header mismatch parentId %d obj->parent is NULL"TENDSTR), -+ tags->objectId, oh->parentObjectId)); ++ (TSTR("Obj %d header mismatch parent_id %d obj->parent is NULL"TENDSTR), ++ tags->obj_id, oh->parent_obj_id)); + + if (parentCheck && obj->parent && -+ oh->parentObjectId != obj->parent->objectId && -+ (oh->parentObjectId != YAFFS_OBJECTID_UNLINKED || -+ obj->parent->objectId != YAFFS_OBJECTID_DELETED)) ++ oh->parent_obj_id != obj->parent->obj_id && ++ (oh->parent_obj_id != YAFFS_OBJECTID_UNLINKED || ++ obj->parent->obj_id != YAFFS_OBJECTID_DELETED)) + T(YAFFS_TRACE_VERIFY, -+ (TSTR("Obj %d header mismatch parentId %d parentObjectId %d"TENDSTR), -+ tags->objectId, oh->parentObjectId, obj->parent->objectId)); ++ (TSTR("Obj %d header mismatch parent_id %d parent_obj_id %d"TENDSTR), ++ tags->obj_id, oh->parent_obj_id, obj->parent->obj_id)); + -+ if (tags->objectId > 1 && oh->name[0] == 0) /* Null name */ ++ if (tags->obj_id > 1 && oh->name[0] == 0) /* Null name */ + T(YAFFS_TRACE_VERIFY, + (TSTR("Obj %d header name is NULL"TENDSTR), -+ obj->objectId)); ++ obj->obj_id)); + -+ if (tags->objectId > 1 && ((__u8)(oh->name[0])) == 0xff) /* Trashed name */ ++ if (tags->obj_id > 1 && ((__u8)(oh->name[0])) == 0xff) /* Trashed name */ + T(YAFFS_TRACE_VERIFY, + (TSTR("Obj %d header name is 0xFF"TENDSTR), -+ obj->objectId)); ++ obj->obj_id)); +} + + +#if 0 +/* Not being used, but don't want to throw away yet */ -+int yaffs_VerifyTnodeWorker(yaffs_Object *obj, yaffs_Tnode *tn, -+ __u32 level, int chunkOffset) ++int yaffs_verify_tnode_worker(yaffs_obj_t *obj, yaffs_tnode_t *tn, ++ __u32 level, int chunk_offset) +{ + int i; -+ yaffs_Device *dev = obj->myDev; ++ yaffs_dev_t *dev = obj->my_dev; + int ok = 1; + + if (tn) { @@ -17464,31 +20698,31 @@ + + for (i = 0; i < YAFFS_NTNODES_INTERNAL && ok; i++) { + if (tn->internal[i]) { -+ ok = yaffs_VerifyTnodeWorker(obj, ++ ok = yaffs_verify_tnode_worker(obj, + tn->internal[i], + level - 1, -+ (chunkOffset<<YAFFS_TNODES_INTERNAL_BITS) + i); ++ (chunk_offset<<YAFFS_TNODES_INTERNAL_BITS) + i); + } + } + } else if (level == 0) { -+ yaffs_ExtendedTags tags; -+ __u32 objectId = obj->objectId; ++ yaffs_ext_tags tags; ++ __u32 obj_id = obj->obj_id; + -+ chunkOffset <<= YAFFS_TNODES_LEVEL0_BITS; ++ chunk_offset <<= YAFFS_TNODES_LEVEL0_BITS; + + for (i = 0; i < YAFFS_NTNODES_LEVEL0; i++) { -+ __u32 theChunk = yaffs_GetChunkGroupBase(dev, tn, i); ++ __u32 theChunk = yaffs_get_group_base(dev, tn, i); + + if (theChunk > 0) { -+ /* T(~0,(TSTR("verifying (%d:%d) %d"TENDSTR),tags.objectId,tags.chunkId,theChunk)); */ -+ yaffs_ReadChunkWithTagsFromNAND(dev, theChunk, NULL, &tags); -+ if (tags.objectId != objectId || tags.chunkId != chunkOffset) { -+ T(~0, (TSTR("Object %d chunkId %d NAND mismatch chunk %d tags (%d:%d)"TENDSTR), -+ objectId, chunkOffset, theChunk, -+ tags.objectId, tags.chunkId)); ++ /* T(~0,(TSTR("verifying (%d:%d) %d"TENDSTR),tags.obj_id,tags.chunk_id,theChunk)); */ ++ yaffs_rd_chunk_tags_nand(dev, theChunk, NULL, &tags); ++ if (tags.obj_id != obj_id || tags.chunk_id != chunk_offset) { ++ T(~0, (TSTR("Object %d chunk_id %d NAND mismatch chunk %d tags (%d:%d)"TENDSTR), ++ obj_id, chunk_offset, theChunk, ++ tags.obj_id, tags.chunk_id)); + } + } -+ chunkOffset++; ++ chunk_offset++; + } + } + } @@ -17499,29 +20733,29 @@ + +#endif + -+void yaffs_VerifyFile(yaffs_Object *obj) ++void yaffs_verify_file(yaffs_obj_t *obj) +{ + int requiredTallness; + int actualTallness; + __u32 lastChunk; + __u32 x; + __u32 i; -+ yaffs_Device *dev; -+ yaffs_ExtendedTags tags; -+ yaffs_Tnode *tn; -+ __u32 objectId; ++ yaffs_dev_t *dev; ++ yaffs_ext_tags tags; ++ yaffs_tnode_t *tn; ++ __u32 obj_id; + + if (!obj) + return; + -+ if (yaffs_SkipVerification(obj->myDev)) ++ if (yaffs_skip_verification(obj->my_dev)) + return; + -+ dev = obj->myDev; -+ objectId = obj->objectId; ++ dev = obj->my_dev; ++ obj_id = obj->obj_id; + + /* Check file size is consistent with tnode depth */ -+ lastChunk = obj->variant.fileVariant.fileSize / dev->nDataBytesPerChunk + 1; ++ lastChunk = obj->variant.file_variant.file_size / dev->data_bytes_per_chunk + 1; + x = lastChunk >> YAFFS_TNODES_LEVEL0_BITS; + requiredTallness = 0; + while (x > 0) { @@ -17529,28 +20763,28 @@ + requiredTallness++; + } + -+ actualTallness = obj->variant.fileVariant.topLevel; ++ actualTallness = obj->variant.file_variant.top_level; + + /* Check that the chunks in the tnode tree are all correct. + * We do this by scanning through the tnode tree and + * checking the tags for every chunk match. + */ + -+ if (yaffs_SkipNANDVerification(dev)) ++ if (yaffs_skip_nand_verification(dev)) + return; + + for (i = 1; i <= lastChunk; i++) { -+ tn = yaffs_FindLevel0Tnode(dev, &obj->variant.fileVariant, i); ++ tn = yaffs_find_tnode_0(dev, &obj->variant.file_variant, i); + + if (tn) { -+ __u32 theChunk = yaffs_GetChunkGroupBase(dev, tn, i); ++ __u32 theChunk = yaffs_get_group_base(dev, tn, i); + if (theChunk > 0) { -+ /* T(~0,(TSTR("verifying (%d:%d) %d"TENDSTR),objectId,i,theChunk)); */ -+ yaffs_ReadChunkWithTagsFromNAND(dev, theChunk, NULL, &tags); -+ if (tags.objectId != objectId || tags.chunkId != i) { -+ T(~0, (TSTR("Object %d chunkId %d NAND mismatch chunk %d tags (%d:%d)"TENDSTR), -+ objectId, i, theChunk, -+ tags.objectId, tags.chunkId)); ++ /* T(~0,(TSTR("verifying (%d:%d) %d"TENDSTR),obj_id,i,theChunk)); */ ++ yaffs_rd_chunk_tags_nand(dev, theChunk, NULL, &tags); ++ if (tags.obj_id != obj_id || tags.chunk_id != i) { ++ T(~0, (TSTR("Object %d chunk_id %d NAND mismatch chunk %d tags (%d:%d)"TENDSTR), ++ obj_id, i, theChunk, ++ tags.obj_id, tags.chunk_id)); + } + } + } @@ -17558,36 +20792,36 @@ +} + + -+void yaffs_VerifyHardLink(yaffs_Object *obj) ++void yaffs_verify_link(yaffs_obj_t *obj) +{ -+ if (obj && yaffs_SkipVerification(obj->myDev)) ++ if (obj && yaffs_skip_verification(obj->my_dev)) + return; + + /* Verify sane equivalent object */ +} + -+void yaffs_VerifySymlink(yaffs_Object *obj) ++void yaffs_verify_symlink(yaffs_obj_t *obj) +{ -+ if (obj && yaffs_SkipVerification(obj->myDev)) ++ if (obj && yaffs_skip_verification(obj->my_dev)) + return; + + /* Verify symlink string */ +} + -+void yaffs_VerifySpecial(yaffs_Object *obj) ++void yaffs_verify_special(yaffs_obj_t *obj) +{ -+ if (obj && yaffs_SkipVerification(obj->myDev)) ++ if (obj && yaffs_skip_verification(obj->my_dev)) + return; +} + -+void yaffs_VerifyObject(yaffs_Object *obj) ++void yaffs_verify_obj(yaffs_obj_t *obj) +{ -+ yaffs_Device *dev; ++ yaffs_dev_t *dev; + + __u32 chunkMin; + __u32 chunkMax; + -+ __u32 chunkIdOk; ++ __u32 chunk_idOk; + __u32 chunkInRange; + __u32 chunkShouldNotBeDeleted; + __u32 chunkValid; @@ -17595,117 +20829,117 @@ + if (!obj) + return; + -+ if (obj->beingCreated) ++ if (obj->being_created) + return; + -+ dev = obj->myDev; ++ dev = obj->my_dev; + -+ if (yaffs_SkipVerification(dev)) ++ if (yaffs_skip_verification(dev)) + return; + + /* Check sane object header chunk */ + -+ chunkMin = dev->internalStartBlock * dev->param.nChunksPerBlock; -+ chunkMax = (dev->internalEndBlock+1) * dev->param.nChunksPerBlock - 1; ++ chunkMin = dev->internal_start_block * dev->param.chunks_per_block; ++ chunkMax = (dev->internal_end_block+1) * dev->param.chunks_per_block - 1; + -+ chunkInRange = (((unsigned)(obj->hdrChunk)) >= chunkMin && ((unsigned)(obj->hdrChunk)) <= chunkMax); -+ chunkIdOk = chunkInRange || (obj->hdrChunk == 0); ++ chunkInRange = (((unsigned)(obj->hdr_chunk)) >= chunkMin && ((unsigned)(obj->hdr_chunk)) <= chunkMax); ++ chunk_idOk = chunkInRange || (obj->hdr_chunk == 0); + chunkValid = chunkInRange && -+ yaffs_CheckChunkBit(dev, -+ obj->hdrChunk / dev->param.nChunksPerBlock, -+ obj->hdrChunk % dev->param.nChunksPerBlock); ++ yaffs_check_chunk_bit(dev, ++ obj->hdr_chunk / dev->param.chunks_per_block, ++ obj->hdr_chunk % dev->param.chunks_per_block); + chunkShouldNotBeDeleted = chunkInRange && !chunkValid; + + if (!obj->fake && -+ (!chunkIdOk || chunkShouldNotBeDeleted)) { ++ (!chunk_idOk || chunkShouldNotBeDeleted)) { + T(YAFFS_TRACE_VERIFY, -+ (TSTR("Obj %d has chunkId %d %s %s"TENDSTR), -+ obj->objectId, obj->hdrChunk, -+ chunkIdOk ? "" : ",out of range", ++ (TSTR("Obj %d has chunk_id %d %s %s"TENDSTR), ++ obj->obj_id, obj->hdr_chunk, ++ chunk_idOk ? "" : ",out of range", + chunkShouldNotBeDeleted ? ",marked as deleted" : "")); + } + -+ if (chunkValid && !yaffs_SkipNANDVerification(dev)) { -+ yaffs_ExtendedTags tags; -+ yaffs_ObjectHeader *oh; -+ __u8 *buffer = yaffs_GetTempBuffer(dev, __LINE__); ++ if (chunkValid && !yaffs_skip_nand_verification(dev)) { ++ yaffs_ext_tags tags; ++ yaffs_obj_header *oh; ++ __u8 *buffer = yaffs_get_temp_buffer(dev, __LINE__); + -+ oh = (yaffs_ObjectHeader *)buffer; ++ oh = (yaffs_obj_header *)buffer; + -+ yaffs_ReadChunkWithTagsFromNAND(dev, obj->hdrChunk, buffer, ++ yaffs_rd_chunk_tags_nand(dev, obj->hdr_chunk, buffer, + &tags); + -+ yaffs_VerifyObjectHeader(obj, oh, &tags, 1); ++ yaffs_verify_oh(obj, oh, &tags, 1); + -+ yaffs_ReleaseTempBuffer(dev, buffer, __LINE__); ++ yaffs_release_temp_buffer(dev, buffer, __LINE__); + } + + /* Verify it has a parent */ + if (obj && !obj->fake && -+ (!obj->parent || obj->parent->myDev != dev)) { ++ (!obj->parent || obj->parent->my_dev != dev)) { + T(YAFFS_TRACE_VERIFY, + (TSTR("Obj %d has parent pointer %p which does not look like an object"TENDSTR), -+ obj->objectId, obj->parent)); ++ obj->obj_id, obj->parent)); + } + + /* Verify parent is a directory */ -+ if (obj->parent && obj->parent->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) { ++ if (obj->parent && obj->parent->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) { + T(YAFFS_TRACE_VERIFY, + (TSTR("Obj %d's parent is not a directory (type %d)"TENDSTR), -+ obj->objectId, obj->parent->variantType)); ++ obj->obj_id, obj->parent->variant_type)); + } + -+ switch (obj->variantType) { ++ switch (obj->variant_type) { + case YAFFS_OBJECT_TYPE_FILE: -+ yaffs_VerifyFile(obj); ++ yaffs_verify_file(obj); + break; + case YAFFS_OBJECT_TYPE_SYMLINK: -+ yaffs_VerifySymlink(obj); ++ yaffs_verify_symlink(obj); + break; + case YAFFS_OBJECT_TYPE_DIRECTORY: -+ yaffs_VerifyDirectory(obj); ++ yaffs_verify_dir(obj); + break; + case YAFFS_OBJECT_TYPE_HARDLINK: -+ yaffs_VerifyHardLink(obj); ++ yaffs_verify_link(obj); + break; + case YAFFS_OBJECT_TYPE_SPECIAL: -+ yaffs_VerifySpecial(obj); ++ yaffs_verify_special(obj); + break; + case YAFFS_OBJECT_TYPE_UNKNOWN: + default: + T(YAFFS_TRACE_VERIFY, + (TSTR("Obj %d has illegaltype %d"TENDSTR), -+ obj->objectId, obj->variantType)); ++ obj->obj_id, obj->variant_type)); + break; + } +} + -+void yaffs_VerifyObjects(yaffs_Device *dev) ++void yaffs_verify_objects(yaffs_dev_t *dev) +{ -+ yaffs_Object *obj; ++ yaffs_obj_t *obj; + int i; + struct ylist_head *lh; + -+ if (yaffs_SkipVerification(dev)) ++ if (yaffs_skip_verification(dev)) + return; + + /* Iterate through the objects in each hash entry */ + + for (i = 0; i < YAFFS_NOBJECT_BUCKETS; i++) { -+ ylist_for_each(lh, &dev->objectBucket[i].list) { ++ ylist_for_each(lh, &dev->obj_bucket[i].list) { + if (lh) { -+ obj = ylist_entry(lh, yaffs_Object, hashLink); -+ yaffs_VerifyObject(obj); ++ obj = ylist_entry(lh, yaffs_obj_t, hash_link); ++ yaffs_verify_obj(obj); + } + } + } +} + + -+void yaffs_VerifyObjectInDirectory(yaffs_Object *obj) ++void yaffs_verify_obj_in_dir(yaffs_obj_t *obj) +{ + struct ylist_head *lh; -+ yaffs_Object *listObj; ++ yaffs_obj_t *listObj; + + int count = 0; + @@ -17715,7 +20949,7 @@ + return; + } + -+ if (yaffs_SkipVerification(obj->myDev)) ++ if (yaffs_skip_verification(obj->my_dev)) + return; + + if (!obj->parent) { @@ -17724,17 +20958,17 @@ + return; + } + -+ if (obj->parent->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) { ++ if (obj->parent->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) { + T(YAFFS_TRACE_ALWAYS, (TSTR("Parent is not directory" TENDSTR))); + YBUG(); + } + + /* Iterate through the objects in each hash entry */ + -+ ylist_for_each(lh, &obj->parent->variant.directoryVariant.children) { ++ ylist_for_each(lh, &obj->parent->variant.dir_variant.children) { + if (lh) { -+ listObj = ylist_entry(lh, yaffs_Object, siblings); -+ yaffs_VerifyObject(listObj); ++ listObj = ylist_entry(lh, yaffs_obj_t, siblings); ++ yaffs_verify_obj(listObj); + if (obj == listObj) + count++; + } @@ -17746,99 +20980,99 @@ + } +} + -+void yaffs_VerifyDirectory(yaffs_Object *directory) ++void yaffs_verify_dir(yaffs_obj_t *directory) +{ + struct ylist_head *lh; -+ yaffs_Object *listObj; ++ yaffs_obj_t *listObj; + + if (!directory) { + YBUG(); + return; + } + -+ if (yaffs_SkipFullVerification(directory->myDev)) ++ if (yaffs_skip_full_verification(directory->my_dev)) + return; + -+ if (directory->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) { -+ T(YAFFS_TRACE_ALWAYS, (TSTR("Directory has wrong type: %d" TENDSTR), directory->variantType)); ++ if (directory->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) { ++ T(YAFFS_TRACE_ALWAYS, (TSTR("Directory has wrong type: %d" TENDSTR), directory->variant_type)); + YBUG(); + } + + /* Iterate through the objects in each hash entry */ + -+ ylist_for_each(lh, &directory->variant.directoryVariant.children) { ++ ylist_for_each(lh, &directory->variant.dir_variant.children) { + if (lh) { -+ listObj = ylist_entry(lh, yaffs_Object, siblings); ++ listObj = ylist_entry(lh, yaffs_obj_t, siblings); + if (listObj->parent != directory) { + T(YAFFS_TRACE_ALWAYS, (TSTR("Object in directory list has wrong parent %p" TENDSTR), listObj->parent)); + YBUG(); + } -+ yaffs_VerifyObjectInDirectory(listObj); ++ yaffs_verify_obj_in_dir(listObj); + } + } +} + -+static int yaffs_freeVerificationFailures; ++static int yaffs_free_verification_failures; + -+void yaffs_VerifyFreeChunks(yaffs_Device *dev) ++void yaffs_verify_free_chunks(yaffs_dev_t *dev) +{ + int counted; + int difference; + -+ if (yaffs_SkipVerification(dev)) ++ if (yaffs_skip_verification(dev)) + return; + -+ counted = yaffs_CountFreeChunks(dev); ++ counted = yaffs_count_free_chunks(dev); + -+ difference = dev->nFreeChunks - counted; ++ difference = dev->n_free_chunks - counted; + + if (difference) { + T(YAFFS_TRACE_ALWAYS, + (TSTR("Freechunks verification failure %d %d %d" TENDSTR), -+ dev->nFreeChunks, counted, difference)); -+ yaffs_freeVerificationFailures++; ++ dev->n_free_chunks, counted, difference)); ++ yaffs_free_verification_failures++; + } +} + -+int yaffs_VerifyFileSanity(yaffs_Object *in) ++int yaffs_verify_file_sane(yaffs_obj_t *in) +{ +#if 0 + int chunk; -+ int nChunks; ++ int n_chunks; + int fSize; + int failed = 0; -+ int objId; -+ yaffs_Tnode *tn; -+ yaffs_Tags localTags; -+ yaffs_Tags *tags = &localTags; ++ int obj_id; ++ yaffs_tnode_t *tn; ++ yaffs_tags_t localTags; ++ yaffs_tags_t *tags = &localTags; + int theChunk; -+ int chunkDeleted; ++ int is_deleted; + -+ if (in->variantType != YAFFS_OBJECT_TYPE_FILE) ++ if (in->variant_type != YAFFS_OBJECT_TYPE_FILE) + return YAFFS_FAIL; + -+ objId = in->objectId; -+ fSize = in->variant.fileVariant.fileSize; -+ nChunks = -+ (fSize + in->myDev->nDataBytesPerChunk - 1) / in->myDev->nDataBytesPerChunk; ++ obj_id = in->obj_id; ++ fSize = in->variant.file_variant.file_size; ++ n_chunks = ++ (fSize + in->my_dev->data_bytes_per_chunk - 1) / in->my_dev->data_bytes_per_chunk; + -+ for (chunk = 1; chunk <= nChunks; chunk++) { -+ tn = yaffs_FindLevel0Tnode(in->myDev, &in->variant.fileVariant, ++ for (chunk = 1; chunk <= n_chunks; chunk++) { ++ tn = yaffs_find_tnode_0(in->my_dev, &in->variant.file_variant, + chunk); + + if (tn) { + -+ theChunk = yaffs_GetChunkGroupBase(dev, tn, chunk); ++ theChunk = yaffs_get_group_base(dev, tn, chunk); + -+ if (yaffs_CheckChunkBits -+ (dev, theChunk / dev->param.nChunksPerBlock, -+ theChunk % dev->param.nChunksPerBlock)) { ++ if (yaffs_check_chunk_bits ++ (dev, theChunk / dev->param.chunks_per_block, ++ theChunk % dev->param.chunks_per_block)) { + -+ yaffs_ReadChunkTagsFromNAND(in->myDev, theChunk, ++ yaffs_rd_chunk_tags_nand(in->my_dev, theChunk, + tags, -+ &chunkDeleted); -+ if (yaffs_TagsMatch -+ (tags, in->objectId, chunk, chunkDeleted)) { ++ &is_deleted); ++ if (yaffs_tags_match ++ (tags, in->obj_id, chunk, is_deleted)) { + /* found it; */ + + } @@ -17858,8 +21092,9 @@ + return YAFFS_OK; +#endif +} ---- /dev/null -+++ b/fs/yaffs2/yaffs_verify.h +diff -Nrup linux-2.6.36-rc8/fs/yaffs2/yaffs_verify.h linux-2.6.36-rc8.new/fs/yaffs2/yaffs_verify.h +--- linux-2.6.36-rc8/fs/yaffs2/yaffs_verify.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.36-rc8.new/fs/yaffs2/yaffs_verify.h 2010-10-20 13:28:16.064000294 +0300 @@ -0,0 +1,39 @@ +/* + * YAFFS: Yet Another Flash File System. A NAND-flash specific file system. @@ -17879,30 +21114,31 @@ + +#include "yaffs_guts.h" + -+void yaffs_VerifyBlock(yaffs_Device *dev, yaffs_BlockInfo *bi, int n); -+void yaffs_VerifyCollectedBlock(yaffs_Device *dev, yaffs_BlockInfo *bi, int n); -+void yaffs_VerifyBlocks(yaffs_Device *dev); ++void yaffs_verify_blk(yaffs_dev_t *dev, yaffs_block_info_t *bi, int n); ++void yaffs_verify_collected_blk(yaffs_dev_t *dev, yaffs_block_info_t *bi, int n); ++void yaffs_verify_blocks(yaffs_dev_t *dev); + -+void yaffs_VerifyObjectHeader(yaffs_Object *obj, yaffs_ObjectHeader *oh, yaffs_ExtendedTags *tags, int parentCheck); -+void yaffs_VerifyFile(yaffs_Object *obj); -+void yaffs_VerifyHardLink(yaffs_Object *obj); -+void yaffs_VerifySymlink(yaffs_Object *obj); -+void yaffs_VerifySpecial(yaffs_Object *obj); -+void yaffs_VerifyObject(yaffs_Object *obj); -+void yaffs_VerifyObjects(yaffs_Device *dev); -+void yaffs_VerifyObjectInDirectory(yaffs_Object *obj); -+void yaffs_VerifyDirectory(yaffs_Object *directory); -+void yaffs_VerifyFreeChunks(yaffs_Device *dev); ++void yaffs_verify_oh(yaffs_obj_t *obj, yaffs_obj_header *oh, yaffs_ext_tags *tags, int parentCheck); ++void yaffs_verify_file(yaffs_obj_t *obj); ++void yaffs_verify_link(yaffs_obj_t *obj); ++void yaffs_verify_symlink(yaffs_obj_t *obj); ++void yaffs_verify_special(yaffs_obj_t *obj); ++void yaffs_verify_obj(yaffs_obj_t *obj); ++void yaffs_verify_objects(yaffs_dev_t *dev); ++void yaffs_verify_obj_in_dir(yaffs_obj_t *obj); ++void yaffs_verify_dir(yaffs_obj_t *directory); ++void yaffs_verify_free_chunks(yaffs_dev_t *dev); + -+int yaffs_VerifyFileSanity(yaffs_Object *obj); ++int yaffs_verify_file_sane(yaffs_obj_t *obj); + -+int yaffs_SkipVerification(yaffs_Device *dev); ++int yaffs_skip_verification(yaffs_dev_t *dev); + +#endif + ---- /dev/null -+++ b/fs/yaffs2/yaffs_vfs_glue.c -@@ -0,0 +1,3577 @@ +diff -Nrup linux-2.6.36-rc8/fs/yaffs2/yaffs_vfs_glue.c linux-2.6.36-rc8.new/fs/yaffs2/yaffs_vfs_glue.c +--- linux-2.6.36-rc8/fs/yaffs2/yaffs_vfs_glue.c 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.36-rc8.new/fs/yaffs2/yaffs_vfs_glue.c 2010-10-20 13:28:16.069000294 +0300 +@@ -0,0 +1,3576 @@ +/* + * YAFFS: Yet Another Flash File System. A NAND-flash specific file system. + * @@ -17929,11 +21165,11 @@ + * the VFS. + * + * Special notes: -+ * >> 2.4: sb->u.generic_sbp points to the yaffs_Device associated with ++ * >> 2.4: sb->u.generic_sbp points to the yaffs_dev_t associated with + * this superblock -+ * >> 2.6: sb->s_fs_info points to the yaffs_Device associated with this ++ * >> 2.6: sb->s_fs_info points to the yaffs_dev_t associated with this + * superblock -+ * >> inode->u.generic_ip points to the associated yaffs_Object. ++ * >> inode->u.generic_ip points to the associated yaffs_obj_t. + */ + +/* @@ -18075,7 +21311,7 @@ +#include "yaffs_mtdif1.h" +#include "yaffs_mtdif2.h" + -+unsigned int yaffs_traceMask = YAFFS_TRACE_BAD_BLOCKS | YAFFS_TRACE_ALWAYS; ++unsigned int yaffs_trace_mask = YAFFS_TRACE_BAD_BLOCKS | YAFFS_TRACE_ALWAYS; +unsigned int yaffs_wr_attempts = YAFFS_WR_ATTEMPTS; +unsigned int yaffs_auto_checkpoint = 1; +unsigned int yaffs_gc_control = 1; @@ -18083,13 +21319,13 @@ + +/* Module Parameters */ +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0)) -+module_param(yaffs_traceMask, uint, 0644); ++module_param(yaffs_trace_mask, uint, 0644); +module_param(yaffs_wr_attempts, uint, 0644); +module_param(yaffs_auto_checkpoint, uint, 0644); +module_param(yaffs_gc_control, uint, 0644); +module_param(yaffs_bg_enable, uint, 0644); +#else -+MODULE_PARM(yaffs_traceMask, "i"); ++MODULE_PARM(yaffs_trace_mask, "i"); +MODULE_PARM(yaffs_wr_attempts, "i"); +MODULE_PARM(yaffs_auto_checkpoint, "i"); +MODULE_PARM(yaffs_gc_control, "i"); @@ -18114,13 +21350,13 @@ +#define yaffs_InodeToObjectLV(iptr) ((iptr)->u.generic_ip) +#endif + -+#define yaffs_InodeToObject(iptr) ((yaffs_Object *)(yaffs_InodeToObjectLV(iptr))) -+#define yaffs_DentryToObject(dptr) yaffs_InodeToObject((dptr)->d_inode) ++#define yaffs_InodeToObject(iptr) ((yaffs_obj_t *)(yaffs_InodeToObjectLV(iptr))) ++#define yaffs_dentry_to_obj(dptr) yaffs_InodeToObject((dptr)->d_inode) + +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0)) -+#define yaffs_SuperToDevice(sb) ((yaffs_Device *)sb->s_fs_info) ++#define yaffs_SuperToDevice(sb) ((yaffs_dev_t *)sb->s_fs_info) +#else -+#define yaffs_SuperToDevice(sb) ((yaffs_Device *)sb->u.generic_sbp) ++#define yaffs_SuperToDevice(sb) ((yaffs_dev_t *)sb->u.generic_sbp) +#endif + + @@ -18245,7 +21481,7 @@ +static int yaffs_follow_link(struct dentry *dentry, struct nameidata *nd); +#endif + -+static void yaffs_MarkSuperBlockDirty(yaffs_Device *dev); ++static void yaffs_touch_super(yaffs_dev_t *dev); + +static loff_t yaffs_dir_llseek(struct file *file, loff_t offset, int origin); + @@ -18412,22 +21648,22 @@ + +} + -+static unsigned yaffs_gc_control_callback(yaffs_Device *dev) ++static unsigned yaffs_gc_control_callback(yaffs_dev_t *dev) +{ + return yaffs_gc_control; +} + -+static void yaffs_GrossLock(yaffs_Device *dev) ++static void yaffs_gross_lock(yaffs_dev_t *dev) +{ + T(YAFFS_TRACE_LOCK, (TSTR("yaffs locking %p\n"), current)); -+ down(&(yaffs_DeviceToLC(dev)->grossLock)); ++ down(&(yaffs_dev_to_lc(dev)->grossLock)); + T(YAFFS_TRACE_LOCK, (TSTR("yaffs locked %p\n"), current)); +} + -+static void yaffs_GrossUnlock(yaffs_Device *dev) ++static void yaffs_gross_unlock(yaffs_dev_t *dev) +{ + T(YAFFS_TRACE_LOCK, (TSTR("yaffs unlocking %p\n"), current)); -+ up(&(yaffs_DeviceToLC(dev)->grossLock)); ++ up(&(yaffs_dev_to_lc(dev)->grossLock)); +} + +#ifdef YAFFS_COMPILE_EXPORTFS @@ -18457,15 +21693,15 @@ + struct dentry *parent = ERR_PTR(-ENOENT); + struct inode *inode; + unsigned long parent_ino; -+ yaffs_Object *d_obj; -+ yaffs_Object *parent_obj; ++ yaffs_obj_t *d_obj; ++ yaffs_obj_t *parent_obj; + + d_obj = yaffs_InodeToObject(dentry->d_inode); + + if (d_obj) { + parent_obj = d_obj->parent; + if (parent_obj) { -+ parent_ino = yaffs_GetObjectInode(parent_obj); ++ parent_ino = yaffs_get_obj_inode(parent_obj); + inode = Y_IGET(sb, parent_ino); + + if (IS_ERR(inode)) { @@ -18504,11 +21740,11 @@ + * A search context iterates along a doubly linked list of siblings in the + * directory. If the iterating object is deleted then this would corrupt + * the list iteration, likely causing a crash. The search context avoids -+ * this by using the removeObjectCallback to move the search context to the ++ * this by using the remove_obj_fn to move the search context to the + * next object before the object is deleted. + * + * Many readdirs (and thus seach conexts) may be alive simulateously so -+ * each yaffs_Device has a list of these. ++ * each yaffs_dev_t has a list of these. + * + * A seach context lives for the duration of a readdir. + * @@ -18516,9 +21752,9 @@ + */ + +struct yaffs_SearchContext { -+ yaffs_Device *dev; -+ yaffs_Object *dirObj; -+ yaffs_Object *nextReturn; ++ yaffs_dev_t *dev; ++ yaffs_obj_t *dirObj; ++ yaffs_obj_t *nextReturn; + struct ylist_head others; +}; + @@ -18528,29 +21764,29 @@ + * + * Called at start of readdir. + */ -+static struct yaffs_SearchContext * yaffs_NewSearch(yaffs_Object *dir) ++static struct yaffs_SearchContext * yaffs_NewSearch(yaffs_obj_t *dir) +{ -+ yaffs_Device *dev = dir->myDev; ++ yaffs_dev_t *dev = dir->my_dev; + struct yaffs_SearchContext *sc = YMALLOC(sizeof(struct yaffs_SearchContext)); + if(sc){ + sc->dirObj = dir; + sc->dev = dev; -+ if( ylist_empty(&sc->dirObj->variant.directoryVariant.children)) ++ if( ylist_empty(&sc->dirObj->variant.dir_variant.children)) + sc->nextReturn = NULL; + else + sc->nextReturn = ylist_entry( -+ dir->variant.directoryVariant.children.next, -+ yaffs_Object,siblings); ++ dir->variant.dir_variant.children.next, ++ yaffs_obj_t,siblings); + YINIT_LIST_HEAD(&sc->others); -+ ylist_add(&sc->others,&(yaffs_DeviceToLC(dev)->searchContexts)); ++ ylist_add(&sc->others,&(yaffs_dev_to_lc(dev)->searchContexts)); + } + return sc; +} + +/* -+ * yaffs_EndSearch() disposes of a search context and cleans up. ++ * yaffs_search_end() disposes of a search context and cleans up. + */ -+static void yaffs_EndSearch(struct yaffs_SearchContext * sc) ++static void yaffs_search_end(struct yaffs_SearchContext * sc) +{ + if(sc){ + ylist_del(&sc->others); @@ -18559,39 +21795,39 @@ +} + +/* -+ * yaffs_SearchAdvance() moves a search context to the next object. ++ * yaffs_search_advance() moves a search context to the next object. + * Called when the search iterates or when an object removal causes + * the search context to be moved to the next object. + */ -+static void yaffs_SearchAdvance(struct yaffs_SearchContext *sc) ++static void yaffs_search_advance(struct yaffs_SearchContext *sc) +{ + if(!sc) + return; + + if( sc->nextReturn == NULL || -+ ylist_empty(&sc->dirObj->variant.directoryVariant.children)) ++ ylist_empty(&sc->dirObj->variant.dir_variant.children)) + sc->nextReturn = NULL; + else { + struct ylist_head *next = sc->nextReturn->siblings.next; + -+ if( next == &sc->dirObj->variant.directoryVariant.children) ++ if( next == &sc->dirObj->variant.dir_variant.children) + sc->nextReturn = NULL; /* end of list */ + else -+ sc->nextReturn = ylist_entry(next,yaffs_Object,siblings); ++ sc->nextReturn = ylist_entry(next,yaffs_obj_t,siblings); + } +} + +/* -+ * yaffs_RemoveObjectCallback() is called when an object is unlinked. ++ * yaffs_remove_obj_callback() is called when an object is unlinked. + * We check open search contexts and advance any which are currently + * on the object being iterated. + */ -+static void yaffs_RemoveObjectCallback(yaffs_Object *obj) ++static void yaffs_remove_obj_callback(yaffs_obj_t *obj) +{ + + struct ylist_head *i; + struct yaffs_SearchContext *sc; -+ struct ylist_head *search_contexts = &(yaffs_DeviceToLC(obj->myDev)->searchContexts); ++ struct ylist_head *search_contexts = &(yaffs_dev_to_lc(obj->my_dev)->searchContexts); + + + /* Iterate through the directory search contexts. @@ -18602,7 +21838,7 @@ + if (i) { + sc = ylist_entry(i, struct yaffs_SearchContext,others); + if(sc->nextReturn == obj) -+ yaffs_SearchAdvance(sc); ++ yaffs_search_advance(sc); + } + } + @@ -18617,13 +21853,13 @@ + unsigned char *alias; + int ret; + -+ yaffs_Device *dev = yaffs_DentryToObject(dentry)->myDev; ++ yaffs_dev_t *dev = yaffs_dentry_to_obj(dentry)->my_dev; + -+ yaffs_GrossLock(dev); ++ yaffs_gross_lock(dev); + -+ alias = yaffs_GetSymlinkAlias(yaffs_DentryToObject(dentry)); ++ alias = yaffs_get_symlink_alias(yaffs_dentry_to_obj(dentry)); + -+ yaffs_GrossUnlock(dev); ++ yaffs_gross_unlock(dev); + + if (!alias) + return -ENOMEM; @@ -18641,12 +21877,12 @@ +{ + unsigned char *alias; + int ret; -+ yaffs_Device *dev = yaffs_DentryToObject(dentry)->myDev; ++ yaffs_dev_t *dev = yaffs_dentry_to_obj(dentry)->my_dev; + -+ yaffs_GrossLock(dev); ++ yaffs_gross_lock(dev); + -+ alias = yaffs_GetSymlinkAlias(yaffs_DentryToObject(dentry)); -+ yaffs_GrossUnlock(dev); ++ alias = yaffs_get_symlink_alias(yaffs_dentry_to_obj(dentry)); ++ yaffs_gross_unlock(dev); + + if (!alias) { + ret = -ENOMEM; @@ -18673,7 +21909,7 @@ +#endif + +struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev, -+ yaffs_Object *obj); ++ yaffs_obj_t *obj); + +/* + * Lookup is used to find objects in the fs @@ -18686,30 +21922,30 @@ +static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry) +#endif +{ -+ yaffs_Object *obj; ++ yaffs_obj_t *obj; + struct inode *inode = NULL; /* NCB 2.5/2.6 needs NULL here */ + -+ yaffs_Device *dev = yaffs_InodeToObject(dir)->myDev; ++ yaffs_dev_t *dev = yaffs_InodeToObject(dir)->my_dev; + -+ if(current != yaffs_DeviceToLC(dev)->readdirProcess) -+ yaffs_GrossLock(dev); ++ if(current != yaffs_dev_to_lc(dev)->readdirProcess) ++ yaffs_gross_lock(dev); + + T(YAFFS_TRACE_OS, + (TSTR("yaffs_lookup for %d:%s\n"), -+ yaffs_InodeToObject(dir)->objectId, dentry->d_name.name)); ++ yaffs_InodeToObject(dir)->obj_id, dentry->d_name.name)); + -+ obj = yaffs_FindObjectByName(yaffs_InodeToObject(dir), ++ obj = yaffs_find_by_name(yaffs_InodeToObject(dir), + dentry->d_name.name); + -+ obj = yaffs_GetEquivalentObject(obj); /* in case it was a hardlink */ ++ obj = yaffs_get_equivalent_obj(obj); /* in case it was a hardlink */ + + /* Can't hold gross lock when calling yaffs_get_inode() */ -+ if(current != yaffs_DeviceToLC(dev)->readdirProcess) -+ yaffs_GrossUnlock(dev); ++ if(current != yaffs_dev_to_lc(dev)->readdirProcess) ++ yaffs_gross_unlock(dev); + + if (obj) { + T(YAFFS_TRACE_OS, -+ (TSTR("yaffs_lookup found %d\n"), obj->objectId)); ++ (TSTR("yaffs_lookup found %d\n"), obj->obj_id)); + + inode = yaffs_get_inode(dir->i_sb, obj->yst_mode, 0, obj); + @@ -18755,19 +21991,19 @@ +#endif + + -+static void yaffs_UnstitchObject(struct inode *inode, yaffs_Object *obj) ++static void yaffs_unstitch_obj(struct inode *inode, yaffs_obj_t *obj) +{ + /* Clear the association between the inode and -+ * the yaffs_Object. ++ * the yaffs_obj_t. + */ -+ obj->myInode = NULL; ++ obj->my_inode = NULL; + yaffs_InodeToObjectLV(inode) = NULL; + + /* If the object freeing was deferred, then the real + * free happens now. + * This should fix the inode inconsistency problem. + */ -+ yaffs_HandleDeferedFree(obj); ++ yaffs_handle_defered_free(obj); +} + +#ifdef YAFFS_HAS_EVICT_INODE @@ -18777,8 +22013,8 @@ + */ +static void yaffs_evict_inode( struct inode *inode) +{ -+ yaffs_Object *obj; -+ yaffs_Device *dev; ++ yaffs_obj_t *obj; ++ yaffs_dev_t *dev; + int deleteme = 0; + + obj = yaffs_InodeToObject(inode); @@ -18794,16 +22030,16 @@ + end_writeback(inode); + + if(deleteme && obj){ -+ dev = obj->myDev; -+ yaffs_GrossLock(dev); -+ yaffs_DeleteObject(obj); -+ yaffs_GrossUnlock(dev); ++ dev = obj->my_dev; ++ yaffs_gross_lock(dev); ++ yaffs_del_obj(obj); ++ yaffs_gross_unlock(dev); + } + if (obj) { -+ dev = obj->myDev; -+ yaffs_GrossLock(dev); -+ yaffs_UnstitchObject(inode,obj); -+ yaffs_GrossUnlock(dev); ++ dev = obj->my_dev; ++ yaffs_gross_lock(dev); ++ yaffs_unstitch_obj(inode,obj); ++ yaffs_gross_unlock(dev); + } + + @@ -18819,8 +22055,8 @@ + +static void yaffs_clear_inode(struct inode *inode) +{ -+ yaffs_Object *obj; -+ yaffs_Device *dev; ++ yaffs_obj_t *obj; ++ yaffs_dev_t *dev; + + obj = yaffs_InodeToObject(inode); + @@ -18830,10 +22066,10 @@ + obj ? "object exists" : "null object")); + + if (obj) { -+ dev = obj->myDev; -+ yaffs_GrossLock(dev); -+ yaffs_UnstitchObject(inode,obj); -+ yaffs_GrossUnlock(dev); ++ dev = obj->my_dev; ++ yaffs_gross_lock(dev); ++ yaffs_unstitch_obj(inode,obj); ++ yaffs_gross_unlock(dev); + } + +} @@ -18845,8 +22081,8 @@ + */ +static void yaffs_delete_inode(struct inode *inode) +{ -+ yaffs_Object *obj = yaffs_InodeToObject(inode); -+ yaffs_Device *dev; ++ yaffs_obj_t *obj = yaffs_InodeToObject(inode); ++ yaffs_dev_t *dev; + + T(YAFFS_TRACE_OS, + (TSTR("yaffs_delete_inode: ino %d, count %d %s\n"), (int)inode->i_ino, @@ -18854,10 +22090,10 @@ + obj ? "object exists" : "null object")); + + if (obj) { -+ dev = obj->myDev; -+ yaffs_GrossLock(dev); -+ yaffs_DeleteObject(obj); -+ yaffs_GrossUnlock(dev); ++ dev = obj->my_dev; ++ yaffs_gross_lock(dev); ++ yaffs_del_obj(obj); ++ yaffs_gross_unlock(dev); + } +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 13)) + truncate_inode_pages(&inode->i_data, 0); @@ -18873,19 +22109,19 @@ +static int yaffs_file_flush(struct file *file) +#endif +{ -+ yaffs_Object *obj = yaffs_DentryToObject(file->f_dentry); ++ yaffs_obj_t *obj = yaffs_dentry_to_obj(file->f_dentry); + -+ yaffs_Device *dev = obj->myDev; ++ yaffs_dev_t *dev = obj->my_dev; + + T(YAFFS_TRACE_OS, -+ (TSTR("yaffs_file_flush object %d (%s)\n"), obj->objectId, ++ (TSTR("yaffs_file_flush object %d (%s)\n"), obj->obj_id, + obj->dirty ? "dirty" : "clean")); + -+ yaffs_GrossLock(dev); ++ yaffs_gross_lock(dev); + -+ yaffs_FlushFile(obj, 1, 0); ++ yaffs_flush_file(obj, 1, 0); + -+ yaffs_GrossUnlock(dev); ++ yaffs_gross_unlock(dev); + + return 0; +} @@ -18894,20 +22130,20 @@ +{ + /* Lifted from jffs2 */ + -+ yaffs_Object *obj; ++ yaffs_obj_t *obj; + unsigned char *pg_buf; + int ret; + -+ yaffs_Device *dev; ++ yaffs_dev_t *dev; + + T(YAFFS_TRACE_OS, + (TSTR("yaffs_readpage_nolock at %08x, size %08x\n"), + (unsigned)(pg->index << PAGE_CACHE_SHIFT), + (unsigned)PAGE_CACHE_SIZE)); + -+ obj = yaffs_DentryToObject(f->f_dentry); ++ obj = yaffs_dentry_to_obj(f->f_dentry); + -+ dev = obj->myDev; ++ dev = obj->my_dev; + +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0)) + BUG_ON(!PageLocked(pg)); @@ -18919,13 +22155,13 @@ + pg_buf = kmap(pg); + /* FIXME: Can kmap fail? */ + -+ yaffs_GrossLock(dev); ++ yaffs_gross_lock(dev); + -+ ret = yaffs_ReadDataFromFile(obj, pg_buf, ++ ret = yaffs_file_rd(obj, pg_buf, + pg->index << PAGE_CACHE_SHIFT, + PAGE_CACHE_SIZE); + -+ yaffs_GrossUnlock(dev); ++ yaffs_gross_unlock(dev); + + if (ret >= 0) + ret = 0; @@ -18970,14 +22206,14 @@ +static int yaffs_writepage(struct page *page) +#endif +{ -+ yaffs_Device *dev; ++ yaffs_dev_t *dev; + struct address_space *mapping = page->mapping; + struct inode *inode; + unsigned long end_index; + char *buffer; -+ yaffs_Object *obj; ++ yaffs_obj_t *obj; + int nWritten = 0; -+ unsigned nBytes; ++ unsigned n_bytes; + loff_t i_size; + + if (!mapping) @@ -18990,11 +22226,11 @@ + end_index = i_size >> PAGE_CACHE_SHIFT; + + if(page->index < end_index) -+ nBytes = PAGE_CACHE_SIZE; ++ n_bytes = PAGE_CACHE_SIZE; + else { -+ nBytes = i_size & (PAGE_CACHE_SIZE -1); ++ n_bytes = i_size & (PAGE_CACHE_SIZE -1); + -+ if (page->index > end_index || !nBytes) { ++ if (page->index > end_index || !n_bytes) { + T(YAFFS_TRACE_OS, + (TSTR("yaffs_writepage at %08x, inode size = %08x!!!\n"), + (unsigned)(page->index << PAGE_CACHE_SHIFT), @@ -19010,34 +22246,34 @@ + } + } + -+ if(nBytes != PAGE_CACHE_SIZE) -+ zero_user_segment(page,nBytes,PAGE_CACHE_SIZE); ++ if(n_bytes != PAGE_CACHE_SIZE) ++ zero_user_segment(page,n_bytes,PAGE_CACHE_SIZE); + + get_page(page); + + buffer = kmap(page); + + obj = yaffs_InodeToObject(inode); -+ dev = obj->myDev; -+ yaffs_GrossLock(dev); ++ dev = obj->my_dev; ++ yaffs_gross_lock(dev); + + T(YAFFS_TRACE_OS, + (TSTR("yaffs_writepage at %08x, size %08x\n"), -+ (unsigned)(page->index << PAGE_CACHE_SHIFT), nBytes)); ++ (unsigned)(page->index << PAGE_CACHE_SHIFT), n_bytes)); + T(YAFFS_TRACE_OS, + (TSTR("writepag0: obj = %05x, ino = %05x\n"), -+ (int)obj->variant.fileVariant.fileSize, (int)inode->i_size)); ++ (int)obj->variant.file_variant.file_size, (int)inode->i_size)); + -+ nWritten = yaffs_WriteDataToFile(obj, buffer, -+ page->index << PAGE_CACHE_SHIFT, nBytes, 0); ++ nWritten = yaffs_wr_file(obj, buffer, ++ page->index << PAGE_CACHE_SHIFT, n_bytes, 0); + -+ yaffs_MarkSuperBlockDirty(dev); ++ yaffs_touch_super(dev); + + T(YAFFS_TRACE_OS, + (TSTR("writepag1: obj = %05x, ino = %05x\n"), -+ (int)obj->variant.fileVariant.fileSize, (int)inode->i_size)); ++ (int)obj->variant.file_variant.file_size, (int)inode->i_size)); + -+ yaffs_GrossUnlock(dev); ++ yaffs_gross_unlock(dev); + + kunmap(page); + set_page_writeback(page); @@ -19045,7 +22281,7 @@ + end_page_writeback(page); + put_page(page); + -+ return (nWritten == nBytes) ? 0 : -ENOSPC; ++ return (nWritten == n_bytes) ? 0 : -ENOSPC; +} + + @@ -19135,7 +22371,7 @@ + addr = kva + offset_into_page; + + T(YAFFS_TRACE_OS, -+ ("yaffs_write_end addr %p pos %x nBytes %d\n", ++ ("yaffs_write_end addr %p pos %x n_bytes %d\n", + addr,(unsigned)pos, copied)); + + ret = yaffs_file_write(filp, addr, copied, &pos); @@ -19164,7 +22400,7 @@ + void *addr, *kva; + + loff_t pos = (((loff_t) pg->index) << PAGE_CACHE_SHIFT) + offset; -+ int nBytes = to - offset; ++ int n_bytes = to - offset; + int nWritten; + + unsigned spos = pos; @@ -19176,15 +22412,15 @@ + saddr = (unsigned) addr; + + T(YAFFS_TRACE_OS, -+ (TSTR("yaffs_commit_write addr %x pos %x nBytes %d\n"), -+ saddr, spos, nBytes)); ++ (TSTR("yaffs_commit_write addr %x pos %x n_bytes %d\n"), ++ saddr, spos, n_bytes)); + -+ nWritten = yaffs_file_write(f, addr, nBytes, &pos); ++ nWritten = yaffs_file_write(f, addr, n_bytes, &pos); + -+ if (nWritten != nBytes) { ++ if (nWritten != n_bytes) { + T(YAFFS_TRACE_OS, -+ (TSTR("yaffs_commit_write not same size nWritten %d nBytes %d\n"), -+ nWritten, nBytes)); ++ (TSTR("yaffs_commit_write not same size nWritten %d n_bytes %d\n"), ++ nWritten, n_bytes)); + SetPageError(pg); + } else { + /* Nothing */ @@ -19194,21 +22430,21 @@ + + T(YAFFS_TRACE_OS, + (TSTR("yaffs_commit_write returning %d\n"), -+ nWritten == nBytes ? 0 : nWritten)); ++ nWritten == n_bytes ? 0 : nWritten)); + -+ return nWritten == nBytes ? 0 : nWritten; ++ return nWritten == n_bytes ? 0 : nWritten; +} +#endif + + -+static void yaffs_FillInodeFromObject(struct inode *inode, yaffs_Object *obj) ++static void yaffs_fill_inode_from_obj(struct inode *inode, yaffs_obj_t *obj) +{ + if (inode && obj) { + + + /* Check mode against the variant type and attempt to repair if broken. */ + __u32 mode = obj->yst_mode; -+ switch (obj->variantType) { ++ switch (obj->variant_type) { + case YAFFS_OBJECT_TYPE_FILE: + if (!S_ISREG(mode)) { + obj->yst_mode &= ~S_IFMT; @@ -19240,7 +22476,7 @@ + + inode->i_flags |= S_NOATIME; + -+ inode->i_ino = obj->objectId; ++ inode->i_ino = obj->obj_id; + inode->i_mode = obj->yst_mode; + inode->i_uid = obj->yst_uid; + inode->i_gid = obj->yst_gid; @@ -19262,13 +22498,13 @@ + inode->i_mtime = obj->yst_mtime; + inode->i_ctime = obj->yst_ctime; +#endif -+ inode->i_size = yaffs_GetObjectFileLength(obj); ++ inode->i_size = yaffs_get_obj_length(obj); + inode->i_blocks = (inode->i_size + 511) >> 9; + -+ inode->i_nlink = yaffs_GetObjectLinkCount(obj); ++ inode->i_nlink = yaffs_get_obj_link_count(obj); + + T(YAFFS_TRACE_OS, -+ (TSTR("yaffs_FillInode mode %x uid %d gid %d size %d count %d\n"), ++ (TSTR("yaffs_fill_inode mode %x uid %d gid %d size %d count %d\n"), + inode->i_mode, inode->i_uid, inode->i_gid, + (int)inode->i_size, atomic_read(&inode->i_count))); + @@ -19299,7 +22535,7 @@ + + yaffs_InodeToObjectLV(inode) = obj; + -+ obj->myInode = inode; ++ obj->my_inode = inode; + + } else { + T(YAFFS_TRACE_OS, @@ -19309,7 +22545,7 @@ +} + +struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev, -+ yaffs_Object *obj) ++ yaffs_obj_t *obj) +{ + struct inode *inode; + @@ -19328,9 +22564,9 @@ + } + + T(YAFFS_TRACE_OS, -+ (TSTR("yaffs_get_inode for object %d\n"), obj->objectId)); ++ (TSTR("yaffs_get_inode for object %d\n"), obj->obj_id)); + -+ inode = Y_IGET(sb, obj->objectId); ++ inode = Y_IGET(sb, obj->obj_id); + if (IS_ERR(inode)) + return NULL; + @@ -19344,16 +22580,16 @@ +static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n, + loff_t *pos) +{ -+ yaffs_Object *obj; ++ yaffs_obj_t *obj; + int nWritten, ipos; + struct inode *inode; -+ yaffs_Device *dev; ++ yaffs_dev_t *dev; + -+ obj = yaffs_DentryToObject(f->f_dentry); ++ obj = yaffs_dentry_to_obj(f->f_dentry); + -+ dev = obj->myDev; ++ dev = obj->my_dev; + -+ yaffs_GrossLock(dev); ++ yaffs_gross_lock(dev); + + inode = f->f_dentry->d_inode; + @@ -19369,11 +22605,11 @@ + T(YAFFS_TRACE_OS, + (TSTR("yaffs_file_write about to write writing %u(%x) bytes" + "to object %d at %d(%x)\n"), -+ (unsigned) n, (unsigned) n, obj->objectId, ipos,ipos)); ++ (unsigned) n, (unsigned) n, obj->obj_id, ipos,ipos)); + -+ nWritten = yaffs_WriteDataToFile(obj, buf, ipos, n, 0); ++ nWritten = yaffs_wr_file(obj, buf, ipos, n, 0); + -+ yaffs_MarkSuperBlockDirty(dev); ++ yaffs_touch_super(dev); + + T(YAFFS_TRACE_OS, + (TSTR("yaffs_file_write: %d(%x) bytes written\n"), @@ -19393,7 +22629,7 @@ + } + + } -+ yaffs_GrossUnlock(dev); ++ yaffs_gross_unlock(dev); + return (nWritten == 0) && (n > 0) ? -ENOSPC : nWritten; +} + @@ -19403,39 +22639,39 @@ + +static ssize_t yaffs_hold_space(struct file *f) +{ -+ yaffs_Object *obj; -+ yaffs_Device *dev; ++ yaffs_obj_t *obj; ++ yaffs_dev_t *dev; + -+ int nFreeChunks; ++ int n_free_chunks; + + -+ obj = yaffs_DentryToObject(f->f_dentry); ++ obj = yaffs_dentry_to_obj(f->f_dentry); + -+ dev = obj->myDev; ++ dev = obj->my_dev; + -+ yaffs_GrossLock(dev); ++ yaffs_gross_lock(dev); + -+ nFreeChunks = yaffs_GetNumberOfFreeChunks(dev); ++ n_free_chunks = yaffs_get_n_free_chunks(dev); + -+ yaffs_GrossUnlock(dev); ++ yaffs_gross_unlock(dev); + -+ return (nFreeChunks > 20) ? 1 : 0; ++ return (n_free_chunks > 20) ? 1 : 0; +} + +static void yaffs_release_space(struct file *f) +{ -+ yaffs_Object *obj; -+ yaffs_Device *dev; ++ yaffs_obj_t *obj; ++ yaffs_dev_t *dev; + + -+ obj = yaffs_DentryToObject(f->f_dentry); ++ obj = yaffs_dentry_to_obj(f->f_dentry); + -+ dev = obj->myDev; ++ dev = obj->my_dev; + -+ yaffs_GrossLock(dev); ++ yaffs_gross_lock(dev); + + -+ yaffs_GrossUnlock(dev); ++ yaffs_gross_unlock(dev); +} + + @@ -19467,22 +22703,22 @@ + +static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir) +{ -+ yaffs_Object *obj; -+ yaffs_Device *dev; ++ yaffs_obj_t *obj; ++ yaffs_dev_t *dev; + struct yaffs_SearchContext *sc; + struct inode *inode = f->f_dentry->d_inode; + unsigned long offset, curoffs; -+ yaffs_Object *l; ++ yaffs_obj_t *l; + int retVal = 0; + + char name[YAFFS_MAX_NAME_LENGTH + 1]; + -+ obj = yaffs_DentryToObject(f->f_dentry); -+ dev = obj->myDev; ++ obj = yaffs_dentry_to_obj(f->f_dentry); ++ dev = obj->my_dev; + -+ yaffs_GrossLock(dev); ++ yaffs_gross_lock(dev); + -+ yaffs_DeviceToLC(dev)->readdirProcess = current; ++ yaffs_dev_to_lc(dev)->readdirProcess = current; + + offset = f->f_pos; + @@ -19498,12 +22734,12 @@ + T(YAFFS_TRACE_OS, + (TSTR("yaffs_readdir: entry . ino %d \n"), + (int)inode->i_ino)); -+ yaffs_GrossUnlock(dev); ++ yaffs_gross_unlock(dev); + if (filldir(dirent, ".", 1, offset, inode->i_ino, DT_DIR) < 0){ -+ yaffs_GrossLock(dev); ++ yaffs_gross_lock(dev); + goto out; + } -+ yaffs_GrossLock(dev); ++ yaffs_gross_lock(dev); + offset++; + f->f_pos++; + } @@ -19511,13 +22747,13 @@ + T(YAFFS_TRACE_OS, + (TSTR("yaffs_readdir: entry .. ino %d \n"), + (int)f->f_dentry->d_parent->d_inode->i_ino)); -+ yaffs_GrossUnlock(dev); ++ yaffs_gross_unlock(dev); + if (filldir(dirent, "..", 2, offset, + f->f_dentry->d_parent->d_inode->i_ino, DT_DIR) < 0){ -+ yaffs_GrossLock(dev); ++ yaffs_gross_lock(dev); + goto out; + } -+ yaffs_GrossLock(dev); ++ yaffs_gross_lock(dev); + offset++; + f->f_pos++; + } @@ -19536,16 +22772,16 @@ + curoffs++; + l = sc->nextReturn; + if (curoffs >= offset) { -+ int this_inode = yaffs_GetObjectInode(l); -+ int this_type = yaffs_GetObjectType(l); ++ int this_inode = yaffs_get_obj_inode(l); ++ int this_type = yaffs_get_obj_type(l); + -+ yaffs_GetObjectName(l, name, ++ yaffs_get_obj_name(l, name, + YAFFS_MAX_NAME_LENGTH + 1); + T(YAFFS_TRACE_OS, + (TSTR("yaffs_readdir: %s inode %d\n"), -+ name, yaffs_GetObjectInode(l))); ++ name, yaffs_get_obj_inode(l))); + -+ yaffs_GrossUnlock(dev); ++ yaffs_gross_unlock(dev); + + if (filldir(dirent, + name, @@ -19553,22 +22789,22 @@ + offset, + this_inode, + this_type) < 0){ -+ yaffs_GrossLock(dev); ++ yaffs_gross_lock(dev); + goto out; + } + -+ yaffs_GrossLock(dev); ++ yaffs_gross_lock(dev); + + offset++; + f->f_pos++; + } -+ yaffs_SearchAdvance(sc); ++ yaffs_search_advance(sc); + } + +out: -+ yaffs_EndSearch(sc); -+ yaffs_DeviceToLC(dev)->readdirProcess = NULL; -+ yaffs_GrossUnlock(dev); ++ yaffs_search_end(sc); ++ yaffs_dev_to_lc(dev)->readdirProcess = NULL; ++ yaffs_gross_unlock(dev); + + return retVal; +} @@ -19595,10 +22831,10 @@ +{ + struct inode *inode; + -+ yaffs_Object *obj = NULL; -+ yaffs_Device *dev; ++ yaffs_obj_t *obj = NULL; ++ yaffs_dev_t *dev; + -+ yaffs_Object *parent = yaffs_InodeToObject(dir); ++ yaffs_obj_t *parent = yaffs_InodeToObject(dir); + + int error = -ENOSPC; + uid_t uid = YCRED(current)->fsuid; @@ -19610,7 +22846,7 @@ + if (parent) { + T(YAFFS_TRACE_OS, + (TSTR("yaffs_mknod: parent object %d type %d\n"), -+ parent->objectId, parent->variantType)); ++ parent->obj_id, parent->variant_type)); + } else { + T(YAFFS_TRACE_OS, + (TSTR("yaffs_mknod: could not get parent object\n"))); @@ -19621,31 +22857,31 @@ + "mode %x dev %x\n"), + dentry->d_name.name, mode, rdev)); + -+ dev = parent->myDev; ++ dev = parent->my_dev; + -+ yaffs_GrossLock(dev); ++ yaffs_gross_lock(dev); + + switch (mode & S_IFMT) { + default: + /* Special (socket, fifo, device...) */ + T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod: making special\n"))); +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0)) -+ obj = yaffs_MknodSpecial(parent, dentry->d_name.name, mode, uid, ++ obj = yaffs_create_special(parent, dentry->d_name.name, mode, uid, + gid, old_encode_dev(rdev)); +#else -+ obj = yaffs_MknodSpecial(parent, dentry->d_name.name, mode, uid, ++ obj = yaffs_create_special(parent, dentry->d_name.name, mode, uid, + gid, rdev); +#endif + break; + case S_IFREG: /* file */ + T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod: making file\n"))); -+ obj = yaffs_MknodFile(parent, dentry->d_name.name, mode, uid, ++ obj = yaffs_create_file(parent, dentry->d_name.name, mode, uid, + gid); + break; + case S_IFDIR: /* directory */ + T(YAFFS_TRACE_OS, + (TSTR("yaffs_mknod: making directory\n"))); -+ obj = yaffs_MknodDirectory(parent, dentry->d_name.name, mode, ++ obj = yaffs_create_dir(parent, dentry->d_name.name, mode, + uid, gid); + break; + case S_IFLNK: /* symlink */ @@ -19655,7 +22891,7 @@ + } + + /* Can not call yaffs_get_inode() with gross lock held */ -+ yaffs_GrossUnlock(dev); ++ yaffs_gross_unlock(dev); + + if (obj) { + inode = yaffs_get_inode(dir->i_sb, mode, rdev, obj); @@ -19663,9 +22899,9 @@ + update_dir_time(dir); + T(YAFFS_TRACE_OS, + (TSTR("yaffs_mknod created object %d count = %d\n"), -+ obj->objectId, atomic_read(&inode->i_count))); ++ obj->obj_id, atomic_read(&inode->i_count))); + error = 0; -+ yaffs_FillInodeFromObject(dir,parent); ++ yaffs_fill_inode_from_obj(dir,parent); + } else { + T(YAFFS_TRACE_OS, + (TSTR("yaffs_mknod failed making object\n"))); @@ -19698,29 +22934,29 @@ +{ + int retVal; + -+ yaffs_Device *dev; -+ yaffs_Object *obj; ++ yaffs_dev_t *dev; ++ yaffs_obj_t *obj; + + T(YAFFS_TRACE_OS, + (TSTR("yaffs_unlink %d:%s\n"), + (int)(dir->i_ino), + dentry->d_name.name)); + obj = yaffs_InodeToObject(dir); -+ dev = obj->myDev; ++ dev = obj->my_dev; + -+ yaffs_GrossLock(dev); ++ yaffs_gross_lock(dev); + -+ retVal = yaffs_Unlink(obj, dentry->d_name.name); ++ retVal = yaffs_unlinker(obj, dentry->d_name.name); + + if (retVal == YAFFS_OK) { + dentry->d_inode->i_nlink--; + dir->i_version++; -+ yaffs_GrossUnlock(dev); ++ yaffs_gross_unlock(dev); + mark_inode_dirty(dentry->d_inode); + update_dir_time(dir); + return 0; + } -+ yaffs_GrossUnlock(dev); ++ yaffs_gross_unlock(dev); + return -ENOTEMPTY; +} + @@ -19731,23 +22967,23 @@ + struct dentry *dentry) +{ + struct inode *inode = old_dentry->d_inode; -+ yaffs_Object *obj = NULL; -+ yaffs_Object *link = NULL; -+ yaffs_Device *dev; ++ yaffs_obj_t *obj = NULL; ++ yaffs_obj_t *link = NULL; ++ yaffs_dev_t *dev; + + T(YAFFS_TRACE_OS, (TSTR("yaffs_link\n"))); + + obj = yaffs_InodeToObject(inode); -+ dev = obj->myDev; ++ dev = obj->my_dev; + -+ yaffs_GrossLock(dev); ++ yaffs_gross_lock(dev); + + if (!S_ISDIR(inode->i_mode)) /* Don't link directories */ -+ link = yaffs_Link(yaffs_InodeToObject(dir), dentry->d_name.name, ++ link = yaffs_link_obj(yaffs_InodeToObject(dir), dentry->d_name.name, + obj); + + if (link) { -+ old_dentry->d_inode->i_nlink = yaffs_GetObjectLinkCount(obj); ++ old_dentry->d_inode->i_nlink = yaffs_get_obj_link_count(obj); + d_instantiate(dentry, old_dentry->d_inode); + atomic_inc(&old_dentry->d_inode->i_count); + T(YAFFS_TRACE_OS, @@ -19756,7 +22992,7 @@ + atomic_read(&old_dentry->d_inode->i_count))); + } + -+ yaffs_GrossUnlock(dev); ++ yaffs_gross_unlock(dev); + + if (link){ + update_dir_time(dir); @@ -19769,18 +23005,18 @@ +static int yaffs_symlink(struct inode *dir, struct dentry *dentry, + const char *symname) +{ -+ yaffs_Object *obj; -+ yaffs_Device *dev; ++ yaffs_obj_t *obj; ++ yaffs_dev_t *dev; + uid_t uid = YCRED(current)->fsuid; + gid_t gid = (dir->i_mode & S_ISGID) ? dir->i_gid : YCRED(current)->fsgid; + + T(YAFFS_TRACE_OS, (TSTR("yaffs_symlink\n"))); + -+ dev = yaffs_InodeToObject(dir)->myDev; -+ yaffs_GrossLock(dev); -+ obj = yaffs_MknodSymLink(yaffs_InodeToObject(dir), dentry->d_name.name, ++ dev = yaffs_InodeToObject(dir)->my_dev; ++ yaffs_gross_lock(dev); ++ obj = yaffs_create_symlink(yaffs_InodeToObject(dir), dentry->d_name.name, + S_IFLNK | S_IRWXUGO, uid, gid, symname); -+ yaffs_GrossUnlock(dev); ++ yaffs_gross_unlock(dev); + + if (obj) { + struct inode *inode; @@ -19805,21 +23041,21 @@ +#endif +{ + -+ yaffs_Object *obj; -+ yaffs_Device *dev; ++ yaffs_obj_t *obj; ++ yaffs_dev_t *dev; +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 34)) + struct dentry *dentry = file->f_path.dentry; +#endif + -+ obj = yaffs_DentryToObject(dentry); ++ obj = yaffs_dentry_to_obj(dentry); + -+ dev = obj->myDev; ++ dev = obj->my_dev; + + T(YAFFS_TRACE_OS | YAFFS_TRACE_SYNC, + (TSTR("yaffs_sync_object\n"))); -+ yaffs_GrossLock(dev); -+ yaffs_FlushFile(obj, 1, datasync); -+ yaffs_GrossUnlock(dev); ++ yaffs_gross_lock(dev); ++ yaffs_flush_file(obj, 1, datasync); ++ yaffs_gross_unlock(dev); + return 0; +} + @@ -19831,37 +23067,37 @@ +static int yaffs_rename(struct inode *old_dir, struct dentry *old_dentry, + struct inode *new_dir, struct dentry *new_dentry) +{ -+ yaffs_Device *dev; ++ yaffs_dev_t *dev; + int retVal = YAFFS_FAIL; -+ yaffs_Object *target; ++ yaffs_obj_t *target; + + T(YAFFS_TRACE_OS, (TSTR("yaffs_rename\n"))); -+ dev = yaffs_InodeToObject(old_dir)->myDev; ++ dev = yaffs_InodeToObject(old_dir)->my_dev; + -+ yaffs_GrossLock(dev); ++ yaffs_gross_lock(dev); + + /* Check if the target is an existing directory that is not empty. */ -+ target = yaffs_FindObjectByName(yaffs_InodeToObject(new_dir), ++ target = yaffs_find_by_name(yaffs_InodeToObject(new_dir), + new_dentry->d_name.name); + + + -+ if (target && target->variantType == YAFFS_OBJECT_TYPE_DIRECTORY && -+ !ylist_empty(&target->variant.directoryVariant.children)) { ++ if (target && target->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY && ++ !ylist_empty(&target->variant.dir_variant.children)) { + + T(YAFFS_TRACE_OS, (TSTR("target is non-empty dir\n"))); + + retVal = YAFFS_FAIL; + } else { + /* Now does unlinking internally using shadowing mechanism */ -+ T(YAFFS_TRACE_OS, (TSTR("calling yaffs_RenameObject\n"))); ++ T(YAFFS_TRACE_OS, (TSTR("calling yaffs_rename_obj\n"))); + -+ retVal = yaffs_RenameObject(yaffs_InodeToObject(old_dir), ++ retVal = yaffs_rename_obj(yaffs_InodeToObject(old_dir), + old_dentry->d_name.name, + yaffs_InodeToObject(new_dir), + new_dentry->d_name.name); + } -+ yaffs_GrossUnlock(dev); ++ yaffs_gross_unlock(dev); + + if (retVal == YAFFS_OK) { + if (target) { @@ -19882,11 +23118,11 @@ +{ + struct inode *inode = dentry->d_inode; + int error = 0; -+ yaffs_Device *dev; ++ yaffs_dev_t *dev; + + T(YAFFS_TRACE_OS, + (TSTR("yaffs_setattr of object %d\n"), -+ yaffs_InodeToObject(inode)->objectId)); ++ yaffs_InodeToObject(inode)->obj_id)); + + /* Fail if a requested resize >= 2GB */ + if (attr->ia_valid & ATTR_SIZE && @@ -19905,19 +23141,19 @@ + inode->i_blocks = (inode->i_size + 511) >> 9; + } + } -+ dev = yaffs_InodeToObject(inode)->myDev; ++ dev = yaffs_InodeToObject(inode)->my_dev; + if (attr->ia_valid & ATTR_SIZE){ + T(YAFFS_TRACE_OS,(TSTR("resize to %d(%x)\n"), + (int)(attr->ia_size),(int)(attr->ia_size))); + } -+ yaffs_GrossLock(dev); -+ result = yaffs_SetAttributes(yaffs_InodeToObject(inode), attr); ++ yaffs_gross_lock(dev); ++ result = yaffs_set_attribs(yaffs_InodeToObject(inode), attr); + if(result == YAFFS_OK) { + error = 0; + } else { + error = -EPERM; + } -+ yaffs_GrossUnlock(dev); ++ yaffs_gross_unlock(dev); + + } + @@ -19933,24 +23169,24 @@ +{ + struct inode *inode = dentry->d_inode; + int error = 0; -+ yaffs_Device *dev; -+ yaffs_Object *obj = yaffs_InodeToObject(inode); ++ yaffs_dev_t *dev; ++ yaffs_obj_t *obj = yaffs_InodeToObject(inode); + + T(YAFFS_TRACE_OS, + (TSTR("yaffs_setxattr of object %d\n"), -+ obj->objectId)); ++ obj->obj_id)); + + + if (error == 0) { + int result; -+ dev = obj->myDev; -+ yaffs_GrossLock(dev); -+ result = yaffs_SetXAttribute(obj, name, value, size, flags); ++ dev = obj->my_dev; ++ yaffs_gross_lock(dev); ++ result = yaffs_set_xattrib(obj, name, value, size, flags); + if(result == YAFFS_OK) + error = 0; + else if(result < 0) + error = result; -+ yaffs_GrossUnlock(dev); ++ yaffs_gross_unlock(dev); + + } + T(YAFFS_TRACE_OS, @@ -19965,18 +23201,18 @@ +{ + struct inode *inode = dentry->d_inode; + int error = 0; -+ yaffs_Device *dev; -+ yaffs_Object *obj = yaffs_InodeToObject(inode); ++ yaffs_dev_t *dev; ++ yaffs_obj_t *obj = yaffs_InodeToObject(inode); + + T(YAFFS_TRACE_OS, + (TSTR("yaffs_getxattr \"%s\" from object %d\n"), -+ name, obj->objectId)); ++ name, obj->obj_id)); + + if (error == 0) { -+ dev = obj->myDev; -+ yaffs_GrossLock(dev); -+ error = yaffs_GetXAttribute(obj, name, buff, size); -+ yaffs_GrossUnlock(dev); ++ dev = obj->my_dev; ++ yaffs_gross_lock(dev); ++ error = yaffs_get_xattrib(obj, name, buff, size); ++ yaffs_gross_unlock(dev); + + } + T(YAFFS_TRACE_OS, @@ -19989,24 +23225,24 @@ +{ + struct inode *inode = dentry->d_inode; + int error = 0; -+ yaffs_Device *dev; -+ yaffs_Object *obj = yaffs_InodeToObject(inode); ++ yaffs_dev_t *dev; ++ yaffs_obj_t *obj = yaffs_InodeToObject(inode); + + T(YAFFS_TRACE_OS, + (TSTR("yaffs_removexattr of object %d\n"), -+ obj->objectId)); ++ obj->obj_id)); + + + if (error == 0) { + int result; -+ dev = obj->myDev; -+ yaffs_GrossLock(dev); -+ result = yaffs_RemoveXAttribute(obj, name); ++ dev = obj->my_dev; ++ yaffs_gross_lock(dev); ++ result = yaffs_remove_xattrib(obj, name); + if(result == YAFFS_OK) + error = 0; + else if(result < 0) + error = result; -+ yaffs_GrossUnlock(dev); ++ yaffs_gross_unlock(dev); + + } + T(YAFFS_TRACE_OS, @@ -20019,19 +23255,19 @@ +{ + struct inode *inode = dentry->d_inode; + int error = 0; -+ yaffs_Device *dev; -+ yaffs_Object *obj = yaffs_InodeToObject(inode); ++ yaffs_dev_t *dev; ++ yaffs_obj_t *obj = yaffs_InodeToObject(inode); + + T(YAFFS_TRACE_OS, + (TSTR("yaffs_listxattr of object %d\n"), -+ obj->objectId)); ++ obj->obj_id)); + + + if (error == 0) { -+ dev = obj->myDev; -+ yaffs_GrossLock(dev); -+ error = yaffs_ListXAttributes(obj, buff, size); -+ yaffs_GrossUnlock(dev); ++ dev = obj->my_dev; ++ yaffs_gross_lock(dev); ++ error = yaffs_list_xattrib(obj, buff, size); ++ yaffs_gross_unlock(dev); + + } + T(YAFFS_TRACE_OS, @@ -20046,121 +23282,121 @@ +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17)) +static int yaffs_statfs(struct dentry *dentry, struct kstatfs *buf) +{ -+ yaffs_Device *dev = yaffs_DentryToObject(dentry)->myDev; ++ yaffs_dev_t *dev = yaffs_dentry_to_obj(dentry)->my_dev; + struct super_block *sb = dentry->d_sb; +#elif (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0)) +static int yaffs_statfs(struct super_block *sb, struct kstatfs *buf) +{ -+ yaffs_Device *dev = yaffs_SuperToDevice(sb); ++ yaffs_dev_t *dev = yaffs_SuperToDevice(sb); +#else +static int yaffs_statfs(struct super_block *sb, struct statfs *buf) +{ -+ yaffs_Device *dev = yaffs_SuperToDevice(sb); ++ yaffs_dev_t *dev = yaffs_SuperToDevice(sb); +#endif + + T(YAFFS_TRACE_OS, (TSTR("yaffs_statfs\n"))); + -+ yaffs_GrossLock(dev); ++ yaffs_gross_lock(dev); + + buf->f_type = YAFFS_MAGIC; + buf->f_bsize = sb->s_blocksize; + buf->f_namelen = 255; + -+ if (dev->nDataBytesPerChunk & (dev->nDataBytesPerChunk - 1)) { ++ if (dev->data_bytes_per_chunk & (dev->data_bytes_per_chunk - 1)) { + /* Do this if chunk size is not a power of 2 */ + + uint64_t bytesInDev; + uint64_t bytesFree; + -+ bytesInDev = ((uint64_t)((dev->param.endBlock - dev->param.startBlock + 1))) * -+ ((uint64_t)(dev->param.nChunksPerBlock * dev->nDataBytesPerChunk)); ++ bytesInDev = ((uint64_t)((dev->param.end_block - dev->param.start_block + 1))) * ++ ((uint64_t)(dev->param.chunks_per_block * dev->data_bytes_per_chunk)); + + do_div(bytesInDev, sb->s_blocksize); /* bytesInDev becomes the number of blocks */ + buf->f_blocks = bytesInDev; + -+ bytesFree = ((uint64_t)(yaffs_GetNumberOfFreeChunks(dev))) * -+ ((uint64_t)(dev->nDataBytesPerChunk)); ++ bytesFree = ((uint64_t)(yaffs_get_n_free_chunks(dev))) * ++ ((uint64_t)(dev->data_bytes_per_chunk)); + + do_div(bytesFree, sb->s_blocksize); + + buf->f_bfree = bytesFree; + -+ } else if (sb->s_blocksize > dev->nDataBytesPerChunk) { ++ } else if (sb->s_blocksize > dev->data_bytes_per_chunk) { + + buf->f_blocks = -+ (dev->param.endBlock - dev->param.startBlock + 1) * -+ dev->param.nChunksPerBlock / -+ (sb->s_blocksize / dev->nDataBytesPerChunk); ++ (dev->param.end_block - dev->param.start_block + 1) * ++ dev->param.chunks_per_block / ++ (sb->s_blocksize / dev->data_bytes_per_chunk); + buf->f_bfree = -+ yaffs_GetNumberOfFreeChunks(dev) / -+ (sb->s_blocksize / dev->nDataBytesPerChunk); ++ yaffs_get_n_free_chunks(dev) / ++ (sb->s_blocksize / dev->data_bytes_per_chunk); + } else { + buf->f_blocks = -+ (dev->param.endBlock - dev->param.startBlock + 1) * -+ dev->param.nChunksPerBlock * -+ (dev->nDataBytesPerChunk / sb->s_blocksize); ++ (dev->param.end_block - dev->param.start_block + 1) * ++ dev->param.chunks_per_block * ++ (dev->data_bytes_per_chunk / sb->s_blocksize); + + buf->f_bfree = -+ yaffs_GetNumberOfFreeChunks(dev) * -+ (dev->nDataBytesPerChunk / sb->s_blocksize); ++ yaffs_get_n_free_chunks(dev) * ++ (dev->data_bytes_per_chunk / sb->s_blocksize); + } + + buf->f_files = 0; + buf->f_ffree = 0; + buf->f_bavail = buf->f_bfree; + -+ yaffs_GrossUnlock(dev); ++ yaffs_gross_unlock(dev); + return 0; +} + + + -+static void yaffs_FlushInodes(struct super_block *sb) ++static void yaffs_flush_inodes(struct super_block *sb) +{ + struct inode *iptr; -+ yaffs_Object *obj; ++ yaffs_obj_t *obj; + + list_for_each_entry(iptr,&sb->s_inodes, i_sb_list){ + obj = yaffs_InodeToObject(iptr); + if(obj){ + T(YAFFS_TRACE_OS, (TSTR("flushing obj %d\n"), -+ obj->objectId)); -+ yaffs_FlushFile(obj,1,0); ++ obj->obj_id)); ++ yaffs_flush_file(obj,1,0); + } + } +} + + -+static void yaffs_FlushSuperBlock(struct super_block *sb, int do_checkpoint) ++static void yaffs_flush_super(struct super_block *sb, int do_checkpoint) +{ -+ yaffs_Device *dev = yaffs_SuperToDevice(sb); ++ yaffs_dev_t *dev = yaffs_SuperToDevice(sb); + if(!dev) + return; + -+ yaffs_FlushInodes(sb); -+ yaffs_UpdateDirtyDirectories(dev); -+ yaffs_FlushEntireDeviceCache(dev); ++ yaffs_flush_inodes(sb); ++ yaffs_update_dirty_dirs(dev); ++ yaffs_flush_whole_cache(dev); + if(do_checkpoint) -+ yaffs_CheckpointSave(dev); ++ yaffs_checkpoint_save(dev); +} + + -+static unsigned yaffs_bg_gc_urgency(yaffs_Device *dev) ++static unsigned yaffs_bg_gc_urgency(yaffs_dev_t *dev) +{ -+ unsigned erasedChunks = dev->nErasedBlocks * dev->param.nChunksPerBlock; -+ struct yaffs_LinuxContext *context = yaffs_DeviceToLC(dev); ++ unsigned erasedChunks = dev->n_erased_blocks * dev->param.chunks_per_block; ++ struct yaffs_LinuxContext *context = yaffs_dev_to_lc(dev); + unsigned scatteredFree = 0; /* Free chunks not in an erased block */ + -+ if(erasedChunks < dev->nFreeChunks) -+ scatteredFree = (dev->nFreeChunks - erasedChunks); ++ if(erasedChunks < dev->n_free_chunks) ++ scatteredFree = (dev->n_free_chunks - erasedChunks); + + if(!context->bgRunning) + return 0; -+ else if(scatteredFree < (dev->param.nChunksPerBlock * 2)) ++ else if(scatteredFree < (dev->param.chunks_per_block * 2)) + return 0; -+ else if(erasedChunks > dev->nFreeChunks/2) ++ else if(erasedChunks > dev->n_free_chunks/2) + return 0; -+ else if(erasedChunks > dev->nFreeChunks/4) ++ else if(erasedChunks > dev->n_free_chunks/4) + return 1; + else + return 2; @@ -20170,7 +23406,7 @@ + int request_checkpoint) +{ + -+ yaffs_Device *dev = yaffs_SuperToDevice(sb); ++ yaffs_dev_t *dev = yaffs_SuperToDevice(sb); + unsigned int oneshot_checkpoint = (yaffs_auto_checkpoint & 4); + unsigned gc_urgent = yaffs_bg_gc_urgency(dev); + int do_checkpoint; @@ -20182,27 +23418,27 @@ + request_checkpoint ? "checkpoint requested" : "no checkpoint", + oneshot_checkpoint ? " one-shot" : "" )); + -+ yaffs_GrossLock(dev); ++ yaffs_gross_lock(dev); + do_checkpoint = ((request_checkpoint && !gc_urgent) || + oneshot_checkpoint) && -+ !dev->isCheckpointed; ++ !dev->is_checkpointed; + + if (sb->s_dirt || do_checkpoint) { -+ yaffs_FlushSuperBlock(sb, !dev->isCheckpointed && do_checkpoint); ++ yaffs_flush_super(sb, !dev->is_checkpointed && do_checkpoint); + sb->s_dirt = 0; + if(oneshot_checkpoint) + yaffs_auto_checkpoint &= ~4; + } -+ yaffs_GrossUnlock(dev); ++ yaffs_gross_unlock(dev); + + return 0; +} + +/* + * yaffs background thread functions . -+ * yaffs_BackgroundThread() the thread function -+ * yaffs_BackgroundStart() launches the background thread. -+ * yaffs_BackgroundStop() cleans up the background thread. ++ * yaffs_bg_thread_fn() the thread function ++ * yaffs_bg_start() launches the background thread. ++ * yaffs_bg_stop() cleans up the background thread. + * + * NB: + * The thread should only run after the yaffs is initialised @@ -20217,10 +23453,10 @@ + wake_up_process((struct task_struct *)data); +} + -+static int yaffs_BackgroundThread(void *data) ++static int yaffs_bg_thread_fn(void *data) +{ -+ yaffs_Device *dev = (yaffs_Device *)data; -+ struct yaffs_LinuxContext *context = yaffs_DeviceToLC(dev); ++ yaffs_dev_t *dev = (yaffs_dev_t *)data; ++ struct yaffs_LinuxContext *context = yaffs_dev_to_lc(dev); + unsigned long now = jiffies; + unsigned long next_dir_update = now; + unsigned long next_gc = now; @@ -20248,19 +23484,19 @@ + if(try_to_freeze()) + continue; +#endif -+ yaffs_GrossLock(dev); ++ yaffs_gross_lock(dev); + + now = jiffies; + + if(time_after(now, next_dir_update) && yaffs_bg_enable){ -+ yaffs_UpdateDirtyDirectories(dev); ++ yaffs_update_dirty_dirs(dev); + next_dir_update = now + HZ; + } + + if(time_after(now,next_gc) && yaffs_bg_enable){ -+ if(!dev->isCheckpointed){ ++ if(!dev->is_checkpointed){ + urgency = yaffs_bg_gc_urgency(dev); -+ gcResult = yaffs_BackgroundGarbageCollect(dev, urgency); ++ gcResult = yaffs_bg_gc(dev, urgency); + if(urgency > 1) + next_gc = now + HZ/20+1; + else if(urgency > 0) @@ -20273,7 +23509,7 @@ + */ + next_gc = next_dir_update; + } -+ yaffs_GrossUnlock(dev); ++ yaffs_gross_unlock(dev); +#if 1 + expires = next_dir_update; + if (time_before(next_gc,expires)) @@ -20298,17 +23534,17 @@ + return 0; +} + -+static int yaffs_BackgroundStart(yaffs_Device *dev) ++static int yaffs_bg_start(yaffs_dev_t *dev) +{ + int retval = 0; -+ struct yaffs_LinuxContext *context = yaffs_DeviceToLC(dev); ++ struct yaffs_LinuxContext *context = yaffs_dev_to_lc(dev); + -+ if(dev->readOnly) ++ if(dev->read_only) + return -1; + + context->bgRunning = 1; + -+ context->bgThread = kthread_run(yaffs_BackgroundThread, ++ context->bgThread = kthread_run(yaffs_bg_thread_fn, + (void *)dev,"yaffs-bg-%d",context->mount_id); + + if(IS_ERR(context->bgThread)){ @@ -20319,9 +23555,9 @@ + return retval; +} + -+static void yaffs_BackgroundStop(yaffs_Device *dev) ++static void yaffs_bg_stop(yaffs_dev_t *dev) +{ -+ struct yaffs_LinuxContext *ctxt = yaffs_DeviceToLC(dev); ++ struct yaffs_LinuxContext *ctxt = yaffs_dev_to_lc(dev); + + ctxt->bgRunning = 0; + @@ -20331,17 +23567,17 @@ + } +} +#else -+static int yaffs_BackgroundThread(void *data) ++static int yaffs_bg_thread_fn(void *data) +{ + return 0; +} + -+static int yaffs_BackgroundStart(yaffs_Device *dev) ++static int yaffs_bg_start(yaffs_dev_t *dev) +{ + return 0; +} + -+static void yaffs_BackgroundStop(yaffs_Device *dev) ++static void yaffs_bg_stop(yaffs_dev_t *dev) +{ +} +#endif @@ -20389,8 +23625,8 @@ +static struct inode *yaffs_iget(struct super_block *sb, unsigned long ino) +{ + struct inode *inode; -+ yaffs_Object *obj; -+ yaffs_Device *dev = yaffs_SuperToDevice(sb); ++ yaffs_obj_t *obj; ++ yaffs_dev_t *dev = yaffs_SuperToDevice(sb); + + T(YAFFS_TRACE_OS, + (TSTR("yaffs_iget for %lu\n"), ino)); @@ -20406,13 +23642,13 @@ + * need to lock again. + */ + -+ yaffs_GrossLock(dev); ++ yaffs_gross_lock(dev); + -+ obj = yaffs_FindObjectByNumber(dev, inode->i_ino); ++ obj = yaffs_find_by_number(dev, inode->i_ino); + -+ yaffs_FillInodeFromObject(inode, obj); ++ yaffs_fill_inode_from_obj(inode, obj); + -+ yaffs_GrossUnlock(dev); ++ yaffs_gross_unlock(dev); + + unlock_new_inode(inode); + return inode; @@ -20427,21 +23663,21 @@ + * need to lock again. + */ + -+ yaffs_Object *obj; -+ yaffs_Device *dev = yaffs_SuperToDevice(inode->i_sb); ++ yaffs_obj_t *obj; ++ yaffs_dev_t *dev = yaffs_SuperToDevice(inode->i_sb); + + T(YAFFS_TRACE_OS, + (TSTR("yaffs_read_inode for %d\n"), (int)inode->i_ino)); + -+ if(current != yaffs_DeviceToLC(dev)->readdirProcess) -+ yaffs_GrossLock(dev); ++ if(current != yaffs_dev_to_lc(dev)->readdirProcess) ++ yaffs_gross_lock(dev); + -+ obj = yaffs_FindObjectByNumber(dev, inode->i_ino); ++ obj = yaffs_find_by_number(dev, inode->i_ino); + -+ yaffs_FillInodeFromObject(inode, obj); ++ yaffs_fill_inode_from_obj(inode, obj); + -+ if(current != yaffs_DeviceToLC(dev)->readdirProcess) -+ yaffs_GrossUnlock(dev); ++ if(current != yaffs_dev_to_lc(dev)->readdirProcess) ++ yaffs_gross_unlock(dev); +} + +#endif @@ -20451,35 +23687,35 @@ + +static void yaffs_put_super(struct super_block *sb) +{ -+ yaffs_Device *dev = yaffs_SuperToDevice(sb); ++ yaffs_dev_t *dev = yaffs_SuperToDevice(sb); + + T(YAFFS_TRACE_OS, (TSTR("yaffs_put_super\n"))); + + T(YAFFS_TRACE_OS | YAFFS_TRACE_BACKGROUND, + (TSTR("Shutting down yaffs background thread\n"))); -+ yaffs_BackgroundStop(dev); ++ yaffs_bg_stop(dev); + T(YAFFS_TRACE_OS | YAFFS_TRACE_BACKGROUND, + (TSTR("yaffs background thread shut down\n"))); + -+ yaffs_GrossLock(dev); ++ yaffs_gross_lock(dev); + -+ yaffs_FlushSuperBlock(sb,1); ++ yaffs_flush_super(sb,1); + -+ if (yaffs_DeviceToLC(dev)->putSuperFunc) -+ yaffs_DeviceToLC(dev)->putSuperFunc(sb); ++ if (yaffs_dev_to_lc(dev)->putSuperFunc) ++ yaffs_dev_to_lc(dev)->putSuperFunc(sb); + + -+ yaffs_Deinitialise(dev); ++ yaffs_deinitialise(dev); + -+ yaffs_GrossUnlock(dev); ++ yaffs_gross_unlock(dev); + + down(&yaffs_context_lock); -+ ylist_del_init(&(yaffs_DeviceToLC(dev)->contextList)); ++ ylist_del_init(&(yaffs_dev_to_lc(dev)->contextList)); + up(&yaffs_context_lock); + -+ if (yaffs_DeviceToLC(dev)->spareBuffer) { -+ YFREE(yaffs_DeviceToLC(dev)->spareBuffer); -+ yaffs_DeviceToLC(dev)->spareBuffer = NULL; ++ if (yaffs_dev_to_lc(dev)->spareBuffer) { ++ YFREE(yaffs_dev_to_lc(dev)->spareBuffer); ++ yaffs_dev_to_lc(dev)->spareBuffer = NULL; + } + + kfree(dev); @@ -20488,7 +23724,7 @@ + +static void yaffs_MTDPutSuper(struct super_block *sb) +{ -+ struct mtd_info *mtd = yaffs_DeviceToMtd(yaffs_SuperToDevice(sb)); ++ struct mtd_info *mtd = yaffs_dev_to_mtd(yaffs_SuperToDevice(sb)); + + if (mtd->sync) + mtd->sync(mtd); @@ -20497,11 +23733,11 @@ +} + + -+static void yaffs_MarkSuperBlockDirty(yaffs_Device *dev) ++static void yaffs_touch_super(yaffs_dev_t *dev) +{ -+ struct super_block *sb = yaffs_DeviceToLC(dev)->superBlock; ++ struct super_block *sb = yaffs_dev_to_lc(dev)->superBlock; + -+ T(YAFFS_TRACE_OS, (TSTR("yaffs_MarkSuperBlockDirty() sb = %p\n"), sb)); ++ T(YAFFS_TRACE_OS, (TSTR("yaffs_touch_super() sb = %p\n"), sb)); + if (sb) + sb->s_dirt = 1; +} @@ -20582,22 +23818,22 @@ + return error; +} + -+static struct super_block *yaffs_internal_read_super(int yaffsVersion, ++static struct super_block *yaffs_internal_read_super(int yaffs_version, + struct super_block *sb, + void *data, int silent) +{ + int nBlocks; + struct inode *inode = NULL; + struct dentry *root; -+ yaffs_Device *dev = 0; ++ yaffs_dev_t *dev = 0; + char devname_buf[BDEVNAME_SIZE + 1]; + struct mtd_info *mtd; + int err; + char *data_str = (char *)data; + struct yaffs_LinuxContext *context = NULL; -+ yaffs_DeviceParam *param; ++ yaffs_param_t *param; + -+ int readOnly = 0; ++ int read_only = 0; + + yaffs_options options; + @@ -20610,7 +23846,7 @@ + sb->s_op = &yaffs_super_ops; + sb->s_flags |= MS_NOATIME; + -+ readOnly =((sb->s_flags & MS_RDONLY) != 0); ++ read_only =((sb->s_flags & MS_RDONLY) != 0); + + +#ifdef YAFFS_COMPILE_EXPORTFS @@ -20627,7 +23863,7 @@ + printk(KERN_INFO "yaffs: dev is %d name is \"%s\" %s\n", + sb->s_dev, + yaffs_devname(sb, devname_buf), -+ readOnly ? "ro" : "rw"); ++ read_only ? "ro" : "rw"); + + if (!data_str) + data_str = ""; @@ -20646,7 +23882,7 @@ + sb->s_blocksize_bits = PAGE_CACHE_SHIFT; + + T(YAFFS_TRACE_OS, -+ (TSTR("yaffs_read_super: Using yaffs%d\n"), yaffsVersion)); ++ (TSTR("yaffs_read_super: Using yaffs%d\n"), yaffs_version)); + T(YAFFS_TRACE_OS, + (TSTR("yaffs_read_super: block size %d\n"), + (int)(sb->s_blocksize))); @@ -20694,22 +23930,22 @@ + +#ifdef CONFIG_YAFFS_AUTO_YAFFS2 + -+ if (yaffsVersion == 1 && WRITE_SIZE(mtd) >= 2048) { ++ if (yaffs_version == 1 && WRITE_SIZE(mtd) >= 2048) { + T(YAFFS_TRACE_ALWAYS, + (TSTR("yaffs: auto selecting yaffs2\n"))); -+ yaffsVersion = 2; ++ yaffs_version = 2; + } + + /* Added NCB 26/5/2006 for completeness */ -+ if (yaffsVersion == 2 && !options.inband_tags && WRITE_SIZE(mtd) == 512) { ++ if (yaffs_version == 2 && !options.inband_tags && WRITE_SIZE(mtd) == 512) { + T(YAFFS_TRACE_ALWAYS, + (TSTR("yaffs: auto selecting yaffs1\n"))); -+ yaffsVersion = 1; ++ yaffs_version = 1; + } + +#endif + -+ if (yaffsVersion == 2) { ++ if (yaffs_version == 2) { + /* Check for version 2 style functions */ + if (!mtd->erase || + !mtd->block_isbad || @@ -20764,16 +24000,16 @@ + + /* OK, so if we got here, we have an MTD that's NAND and looks + * like it has the right capabilities -+ * Set the yaffs_Device up for mtd ++ * Set the yaffs_dev_t up for mtd + */ + -+ if (!readOnly && !(mtd->flags & MTD_WRITEABLE)){ -+ readOnly = 1; ++ if (!read_only && !(mtd->flags & MTD_WRITEABLE)){ ++ read_only = 1; + printk(KERN_INFO "yaffs: mtd is read only, setting superblock read only"); + sb->s_flags |= MS_RDONLY; + } + -+ dev = kmalloc(sizeof(yaffs_Device), GFP_KERNEL); ++ dev = kmalloc(sizeof(yaffs_dev_t), GFP_KERNEL); + context = kmalloc(sizeof(struct yaffs_LinuxContext),GFP_KERNEL); + + if(!dev || !context ){ @@ -20789,19 +24025,19 @@ + /* Deep shit could not allocate device structure */ + T(YAFFS_TRACE_ALWAYS, + (TSTR("yaffs_read_super: Failed trying to allocate " -+ "yaffs_Device. \n"))); ++ "yaffs_dev_t. \n"))); + return NULL; + } -+ memset(dev, 0, sizeof(yaffs_Device)); ++ memset(dev, 0, sizeof(yaffs_dev_t)); + param = &(dev->param); + + memset(context,0,sizeof(struct yaffs_LinuxContext)); -+ dev->osContext = context; ++ dev->os_context = context; + YINIT_LIST_HEAD(&(context->contextList)); + context->dev = dev; + context->superBlock = sb; + -+ dev->readOnly = readOnly; ++ dev->read_only = read_only; + +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0)) + sb->s_fs_info = dev; @@ -20809,117 +24045,117 @@ + sb->u.generic_sbp = dev; +#endif + -+ dev->driverContext = mtd; ++ dev->driver_context = mtd; + param->name = mtd->name; + + /* Set up the memory size parameters.... */ + + nBlocks = YCALCBLOCKS(mtd->size, (YAFFS_CHUNKS_PER_BLOCK * YAFFS_BYTES_PER_CHUNK)); + -+ param->startBlock = 0; -+ param->endBlock = nBlocks - 1; -+ param->nChunksPerBlock = YAFFS_CHUNKS_PER_BLOCK; -+ param->totalBytesPerChunk = YAFFS_BYTES_PER_CHUNK; -+ param->nReservedBlocks = 5; -+ param->nShortOpCaches = (options.no_cache) ? 0 : 10; -+ param->inbandTags = options.inband_tags; ++ param->start_block = 0; ++ param->end_block = nBlocks - 1; ++ param->chunks_per_block = YAFFS_CHUNKS_PER_BLOCK; ++ param->total_bytes_per_chunk = YAFFS_BYTES_PER_CHUNK; ++ param->n_reserved_blocks = 5; ++ param->n_caches = (options.no_cache) ? 0 : 10; ++ param->inband_tags = options.inband_tags; + +#ifdef CONFIG_YAFFS_DISABLE_LAZY_LOAD -+ param->disableLazyLoad = 1; ++ param->disable_lazy_load = 1; +#endif +#ifdef CONFIG_YAFFS_XATTR -+ param->enableXattr = 1; ++ param->enable_xattr = 1; +#endif + if(options.lazy_loading_overridden) -+ param->disableLazyLoad = !options.lazy_loading_enabled; ++ param->disable_lazy_load = !options.lazy_loading_enabled; + +#ifdef CONFIG_YAFFS_DISABLE_TAGS_ECC -+ param->noTagsECC = 1; ++ param->no_tags_ecc = 1; +#endif + +#ifdef CONFIG_YAFFS_DISABLE_BACKGROUND +#else -+ param->deferDirectoryUpdate = 1; ++ param->defered_dir_update = 1; +#endif + + if(options.tags_ecc_overridden) -+ param->noTagsECC = !options.tags_ecc_on; ++ param->no_tags_ecc = !options.tags_ecc_on; + +#ifdef CONFIG_YAFFS_EMPTY_LOST_AND_FOUND -+ param->emptyLostAndFound = 1; ++ param->empty_lost_n_found = 1; +#endif + +#ifdef CONFIG_YAFFS_DISABLE_BLOCK_REFRESHING -+ param->refreshPeriod = 0; ++ param->refresh_period = 0; +#else -+ param->refreshPeriod = 500; ++ param->refresh_period = 500; +#endif + +#ifdef CONFIG_YAFFS__ALWAYS_CHECK_CHUNK_ERASED -+ param->alwaysCheckErased = 1; ++ param->always_check_erased = 1; +#endif + + if(options.empty_lost_and_found_overridden) -+ param->emptyLostAndFound = options.empty_lost_and_found; ++ param->empty_lost_n_found = options.empty_lost_and_found; + + /* ... and the functions. */ -+ if (yaffsVersion == 2) { -+ param->writeChunkWithTagsToNAND = ++ if (yaffs_version == 2) { ++ param->write_chunk_tags_fn = + nandmtd2_WriteChunkWithTagsToNAND; -+ param->readChunkWithTagsFromNAND = ++ param->read_chunk_tags_fn = + nandmtd2_ReadChunkWithTagsFromNAND; -+ param->markNANDBlockBad = nandmtd2_MarkNANDBlockBad; -+ param->queryNANDBlock = nandmtd2_QueryNANDBlock; -+ yaffs_DeviceToLC(dev)->spareBuffer = YMALLOC(mtd->oobsize); -+ param->isYaffs2 = 1; ++ param->bad_block_fn = nandmtd2_MarkNANDBlockBad; ++ param->query_block_fn = nandmtd2_QueryNANDBlock; ++ yaffs_dev_to_lc(dev)->spareBuffer = YMALLOC(mtd->oobsize); ++ param->is_yaffs2 = 1; +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17)) -+ param->totalBytesPerChunk = mtd->writesize; -+ param->nChunksPerBlock = mtd->erasesize / mtd->writesize; ++ param->total_bytes_per_chunk = mtd->writesize; ++ param->chunks_per_block = mtd->erasesize / mtd->writesize; +#else -+ param->totalBytesPerChunk = mtd->oobblock; -+ param->nChunksPerBlock = mtd->erasesize / mtd->oobblock; ++ param->total_bytes_per_chunk = mtd->oobblock; ++ param->chunks_per_block = mtd->erasesize / mtd->oobblock; +#endif + nBlocks = YCALCBLOCKS(mtd->size, mtd->erasesize); + -+ param->startBlock = 0; -+ param->endBlock = nBlocks - 1; ++ param->start_block = 0; ++ param->end_block = nBlocks - 1; + } else { +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17)) + /* use the MTD interface in yaffs_mtdif1.c */ -+ param->writeChunkWithTagsToNAND = ++ param->write_chunk_tags_fn = + nandmtd1_WriteChunkWithTagsToNAND; -+ param->readChunkWithTagsFromNAND = ++ param->read_chunk_tags_fn = + nandmtd1_ReadChunkWithTagsFromNAND; -+ param->markNANDBlockBad = nandmtd1_MarkNANDBlockBad; -+ param->queryNANDBlock = nandmtd1_QueryNANDBlock; ++ param->bad_block_fn = nandmtd1_MarkNANDBlockBad; ++ param->query_block_fn = nandmtd1_QueryNANDBlock; +#else -+ param->writeChunkToNAND = nandmtd_WriteChunkToNAND; -+ param->readChunkFromNAND = nandmtd_ReadChunkFromNAND; ++ param->write_chunk_fn = nandmtd_WriteChunkToNAND; ++ param->read_chunk_fn = nandmtd_ReadChunkFromNAND; +#endif -+ param->isYaffs2 = 0; ++ param->is_yaffs2 = 0; + } + /* ... and common functions */ -+ param->eraseBlockInNAND = nandmtd_EraseBlockInNAND; -+ param->initialiseNAND = nandmtd_InitialiseNAND; ++ param->erase_fn = nandmtd_EraseBlockInNAND; ++ param->initialise_flash_fn = nandmtd_InitialiseNAND; + -+ yaffs_DeviceToLC(dev)->putSuperFunc = yaffs_MTDPutSuper; ++ yaffs_dev_to_lc(dev)->putSuperFunc = yaffs_MTDPutSuper; + -+ param->markSuperBlockDirty = yaffs_MarkSuperBlockDirty; -+ param->gcControl = yaffs_gc_control_callback; ++ param->sb_dirty_fn = yaffs_touch_super; ++ param->gc_control = yaffs_gc_control_callback; + -+ yaffs_DeviceToLC(dev)->superBlock= sb; ++ yaffs_dev_to_lc(dev)->superBlock= sb; + + +#ifndef CONFIG_YAFFS_DOES_ECC -+ param->useNANDECC = 1; ++ param->use_nand_ecc = 1; +#endif + +#ifdef CONFIG_YAFFS_DISABLE_WIDE_TNODES -+ param->wideTnodesDisabled = 1; ++ param->wide_tnodes_disabled = 1; +#endif + -+ param->skipCheckpointRead = options.skip_checkpoint_read; -+ param->skipCheckpointWrite = options.skip_checkpoint_write; ++ param->skip_checkpt_rd = options.skip_checkpoint_read; ++ param->skip_checkpt_wr = options.skip_checkpoint_write; + + down(&yaffs_context_lock); + /* Get a mount id */ @@ -20934,37 +24170,37 @@ + } + context->mount_id = mount_id; + -+ ylist_add_tail(&(yaffs_DeviceToLC(dev)->contextList), &yaffs_context_list); ++ ylist_add_tail(&(yaffs_dev_to_lc(dev)->contextList), &yaffs_context_list); + up(&yaffs_context_lock); + + /* Directory search handling...*/ -+ YINIT_LIST_HEAD(&(yaffs_DeviceToLC(dev)->searchContexts)); -+ param->removeObjectCallback = yaffs_RemoveObjectCallback; ++ YINIT_LIST_HEAD(&(yaffs_dev_to_lc(dev)->searchContexts)); ++ param->remove_obj_fn = yaffs_remove_obj_callback; + -+ init_MUTEX(&(yaffs_DeviceToLC(dev)->grossLock)); ++ init_MUTEX(&(yaffs_dev_to_lc(dev)->grossLock)); + -+ yaffs_GrossLock(dev); ++ yaffs_gross_lock(dev); + -+ err = yaffs_GutsInitialise(dev); ++ err = yaffs_guts_initialise(dev); + + T(YAFFS_TRACE_OS, + (TSTR("yaffs_read_super: guts initialised %s\n"), + (err == YAFFS_OK) ? "OK" : "FAILED")); + + if(err == YAFFS_OK) -+ yaffs_BackgroundStart(dev); ++ yaffs_bg_start(dev); + + if(!context->bgThread) -+ param->deferDirectoryUpdate = 0; ++ param->defered_dir_update = 0; + + + /* Release lock before yaffs_get_inode() */ -+ yaffs_GrossUnlock(dev); ++ yaffs_gross_unlock(dev); + + /* Create root inode */ + if (err == YAFFS_OK) + inode = yaffs_get_inode(sb, S_IFDIR | 0755, 0, -+ yaffs_Root(dev)); ++ yaffs_root(dev)); + + if (!inode) + return NULL; @@ -20983,10 +24219,10 @@ + return NULL; + } + sb->s_root = root; -+ sb->s_dirt = !dev->isCheckpointed; ++ sb->s_dirt = !dev->is_checkpointed; + T(YAFFS_TRACE_ALWAYS, -+ (TSTR("yaffs_read_super: isCheckpointed %d\n"), -+ dev->isCheckpointed)); ++ (TSTR("yaffs_read_super: is_checkpointed %d\n"), ++ dev->is_checkpointed)); + + T(YAFFS_TRACE_OS, (TSTR("yaffs_read_super: done\n"))); + return sb; @@ -21090,21 +24326,21 @@ +static struct proc_dir_entry *my_proc_entry; +static struct proc_dir_entry *debug_proc_entry; + -+static char *yaffs_dump_dev_part0(char *buf, yaffs_Device * dev) -+{ -+ buf += sprintf(buf, "startBlock......... %d\n", dev->param.startBlock); -+ buf += sprintf(buf, "endBlock........... %d\n", dev->param.endBlock); -+ buf += sprintf(buf, "totalBytesPerChunk. %d\n", dev->param.totalBytesPerChunk); -+ buf += sprintf(buf, "useNANDECC......... %d\n", dev->param.useNANDECC); -+ buf += sprintf(buf, "noTagsECC.......... %d\n", dev->param.noTagsECC); -+ buf += sprintf(buf, "isYaffs2........... %d\n", dev->param.isYaffs2); -+ buf += sprintf(buf, "inbandTags......... %d\n", dev->param.inbandTags); -+ buf += sprintf(buf, "emptyLostAndFound.. %d\n", dev->param.emptyLostAndFound); -+ buf += sprintf(buf, "disableLazyLoad.... %d\n", dev->param.disableLazyLoad); -+ buf += sprintf(buf, "refreshPeriod...... %d\n", dev->param.refreshPeriod); -+ buf += sprintf(buf, "nShortOpCaches..... %d\n", dev->param.nShortOpCaches); -+ buf += sprintf(buf, "nReservedBlocks.... %d\n", dev->param.nReservedBlocks); -+ buf += sprintf(buf, "alwaysCheckErased.. %d\n", dev->param.alwaysCheckErased); ++static char *yaffs_dump_dev_part0(char *buf, yaffs_dev_t * dev) ++{ ++ buf += sprintf(buf, "start_block.......... %d\n", dev->param.start_block); ++ buf += sprintf(buf, "end_block............ %d\n", dev->param.end_block); ++ buf += sprintf(buf, "total_bytes_per_chunk %d\n", dev->param.total_bytes_per_chunk); ++ buf += sprintf(buf, "use_nand_ecc......... %d\n", dev->param.use_nand_ecc); ++ buf += sprintf(buf, "no_tags_ecc.......... %d\n", dev->param.no_tags_ecc); ++ buf += sprintf(buf, "is_yaffs2............ %d\n", dev->param.is_yaffs2); ++ buf += sprintf(buf, "inband_tags.......... %d\n", dev->param.inband_tags); ++ buf += sprintf(buf, "empty_lost_n_found... %d\n", dev->param.empty_lost_n_found); ++ buf += sprintf(buf, "disable_lazy_load.... %d\n", dev->param.disable_lazy_load); ++ buf += sprintf(buf, "refresh_period....... %d\n", dev->param.refresh_period); ++ buf += sprintf(buf, "n_caches............. %d\n", dev->param.n_caches); ++ buf += sprintf(buf, "n_reserved_blocks.... %d\n", dev->param.n_reserved_blocks); ++ buf += sprintf(buf, "always_check_erased.. %d\n", dev->param.always_check_erased); + + buf += sprintf(buf, "\n"); + @@ -21112,39 +24348,38 @@ +} + + -+static char *yaffs_dump_dev_part1(char *buf, yaffs_Device * dev) ++static char *yaffs_dump_dev_part1(char *buf, yaffs_dev_t * dev) +{ -+ buf += sprintf(buf, "nDataBytesPerChunk. %d\n", dev->nDataBytesPerChunk); -+ buf += sprintf(buf, "chunkGroupBits..... %d\n", dev->chunkGroupBits); -+ buf += sprintf(buf, "chunkGroupSize..... %d\n", dev->chunkGroupSize); -+ buf += sprintf(buf, "nErasedBlocks...... %d\n", dev->nErasedBlocks); -+ buf += sprintf(buf, "blocksInCheckpoint. %d\n", dev->blocksInCheckpoint); ++ buf += sprintf(buf, "data_bytes_per_chunk. %d\n", dev->data_bytes_per_chunk); ++ buf += sprintf(buf, "chunk_grp_bits....... %d\n", dev->chunk_grp_bits); ++ buf += sprintf(buf, "chunk_grp_size....... %d\n", dev->chunk_grp_size); ++ buf += sprintf(buf, "n_erased_blocks...... %d\n", dev->n_erased_blocks); ++ buf += sprintf(buf, "blocks_in_checkpt.... %d\n", dev->blocks_in_checkpt); + buf += sprintf(buf, "\n"); -+ buf += sprintf(buf, "nTnodes............ %d\n", dev->nTnodes); -+ buf += sprintf(buf, "nObjects........... %d\n", dev->nObjects); -+ buf += sprintf(buf, "nFreeChunks........ %d\n", dev->nFreeChunks); ++ buf += sprintf(buf, "n_tnodes............. %d\n", dev->n_tnodes); ++ buf += sprintf(buf, "n_obj................ %d\n", dev->n_obj); ++ buf += sprintf(buf, "n_free_chunks........ %d\n", dev->n_free_chunks); + buf += sprintf(buf, "\n"); -+ buf += sprintf(buf, "nPageWrites........ %u\n", dev->nPageWrites); -+ buf += sprintf(buf, "nPageReads......... %u\n", dev->nPageReads); -+ buf += sprintf(buf, "nBlockErasures..... %u\n", dev->nBlockErasures); -+ buf += sprintf(buf, "nGCCopies.......... %u\n", dev->nGCCopies); -+ buf += sprintf(buf, "allGCs............. %u\n", dev->allGCs); -+ buf += sprintf(buf, "passiveGCs......... %u\n", dev->passiveGCs); -+ buf += sprintf(buf, "oldestDirtyGCs..... %u\n", dev->oldestDirtyGCs); -+ buf += sprintf(buf, "nGCBlocks.......... %u\n", dev->nGCBlocks); -+ buf += sprintf(buf, "backgroundGCs...... %u\n", dev->backgroundGCs); -+ buf += sprintf(buf, "nRetriedWrites..... %u\n", dev->nRetriedWrites); -+ buf += sprintf(buf, "nRetireBlocks...... %u\n", dev->nRetiredBlocks); -+ buf += sprintf(buf, "eccFixed........... %u\n", dev->eccFixed); -+ buf += sprintf(buf, "eccUnfixed......... %u\n", dev->eccUnfixed); -+ buf += sprintf(buf, "tagsEccFixed....... %u\n", dev->tagsEccFixed); -+ buf += sprintf(buf, "tagsEccUnfixed..... %u\n", dev->tagsEccUnfixed); -+ buf += sprintf(buf, "cacheHits.......... %u\n", dev->cacheHits); -+ buf += sprintf(buf, "nDeletedFiles...... %u\n", dev->nDeletedFiles); -+ buf += sprintf(buf, "nUnlinkedFiles..... %u\n", dev->nUnlinkedFiles); -+ buf += sprintf(buf, "refreshCount....... %u\n", dev->refreshCount); -+ buf += -+ sprintf(buf, "nBackgroudDeletions %u\n", dev->nBackgroundDeletions); ++ buf += sprintf(buf, "n_page_writes........ %u\n", dev->n_page_writes); ++ buf += sprintf(buf, "n_page_reads......... %u\n", dev->n_page_reads); ++ buf += sprintf(buf, "n_erasures........... %u\n", dev->n_erasures); ++ buf += sprintf(buf, "n_gc_copies.......... %u\n", dev->n_gc_copies); ++ buf += sprintf(buf, "all_gcs.............. %u\n", dev->all_gcs); ++ buf += sprintf(buf, "passive_gc_count..... %u\n", dev->passive_gc_count); ++ buf += sprintf(buf, "oldest_dirty_gc_count %u\n", dev->oldest_dirty_gc_count); ++ buf += sprintf(buf, "n_gc_blocks.......... %u\n", dev->n_gc_blocks); ++ buf += sprintf(buf, "bg_gcs............... %u\n", dev->bg_gcs); ++ buf += sprintf(buf, "n_retired_writes..... %u\n", dev->n_retired_writes); ++ buf += sprintf(buf, "nRetireBlocks........ %u\n", dev->n_retired_blocks); ++ buf += sprintf(buf, "n_ecc_fixed.......... %u\n", dev->n_ecc_fixed); ++ buf += sprintf(buf, "n_ecc_unfixed........ %u\n", dev->n_ecc_unfixed); ++ buf += sprintf(buf, "n_tags_ecc_fixed..... %u\n", dev->n_tags_ecc_fixed); ++ buf += sprintf(buf, "n_tags_ecc_unfixed... %u\n", dev->n_tags_ecc_unfixed); ++ buf += sprintf(buf, "cache_hits........... %u\n", dev->cache_hits); ++ buf += sprintf(buf, "n_deleted_files...... %u\n", dev->n_deleted_files); ++ buf += sprintf(buf, "n_unlinked_files..... %u\n", dev->n_unlinked_files); ++ buf += sprintf(buf, "refresh_count........ %u\n", dev->refresh_count); ++ buf += sprintf(buf, "n_bg_deletions....... %u\n", dev->n_bg_deletions); + + return buf; +} @@ -21159,7 +24394,7 @@ + int n = 0; + + /* Get proc_file_read() to step 'offset' by one on each sucessive call. -+ * We use 'offset' (*ppos) to indicate where we are in devList. ++ * We use 'offset' (*ppos) to indicate where we are in dev_list. + * This also assumes the user has posted a read buffer large + * enough to hold the complete output; but that's life in /proc. + */ @@ -21179,7 +24414,7 @@ + /* Locate and print the Nth entry. Order N-squared but N is small. */ + ylist_for_each(item, &yaffs_context_list) { + struct yaffs_LinuxContext *dc = ylist_entry(item, struct yaffs_LinuxContext, contextList); -+ yaffs_Device *dev = dc->dev; ++ yaffs_dev_t *dev = dc->dev; + + if (n < (step & ~1)) { + n+=2; @@ -21212,16 +24447,16 @@ + /* Locate and print the Nth entry. Order N-squared but N is small. */ + ylist_for_each(item, &yaffs_context_list) { + struct yaffs_LinuxContext *dc = ylist_entry(item, struct yaffs_LinuxContext, contextList); -+ yaffs_Device *dev = dc->dev; ++ yaffs_dev_t *dev = dc->dev; + + int erasedChunks; + -+ erasedChunks = dev->nErasedBlocks * dev->param.nChunksPerBlock; ++ erasedChunks = dev->n_erased_blocks * dev->param.chunks_per_block; + + buf += sprintf(buf,"%d, %d, %d, %u, %u, %u, %u\n", -+ n, dev->nFreeChunks, erasedChunks, -+ dev->backgroundGCs, dev->oldestDirtyGCs, -+ dev->nObjects, dev->nTnodes); ++ n, dev->n_free_chunks, erasedChunks, ++ dev->bg_gcs, dev->oldest_dirty_gc_count, ++ dev->n_obj, dev->n_tnodes); + } + up(&yaffs_context_lock); + @@ -21285,7 +24520,7 @@ + int add, len = 0; + int pos = 0; + -+ rg = yaffs_traceMask; ++ rg = yaffs_trace_mask; + + while (!done && (pos < count)) { + done = 1; @@ -21349,9 +24584,9 @@ + } + } + -+ yaffs_traceMask = rg | YAFFS_TRACE_ALWAYS; ++ yaffs_trace_mask = rg | YAFFS_TRACE_ALWAYS; + -+ printk(KERN_DEBUG "new trace = 0x%08X\n", yaffs_traceMask); ++ printk(KERN_DEBUG "new trace = 0x%08X\n", yaffs_trace_mask); + + if (rg & YAFFS_TRACE_ALWAYS) { + for (i = 0; mask_flags[i].mask_name != NULL; i++) { @@ -21480,8 +24715,9 @@ +MODULE_DESCRIPTION("YAFFS2 - a NAND specific flash file system"); +MODULE_AUTHOR("Charles Manning, Aleph One Ltd., 2002-2010"); +MODULE_LICENSE("GPL"); ---- /dev/null -+++ b/fs/yaffs2/yaffs_yaffs1.c +diff -Nrup linux-2.6.36-rc8/fs/yaffs2/yaffs_yaffs1.c linux-2.6.36-rc8.new/fs/yaffs2/yaffs_yaffs1.c +--- linux-2.6.36-rc8/fs/yaffs2/yaffs_yaffs1.c 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.36-rc8.new/fs/yaffs2/yaffs_yaffs1.c 2010-10-20 13:28:16.039000295 +0300 @@ -0,0 +1,465 @@ +/* + * YAFFS: Yet Another Flash File System. A NAND-flash specific file system. @@ -21503,9 +24739,9 @@ +#include "yaffs_nand.h" + + -+int yaffs1_Scan(yaffs_Device *dev) ++int yaffs1_scan(yaffs_dev_t *dev) +{ -+ yaffs_ExtendedTags tags; ++ yaffs_ext_tags tags; + int blk; + int blockIterator; + int startIterator; @@ -21515,17 +24751,17 @@ + int chunk; + int c; + int deleted; -+ yaffs_BlockState state; -+ yaffs_Object *hardList = NULL; -+ yaffs_BlockInfo *bi; -+ __u32 sequenceNumber; -+ yaffs_ObjectHeader *oh; -+ yaffs_Object *in; -+ yaffs_Object *parent; ++ yaffs_block_state_t state; ++ yaffs_obj_t *hard_list = NULL; ++ yaffs_block_info_t *bi; ++ __u32 seq_number; ++ yaffs_obj_header *oh; ++ yaffs_obj_t *in; ++ yaffs_obj_t *parent; + + int alloc_failed = 0; + -+ struct yaffs_ShadowFixerStruct *shadowFixerList = NULL; ++ struct yaffs_shadow_fixer_s *shadowFixerList = NULL; + + + __u8 *chunkData; @@ -21533,31 +24769,31 @@ + + + T(YAFFS_TRACE_SCAN, -+ (TSTR("yaffs1_Scan starts intstartblk %d intendblk %d..." TENDSTR), -+ dev->internalStartBlock, dev->internalEndBlock)); ++ (TSTR("yaffs1_scan starts intstartblk %d intendblk %d..." TENDSTR), ++ dev->internal_start_block, dev->internal_end_block)); + -+ chunkData = yaffs_GetTempBuffer(dev, __LINE__); ++ chunkData = yaffs_get_temp_buffer(dev, __LINE__); + -+ dev->sequenceNumber = YAFFS_LOWEST_SEQUENCE_NUMBER; ++ dev->seq_number = YAFFS_LOWEST_SEQUENCE_NUMBER; + + /* Scan all the blocks to determine their state */ -+ bi = dev->blockInfo; -+ for (blk = dev->internalStartBlock; blk <= dev->internalEndBlock; blk++) { -+ yaffs_ClearChunkBits(dev, blk); -+ bi->pagesInUse = 0; -+ bi->softDeletions = 0; ++ bi = dev->block_info; ++ for (blk = dev->internal_start_block; blk <= dev->internal_end_block; blk++) { ++ yaffs_clear_chunk_bits(dev, blk); ++ bi->pages_in_use = 0; ++ bi->soft_del_pages = 0; + -+ yaffs_QueryInitialBlockState(dev, blk, &state, &sequenceNumber); ++ yaffs_query_init_block_state(dev, blk, &state, &seq_number); + -+ bi->blockState = state; -+ bi->sequenceNumber = sequenceNumber; ++ bi->block_state = state; ++ bi->seq_number = seq_number; + -+ if (bi->sequenceNumber == YAFFS_SEQUENCE_BAD_BLOCK) -+ bi->blockState = state = YAFFS_BLOCK_STATE_DEAD; ++ if (bi->seq_number == YAFFS_SEQUENCE_BAD_BLOCK) ++ bi->block_state = state = YAFFS_BLOCK_STATE_DEAD; + + T(YAFFS_TRACE_SCAN_DEBUG, + (TSTR("Block scanning block %d state %d seq %d" TENDSTR), blk, -+ state, sequenceNumber)); ++ state, seq_number)); + + if (state == YAFFS_BLOCK_STATE_DEAD) { + T(YAFFS_TRACE_BAD_BLOCKS, @@ -21565,14 +24801,14 @@ + } else if (state == YAFFS_BLOCK_STATE_EMPTY) { + T(YAFFS_TRACE_SCAN_DEBUG, + (TSTR("Block empty " TENDSTR))); -+ dev->nErasedBlocks++; -+ dev->nFreeChunks += dev->param.nChunksPerBlock; ++ dev->n_erased_blocks++; ++ dev->n_free_chunks += dev->param.chunks_per_block; + } + bi++; + } + -+ startIterator = dev->internalStartBlock; -+ endIterator = dev->internalEndBlock; ++ startIterator = dev->internal_start_block; ++ endIterator = dev->internal_end_block; + + /* For each block.... */ + for (blockIterator = startIterator; !alloc_failed && blockIterator <= endIterator; @@ -21584,30 +24820,30 @@ + + blk = blockIterator; + -+ bi = yaffs_GetBlockInfo(dev, blk); -+ state = bi->blockState; ++ bi = yaffs_get_block_info(dev, blk); ++ state = bi->block_state; + + deleted = 0; + + /* For each chunk in each block that needs scanning....*/ -+ for (c = 0; !alloc_failed && c < dev->param.nChunksPerBlock && ++ for (c = 0; !alloc_failed && c < dev->param.chunks_per_block && + state == YAFFS_BLOCK_STATE_NEEDS_SCANNING; c++) { + /* Read the tags and decide what to do */ -+ chunk = blk * dev->param.nChunksPerBlock + c; ++ chunk = blk * dev->param.chunks_per_block + c; + -+ result = yaffs_ReadChunkWithTagsFromNAND(dev, chunk, NULL, ++ result = yaffs_rd_chunk_tags_nand(dev, chunk, NULL, + &tags); + + /* Let's have a good look at this chunk... */ + -+ if (tags.eccResult == YAFFS_ECC_RESULT_UNFIXED || tags.chunkDeleted) { ++ if (tags.ecc_result == YAFFS_ECC_RESULT_UNFIXED || tags.is_deleted) { + /* YAFFS1 only... + * A deleted chunk + */ + deleted++; -+ dev->nFreeChunks++; ++ dev->n_free_chunks++; + /*T((" %d %d deleted\n",blk,c)); */ -+ } else if (!tags.chunkUsed) { ++ } else if (!tags.chunk_used) { + /* An unassigned chunk in the block + * This means that either the block is empty or + * this is the one being allocated from @@ -21616,7 +24852,7 @@ + if (c == 0) { + /* We're looking at the first chunk in the block so the block is unused */ + state = YAFFS_BLOCK_STATE_EMPTY; -+ dev->nErasedBlocks++; ++ dev->n_erased_blocks++; + } else { + /* this is the block being allocated from */ + T(YAFFS_TRACE_SCAN, @@ -21624,102 +24860,102 @@ + (" Allocating from %d %d" TENDSTR), + blk, c)); + state = YAFFS_BLOCK_STATE_ALLOCATING; -+ dev->allocationBlock = blk; -+ dev->allocationPage = c; -+ dev->allocationBlockFinder = blk; ++ dev->alloc_block = blk; ++ dev->alloc_page = c; ++ dev->alloc_block_finder = blk; + /* Set block finder here to encourage the allocator to go forth from here. */ + + } + -+ dev->nFreeChunks += (dev->param.nChunksPerBlock - c); -+ } else if (tags.chunkId > 0) { -+ /* chunkId > 0 so it is a data chunk... */ ++ dev->n_free_chunks += (dev->param.chunks_per_block - c); ++ } else if (tags.chunk_id > 0) { ++ /* chunk_id > 0 so it is a data chunk... */ + unsigned int endpos; + -+ yaffs_SetChunkBit(dev, blk, c); -+ bi->pagesInUse++; ++ yaffs_set_chunk_bit(dev, blk, c); ++ bi->pages_in_use++; + -+ in = yaffs_FindOrCreateObjectByNumber(dev, ++ in = yaffs_find_or_create_by_number(dev, + tags. -+ objectId, ++ obj_id, + YAFFS_OBJECT_TYPE_FILE); + /* PutChunkIntoFile checks for a clash (two data chunks with -+ * the same chunkId). ++ * the same chunk_id). + */ + + if (!in) + alloc_failed = 1; + + if (in) { -+ if (!yaffs_PutChunkIntoFile(in, tags.chunkId, chunk, 1)) ++ if (!yaffs_put_chunk_in_file(in, tags.chunk_id, chunk, 1)) + alloc_failed = 1; + } + + endpos = -+ (tags.chunkId - 1) * dev->nDataBytesPerChunk + -+ tags.byteCount; ++ (tags.chunk_id - 1) * dev->data_bytes_per_chunk + ++ tags.n_bytes; + if (in && -+ in->variantType == YAFFS_OBJECT_TYPE_FILE -+ && in->variant.fileVariant.scannedFileSize < ++ in->variant_type == YAFFS_OBJECT_TYPE_FILE ++ && in->variant.file_variant.scanned_size < + endpos) { -+ in->variant.fileVariant. -+ scannedFileSize = endpos; -+ if (!dev->param.useHeaderFileSize) { -+ in->variant.fileVariant. -+ fileSize = -+ in->variant.fileVariant. -+ scannedFileSize; ++ in->variant.file_variant. ++ scanned_size = endpos; ++ if (!dev->param.use_header_file_size) { ++ in->variant.file_variant. ++ file_size = ++ in->variant.file_variant. ++ scanned_size; + } + + } -+ /* T((" %d %d data %d %d\n",blk,c,tags.objectId,tags.chunkId)); */ ++ /* T((" %d %d data %d %d\n",blk,c,tags.obj_id,tags.chunk_id)); */ + } else { -+ /* chunkId == 0, so it is an ObjectHeader. ++ /* chunk_id == 0, so it is an ObjectHeader. + * Thus, we read in the object header and make the object + */ -+ yaffs_SetChunkBit(dev, blk, c); -+ bi->pagesInUse++; ++ yaffs_set_chunk_bit(dev, blk, c); ++ bi->pages_in_use++; + -+ result = yaffs_ReadChunkWithTagsFromNAND(dev, chunk, ++ result = yaffs_rd_chunk_tags_nand(dev, chunk, + chunkData, + NULL); + -+ oh = (yaffs_ObjectHeader *) chunkData; ++ oh = (yaffs_obj_header *) chunkData; + -+ in = yaffs_FindObjectByNumber(dev, -+ tags.objectId); -+ if (in && in->variantType != oh->type) { ++ in = yaffs_find_by_number(dev, ++ tags.obj_id); ++ if (in && in->variant_type != oh->type) { + /* This should not happen, but somehow -+ * Wev'e ended up with an objectId that has been reused but not yet ++ * Wev'e ended up with an obj_id that has been reused but not yet + * deleted, and worse still it has changed type. Delete the old object. + */ + -+ yaffs_DeleteObject(in); ++ yaffs_del_obj(in); + + in = 0; + } + -+ in = yaffs_FindOrCreateObjectByNumber(dev, ++ in = yaffs_find_or_create_by_number(dev, + tags. -+ objectId, ++ obj_id, + oh->type); + + if (!in) + alloc_failed = 1; + -+ if (in && oh->shadowsObject > 0) { ++ if (in && oh->shadows_obj > 0) { + -+ struct yaffs_ShadowFixerStruct *fixer; -+ fixer = YMALLOC(sizeof(struct yaffs_ShadowFixerStruct)); ++ struct yaffs_shadow_fixer_s *fixer; ++ fixer = YMALLOC(sizeof(struct yaffs_shadow_fixer_s)); + if (fixer) { + fixer->next = shadowFixerList; + shadowFixerList = fixer; -+ fixer->objectId = tags.objectId; -+ fixer->shadowedId = oh->shadowsObject; ++ fixer->obj_id = tags.obj_id; ++ fixer->shadowed_id = oh->shadows_obj; + T(YAFFS_TRACE_SCAN, + (TSTR + (" Shadow fixer: %d shadows %d" TENDSTR), -+ fixer->objectId, fixer->shadowedId)); ++ fixer->obj_id, fixer->shadowed_id)); + + } + @@ -21729,27 +24965,27 @@ + /* We have already filled this one. We have a duplicate and need to resolve it. */ + + unsigned existingSerial = in->serial; -+ unsigned newSerial = tags.serialNumber; ++ unsigned newSerial = tags.serial_number; + + if (((existingSerial + 1) & 3) == newSerial) { + /* Use new one - destroy the exisiting one */ -+ yaffs_DeleteChunk(dev, -+ in->hdrChunk, ++ yaffs_chunk_del(dev, ++ in->hdr_chunk, + 1, __LINE__); + in->valid = 0; + } else { + /* Use existing - destroy this one. */ -+ yaffs_DeleteChunk(dev, chunk, 1, ++ yaffs_chunk_del(dev, chunk, 1, + __LINE__); + } + } + + if (in && !in->valid && -+ (tags.objectId == YAFFS_OBJECTID_ROOT || -+ tags.objectId == YAFFS_OBJECTID_LOSTNFOUND)) { ++ (tags.obj_id == YAFFS_OBJECTID_ROOT || ++ tags.obj_id == YAFFS_OBJECTID_LOSTNFOUND)) { + /* We only load some info, don't fiddle with directory structure */ + in->valid = 1; -+ in->variantType = oh->type; ++ in->variant_type = oh->type; + + in->yst_mode = oh->yst_mode; +#ifdef CONFIG_YAFFS_WINCE @@ -21767,14 +25003,14 @@ + in->yst_ctime = oh->yst_ctime; + in->yst_rdev = oh->yst_rdev; +#endif -+ in->hdrChunk = chunk; -+ in->serial = tags.serialNumber; ++ in->hdr_chunk = chunk; ++ in->serial = tags.serial_number; + + } else if (in && !in->valid) { + /* we need to load this info */ + + in->valid = 1; -+ in->variantType = oh->type; ++ in->variant_type = oh->type; + + in->yst_mode = oh->yst_mode; +#ifdef CONFIG_YAFFS_WINCE @@ -21792,10 +25028,10 @@ + in->yst_ctime = oh->yst_ctime; + in->yst_rdev = oh->yst_rdev; +#endif -+ in->hdrChunk = chunk; -+ in->serial = tags.serialNumber; ++ in->hdr_chunk = chunk; ++ in->serial = tags.serial_number; + -+ yaffs_SetObjectNameFromOH(in, oh); ++ yaffs_set_obj_name_from_oh(in, oh); + in->dirty = 0; + + /* directory stuff... @@ -21803,20 +25039,20 @@ + */ + + parent = -+ yaffs_FindOrCreateObjectByNumber -+ (dev, oh->parentObjectId, ++ yaffs_find_or_create_by_number ++ (dev, oh->parent_obj_id, + YAFFS_OBJECT_TYPE_DIRECTORY); + if (!parent) + alloc_failed = 1; -+ if (parent && parent->variantType == ++ if (parent && parent->variant_type == + YAFFS_OBJECT_TYPE_UNKNOWN) { + /* Set up as a directory */ -+ parent->variantType = ++ parent->variant_type = + YAFFS_OBJECT_TYPE_DIRECTORY; + YINIT_LIST_HEAD(&parent->variant. -+ directoryVariant. ++ dir_variant. + children); -+ } else if (!parent || parent->variantType != ++ } else if (!parent || parent->variant_type != + YAFFS_OBJECT_TYPE_DIRECTORY) { + /* Hoosterman, another problem.... + * We're trying to use a non-directory as a directory @@ -21826,15 +25062,15 @@ + (TSTR + ("yaffs tragedy: attempting to use non-directory as a directory in scan. Put in lost+found." + TENDSTR))); -+ parent = dev->lostNFoundDir; ++ parent = dev->lost_n_found; + } + -+ yaffs_AddObjectToDirectory(parent, in); ++ yaffs_add_obj_to_dir(parent, in); + -+ if (0 && (parent == dev->deletedDir || -+ parent == dev->unlinkedDir)) { ++ if (0 && (parent == dev->del_dir || ++ parent == dev->unlinked_dir)) { + in->deleted = 1; /* If it is unlinked at start up then it wants deleting */ -+ dev->nDeletedFiles++; ++ dev->n_deleted_files++; + } + /* Note re hardlinks. + * Since we might scan a hardlink before its equivalent object is scanned @@ -21843,26 +25079,26 @@ + * list and fix up all the chains. + */ + -+ switch (in->variantType) { ++ switch (in->variant_type) { + case YAFFS_OBJECT_TYPE_UNKNOWN: + /* Todo got a problem */ + break; + case YAFFS_OBJECT_TYPE_FILE: -+ if (dev->param.useHeaderFileSize) ++ if (dev->param.use_header_file_size) + -+ in->variant.fileVariant. -+ fileSize = -+ oh->fileSize; ++ in->variant.file_variant. ++ file_size = ++ oh->file_size; + + break; + case YAFFS_OBJECT_TYPE_HARDLINK: -+ in->variant.hardLinkVariant. -+ equivalentObjectId = -+ oh->equivalentObjectId; -+ in->hardLinks.next = ++ in->variant.hardlink_variant. ++ equiv_id = ++ oh->equiv_id; ++ in->hard_links.next = + (struct ylist_head *) -+ hardList; -+ hardList = in; ++ hard_list; ++ hard_list = in; + break; + case YAFFS_OBJECT_TYPE_DIRECTORY: + /* Do nothing */ @@ -21871,9 +25107,9 @@ + /* Do nothing */ + break; + case YAFFS_OBJECT_TYPE_SYMLINK: -+ in->variant.symLinkVariant.alias = -+ yaffs_CloneString(oh->alias); -+ if (!in->variant.symLinkVariant.alias) ++ in->variant.symlink_variant.alias = ++ yaffs_clone_str(oh->alias); ++ if (!in->variant.symlink_variant.alias) + alloc_failed = 1; + break; + } @@ -21890,16 +25126,16 @@ + if (state == YAFFS_BLOCK_STATE_ALLOCATING) { + /* If the block was partially allocated then treat it as fully allocated.*/ + state = YAFFS_BLOCK_STATE_FULL; -+ dev->allocationBlock = -1; ++ dev->alloc_block = -1; + } + -+ bi->blockState = state; ++ bi->block_state = state; + + /* Now let's see if it was dirty */ -+ if (bi->pagesInUse == 0 && -+ !bi->hasShrinkHeader && -+ bi->blockState == YAFFS_BLOCK_STATE_FULL) { -+ yaffs_BlockBecameDirty(dev, blk); ++ if (bi->pages_in_use == 0 && ++ !bi->has_shrink_hdr && ++ bi->block_state == YAFFS_BLOCK_STATE_FULL) { ++ yaffs_block_became_dirty(dev, blk); + } + + } @@ -21911,12 +25147,12 @@ + * hardlinks. + */ + -+ yaffs_HardlinkFixup(dev, hardList); ++ yaffs_link_fixup(dev, hard_list); + + /* Fix up any shadowed objects */ + { -+ struct yaffs_ShadowFixerStruct *fixer; -+ yaffs_Object *obj; ++ struct yaffs_shadow_fixer_s *fixer; ++ yaffs_obj_t *obj; + + while (shadowFixerList) { + fixer = shadowFixerList; @@ -21924,32 +25160,33 @@ + /* Complete the rename transaction by deleting the shadowed object + * then setting the object header to unshadowed. + */ -+ obj = yaffs_FindObjectByNumber(dev, fixer->shadowedId); ++ obj = yaffs_find_by_number(dev, fixer->shadowed_id); + if (obj) -+ yaffs_DeleteObject(obj); ++ yaffs_del_obj(obj); + -+ obj = yaffs_FindObjectByNumber(dev, fixer->objectId); ++ obj = yaffs_find_by_number(dev, fixer->obj_id); + + if (obj) -+ yaffs_UpdateObjectHeader(obj, NULL, 1, 0, 0, NULL); ++ yaffs_update_oh(obj, NULL, 1, 0, 0, NULL); + + YFREE(fixer); + } + } + -+ yaffs_ReleaseTempBuffer(dev, chunkData, __LINE__); ++ yaffs_release_temp_buffer(dev, chunkData, __LINE__); + + if (alloc_failed) + return YAFFS_FAIL; + -+ T(YAFFS_TRACE_SCAN, (TSTR("yaffs1_Scan ends" TENDSTR))); ++ T(YAFFS_TRACE_SCAN, (TSTR("yaffs1_scan ends" TENDSTR))); + + + return YAFFS_OK; +} + ---- /dev/null -+++ b/fs/yaffs2/yaffs_yaffs1.h +diff -Nrup linux-2.6.36-rc8/fs/yaffs2/yaffs_yaffs1.h linux-2.6.36-rc8.new/fs/yaffs2/yaffs_yaffs1.h +--- linux-2.6.36-rc8/fs/yaffs2/yaffs_yaffs1.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.36-rc8.new/fs/yaffs2/yaffs_yaffs1.h 2010-10-20 13:28:16.064000294 +0300 @@ -0,0 +1,22 @@ +/* + * YAFFS: Yet another Flash File System . A NAND-flash specific file system. @@ -21970,11 +25207,12 @@ +#define __YAFFS_YAFFS1_H__ + +#include "yaffs_guts.h" -+int yaffs1_Scan(yaffs_Device *dev); ++int yaffs1_scan(yaffs_dev_t *dev); + +#endif ---- /dev/null -+++ b/fs/yaffs2/yaffs_yaffs2.c +diff -Nrup linux-2.6.36-rc8/fs/yaffs2/yaffs_yaffs2.c linux-2.6.36-rc8.new/fs/yaffs2/yaffs_yaffs2.c +--- linux-2.6.36-rc8/fs/yaffs2/yaffs_yaffs2.c 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.36-rc8.new/fs/yaffs2/yaffs_yaffs2.c 2010-10-20 13:28:16.050000294 +0300 @@ -0,0 +1,1540 @@ +/* + * YAFFS: Yet Another Flash File System. A NAND-flash specific file system. @@ -22015,134 +25253,134 @@ + * Oldest Dirty Sequence Number handling. + */ + -+/* yaffs2_CalcOldestDirtySequence() -+ * yaffs2_FindOldestDirtySequence() ++/* yaffs_calc_oldest_dirty_seq() ++ * yaffs2_find_oldest_dirty_seq() + * Calculate the oldest dirty sequence number if we don't know it. + */ -+void yaffs2_CalcOldestDirtySequence(yaffs_Device *dev) ++void yaffs_calc_oldest_dirty_seq(yaffs_dev_t *dev) +{ + int i; + unsigned seq; -+ unsigned blockNo = 0; -+ yaffs_BlockInfo *b; ++ unsigned block_no = 0; ++ yaffs_block_info_t *b; + -+ if(!dev->param.isYaffs2) ++ if(!dev->param.is_yaffs2) + return; + + /* Find the oldest dirty sequence number. */ -+ seq = dev->sequenceNumber + 1; -+ b = dev->blockInfo; -+ for (i = dev->internalStartBlock; i <= dev->internalEndBlock; i++) { -+ if (b->blockState == YAFFS_BLOCK_STATE_FULL && -+ (b->pagesInUse - b->softDeletions) < dev->param.nChunksPerBlock && -+ b->sequenceNumber < seq) { -+ seq = b->sequenceNumber; -+ blockNo = i; ++ seq = dev->seq_number + 1; ++ b = dev->block_info; ++ for (i = dev->internal_start_block; i <= dev->internal_end_block; i++) { ++ if (b->block_state == YAFFS_BLOCK_STATE_FULL && ++ (b->pages_in_use - b->soft_del_pages) < dev->param.chunks_per_block && ++ b->seq_number < seq) { ++ seq = b->seq_number; ++ block_no = i; + } + b++; + } + -+ if(blockNo){ -+ dev->oldestDirtySequence = seq; -+ dev->oldestDirtyBlock = blockNo; ++ if(block_no){ ++ dev->oldest_dirty_seq = seq; ++ dev->oldest_dirty_block = block_no; + } + +} + + -+void yaffs2_FindOldestDirtySequence(yaffs_Device *dev) ++void yaffs2_find_oldest_dirty_seq(yaffs_dev_t *dev) +{ -+ if(!dev->param.isYaffs2) ++ if(!dev->param.is_yaffs2) + return; + -+ if(!dev->oldestDirtySequence) -+ yaffs2_CalcOldestDirtySequence(dev); ++ if(!dev->oldest_dirty_seq) ++ yaffs_calc_oldest_dirty_seq(dev); +} + +/* -+ * yaffs_ClearOldestDirtySequence() -+ * Called when a block is erased or marked bad. (ie. when its sequenceNumber ++ * yaffs_clear_oldest_dirty_seq() ++ * Called when a block is erased or marked bad. (ie. when its seq_number + * becomes invalid). If the value matches the oldest then we clear -+ * dev->oldestDirtySequence to force its recomputation. ++ * dev->oldest_dirty_seq to force its recomputation. + */ -+void yaffs2_ClearOldestDirtySequence(yaffs_Device *dev, yaffs_BlockInfo *bi) ++void yaffs2_clear_oldest_dirty_seq(yaffs_dev_t *dev, yaffs_block_info_t *bi) +{ + -+ if(!dev->param.isYaffs2) ++ if(!dev->param.is_yaffs2) + return; + -+ if(!bi || bi->sequenceNumber == dev->oldestDirtySequence){ -+ dev->oldestDirtySequence = 0; -+ dev->oldestDirtyBlock = 0; ++ if(!bi || bi->seq_number == dev->oldest_dirty_seq){ ++ dev->oldest_dirty_seq = 0; ++ dev->oldest_dirty_block = 0; + } +} + +/* -+ * yaffs2_UpdateOldestDirtySequence() ++ * yaffs2_update_oldest_dirty_seq() + * Update the oldest dirty sequence number whenever we dirty a block. -+ * Only do this if the oldestDirtySequence is actually being tracked. ++ * Only do this if the oldest_dirty_seq is actually being tracked. + */ -+void yaffs2_UpdateOldestDirtySequence(yaffs_Device *dev, unsigned blockNo, yaffs_BlockInfo *bi) ++void yaffs2_update_oldest_dirty_seq(yaffs_dev_t *dev, unsigned block_no, yaffs_block_info_t *bi) +{ -+ if(!dev->param.isYaffs2) ++ if(!dev->param.is_yaffs2) + return; + -+ if(dev->oldestDirtySequence){ -+ if(dev->oldestDirtySequence > bi->sequenceNumber){ -+ dev->oldestDirtySequence = bi->sequenceNumber; -+ dev->oldestDirtyBlock = blockNo; ++ if(dev->oldest_dirty_seq){ ++ if(dev->oldest_dirty_seq > bi->seq_number){ ++ dev->oldest_dirty_seq = bi->seq_number; ++ dev->oldest_dirty_block = block_no; + } + } +} + -+int yaffs2_BlockNotDisqualifiedFromGC(yaffs_Device *dev, -+ yaffs_BlockInfo *bi) ++int yaffs_block_ok_for_gc(yaffs_dev_t *dev, ++ yaffs_block_info_t *bi) +{ + -+ if (!dev->param.isYaffs2) ++ if (!dev->param.is_yaffs2) + return 1; /* disqualification only applies to yaffs2. */ + -+ if (!bi->hasShrinkHeader) ++ if (!bi->has_shrink_hdr) + return 1; /* can gc */ + -+ yaffs2_FindOldestDirtySequence(dev); ++ yaffs2_find_oldest_dirty_seq(dev); + + /* Can't do gc of this block if there are any blocks older than this one that have + * discarded pages. + */ -+ return (bi->sequenceNumber <= dev->oldestDirtySequence); ++ return (bi->seq_number <= dev->oldest_dirty_seq); +} + +/* -+ * yaffs2_FindRefreshBlock() ++ * yaffs2_find_refresh_block() + * periodically finds the oldest full block by sequence number for refreshing. + * Only for yaffs2. + */ -+__u32 yaffs2_FindRefreshBlock(yaffs_Device *dev) ++__u32 yaffs2_find_refresh_block(yaffs_dev_t *dev) +{ + __u32 b ; + + __u32 oldest = 0; + __u32 oldestSequence = 0; + -+ yaffs_BlockInfo *bi; ++ yaffs_block_info_t *bi; + -+ if(!dev->param.isYaffs2) ++ if(!dev->param.is_yaffs2) + return oldest; + + /* + * If refresh period < 10 then refreshing is disabled. + */ -+ if(dev->param.refreshPeriod < 10) ++ if(dev->param.refresh_period < 10) + return oldest; + + /* + * Fix broken values. + */ -+ if(dev->refreshSkip > dev->param.refreshPeriod) -+ dev->refreshSkip = dev->param.refreshPeriod; ++ if(dev->refresh_skip > dev->param.refresh_period) ++ dev->refresh_skip = dev->param.refresh_period; + -+ if(dev->refreshSkip > 0) ++ if(dev->refresh_skip > 0) + return oldest; + + /* @@ -22150,17 +25388,17 @@ + * We'll do a refresh this time around.... + * Update the refresh skip and find the oldest block. + */ -+ dev->refreshSkip = dev->param.refreshPeriod; -+ dev->refreshCount++; -+ bi = dev->blockInfo; -+ for (b = dev->internalStartBlock; b <=dev->internalEndBlock; b++){ ++ dev->refresh_skip = dev->param.refresh_period; ++ dev->refresh_count++; ++ bi = dev->block_info; ++ for (b = dev->internal_start_block; b <=dev->internal_end_block; b++){ + -+ if (bi->blockState == YAFFS_BLOCK_STATE_FULL){ ++ if (bi->block_state == YAFFS_BLOCK_STATE_FULL){ + + if(oldest < 1 || -+ bi->sequenceNumber < oldestSequence){ ++ bi->seq_number < oldestSequence){ + oldest = b; -+ oldestSequence = bi->sequenceNumber; ++ oldestSequence = bi->seq_number; + } + } + bi++; @@ -22168,58 +25406,58 @@ + + if (oldest > 0) { + T(YAFFS_TRACE_GC, -+ (TSTR("GC refresh count %d selected block %d with sequenceNumber %d" TENDSTR), -+ dev->refreshCount, oldest, oldestSequence)); ++ (TSTR("GC refresh count %d selected block %d with seq_number %d" TENDSTR), ++ dev->refresh_count, oldest, oldestSequence)); + } + + return oldest; +} + -+int yaffs2_CheckpointRequired(yaffs_Device *dev) ++int yaffs2_checkpt_required(yaffs_dev_t *dev) +{ + int nblocks; + -+ if(!dev->param.isYaffs2) ++ if(!dev->param.is_yaffs2) + return 0; + -+ nblocks = dev->internalEndBlock - dev->internalStartBlock + 1 ; ++ nblocks = dev->internal_end_block - dev->internal_start_block + 1 ; + -+ return !dev->param.skipCheckpointWrite && -+ !dev->readOnly && ++ return !dev->param.skip_checkpt_wr && ++ !dev->read_only && + (nblocks >= YAFFS_CHECKPOINT_MIN_BLOCKS); +} + -+int yaffs2_CalcCheckpointBlocksRequired(yaffs_Device *dev) ++int yaffs_calc_checkpt_blocks_required(yaffs_dev_t *dev) +{ + int retval; + -+ if(!dev->param.isYaffs2) ++ if(!dev->param.is_yaffs2) + return 0; + -+ if (!dev->nCheckpointBlocksRequired && -+ yaffs2_CheckpointRequired(dev)){ ++ if (!dev->checkpoint_blocks_required && ++ yaffs2_checkpt_required(dev)){ + /* Not a valid value so recalculate */ -+ int nBytes = 0; ++ int n_bytes = 0; + int nBlocks; -+ int devBlocks = (dev->param.endBlock - dev->param.startBlock + 1); ++ int devBlocks = (dev->param.end_block - dev->param.start_block + 1); + -+ nBytes += sizeof(yaffs_CheckpointValidity); -+ nBytes += sizeof(yaffs_CheckpointDevice); -+ nBytes += devBlocks * sizeof(yaffs_BlockInfo); -+ nBytes += devBlocks * dev->chunkBitmapStride; -+ nBytes += (sizeof(yaffs_CheckpointObject) + sizeof(__u32)) * (dev->nObjects); -+ nBytes += (dev->tnodeSize + sizeof(__u32)) * (dev->nTnodes); -+ nBytes += sizeof(yaffs_CheckpointValidity); -+ nBytes += sizeof(__u32); /* checksum*/ ++ n_bytes += sizeof(yaffs_checkpt_validty_t); ++ n_bytes += sizeof(yaffs_checkpt_dev_t); ++ n_bytes += devBlocks * sizeof(yaffs_block_info_t); ++ n_bytes += devBlocks * dev->chunk_bit_stride; ++ n_bytes += (sizeof(yaffs_checkpt_obj_t) + sizeof(__u32)) * (dev->n_obj); ++ n_bytes += (dev->tnode_size + sizeof(__u32)) * (dev->n_tnodes); ++ n_bytes += sizeof(yaffs_checkpt_validty_t); ++ n_bytes += sizeof(__u32); /* checksum*/ + + /* Round up and add 2 blocks to allow for some bad blocks, so add 3 */ + -+ nBlocks = (nBytes/(dev->nDataBytesPerChunk * dev->param.nChunksPerBlock)) + 3; ++ nBlocks = (n_bytes/(dev->data_bytes_per_chunk * dev->param.chunks_per_block)) + 3; + -+ dev->nCheckpointBlocksRequired = nBlocks; ++ dev->checkpoint_blocks_required = nBlocks; + } + -+ retval = dev->nCheckpointBlocksRequired - dev->blocksInCheckpoint; ++ retval = dev->checkpoint_blocks_required - dev->blocks_in_checkpt; + if(retval < 0) + retval = 0; + return retval; @@ -22228,212 +25466,212 @@ +/*--------------------- Checkpointing --------------------*/ + + -+static int yaffs2_WriteCheckpointValidityMarker(yaffs_Device *dev, int head) ++static int yaffs2_wr_checkpt_validity_marker(yaffs_dev_t *dev, int head) +{ -+ yaffs_CheckpointValidity cp; ++ yaffs_checkpt_validty_t cp; + + memset(&cp, 0, sizeof(cp)); + -+ cp.structType = sizeof(cp); ++ cp.struct_type = sizeof(cp); + cp.magic = YAFFS_MAGIC; + cp.version = YAFFS_CHECKPOINT_VERSION; + cp.head = (head) ? 1 : 0; + -+ return (yaffs2_CheckpointWrite(dev, &cp, sizeof(cp)) == sizeof(cp)) ? ++ return (yaffs2_checkpt_wr(dev, &cp, sizeof(cp)) == sizeof(cp)) ? + 1 : 0; +} + -+static int yaffs2_ReadCheckpointValidityMarker(yaffs_Device *dev, int head) ++static int yaffs2_rd_checkpt_validty_marker(yaffs_dev_t *dev, int head) +{ -+ yaffs_CheckpointValidity cp; ++ yaffs_checkpt_validty_t cp; + int ok; + -+ ok = (yaffs2_CheckpointRead(dev, &cp, sizeof(cp)) == sizeof(cp)); ++ ok = (yaffs2_checkpt_rd(dev, &cp, sizeof(cp)) == sizeof(cp)); + + if (ok) -+ ok = (cp.structType == sizeof(cp)) && ++ ok = (cp.struct_type == sizeof(cp)) && + (cp.magic == YAFFS_MAGIC) && + (cp.version == YAFFS_CHECKPOINT_VERSION) && + (cp.head == ((head) ? 1 : 0)); + return ok ? 1 : 0; +} + -+static void yaffs2_DeviceToCheckpointDevice(yaffs_CheckpointDevice *cp, -+ yaffs_Device *dev) ++static void yaffs2_dev_to_checkpt_dev(yaffs_checkpt_dev_t *cp, ++ yaffs_dev_t *dev) +{ -+ cp->nErasedBlocks = dev->nErasedBlocks; -+ cp->allocationBlock = dev->allocationBlock; -+ cp->allocationPage = dev->allocationPage; -+ cp->nFreeChunks = dev->nFreeChunks; ++ cp->n_erased_blocks = dev->n_erased_blocks; ++ cp->alloc_block = dev->alloc_block; ++ cp->alloc_page = dev->alloc_page; ++ cp->n_free_chunks = dev->n_free_chunks; + -+ cp->nDeletedFiles = dev->nDeletedFiles; -+ cp->nUnlinkedFiles = dev->nUnlinkedFiles; -+ cp->nBackgroundDeletions = dev->nBackgroundDeletions; -+ cp->sequenceNumber = dev->sequenceNumber; ++ cp->n_deleted_files = dev->n_deleted_files; ++ cp->n_unlinked_files = dev->n_unlinked_files; ++ cp->n_bg_deletions = dev->n_bg_deletions; ++ cp->seq_number = dev->seq_number; + +} + -+static void yaffs2_CheckpointDeviceToDevice(yaffs_Device *dev, -+ yaffs_CheckpointDevice *cp) ++static void yaffs_checkpt_dev_to_dev(yaffs_dev_t *dev, ++ yaffs_checkpt_dev_t *cp) +{ -+ dev->nErasedBlocks = cp->nErasedBlocks; -+ dev->allocationBlock = cp->allocationBlock; -+ dev->allocationPage = cp->allocationPage; -+ dev->nFreeChunks = cp->nFreeChunks; ++ dev->n_erased_blocks = cp->n_erased_blocks; ++ dev->alloc_block = cp->alloc_block; ++ dev->alloc_page = cp->alloc_page; ++ dev->n_free_chunks = cp->n_free_chunks; + -+ dev->nDeletedFiles = cp->nDeletedFiles; -+ dev->nUnlinkedFiles = cp->nUnlinkedFiles; -+ dev->nBackgroundDeletions = cp->nBackgroundDeletions; -+ dev->sequenceNumber = cp->sequenceNumber; ++ dev->n_deleted_files = cp->n_deleted_files; ++ dev->n_unlinked_files = cp->n_unlinked_files; ++ dev->n_bg_deletions = cp->n_bg_deletions; ++ dev->seq_number = cp->seq_number; +} + + -+static int yaffs2_WriteCheckpointDevice(yaffs_Device *dev) ++static int yaffs2_wr_checkpt_dev(yaffs_dev_t *dev) +{ -+ yaffs_CheckpointDevice cp; -+ __u32 nBytes; -+ __u32 nBlocks = (dev->internalEndBlock - dev->internalStartBlock + 1); ++ yaffs_checkpt_dev_t cp; ++ __u32 n_bytes; ++ __u32 nBlocks = (dev->internal_end_block - dev->internal_start_block + 1); + + int ok; + + /* Write device runtime values*/ -+ yaffs2_DeviceToCheckpointDevice(&cp, dev); -+ cp.structType = sizeof(cp); ++ yaffs2_dev_to_checkpt_dev(&cp, dev); ++ cp.struct_type = sizeof(cp); + -+ ok = (yaffs2_CheckpointWrite(dev, &cp, sizeof(cp)) == sizeof(cp)); ++ ok = (yaffs2_checkpt_wr(dev, &cp, sizeof(cp)) == sizeof(cp)); + + /* Write block info */ + if (ok) { -+ nBytes = nBlocks * sizeof(yaffs_BlockInfo); -+ ok = (yaffs2_CheckpointWrite(dev, dev->blockInfo, nBytes) == nBytes); ++ n_bytes = nBlocks * sizeof(yaffs_block_info_t); ++ ok = (yaffs2_checkpt_wr(dev, dev->block_info, n_bytes) == n_bytes); + } + + /* Write chunk bits */ + if (ok) { -+ nBytes = nBlocks * dev->chunkBitmapStride; -+ ok = (yaffs2_CheckpointWrite(dev, dev->chunkBits, nBytes) == nBytes); ++ n_bytes = nBlocks * dev->chunk_bit_stride; ++ ok = (yaffs2_checkpt_wr(dev, dev->chunk_bits, n_bytes) == n_bytes); + } + return ok ? 1 : 0; + +} + -+static int yaffs2_ReadCheckpointDevice(yaffs_Device *dev) ++static int yaffs2_rd_checkpt_dev(yaffs_dev_t *dev) +{ -+ yaffs_CheckpointDevice cp; -+ __u32 nBytes; -+ __u32 nBlocks = (dev->internalEndBlock - dev->internalStartBlock + 1); ++ yaffs_checkpt_dev_t cp; ++ __u32 n_bytes; ++ __u32 nBlocks = (dev->internal_end_block - dev->internal_start_block + 1); + + int ok; + -+ ok = (yaffs2_CheckpointRead(dev, &cp, sizeof(cp)) == sizeof(cp)); ++ ok = (yaffs2_checkpt_rd(dev, &cp, sizeof(cp)) == sizeof(cp)); + if (!ok) + return 0; + -+ if (cp.structType != sizeof(cp)) ++ if (cp.struct_type != sizeof(cp)) + return 0; + + -+ yaffs2_CheckpointDeviceToDevice(dev, &cp); ++ yaffs_checkpt_dev_to_dev(dev, &cp); + -+ nBytes = nBlocks * sizeof(yaffs_BlockInfo); ++ n_bytes = nBlocks * sizeof(yaffs_block_info_t); + -+ ok = (yaffs2_CheckpointRead(dev, dev->blockInfo, nBytes) == nBytes); ++ ok = (yaffs2_checkpt_rd(dev, dev->block_info, n_bytes) == n_bytes); + + if (!ok) + return 0; -+ nBytes = nBlocks * dev->chunkBitmapStride; ++ n_bytes = nBlocks * dev->chunk_bit_stride; + -+ ok = (yaffs2_CheckpointRead(dev, dev->chunkBits, nBytes) == nBytes); ++ ok = (yaffs2_checkpt_rd(dev, dev->chunk_bits, n_bytes) == n_bytes); + + return ok ? 1 : 0; +} + -+static void yaffs2_ObjectToCheckpointObject(yaffs_CheckpointObject *cp, -+ yaffs_Object *obj) ++static void yaffs2_obj_checkpt_obj(yaffs_checkpt_obj_t *cp, ++ yaffs_obj_t *obj) +{ + -+ cp->objectId = obj->objectId; -+ cp->parentId = (obj->parent) ? obj->parent->objectId : 0; -+ cp->hdrChunk = obj->hdrChunk; -+ cp->variantType = obj->variantType; ++ cp->obj_id = obj->obj_id; ++ cp->parent_id = (obj->parent) ? obj->parent->obj_id : 0; ++ cp->hdr_chunk = obj->hdr_chunk; ++ cp->variant_type = obj->variant_type; + cp->deleted = obj->deleted; -+ cp->softDeleted = obj->softDeleted; ++ cp->soft_del = obj->soft_del; + cp->unlinked = obj->unlinked; + cp->fake = obj->fake; -+ cp->renameAllowed = obj->renameAllowed; -+ cp->unlinkAllowed = obj->unlinkAllowed; ++ cp->rename_allowed = obj->rename_allowed; ++ cp->unlink_allowed = obj->unlink_allowed; + cp->serial = obj->serial; -+ cp->nDataChunks = obj->nDataChunks; ++ cp->n_data_chunks = obj->n_data_chunks; + -+ if (obj->variantType == YAFFS_OBJECT_TYPE_FILE) -+ cp->fileSizeOrEquivalentObjectId = obj->variant.fileVariant.fileSize; -+ else if (obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK) -+ cp->fileSizeOrEquivalentObjectId = obj->variant.hardLinkVariant.equivalentObjectId; ++ if (obj->variant_type == YAFFS_OBJECT_TYPE_FILE) ++ cp->size_or_equiv_obj = obj->variant.file_variant.file_size; ++ else if (obj->variant_type == YAFFS_OBJECT_TYPE_HARDLINK) ++ cp->size_or_equiv_obj = obj->variant.hardlink_variant.equiv_id; +} + -+static int yaffs2_CheckpointObjectToObject(yaffs_Object *obj, yaffs_CheckpointObject *cp) ++static int taffs2_checkpt_obj_to_obj(yaffs_obj_t *obj, yaffs_checkpt_obj_t *cp) +{ + -+ yaffs_Object *parent; ++ yaffs_obj_t *parent; + -+ if (obj->variantType != cp->variantType) { ++ if (obj->variant_type != cp->variant_type) { + T(YAFFS_TRACE_ERROR, (TSTR("Checkpoint read object %d type %d " + TCONT("chunk %d does not match existing object type %d") -+ TENDSTR), cp->objectId, cp->variantType, cp->hdrChunk, -+ obj->variantType)); ++ TENDSTR), cp->obj_id, cp->variant_type, cp->hdr_chunk, ++ obj->variant_type)); + return 0; + } + -+ obj->objectId = cp->objectId; ++ obj->obj_id = cp->obj_id; + -+ if (cp->parentId) -+ parent = yaffs_FindOrCreateObjectByNumber( -+ obj->myDev, -+ cp->parentId, ++ if (cp->parent_id) ++ parent = yaffs_find_or_create_by_number( ++ obj->my_dev, ++ cp->parent_id, + YAFFS_OBJECT_TYPE_DIRECTORY); + else + parent = NULL; + + if (parent) { -+ if (parent->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) { ++ if (parent->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) { + T(YAFFS_TRACE_ALWAYS, (TSTR("Checkpoint read object %d parent %d type %d" + TCONT(" chunk %d Parent type, %d, not directory") + TENDSTR), -+ cp->objectId, cp->parentId, cp->variantType, -+ cp->hdrChunk, parent->variantType)); ++ cp->obj_id, cp->parent_id, cp->variant_type, ++ cp->hdr_chunk, parent->variant_type)); + return 0; + } -+ yaffs_AddObjectToDirectory(parent, obj); ++ yaffs_add_obj_to_dir(parent, obj); + } + -+ obj->hdrChunk = cp->hdrChunk; -+ obj->variantType = cp->variantType; ++ obj->hdr_chunk = cp->hdr_chunk; ++ obj->variant_type = cp->variant_type; + obj->deleted = cp->deleted; -+ obj->softDeleted = cp->softDeleted; ++ obj->soft_del = cp->soft_del; + obj->unlinked = cp->unlinked; + obj->fake = cp->fake; -+ obj->renameAllowed = cp->renameAllowed; -+ obj->unlinkAllowed = cp->unlinkAllowed; ++ obj->rename_allowed = cp->rename_allowed; ++ obj->unlink_allowed = cp->unlink_allowed; + obj->serial = cp->serial; -+ obj->nDataChunks = cp->nDataChunks; ++ obj->n_data_chunks = cp->n_data_chunks; + -+ if (obj->variantType == YAFFS_OBJECT_TYPE_FILE) -+ obj->variant.fileVariant.fileSize = cp->fileSizeOrEquivalentObjectId; -+ else if (obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK) -+ obj->variant.hardLinkVariant.equivalentObjectId = cp->fileSizeOrEquivalentObjectId; ++ if (obj->variant_type == YAFFS_OBJECT_TYPE_FILE) ++ obj->variant.file_variant.file_size = cp->size_or_equiv_obj; ++ else if (obj->variant_type == YAFFS_OBJECT_TYPE_HARDLINK) ++ obj->variant.hardlink_variant.equiv_id = cp->size_or_equiv_obj; + -+ if (obj->hdrChunk > 0) -+ obj->lazyLoaded = 1; ++ if (obj->hdr_chunk > 0) ++ obj->lazy_loaded = 1; + return 1; +} + + + -+static int yaffs2_CheckpointTnodeWorker(yaffs_Object *in, yaffs_Tnode *tn, -+ __u32 level, int chunkOffset) ++static int yaffs2_checkpt_tnode_worker(yaffs_obj_t *in, yaffs_tnode_t *tn, ++ __u32 level, int chunk_offset) +{ + int i; -+ yaffs_Device *dev = in->myDev; ++ yaffs_dev_t *dev = in->my_dev; + int ok = 1; + + if (tn) { @@ -22441,17 +25679,17 @@ + + for (i = 0; i < YAFFS_NTNODES_INTERNAL && ok; i++) { + if (tn->internal[i]) { -+ ok = yaffs2_CheckpointTnodeWorker(in, ++ ok = yaffs2_checkpt_tnode_worker(in, + tn->internal[i], + level - 1, -+ (chunkOffset<<YAFFS_TNODES_INTERNAL_BITS) + i); ++ (chunk_offset<<YAFFS_TNODES_INTERNAL_BITS) + i); + } + } + } else if (level == 0) { -+ __u32 baseOffset = chunkOffset << YAFFS_TNODES_LEVEL0_BITS; -+ ok = (yaffs2_CheckpointWrite(dev, &baseOffset, sizeof(baseOffset)) == sizeof(baseOffset)); ++ __u32 baseOffset = chunk_offset << YAFFS_TNODES_LEVEL0_BITS; ++ ok = (yaffs2_checkpt_wr(dev, &baseOffset, sizeof(baseOffset)) == sizeof(baseOffset)); + if (ok) -+ ok = (yaffs2_CheckpointWrite(dev, tn, dev->tnodeSize) == dev->tnodeSize); ++ ok = (yaffs2_checkpt_wr(dev, tn, dev->tnode_size) == dev->tnode_size); + } + } + @@ -22459,54 +25697,54 @@ + +} + -+static int yaffs2_WriteCheckpointTnodes(yaffs_Object *obj) ++static int yaffs2_wr_checkpt_tnodes(yaffs_obj_t *obj) +{ + __u32 endMarker = ~0; + int ok = 1; + -+ if (obj->variantType == YAFFS_OBJECT_TYPE_FILE) { -+ ok = yaffs2_CheckpointTnodeWorker(obj, -+ obj->variant.fileVariant.top, -+ obj->variant.fileVariant.topLevel, ++ if (obj->variant_type == YAFFS_OBJECT_TYPE_FILE) { ++ ok = yaffs2_checkpt_tnode_worker(obj, ++ obj->variant.file_variant.top, ++ obj->variant.file_variant.top_level, + 0); + if (ok) -+ ok = (yaffs2_CheckpointWrite(obj->myDev, &endMarker, sizeof(endMarker)) == ++ ok = (yaffs2_checkpt_wr(obj->my_dev, &endMarker, sizeof(endMarker)) == + sizeof(endMarker)); + } + + return ok ? 1 : 0; +} + -+static int yaffs2_ReadCheckpointTnodes(yaffs_Object *obj) ++static int yaffs2_rd_checkpt_tnodes(yaffs_obj_t *obj) +{ + __u32 baseChunk; + int ok = 1; -+ yaffs_Device *dev = obj->myDev; -+ yaffs_FileStructure *fileStructPtr = &obj->variant.fileVariant; -+ yaffs_Tnode *tn; ++ yaffs_dev_t *dev = obj->my_dev; ++ yaffs_file_s *fileStructPtr = &obj->variant.file_variant; ++ yaffs_tnode_t *tn; + int nread = 0; + -+ ok = (yaffs2_CheckpointRead(dev, &baseChunk, sizeof(baseChunk)) == sizeof(baseChunk)); ++ ok = (yaffs2_checkpt_rd(dev, &baseChunk, sizeof(baseChunk)) == sizeof(baseChunk)); + + while (ok && (~baseChunk)) { + nread++; + /* Read level 0 tnode */ + + -+ tn = yaffs_GetTnode(dev); ++ tn = yaffs_get_tnode(dev); + if (tn){ -+ ok = (yaffs2_CheckpointRead(dev, tn, dev->tnodeSize) == dev->tnodeSize); ++ ok = (yaffs2_checkpt_rd(dev, tn, dev->tnode_size) == dev->tnode_size); + } else + ok = 0; + + if (tn && ok) -+ ok = yaffs_AddOrFindLevel0Tnode(dev, ++ ok = yaffs_add_find_tnode_0(dev, + fileStructPtr, + baseChunk, + tn) ? 1 : 0; + + if (ok) -+ ok = (yaffs2_CheckpointRead(dev, &baseChunk, sizeof(baseChunk)) == sizeof(baseChunk)); ++ ok = (yaffs2_checkpt_rd(dev, &baseChunk, sizeof(baseChunk)) == sizeof(baseChunk)); + + } + @@ -22518,10 +25756,10 @@ +} + + -+static int yaffs2_WriteCheckpointObjects(yaffs_Device *dev) ++static int yaffs2_wr_checkpt_objs(yaffs_dev_t *dev) +{ -+ yaffs_Object *obj; -+ yaffs_CheckpointObject cp; ++ yaffs_obj_t *obj; ++ yaffs_checkpt_obj_t cp; + int i; + int ok = 1; + struct ylist_head *lh; @@ -22532,69 +25770,69 @@ + */ + + for (i = 0; ok && i < YAFFS_NOBJECT_BUCKETS; i++) { -+ ylist_for_each(lh, &dev->objectBucket[i].list) { ++ ylist_for_each(lh, &dev->obj_bucket[i].list) { + if (lh) { -+ obj = ylist_entry(lh, yaffs_Object, hashLink); -+ if (!obj->deferedFree) { -+ yaffs2_ObjectToCheckpointObject(&cp, obj); -+ cp.structType = sizeof(cp); ++ obj = ylist_entry(lh, yaffs_obj_t, hash_link); ++ if (!obj->defered_free) { ++ yaffs2_obj_checkpt_obj(&cp, obj); ++ cp.struct_type = sizeof(cp); + + T(YAFFS_TRACE_CHECKPOINT, ( + TSTR("Checkpoint write object %d parent %d type %d chunk %d obj addr %p" TENDSTR), -+ cp.objectId, cp.parentId, cp.variantType, cp.hdrChunk, obj)); ++ cp.obj_id, cp.parent_id, cp.variant_type, cp.hdr_chunk, obj)); + -+ ok = (yaffs2_CheckpointWrite(dev, &cp, sizeof(cp)) == sizeof(cp)); ++ ok = (yaffs2_checkpt_wr(dev, &cp, sizeof(cp)) == sizeof(cp)); + -+ if (ok && obj->variantType == YAFFS_OBJECT_TYPE_FILE) -+ ok = yaffs2_WriteCheckpointTnodes(obj); ++ if (ok && obj->variant_type == YAFFS_OBJECT_TYPE_FILE) ++ ok = yaffs2_wr_checkpt_tnodes(obj); + } + } + } + } + + /* Dump end of list */ -+ memset(&cp, 0xFF, sizeof(yaffs_CheckpointObject)); -+ cp.structType = sizeof(cp); ++ memset(&cp, 0xFF, sizeof(yaffs_checkpt_obj_t)); ++ cp.struct_type = sizeof(cp); + + if (ok) -+ ok = (yaffs2_CheckpointWrite(dev, &cp, sizeof(cp)) == sizeof(cp)); ++ ok = (yaffs2_checkpt_wr(dev, &cp, sizeof(cp)) == sizeof(cp)); + + return ok ? 1 : 0; +} + -+static int yaffs2_ReadCheckpointObjects(yaffs_Device *dev) ++static int yaffs2_rd_checkpt_objs(yaffs_dev_t *dev) +{ -+ yaffs_Object *obj; -+ yaffs_CheckpointObject cp; ++ yaffs_obj_t *obj; ++ yaffs_checkpt_obj_t cp; + int ok = 1; + int done = 0; -+ yaffs_Object *hardList = NULL; ++ yaffs_obj_t *hard_list = NULL; + + while (ok && !done) { -+ ok = (yaffs2_CheckpointRead(dev, &cp, sizeof(cp)) == sizeof(cp)); -+ if (cp.structType != sizeof(cp)) { ++ ok = (yaffs2_checkpt_rd(dev, &cp, sizeof(cp)) == sizeof(cp)); ++ if (cp.struct_type != sizeof(cp)) { + T(YAFFS_TRACE_CHECKPOINT, (TSTR("struct size %d instead of %d ok %d"TENDSTR), -+ cp.structType, (int)sizeof(cp), ok)); ++ cp.struct_type, (int)sizeof(cp), ok)); + ok = 0; + } + + T(YAFFS_TRACE_CHECKPOINT, (TSTR("Checkpoint read object %d parent %d type %d chunk %d " TENDSTR), -+ cp.objectId, cp.parentId, cp.variantType, cp.hdrChunk)); ++ cp.obj_id, cp.parent_id, cp.variant_type, cp.hdr_chunk)); + -+ if (ok && cp.objectId == ~0) ++ if (ok && cp.obj_id == ~0) + done = 1; + else if (ok) { -+ obj = yaffs_FindOrCreateObjectByNumber(dev, cp.objectId, cp.variantType); ++ obj = yaffs_find_or_create_by_number(dev, cp.obj_id, cp.variant_type); + if (obj) { -+ ok = yaffs2_CheckpointObjectToObject(obj, &cp); ++ ok = taffs2_checkpt_obj_to_obj(obj, &cp); + if (!ok) + break; -+ if (obj->variantType == YAFFS_OBJECT_TYPE_FILE) { -+ ok = yaffs2_ReadCheckpointTnodes(obj); -+ } else if (obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK) { -+ obj->hardLinks.next = -+ (struct ylist_head *) hardList; -+ hardList = obj; ++ if (obj->variant_type == YAFFS_OBJECT_TYPE_FILE) { ++ ok = yaffs2_rd_checkpt_tnodes(obj); ++ } else if (obj->variant_type == YAFFS_OBJECT_TYPE_HARDLINK) { ++ obj->hard_links.next = ++ (struct ylist_head *) hard_list; ++ hard_list = obj; + } + } else + ok = 0; @@ -22602,19 +25840,19 @@ + } + + if (ok) -+ yaffs_HardlinkFixup(dev, hardList); ++ yaffs_link_fixup(dev, hard_list); + + return ok ? 1 : 0; +} + -+static int yaffs2_WriteCheckpointSum(yaffs_Device *dev) ++static int yaffs2_wr_checkpt_sum(yaffs_dev_t *dev) +{ -+ __u32 checkpointSum; ++ __u32 checkpt_sum; + int ok; + -+ yaffs2_GetCheckpointSum(dev, &checkpointSum); ++ yaffs2_get_checkpt_sum(dev, &checkpt_sum); + -+ ok = (yaffs2_CheckpointWrite(dev, &checkpointSum, sizeof(checkpointSum)) == sizeof(checkpointSum)); ++ ok = (yaffs2_checkpt_wr(dev, &checkpt_sum, sizeof(checkpt_sum)) == sizeof(checkpt_sum)); + + if (!ok) + return 0; @@ -22622,168 +25860,168 @@ + return 1; +} + -+static int yaffs2_ReadCheckpointSum(yaffs_Device *dev) ++static int yaffs2_rd_checkpt_sum(yaffs_dev_t *dev) +{ -+ __u32 checkpointSum0; -+ __u32 checkpointSum1; ++ __u32 checkpt_sum0; ++ __u32 checkpt_sum1; + int ok; + -+ yaffs2_GetCheckpointSum(dev, &checkpointSum0); ++ yaffs2_get_checkpt_sum(dev, &checkpt_sum0); + -+ ok = (yaffs2_CheckpointRead(dev, &checkpointSum1, sizeof(checkpointSum1)) == sizeof(checkpointSum1)); ++ ok = (yaffs2_checkpt_rd(dev, &checkpt_sum1, sizeof(checkpt_sum1)) == sizeof(checkpt_sum1)); + + if (!ok) + return 0; + -+ if (checkpointSum0 != checkpointSum1) ++ if (checkpt_sum0 != checkpt_sum1) + return 0; + + return 1; +} + + -+static int yaffs2_WriteCheckpointData(yaffs_Device *dev) ++static int yaffs2_wr_checkpt_data(yaffs_dev_t *dev) +{ + int ok = 1; + -+ if (!yaffs2_CheckpointRequired(dev)) { ++ if (!yaffs2_checkpt_required(dev)) { + T(YAFFS_TRACE_CHECKPOINT, (TSTR("skipping checkpoint write" TENDSTR))); + ok = 0; + } + + if (ok) -+ ok = yaffs2_CheckpointOpen(dev, 1); ++ ok = yaffs2_checkpt_open(dev, 1); + + if (ok) { + T(YAFFS_TRACE_CHECKPOINT, (TSTR("write checkpoint validity" TENDSTR))); -+ ok = yaffs2_WriteCheckpointValidityMarker(dev, 1); ++ ok = yaffs2_wr_checkpt_validity_marker(dev, 1); + } + if (ok) { + T(YAFFS_TRACE_CHECKPOINT, (TSTR("write checkpoint device" TENDSTR))); -+ ok = yaffs2_WriteCheckpointDevice(dev); ++ ok = yaffs2_wr_checkpt_dev(dev); + } + if (ok) { + T(YAFFS_TRACE_CHECKPOINT, (TSTR("write checkpoint objects" TENDSTR))); -+ ok = yaffs2_WriteCheckpointObjects(dev); ++ ok = yaffs2_wr_checkpt_objs(dev); + } + if (ok) { + T(YAFFS_TRACE_CHECKPOINT, (TSTR("write checkpoint validity" TENDSTR))); -+ ok = yaffs2_WriteCheckpointValidityMarker(dev, 0); ++ ok = yaffs2_wr_checkpt_validity_marker(dev, 0); + } + + if (ok) -+ ok = yaffs2_WriteCheckpointSum(dev); ++ ok = yaffs2_wr_checkpt_sum(dev); + -+ if (!yaffs2_CheckpointClose(dev)) ++ if (!yaffs_checkpt_close(dev)) + ok = 0; + + if (ok) -+ dev->isCheckpointed = 1; ++ dev->is_checkpointed = 1; + else -+ dev->isCheckpointed = 0; ++ dev->is_checkpointed = 0; + -+ return dev->isCheckpointed; ++ return dev->is_checkpointed; +} + -+static int yaffs2_ReadCheckpointData(yaffs_Device *dev) ++static int yaffs2_rd_checkpt_data(yaffs_dev_t *dev) +{ + int ok = 1; + -+ if(!dev->param.isYaffs2) ++ if(!dev->param.is_yaffs2) + ok = 0; + -+ if (ok && dev->param.skipCheckpointRead) { ++ if (ok && dev->param.skip_checkpt_rd) { + T(YAFFS_TRACE_CHECKPOINT, (TSTR("skipping checkpoint read" TENDSTR))); + ok = 0; + } + + if (ok) -+ ok = yaffs2_CheckpointOpen(dev, 0); /* open for read */ ++ ok = yaffs2_checkpt_open(dev, 0); /* open for read */ + + if (ok) { + T(YAFFS_TRACE_CHECKPOINT, (TSTR("read checkpoint validity" TENDSTR))); -+ ok = yaffs2_ReadCheckpointValidityMarker(dev, 1); ++ ok = yaffs2_rd_checkpt_validty_marker(dev, 1); + } + if (ok) { + T(YAFFS_TRACE_CHECKPOINT, (TSTR("read checkpoint device" TENDSTR))); -+ ok = yaffs2_ReadCheckpointDevice(dev); ++ ok = yaffs2_rd_checkpt_dev(dev); + } + if (ok) { + T(YAFFS_TRACE_CHECKPOINT, (TSTR("read checkpoint objects" TENDSTR))); -+ ok = yaffs2_ReadCheckpointObjects(dev); ++ ok = yaffs2_rd_checkpt_objs(dev); + } + if (ok) { + T(YAFFS_TRACE_CHECKPOINT, (TSTR("read checkpoint validity" TENDSTR))); -+ ok = yaffs2_ReadCheckpointValidityMarker(dev, 0); ++ ok = yaffs2_rd_checkpt_validty_marker(dev, 0); + } + + if (ok) { -+ ok = yaffs2_ReadCheckpointSum(dev); ++ ok = yaffs2_rd_checkpt_sum(dev); + T(YAFFS_TRACE_CHECKPOINT, (TSTR("read checkpoint checksum %d" TENDSTR), ok)); + } + -+ if (!yaffs2_CheckpointClose(dev)) ++ if (!yaffs_checkpt_close(dev)) + ok = 0; + + if (ok) -+ dev->isCheckpointed = 1; ++ dev->is_checkpointed = 1; + else -+ dev->isCheckpointed = 0; ++ dev->is_checkpointed = 0; + + return ok ? 1 : 0; + +} + -+void yaffs2_InvalidateCheckpoint(yaffs_Device *dev) ++void yaffs2_checkpt_invalidate(yaffs_dev_t *dev) +{ -+ if (dev->isCheckpointed || -+ dev->blocksInCheckpoint > 0) { -+ dev->isCheckpointed = 0; -+ yaffs2_CheckpointInvalidateStream(dev); ++ if (dev->is_checkpointed || ++ dev->blocks_in_checkpt > 0) { ++ dev->is_checkpointed = 0; ++ yaffs2_checkpt_invalidate_stream(dev); + } -+ if (dev->param.markSuperBlockDirty) -+ dev->param.markSuperBlockDirty(dev); ++ if (dev->param.sb_dirty_fn) ++ dev->param.sb_dirty_fn(dev); +} + + -+int yaffs_CheckpointSave(yaffs_Device *dev) ++int yaffs_checkpoint_save(yaffs_dev_t *dev) +{ + -+ T(YAFFS_TRACE_CHECKPOINT, (TSTR("save entry: isCheckpointed %d"TENDSTR), dev->isCheckpointed)); ++ T(YAFFS_TRACE_CHECKPOINT, (TSTR("save entry: is_checkpointed %d"TENDSTR), dev->is_checkpointed)); + -+ yaffs_VerifyObjects(dev); -+ yaffs_VerifyBlocks(dev); -+ yaffs_VerifyFreeChunks(dev); ++ yaffs_verify_objects(dev); ++ yaffs_verify_blocks(dev); ++ yaffs_verify_free_chunks(dev); + -+ if (!dev->isCheckpointed) { -+ yaffs2_InvalidateCheckpoint(dev); -+ yaffs2_WriteCheckpointData(dev); ++ if (!dev->is_checkpointed) { ++ yaffs2_checkpt_invalidate(dev); ++ yaffs2_wr_checkpt_data(dev); + } + -+ T(YAFFS_TRACE_ALWAYS, (TSTR("save exit: isCheckpointed %d"TENDSTR), dev->isCheckpointed)); ++ T(YAFFS_TRACE_ALWAYS, (TSTR("save exit: is_checkpointed %d"TENDSTR), dev->is_checkpointed)); + -+ return dev->isCheckpointed; ++ return dev->is_checkpointed; +} + -+int yaffs2_CheckpointRestore(yaffs_Device *dev) ++int yaffs2_checkpt_restore(yaffs_dev_t *dev) +{ + int retval; -+ T(YAFFS_TRACE_CHECKPOINT, (TSTR("restore entry: isCheckpointed %d"TENDSTR), dev->isCheckpointed)); ++ T(YAFFS_TRACE_CHECKPOINT, (TSTR("restore entry: is_checkpointed %d"TENDSTR), dev->is_checkpointed)); + -+ retval = yaffs2_ReadCheckpointData(dev); ++ retval = yaffs2_rd_checkpt_data(dev); + -+ if (dev->isCheckpointed) { -+ yaffs_VerifyObjects(dev); -+ yaffs_VerifyBlocks(dev); -+ yaffs_VerifyFreeChunks(dev); ++ if (dev->is_checkpointed) { ++ yaffs_verify_objects(dev); ++ yaffs_verify_blocks(dev); ++ yaffs_verify_free_chunks(dev); + } + -+ T(YAFFS_TRACE_CHECKPOINT, (TSTR("restore exit: isCheckpointed %d"TENDSTR), dev->isCheckpointed)); ++ T(YAFFS_TRACE_CHECKPOINT, (TSTR("restore exit: is_checkpointed %d"TENDSTR), dev->is_checkpointed)); + + return retval; +} + -+int yaffs2_HandleHole(yaffs_Object *obj, loff_t newSize) ++int yaffs2_handle_hole(yaffs_obj_t *obj, loff_t new_size) +{ + /* if newsSize > oldFileSize. + * We're going to be writing a hole. @@ -22795,7 +26033,7 @@ + int increase; + int smallHole ; + int result = YAFFS_OK; -+ yaffs_Device *dev = NULL; ++ yaffs_dev_t *dev = NULL; + + __u8 *localBuffer = NULL; + @@ -22804,44 +26042,44 @@ + if(!obj) + return YAFFS_FAIL; + -+ if(obj->variantType != YAFFS_OBJECT_TYPE_FILE) ++ if(obj->variant_type != YAFFS_OBJECT_TYPE_FILE) + return YAFFS_FAIL; + -+ dev = obj->myDev; ++ dev = obj->my_dev; + + /* Bail out if not yaffs2 mode */ -+ if(!dev->param.isYaffs2) ++ if(!dev->param.is_yaffs2) + return YAFFS_OK; + -+ oldFileSize = obj->variant.fileVariant.fileSize; ++ oldFileSize = obj->variant.file_variant.file_size; + -+ if (newSize <= oldFileSize) ++ if (new_size <= oldFileSize) + return YAFFS_OK; + -+ increase = newSize - oldFileSize; ++ increase = new_size - oldFileSize; + -+ if(increase < YAFFS_SMALL_HOLE_THRESHOLD * dev->nDataBytesPerChunk && -+ yaffs_CheckSpaceForAllocation(dev, YAFFS_SMALL_HOLE_THRESHOLD + 1)) ++ if(increase < YAFFS_SMALL_HOLE_THRESHOLD * dev->data_bytes_per_chunk && ++ yaffs_check_alloc_available(dev, YAFFS_SMALL_HOLE_THRESHOLD + 1)) + smallHole = 1; + else + smallHole = 0; + + if(smallHole) -+ localBuffer= yaffs_GetTempBuffer(dev, __LINE__); ++ localBuffer= yaffs_get_temp_buffer(dev, __LINE__); + + if(localBuffer){ + /* fill hole with zero bytes */ + int pos = oldFileSize; + int thisWrite; + int written; -+ memset(localBuffer,0,dev->nDataBytesPerChunk); ++ memset(localBuffer,0,dev->data_bytes_per_chunk); + smallIncreaseOk = 1; + + while(increase > 0 && smallIncreaseOk){ + thisWrite = increase; -+ if(thisWrite > dev->nDataBytesPerChunk) -+ thisWrite = dev->nDataBytesPerChunk; -+ written = yaffs_DoWriteDataToFile(obj,localBuffer,pos,thisWrite,0); ++ if(thisWrite > dev->data_bytes_per_chunk) ++ thisWrite = dev->data_bytes_per_chunk; ++ written = yaffs_do_file_wr(obj,localBuffer,pos,thisWrite,0); + if(written == thisWrite){ + pos += thisWrite; + increase -= thisWrite; @@ -22849,19 +26087,19 @@ + smallIncreaseOk = 0; + } + -+ yaffs_ReleaseTempBuffer(dev,localBuffer,__LINE__); ++ yaffs_release_temp_buffer(dev,localBuffer,__LINE__); + + /* If we were out of space then reverse any chunks we've added */ + if(!smallIncreaseOk) -+ yaffs_ResizeDown(obj, oldFileSize); ++ yaffs_resize_file_down(obj, oldFileSize); + } + + if (!smallIncreaseOk && + obj->parent && -+ obj->parent->objectId != YAFFS_OBJECTID_UNLINKED && -+ obj->parent->objectId != YAFFS_OBJECTID_DELETED){ ++ obj->parent->obj_id != YAFFS_OBJECTID_UNLINKED && ++ obj->parent->obj_id != YAFFS_OBJECTID_DELETED){ + /* Write a hole start header with the old file size */ -+ yaffs_UpdateObjectHeader(obj, NULL, 0, 1, 0, NULL); ++ yaffs_update_oh(obj, NULL, 0, 1, 0, NULL); + } + + return result; @@ -22887,9 +26125,9 @@ + return aseq - bseq; +} + -+int yaffs2_ScanBackwards(yaffs_Device *dev) ++int yaffs2_scan_backwards(yaffs_dev_t *dev) +{ -+ yaffs_ExtendedTags tags; ++ yaffs_ext_tags tags; + int blk; + int blockIterator; + int startIterator; @@ -22900,21 +26138,21 @@ + int result; + int c; + int deleted; -+ yaffs_BlockState state; -+ yaffs_Object *hardList = NULL; -+ yaffs_BlockInfo *bi; -+ __u32 sequenceNumber; -+ yaffs_ObjectHeader *oh; -+ yaffs_Object *in; -+ yaffs_Object *parent; -+ int nBlocks = dev->internalEndBlock - dev->internalStartBlock + 1; ++ yaffs_block_state_t state; ++ yaffs_obj_t *hard_list = NULL; ++ yaffs_block_info_t *bi; ++ __u32 seq_number; ++ yaffs_obj_header *oh; ++ yaffs_obj_t *in; ++ yaffs_obj_t *parent; ++ int nBlocks = dev->internal_end_block - dev->internal_start_block + 1; + int itsUnlinked; + __u8 *chunkData; + -+ int fileSize; -+ int isShrink; ++ int file_size; ++ int is_shrink; + int foundChunksInBlock; -+ int equivalentObjectId; ++ int equiv_id; + int alloc_failed = 0; + + @@ -22923,11 +26161,11 @@ + + T(YAFFS_TRACE_SCAN, + (TSTR -+ ("yaffs2_ScanBackwards starts intstartblk %d intendblk %d..." -+ TENDSTR), dev->internalStartBlock, dev->internalEndBlock)); ++ ("yaffs2_scan_backwards starts intstartblk %d intendblk %d..." ++ TENDSTR), dev->internal_start_block, dev->internal_end_block)); + + -+ dev->sequenceNumber = YAFFS_LOWEST_SEQUENCE_NUMBER; ++ dev->seq_number = YAFFS_LOWEST_SEQUENCE_NUMBER; + + blockIndex = YMALLOC(nBlocks * sizeof(yaffs_BlockIndex)); + @@ -22938,38 +26176,38 @@ + + if (!blockIndex) { + T(YAFFS_TRACE_SCAN, -+ (TSTR("yaffs2_ScanBackwards() could not allocate block index!" TENDSTR))); ++ (TSTR("yaffs2_scan_backwards() could not allocate block index!" TENDSTR))); + return YAFFS_FAIL; + } + -+ dev->blocksInCheckpoint = 0; ++ dev->blocks_in_checkpt = 0; + -+ chunkData = yaffs_GetTempBuffer(dev, __LINE__); ++ chunkData = yaffs_get_temp_buffer(dev, __LINE__); + + /* Scan all the blocks to determine their state */ -+ bi = dev->blockInfo; -+ for (blk = dev->internalStartBlock; blk <= dev->internalEndBlock; blk++) { -+ yaffs_ClearChunkBits(dev, blk); -+ bi->pagesInUse = 0; -+ bi->softDeletions = 0; ++ bi = dev->block_info; ++ for (blk = dev->internal_start_block; blk <= dev->internal_end_block; blk++) { ++ yaffs_clear_chunk_bits(dev, blk); ++ bi->pages_in_use = 0; ++ bi->soft_del_pages = 0; + -+ yaffs_QueryInitialBlockState(dev, blk, &state, &sequenceNumber); ++ yaffs_query_init_block_state(dev, blk, &state, &seq_number); + -+ bi->blockState = state; -+ bi->sequenceNumber = sequenceNumber; ++ bi->block_state = state; ++ bi->seq_number = seq_number; + -+ if (bi->sequenceNumber == YAFFS_SEQUENCE_CHECKPOINT_DATA) -+ bi->blockState = state = YAFFS_BLOCK_STATE_CHECKPOINT; -+ if (bi->sequenceNumber == YAFFS_SEQUENCE_BAD_BLOCK) -+ bi->blockState = state = YAFFS_BLOCK_STATE_DEAD; ++ if (bi->seq_number == YAFFS_SEQUENCE_CHECKPOINT_DATA) ++ bi->block_state = state = YAFFS_BLOCK_STATE_CHECKPOINT; ++ if (bi->seq_number == YAFFS_SEQUENCE_BAD_BLOCK) ++ bi->block_state = state = YAFFS_BLOCK_STATE_DEAD; + + T(YAFFS_TRACE_SCAN_DEBUG, + (TSTR("Block scanning block %d state %d seq %d" TENDSTR), blk, -+ state, sequenceNumber)); ++ state, seq_number)); + + + if (state == YAFFS_BLOCK_STATE_CHECKPOINT) { -+ dev->blocksInCheckpoint++; ++ dev->blocks_in_checkpt++; + + } else if (state == YAFFS_BLOCK_STATE_DEAD) { + T(YAFFS_TRACE_BAD_BLOCKS, @@ -22977,27 +26215,27 @@ + } else if (state == YAFFS_BLOCK_STATE_EMPTY) { + T(YAFFS_TRACE_SCAN_DEBUG, + (TSTR("Block empty " TENDSTR))); -+ dev->nErasedBlocks++; -+ dev->nFreeChunks += dev->param.nChunksPerBlock; ++ dev->n_erased_blocks++; ++ dev->n_free_chunks += dev->param.chunks_per_block; + } else if (state == YAFFS_BLOCK_STATE_NEEDS_SCANNING) { + + /* Determine the highest sequence number */ -+ if (sequenceNumber >= YAFFS_LOWEST_SEQUENCE_NUMBER && -+ sequenceNumber < YAFFS_HIGHEST_SEQUENCE_NUMBER) { ++ if (seq_number >= YAFFS_LOWEST_SEQUENCE_NUMBER && ++ seq_number < YAFFS_HIGHEST_SEQUENCE_NUMBER) { + -+ blockIndex[nBlocksToScan].seq = sequenceNumber; ++ blockIndex[nBlocksToScan].seq = seq_number; + blockIndex[nBlocksToScan].block = blk; + + nBlocksToScan++; + -+ if (sequenceNumber >= dev->sequenceNumber) -+ dev->sequenceNumber = sequenceNumber; ++ if (seq_number >= dev->seq_number) ++ dev->seq_number = seq_number; + } else { + /* TODO: Nasty sequence number! */ + T(YAFFS_TRACE_SCAN, + (TSTR + ("Block scanning block %d has bad sequence number %d" -+ TENDSTR), blk, sequenceNumber)); ++ TENDSTR), blk, seq_number)); + + } + } @@ -23034,16 +26272,16 @@ + /* get the block to scan in the correct order */ + blk = blockIndex[blockIterator].block; + -+ bi = yaffs_GetBlockInfo(dev, blk); ++ bi = yaffs_get_block_info(dev, blk); + + -+ state = bi->blockState; ++ state = bi->block_state; + + deleted = 0; + + /* For each chunk in each block that needs scanning.... */ + foundChunksInBlock = 0; -+ for (c = dev->param.nChunksPerBlock - 1; ++ for (c = dev->param.chunks_per_block - 1; + !alloc_failed && c >= 0 && + (state == YAFFS_BLOCK_STATE_NEEDS_SCANNING || + state == YAFFS_BLOCK_STATE_ALLOCATING); c--) { @@ -23051,14 +26289,14 @@ + * Read the tags and decide what to do + */ + -+ chunk = blk * dev->param.nChunksPerBlock + c; ++ chunk = blk * dev->param.chunks_per_block + c; + -+ result = yaffs_ReadChunkWithTagsFromNAND(dev, chunk, NULL, ++ result = yaffs_rd_chunk_tags_nand(dev, chunk, NULL, + &tags); + + /* Let's have a good look at this chunk... */ + -+ if (!tags.chunkUsed) { ++ if (!tags.chunk_used) { + /* An unassigned chunk in the block. + * If there are used chunks after this one, then + * it is a chunk that was skipped due to failing the erased @@ -23073,11 +26311,11 @@ + } else if (c == 0) { + /* We're looking at the first chunk in the block so the block is unused */ + state = YAFFS_BLOCK_STATE_EMPTY; -+ dev->nErasedBlocks++; ++ dev->n_erased_blocks++; + } else { + if (state == YAFFS_BLOCK_STATE_NEEDS_SCANNING || + state == YAFFS_BLOCK_STATE_ALLOCATING) { -+ if (dev->sequenceNumber == bi->sequenceNumber) { ++ if (dev->seq_number == bi->seq_number) { + /* this is the block being allocated from */ + + T(YAFFS_TRACE_SCAN, @@ -23086,9 +26324,9 @@ + TENDSTR), blk, c)); + + state = YAFFS_BLOCK_STATE_ALLOCATING; -+ dev->allocationBlock = blk; -+ dev->allocationPage = c; -+ dev->allocationBlockFinder = blk; ++ dev->alloc_block = blk; ++ dev->alloc_page = c; ++ dev->alloc_block_finder = blk; + } else { + /* This is a partially written block that is not + * the current allocation block. @@ -23101,40 +26339,40 @@ + } + } + -+ dev->nFreeChunks++; ++ dev->n_free_chunks++; + -+ } else if (tags.eccResult == YAFFS_ECC_RESULT_UNFIXED) { ++ } else if (tags.ecc_result == YAFFS_ECC_RESULT_UNFIXED) { + T(YAFFS_TRACE_SCAN, + (TSTR(" Unfixed ECC in chunk(%d:%d), chunk ignored"TENDSTR), + blk, c)); + -+ dev->nFreeChunks++; ++ dev->n_free_chunks++; + -+ } else if (tags.objectId > YAFFS_MAX_OBJECT_ID || -+ tags.chunkId > YAFFS_MAX_CHUNK_ID || -+ (tags.chunkId > 0 && tags.byteCount > dev->nDataBytesPerChunk) || -+ tags.sequenceNumber != bi->sequenceNumber ) { ++ } else if (tags.obj_id > YAFFS_MAX_OBJECT_ID || ++ tags.chunk_id > YAFFS_MAX_CHUNK_ID || ++ (tags.chunk_id > 0 && tags.n_bytes > dev->data_bytes_per_chunk) || ++ tags.seq_number != bi->seq_number ) { + T(YAFFS_TRACE_SCAN, -+ (TSTR("Chunk (%d:%d) with bad tags:obj = %d, chunkId = %d, byteCount = %d, ignored"TENDSTR), -+ blk, c,tags.objectId, tags.chunkId, tags.byteCount)); ++ (TSTR("Chunk (%d:%d) with bad tags:obj = %d, chunk_id = %d, n_bytes = %d, ignored"TENDSTR), ++ blk, c,tags.obj_id, tags.chunk_id, tags.n_bytes)); + -+ dev->nFreeChunks++; ++ dev->n_free_chunks++; + -+ } else if (tags.chunkId > 0) { -+ /* chunkId > 0 so it is a data chunk... */ ++ } else if (tags.chunk_id > 0) { ++ /* chunk_id > 0 so it is a data chunk... */ + unsigned int endpos; + __u32 chunkBase = -+ (tags.chunkId - 1) * dev->nDataBytesPerChunk; ++ (tags.chunk_id - 1) * dev->data_bytes_per_chunk; + + foundChunksInBlock = 1; + + -+ yaffs_SetChunkBit(dev, blk, c); -+ bi->pagesInUse++; ++ yaffs_set_chunk_bit(dev, blk, c); ++ bi->pages_in_use++; + -+ in = yaffs_FindOrCreateObjectByNumber(dev, ++ in = yaffs_find_or_create_by_number(dev, + tags. -+ objectId, ++ obj_id, + YAFFS_OBJECT_TYPE_FILE); + if (!in) { + /* Out of memory */ @@ -23142,77 +26380,77 @@ + } + + if (in && -+ in->variantType == YAFFS_OBJECT_TYPE_FILE -+ && chunkBase < in->variant.fileVariant.shrinkSize) { ++ in->variant_type == YAFFS_OBJECT_TYPE_FILE ++ && chunkBase < in->variant.file_variant.shrink_size) { + /* This has not been invalidated by a resize */ -+ if (!yaffs_PutChunkIntoFile(in, tags.chunkId, chunk, -1)) { ++ if (!yaffs_put_chunk_in_file(in, tags.chunk_id, chunk, -1)) { + alloc_failed = 1; + } + + /* File size is calculated by looking at the data chunks if we have not + * seen an object header yet. Stop this practice once we find an object header. + */ -+ endpos = chunkBase + tags.byteCount; ++ endpos = chunkBase + tags.n_bytes; + + if (!in->valid && /* have not got an object header yet */ -+ in->variant.fileVariant.scannedFileSize < endpos) { -+ in->variant.fileVariant.scannedFileSize = endpos; -+ in->variant.fileVariant.fileSize = endpos; ++ in->variant.file_variant.scanned_size < endpos) { ++ in->variant.file_variant.scanned_size = endpos; ++ in->variant.file_variant.file_size = endpos; + } + + } else if (in) { + /* This chunk has been invalidated by a resize, or a past file deletion + * so delete the chunk*/ -+ yaffs_DeleteChunk(dev, chunk, 1, __LINE__); ++ yaffs_chunk_del(dev, chunk, 1, __LINE__); + + } + } else { -+ /* chunkId == 0, so it is an ObjectHeader. ++ /* chunk_id == 0, so it is an ObjectHeader. + * Thus, we read in the object header and make the object + */ + foundChunksInBlock = 1; + -+ yaffs_SetChunkBit(dev, blk, c); -+ bi->pagesInUse++; ++ yaffs_set_chunk_bit(dev, blk, c); ++ bi->pages_in_use++; + + oh = NULL; + in = NULL; + -+ if (tags.extraHeaderInfoAvailable) { -+ in = yaffs_FindOrCreateObjectByNumber(dev, -+ tags.objectId, -+ tags.extraObjectType); ++ if (tags.extra_available) { ++ in = yaffs_find_or_create_by_number(dev, ++ tags.obj_id, ++ tags.extra_obj_type); + if (!in) + alloc_failed = 1; + } + + if (!in || -+ (!in->valid && dev->param.disableLazyLoad) || -+ tags.extraShadows || ++ (!in->valid && dev->param.disable_lazy_load) || ++ tags.extra_shadows || + (!in->valid && -+ (tags.objectId == YAFFS_OBJECTID_ROOT || -+ tags.objectId == YAFFS_OBJECTID_LOSTNFOUND))) { ++ (tags.obj_id == YAFFS_OBJECTID_ROOT || ++ tags.obj_id == YAFFS_OBJECTID_LOSTNFOUND))) { + + /* If we don't have valid info then we need to read the chunk + * TODO In future we can probably defer reading the chunk and + * living with invalid data until needed. + */ + -+ result = yaffs_ReadChunkWithTagsFromNAND(dev, ++ result = yaffs_rd_chunk_tags_nand(dev, + chunk, + chunkData, + NULL); + -+ oh = (yaffs_ObjectHeader *) chunkData; ++ oh = (yaffs_obj_header *) chunkData; + -+ if (dev->param.inbandTags) { ++ if (dev->param.inband_tags) { + /* Fix up the header if they got corrupted by inband tags */ -+ oh->shadowsObject = oh->inbandShadowsObject; -+ oh->isShrink = oh->inbandIsShrink; ++ oh->shadows_obj = oh->inband_shadowed_obj_id; ++ oh->is_shrink = oh->inband_is_shrink; + } + + if (!in) { -+ in = yaffs_FindOrCreateObjectByNumber(dev, tags.objectId, oh->type); ++ in = yaffs_find_or_create_by_number(dev, tags.obj_id, oh->type); + if (!in) + alloc_failed = 1; + } @@ -23224,7 +26462,7 @@ + T(YAFFS_TRACE_ERROR, + (TSTR + ("yaffs tragedy: Could not make object for object %d at chunk %d during scan" -+ TENDSTR), tags.objectId, chunk)); ++ TENDSTR), tags.obj_id, chunk)); + continue; + } + @@ -23234,61 +26472,61 @@ + * we first have to suck out resize info if it is a file. + */ + -+ if ((in->variantType == YAFFS_OBJECT_TYPE_FILE) && ++ if ((in->variant_type == YAFFS_OBJECT_TYPE_FILE) && + ((oh && + oh->type == YAFFS_OBJECT_TYPE_FILE) || -+ (tags.extraHeaderInfoAvailable && -+ tags.extraObjectType == YAFFS_OBJECT_TYPE_FILE))) { ++ (tags.extra_available && ++ tags.extra_obj_type == YAFFS_OBJECT_TYPE_FILE))) { + __u32 thisSize = -+ (oh) ? oh->fileSize : tags. -+ extraFileLength; -+ __u32 parentObjectId = ++ (oh) ? oh->file_size : tags. ++ extra_length; ++ __u32 parent_obj_id = + (oh) ? oh-> -+ parentObjectId : tags. -+ extraParentObjectId; ++ parent_obj_id : tags. ++ extra_parent_id; + + -+ isShrink = -+ (oh) ? oh->isShrink : tags. -+ extraIsShrinkHeader; ++ is_shrink = ++ (oh) ? oh->is_shrink : tags. ++ extra_is_shrink; + + /* If it is deleted (unlinked at start also means deleted) + * we treat the file size as being zeroed at this point. + */ -+ if (parentObjectId == ++ if (parent_obj_id == + YAFFS_OBJECTID_DELETED -+ || parentObjectId == ++ || parent_obj_id == + YAFFS_OBJECTID_UNLINKED) { + thisSize = 0; -+ isShrink = 1; ++ is_shrink = 1; + } + -+ if (isShrink && in->variant.fileVariant.shrinkSize > thisSize) -+ in->variant.fileVariant.shrinkSize = thisSize; ++ if (is_shrink && in->variant.file_variant.shrink_size > thisSize) ++ in->variant.file_variant.shrink_size = thisSize; + -+ if (isShrink) -+ bi->hasShrinkHeader = 1; ++ if (is_shrink) ++ bi->has_shrink_hdr = 1; + + } + /* Use existing - destroy this one. */ -+ yaffs_DeleteChunk(dev, chunk, 1, __LINE__); ++ yaffs_chunk_del(dev, chunk, 1, __LINE__); + + } + -+ if (!in->valid && in->variantType != -+ (oh ? oh->type : tags.extraObjectType)) ++ if (!in->valid && in->variant_type != ++ (oh ? oh->type : tags.extra_obj_type)) + T(YAFFS_TRACE_ERROR, ( + TSTR("yaffs tragedy: Bad object type, " + TCONT("%d != %d, for object %d at chunk ") + TCONT("%d during scan") + TENDSTR), oh ? -+ oh->type : tags.extraObjectType, -+ in->variantType, tags.objectId, ++ oh->type : tags.extra_obj_type, ++ in->variant_type, tags.obj_id, + chunk)); + + if (!in->valid && -+ (tags.objectId == YAFFS_OBJECTID_ROOT || -+ tags.objectId == ++ (tags.obj_id == YAFFS_OBJECTID_ROOT || ++ tags.obj_id == + YAFFS_OBJECTID_LOSTNFOUND)) { + /* We only load some info, don't fiddle with directory structure */ + in->valid = 1; @@ -23311,22 +26549,22 @@ + in->yst_ctime = oh->yst_ctime; + in->yst_rdev = oh->yst_rdev; + -+ in->lazyLoaded = 0; ++ in->lazy_loaded = 0; + +#endif + } else -+ in->lazyLoaded = 1; ++ in->lazy_loaded = 1; + -+ in->hdrChunk = chunk; ++ in->hdr_chunk = chunk; + + } else if (!in->valid) { + /* we need to load this info */ + + in->valid = 1; -+ in->hdrChunk = chunk; ++ in->hdr_chunk = chunk; + + if (oh) { -+ in->variantType = oh->type; ++ in->variant_type = oh->type; + + in->yst_mode = oh->yst_mode; +#ifdef CONFIG_YAFFS_WINCE @@ -23345,34 +26583,34 @@ + in->yst_rdev = oh->yst_rdev; +#endif + -+ if (oh->shadowsObject > 0) -+ yaffs_HandleShadowedObject(dev, ++ if (oh->shadows_obj > 0) ++ yaffs_handle_shadowed_obj(dev, + oh-> -+ shadowsObject, ++ shadows_obj, + 1); + + + -+ yaffs_SetObjectNameFromOH(in, oh); ++ yaffs_set_obj_name_from_oh(in, oh); + parent = -+ yaffs_FindOrCreateObjectByNumber -+ (dev, oh->parentObjectId, ++ yaffs_find_or_create_by_number ++ (dev, oh->parent_obj_id, + YAFFS_OBJECT_TYPE_DIRECTORY); + -+ fileSize = oh->fileSize; -+ isShrink = oh->isShrink; -+ equivalentObjectId = oh->equivalentObjectId; ++ file_size = oh->file_size; ++ is_shrink = oh->is_shrink; ++ equiv_id = oh->equiv_id; + + } else { -+ in->variantType = tags.extraObjectType; ++ in->variant_type = tags.extra_obj_type; + parent = -+ yaffs_FindOrCreateObjectByNumber -+ (dev, tags.extraParentObjectId, ++ yaffs_find_or_create_by_number ++ (dev, tags.extra_parent_id, + YAFFS_OBJECT_TYPE_DIRECTORY); -+ fileSize = tags.extraFileLength; -+ isShrink = tags.extraIsShrinkHeader; -+ equivalentObjectId = tags.extraEquivalentObjectId; -+ in->lazyLoaded = 1; ++ file_size = tags.extra_length; ++ is_shrink = tags.extra_is_shrink; ++ equiv_id = tags.extra_equiv_id; ++ in->lazy_loaded = 1; + + } + in->dirty = 0; @@ -23384,15 +26622,15 @@ + * hook up to parent + */ + -+ if (parent && parent->variantType == ++ if (parent && parent->variant_type == + YAFFS_OBJECT_TYPE_UNKNOWN) { + /* Set up as a directory */ -+ parent->variantType = ++ parent->variant_type = + YAFFS_OBJECT_TYPE_DIRECTORY; + YINIT_LIST_HEAD(&parent->variant. -+ directoryVariant. ++ dir_variant. + children); -+ } else if (!parent || parent->variantType != ++ } else if (!parent || parent->variant_type != + YAFFS_OBJECT_TYPE_DIRECTORY) { + /* Hoosterman, another problem.... + * We're trying to use a non-directory as a directory @@ -23402,17 +26640,17 @@ + (TSTR + ("yaffs tragedy: attempting to use non-directory as a directory in scan. Put in lost+found." + TENDSTR))); -+ parent = dev->lostNFoundDir; ++ parent = dev->lost_n_found; + } + -+ yaffs_AddObjectToDirectory(parent, in); ++ yaffs_add_obj_to_dir(parent, in); + -+ itsUnlinked = (parent == dev->deletedDir) || -+ (parent == dev->unlinkedDir); ++ itsUnlinked = (parent == dev->del_dir) || ++ (parent == dev->unlinked_dir); + -+ if (isShrink) { ++ if (is_shrink) { + /* Mark the block as having a shrinkHeader */ -+ bi->hasShrinkHeader = 1; ++ bi->has_shrink_hdr = 1; + } + + /* Note re hardlinks. @@ -23422,35 +26660,35 @@ + * through this list and fix up all the chains. + */ + -+ switch (in->variantType) { ++ switch (in->variant_type) { + case YAFFS_OBJECT_TYPE_UNKNOWN: + /* Todo got a problem */ + break; + case YAFFS_OBJECT_TYPE_FILE: + -+ if (in->variant.fileVariant. -+ scannedFileSize < fileSize) { ++ if (in->variant.file_variant. ++ scanned_size < file_size) { + /* This covers the case where the file size is greater + * than where the data is + * This will happen if the file is resized to be larger + * than its current data extents. + */ -+ in->variant.fileVariant.fileSize = fileSize; -+ in->variant.fileVariant.scannedFileSize = fileSize; ++ in->variant.file_variant.file_size = file_size; ++ in->variant.file_variant.scanned_size = file_size; + } + -+ if (in->variant.fileVariant.shrinkSize > fileSize) -+ in->variant.fileVariant.shrinkSize = fileSize; ++ if (in->variant.file_variant.shrink_size > file_size) ++ in->variant.file_variant.shrink_size = file_size; + + + break; + case YAFFS_OBJECT_TYPE_HARDLINK: + if (!itsUnlinked) { -+ in->variant.hardLinkVariant.equivalentObjectId = -+ equivalentObjectId; -+ in->hardLinks.next = -+ (struct ylist_head *) hardList; -+ hardList = in; ++ in->variant.hardlink_variant.equiv_id = ++ equiv_id; ++ in->hard_links.next = ++ (struct ylist_head *) hard_list; ++ hard_list = in; + } + break; + case YAFFS_OBJECT_TYPE_DIRECTORY: @@ -23461,9 +26699,9 @@ + break; + case YAFFS_OBJECT_TYPE_SYMLINK: + if (oh) { -+ in->variant.symLinkVariant.alias = -+ yaffs_CloneString(oh->alias); -+ if (!in->variant.symLinkVariant.alias) ++ in->variant.symlink_variant.alias = ++ yaffs_clone_str(oh->alias); ++ if (!in->variant.symlink_variant.alias) + alloc_failed = 1; + } + break; @@ -23481,18 +26719,18 @@ + } + + -+ bi->blockState = state; ++ bi->block_state = state; + + /* Now let's see if it was dirty */ -+ if (bi->pagesInUse == 0 && -+ !bi->hasShrinkHeader && -+ bi->blockState == YAFFS_BLOCK_STATE_FULL) { -+ yaffs_BlockBecameDirty(dev, blk); ++ if (bi->pages_in_use == 0 && ++ !bi->has_shrink_hdr && ++ bi->block_state == YAFFS_BLOCK_STATE_FULL) { ++ yaffs_block_became_dirty(dev, blk); + } + + } + -+ yaffs_SkipRestOfBlock(dev); ++ yaffs_skip_rest_of_block(dev); + + if (altBlockIndex) + YFREE_ALT(blockIndex); @@ -23504,20 +26742,21 @@ + * We should now have scanned all the objects, now it's time to add these + * hardlinks. + */ -+ yaffs_HardlinkFixup(dev, hardList); ++ yaffs_link_fixup(dev, hard_list); + + -+ yaffs_ReleaseTempBuffer(dev, chunkData, __LINE__); ++ yaffs_release_temp_buffer(dev, chunkData, __LINE__); + + if (alloc_failed) + return YAFFS_FAIL; + -+ T(YAFFS_TRACE_SCAN, (TSTR("yaffs2_ScanBackwards ends" TENDSTR))); ++ T(YAFFS_TRACE_SCAN, (TSTR("yaffs2_scan_backwards ends" TENDSTR))); + + return YAFFS_OK; +} ---- /dev/null -+++ b/fs/yaffs2/yaffs_yaffs2.h +diff -Nrup linux-2.6.36-rc8/fs/yaffs2/yaffs_yaffs2.h linux-2.6.36-rc8.new/fs/yaffs2/yaffs_yaffs2.h +--- linux-2.6.36-rc8/fs/yaffs2/yaffs_yaffs2.h 1970-01-01 02:00:00.000000000 +0200 ++++ linux-2.6.36-rc8.new/fs/yaffs2/yaffs_yaffs2.h 2010-10-20 13:28:16.067000294 +0300 @@ -0,0 +1,36 @@ +/* + * YAFFS: Yet Another Flash File System. A NAND-flash specific file system. @@ -23537,26 +26776,27 @@ + +#include "yaffs_guts.h" + -+void yaffs2_CalcOldestDirtySequence(yaffs_Device *dev); -+void yaffs2_FindOldestDirtySequence(yaffs_Device *dev); -+void yaffs2_ClearOldestDirtySequence(yaffs_Device *dev, yaffs_BlockInfo *bi); -+void yaffs2_UpdateOldestDirtySequence(yaffs_Device *dev, unsigned blockNo, yaffs_BlockInfo *bi); -+int yaffs2_BlockNotDisqualifiedFromGC(yaffs_Device *dev, yaffs_BlockInfo *bi); -+__u32 yaffs2_FindRefreshBlock(yaffs_Device *dev); -+int yaffs2_CheckpointRequired(yaffs_Device *dev); -+int yaffs2_CalcCheckpointBlocksRequired(yaffs_Device *dev); ++void yaffs_calc_oldest_dirty_seq(yaffs_dev_t *dev); ++void yaffs2_find_oldest_dirty_seq(yaffs_dev_t *dev); ++void yaffs2_clear_oldest_dirty_seq(yaffs_dev_t *dev, yaffs_block_info_t *bi); ++void yaffs2_update_oldest_dirty_seq(yaffs_dev_t *dev, unsigned block_no, yaffs_block_info_t *bi); ++int yaffs_block_ok_for_gc(yaffs_dev_t *dev, yaffs_block_info_t *bi); ++__u32 yaffs2_find_refresh_block(yaffs_dev_t *dev); ++int yaffs2_checkpt_required(yaffs_dev_t *dev); ++int yaffs_calc_checkpt_blocks_required(yaffs_dev_t *dev); + + -+void yaffs2_InvalidateCheckpoint(yaffs_Device *dev); -+int yaffs2_CheckpointSave(yaffs_Device *dev); -+int yaffs2_CheckpointRestore(yaffs_Device *dev); ++void yaffs2_checkpt_invalidate(yaffs_dev_t *dev); ++int yaffs2_checkpt_save(yaffs_dev_t *dev); ++int yaffs2_checkpt_restore(yaffs_dev_t *dev); + -+int yaffs2_HandleHole(yaffs_Object *obj, loff_t newSize); -+int yaffs2_ScanBackwards(yaffs_Device *dev); ++int yaffs2_handle_hole(yaffs_obj_t *obj, loff_t new_size); ++int yaffs2_scan_backwards(yaffs_dev_t *dev); + +#endif ---- a/fs/yaffs2/yportenv.h -+++ b/fs/yaffs2/yportenv.h +diff -Nrup linux-2.6.36-rc8/fs/yaffs2/yportenv.h linux-2.6.36-rc8.new/fs/yaffs2/yportenv.h +--- linux-2.6.36-rc8/fs/yaffs2/yportenv.h 2010-10-20 13:17:58.988000294 +0300 ++++ linux-2.6.36-rc8.new/fs/yaffs2/yportenv.h 2010-10-20 13:28:16.067000294 +0300 @@ -1,7 +1,7 @@ /* * YAFFS: Yet another Flash File System . A NAND-flash specific file system. @@ -23610,7 +26850,12 @@ #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0)) #define Y_CURRENT_TIME CURRENT_TIME.tv_sec -@@ -89,15 +91,10 @@ +@@ -85,19 +87,14 @@ + #define Y_TIME_CONVERT(x) (x) + #endif + +-#define yaffs_SumCompare(x, y) ((x) == (y)) ++#define yaffs_sum_cmp(x, y) ((x) == (y)) #define yaffs_strcmp(a, b) strcmp(a, b) #define TENDSTR "\n" @@ -23644,7 +26889,7 @@ #define yaffs_sprintf sprintf #define yaffs_toupper(a) toupper(a) -@@ -146,8 +142,8 @@ +@@ -146,10 +142,10 @@ #define YAFFS_LOSTNFOUND_PREFIX "obj" /* #define YPRINTF(x) printf x */ @@ -23653,8 +26898,11 @@ +#define YAFFS_ROOT_MODE 0755 +#define YAFFS_LOSTNFOUND_MODE 0700 - #define yaffs_SumCompare(x, y) ((x) == (y)) +-#define yaffs_SumCompare(x, y) ((x) == (y)) ++#define yaffs_sum_cmp(x, y) ((x) == (y)) #define yaffs_strcmp(a, b) strcmp(a, b) + + #else @@ -158,46 +154,180 @@ #endif |