Merge branch 'mainlining'
authorCharles Manning <cdhmanning@gmail.com>
Fri, 10 Dec 2010 02:58:57 +0000 (15:58 +1300)
committerCharles Manning <cdhmanning@gmail.com>
Fri, 10 Dec 2010 02:58:57 +0000 (15:58 +1300)
36 files changed:
direct/basic-test/yaffs_fileem.c
direct/basic-test/yaffs_fileem2k.c
direct/basic-test/yaffs_norif1.c
direct/basic-test/yaffs_ramdisk.c
direct/basic-test/yaffs_ramem2k.c
direct/basic-test/yramsim.c
direct/yaffs_attribs.c
direct/yaffs_flashif.c
direct/yaffs_list.h
direct/yaffs_nandif.c
direct/yaffsfs.c
direct/ydirectenv.h
direct/yportenv.h
patches/yaffs_linux_allocator.c
yaffs_allocator.c
yaffs_attribs.c
yaffs_bitmap.c
yaffs_checkptrw.c
yaffs_getblockinfo.h
yaffs_guts.c
yaffs_mtdif1_multi.c
yaffs_mtdif1_single.c
yaffs_mtdif2_multi.c
yaffs_mtdif2_single.c
yaffs_nameval.c
yaffs_nand.c
yaffs_packedtags2.c
yaffs_tagscompat.c
yaffs_trace.h
yaffs_verify.c
yaffs_vfs_multi.c
yaffs_vfs_single.c
yaffs_yaffs1.c
yaffs_yaffs2.c
yportenv_multi.h
yportenv_single.h

index 702acbe..66ba93a 100644 (file)
@@ -185,7 +185,9 @@ int yflash_EraseBlockInNAND(struct yaffs_dev *dev, int blockNumber)
        
        if(blockNumber < 0 || blockNumber >= filedisk.nBlocks)
        {
-               T(YAFFS_TRACE_ALWAYS,("Attempt to erase non-existant block %d\n",blockNumber));
+               yaffs_trace(YAFFS_TRACE_ALWAYS,
+                       "Attempt to erase non-existant block %d\n",
+                       blockNumber);
                return YAFFS_FAIL;
        }
        else
index 51c3aa4..52f1e11 100644 (file)
@@ -179,7 +179,7 @@ int yflash2_WriteChunkWithTagsToNAND(struct yaffs_dev *dev,int nand_chunk,const
        int nRead;
        int error;
        
-       T(YAFFS_TRACE_MTD,(TSTR("write chunk %d data %p tags %p" TENDSTR),nand_chunk, data, tags));
+       yaffs_trace(YAFFS_TRACE_MTD, "write chunk %d data %p tags %p",nand_chunk, data, tags);
 
        CheckInit();
        
@@ -396,7 +396,7 @@ int yflash2_ReadChunkWithTagsFromNAND(struct yaffs_dev *dev,int nand_chunk, u8 *
        int retval = YAFFS_OK;
        int nRead;
        
-       T(YAFFS_TRACE_MTD,(TSTR("read chunk %d data %p tags %p" TENDSTR),nand_chunk, data, tags));
+       yaffs_trace(YAFFS_TRACE_MTD,"read chunk %d data %p tags %p",nand_chunk, data, tags);
        
        CheckInit();
        
@@ -543,7 +543,7 @@ int yflash2_EraseBlockInNAND(struct yaffs_dev *dev, int blockNumber)
        
        if(blockNumber < 0 || blockNumber >= filedisk.nBlocks)
        {
-               T(YAFFS_TRACE_ALWAYS,("Attempt to erase non-existant block %d\n",blockNumber));
+               yaffs_trace(YAFFS_TRACE_ALWAYS,"Attempt to erase non-existant block %d",blockNumber);
                return YAFFS_FAIL;
        }
        else
index 7be6295..5394f0e 100644 (file)
@@ -272,7 +272,9 @@ int ynorif1_EraseBlockInNAND(struct yaffs_dev *dev, int blockNumber)
 
        if(blockNumber < 0 || blockNumber >= BLOCKS_IN_DEVICE)
        {
-               T(YAFFS_TRACE_ALWAYS,("Attempt to erase non-existant block %d\n",blockNumber));
+               yaffs_trace(YAFFS_TRACE_ALWAYS,
+                       "Attempt to erase non-existant block %d\n",
+                       blockNumber);
                return YAFFS_FAIL;
        }
        else
index babddde..5d389b9 100644 (file)
@@ -79,7 +79,7 @@ static int  CheckInit(struct yaffs_dev *dev)
        
        ramdisk.nBlocks = (SIZE_IN_MB * 1024 * 1024)/(16 * 1024);
        
-       ramdisk.block = YMALLOC(sizeof(yramdisk_block *) * ramdisk.nBlocks);
+       ramdisk.block = malloc(sizeof(yramdisk_block *) * ramdisk.nBlocks);
        
        if(!ramdisk.block) return 0;
        
@@ -90,7 +90,7 @@ static int  CheckInit(struct yaffs_dev *dev)
        
        for(i=0; i <ramdisk.nBlocks && !fail; i++)
        {
-               if((ramdisk.block[i] = YMALLOC(sizeof(yramdisk_block))) == 0)
+               if((ramdisk.block[i] = malloc(sizeof(yramdisk_block))) == 0)
                {
                        fail = 1;
                }
@@ -105,12 +105,13 @@ static int  CheckInit(struct yaffs_dev *dev)
        {
                for(i = 0; i < nAllocated; i++)
                {
-                       YFREE(ramdisk.block[i]);
+                       kfree(ramdisk.block[i]);
                }
-               YFREE(ramdisk.block);
+               kfree(ramdisk.block);
                
-               T(YAFFS_TRACE_ALWAYS,("Allocation failed, could only allocate %dMB of %dMB requested.\n",
-                  nAllocated/64,ramdisk.nBlocks * 528));
+               yaffs_trace(YAFFS_TRACE_ALWAYS,
+                       "Allocation failed, could only allocate %dMB of %dMB requested.\n",
+                       nAllocated/64,ramdisk.nBlocks * 528);
                return 0;
        }
        
@@ -212,7 +213,9 @@ int yramdisk_erase(struct yaffs_dev *dev, int blockNumber)
        
        if(blockNumber < 0 || blockNumber >= ramdisk.nBlocks)
        {
-               T(YAFFS_TRACE_ALWAYS,("Attempt to erase non-existant block %d\n",blockNumber));
+               yaffs_trace(YAFFS_TRACE_ALWAYS,
+                       "Attempt to erase non-existant block %d\n",
+                       blockNumber);
                return YAFFS_FAIL;
        }
        else
@@ -231,4 +234,3 @@ int yramdisk_initialise(struct yaffs_dev *dev)
        return YAFFS_OK;
 }
 
-
index 7f88b7c..e86760b 100644 (file)
@@ -135,7 +135,7 @@ static int  CheckInit(void)
        ned.nBlocks = nBlocks = nandemul2k_CalcNBlocks();
 
        
-       ned.block = YMALLOC(sizeof(nandemul_Block*) * nBlocks );
+       ned.block = malloc(sizeof(nandemul_Block*) * nBlocks );
        
        if(!ned.block) return YAFFS_FAIL;
        
@@ -148,7 +148,7 @@ static int  CheckInit(void)
                
                nandemul_Block *blk;
                
-               if(!(blk = ned.block[i] = YMALLOC(sizeof(nandemul_Block))))
+               if(!(blk = ned.block[i] = malloc(sizeof(nandemul_Block))))
                {
                 fail = 1;
                }  
@@ -156,7 +156,7 @@ static int  CheckInit(void)
                {
                        for(j = 0; j < PAGES_PER_BLOCK; j++)
                        {
-                               if((blk->page[j] = YMALLOC(sizeof(nandemul_Page))) == 0)
+                               if((blk->page[j] = malloc(sizeof(nandemul_Page))) == 0)
                                {
                                        fail = 1;
                                }
@@ -173,12 +173,13 @@ static int  CheckInit(void)
                
                for(i = 0; i < nAllocated; i++)
                {
-                       YFREE(ned.block[i]);
+                       kfree(ned.block[i]);
                }
-               YFREE(ned.block);
+               kfree(ned.block);
                
-               T(YAFFS_TRACE_ALWAYS,("Allocation failed, could only allocate %dMB of %dMB requested.\n",
-                  nAllocated/64,sizeInMB));
+               yaffs_trace(YAFFS_TRACE_ALWAYS,
+                       "Allocation failed, could only allocate %dMB of %dMB requested.\n",
+                       nAllocated/64,sizeInMB);
                return 0;
        }
        
@@ -292,11 +293,15 @@ int nandemul2k_EraseBlockInNAND(struct yaffs_dev *dev, int blockNumber)
        
        if(blockNumber < 0 || blockNumber >= ned.nBlocks)
        {
-               T(YAFFS_TRACE_ALWAYS,("Attempt to erase non-existant block %d\n",blockNumber));
+               yaffs_trace(YAFFS_TRACE_ALWAYS,
+                       "Attempt to erase non-existant block %d\n",
+                       blockNumber);
        }
        else if(ned.block[blockNumber]->damaged)
        {
-               T(YAFFS_TRACE_ALWAYS,("Attempt to erase damaged block %d\n",blockNumber));
+               yaffs_trace(YAFFS_TRACE_ALWAYS,
+                       "Attempt to erase damaged block %d\n",
+                       blockNumber);
        }
        else
        {
index 9b50a39..1fbf5fe 100644 (file)
@@ -260,11 +260,11 @@ struct yaffs_dev *yramsim_CreateRamSim(const YCHAR *name,
 
        sim = yramsim_alloc_sim_data(devId, nBlocks);
 
-       g = YMALLOC(sizeof(ynandif_Geometry));
+       g = malloc(sizeof(ynandif_Geometry));
 
        if(!sim || !g){
                if(g)
-                       YFREE(g);
+                       free(g);
                return NULL;
        }
 
index 89cd7fc..86e5e6e 100644 (file)
@@ -92,7 +92,7 @@ loff_t yaffs_get_file_size(struct yaffs_obj *obj)
                alias = obj->variant.symlink_variant.alias;
                if(!alias)
                        return 0;
-               return yaffs_strnlen(alias,YAFFS_MAX_ALIAS_LENGTH);
+               return strnlen(alias,YAFFS_MAX_ALIAS_LENGTH);
        default:
                return 0;
        }
index 8595804..95ac613 100644 (file)
@@ -67,7 +67,7 @@ static int  CheckInit(struct yaffs_dev *dev)
        
        ramdisk.nBlocks = (SIZE_IN_MB * 1024 * 1024)/(16 * 1024);
        
-       ramdisk.block = YMALLOC(sizeof(yflash_Block *) * ramdisk.nBlocks);
+       ramdisk.block = kmalloc(sizeof(yflash_Block *) * ramdisk.nBlocks);
        
        if(!ramdisk.block) return 0;
        
@@ -78,7 +78,7 @@ static int  CheckInit(struct yaffs_dev *dev)
        
        for(i=0; i <ramdisk.nBlocks && !fail; i++)
        {
-               if((ramdisk.block[i] = YMALLOC(sizeof(yflash_Block))) == 0)
+               if((ramdisk.block[i] = kmalloc(sizeof(yflash_Block))) == 0)
                {
                        fail = 1;
                }
@@ -93,9 +93,9 @@ static int  CheckInit(struct yaffs_dev *dev)
        {
                for(i = 0; i < nAllocated; i++)
                {
-                       YFREE(ramdisk.block[i]);
+                       kfree(ramdisk.block[i]);
                }
-               YFREE(ramdisk.block);
+               kfree(ramdisk.block);
                
                T(YAFFS_TRACE_ALWAYS,("Allocation failed, could only allocate %dMB of %dMB requested.\n",
                   nAllocated/64,ramdisk.nBlocks * YAFFS_BYTES_PER_BLOCK));
index 624cd5f..6bb4646 100644 (file)
@@ -52,7 +52,7 @@ do { \
 
 
 /* Add an element to a list */
-static Y_INLINE void list_add(struct list_head *new_entry,
+static inline void list_add(struct list_head *new_entry,
                                struct list_head *list)
 {
        struct list_head *list_next = list->next;
@@ -64,7 +64,7 @@ static Y_INLINE void list_add(struct list_head *new_entry,
 
 }
 
-static Y_INLINE void list_add_tail(struct list_head *new_entry,
+static inline void list_add_tail(struct list_head *new_entry,
                                 struct list_head *list)
 {
        struct list_head *list_prev = list->prev;
@@ -79,7 +79,7 @@ static Y_INLINE void list_add_tail(struct list_head *new_entry,
 
 /* Take an element out of its current list, with or without
  * reinitialising the links.of the entry*/
-static Y_INLINE void list_del(struct list_head *entry)
+static inline void list_del(struct list_head *entry)
 {
        struct list_head *list_next = entry->next;
        struct list_head *list_prev = entry->prev;
@@ -89,7 +89,7 @@ static Y_INLINE void list_del(struct list_head *entry)
 
 }
 
-static Y_INLINE void list_del_init(struct list_head *entry)
+static inline void list_del_init(struct list_head *entry)
 {
        list_del(entry);
        entry->next = entry->prev = entry;
@@ -97,7 +97,7 @@ static Y_INLINE void list_del_init(struct list_head *entry)
 
 
 /* Test if the list is empty */
-static Y_INLINE int list_empty(struct list_head *entry)
+static inline int list_empty(struct list_head *entry)
 {
        return (entry->next == entry);
 }
index 9a22f7f..e103757 100644 (file)
@@ -39,10 +39,9 @@ int ynandif_WriteChunkWithTagsToNAND(struct yaffs_dev * dev, int nand_chunk,
        unsigned spareSize = 0;
        ynandif_Geometry *geometry = (ynandif_Geometry *)(dev->driver_context);
 
-       T(YAFFS_TRACE_MTD,
-         (TSTR
-          ("nandmtd2_WriteChunkWithTagsToNAND chunk %d data %p tags %p"
-           TENDSTR), nand_chunk, data, tags));
+       yaffs_trace(YAFFS_TRACE_MTD,
+               "nandmtd2_WriteChunkWithTagsToNAND chunk %d data %p tags %p",
+               nand_chunk, data, tags);
            
 
        /* For yaffs2 writing there must be both data and tags.
@@ -52,7 +51,8 @@ int ynandif_WriteChunkWithTagsToNAND(struct yaffs_dev * dev, int nand_chunk,
 
        if(dev->param.inband_tags){
                struct yaffs_packed_tags2_tags_only *pt2tp;
-               pt2tp = (struct yaffs_packed_tags2_tags_only *)(data + dev->data_bytes_per_chunk);
+               pt2tp = (struct yaffs_packed_tags2_tags_only *)
+                       (data + dev->data_bytes_per_chunk);
                yaffs_pack_tags2_tags_only(pt2tp,tags);
                spare = NULL;
                spareSize = 0;
@@ -64,7 +64,8 @@ int ynandif_WriteChunkWithTagsToNAND(struct yaffs_dev * dev, int nand_chunk,
        }
        
        retval = geometry->writeChunk(dev,nand_chunk,
-                                         data, dev->param.total_bytes_per_chunk, spare, spareSize);
+                               data, dev->param.total_bytes_per_chunk,
+                               spare, spareSize);
 
        return retval;
 }
@@ -80,10 +81,9 @@ int ynandif_ReadChunkWithTagsFromNAND(struct yaffs_dev * dev, int nand_chunk,
        int eccStatus; //0 = ok, 1 = fixed, -1 = unfixed
        ynandif_Geometry *geometry = (ynandif_Geometry *)(dev->driver_context);
 
-       T(YAFFS_TRACE_MTD,
-         (TSTR
-          ("nandmtd2_ReadChunkWithTagsFromNAND chunk %d data %p tags %p"
-           TENDSTR), nand_chunk, data, tags));
+       yaffs_trace(YAFFS_TRACE_MTD,
+               "nandmtd2_ReadChunkWithTagsFromNAND chunk %d data %p tags %p",
+               nand_chunk, data, tags);
            
        if(!tags){
                spare = NULL;
@@ -161,7 +161,8 @@ static int ynandif_IsBlockOk(struct yaffs_dev *dev, int blockId)
        return geometry->checkBlockOk(dev,blockId);
 }
 
-int ynandif_QueryNANDBlock(struct yaffs_dev *dev, int blockId, enum yaffs_block_state *state, u32 *seq_number)
+int ynandif_QueryNANDBlock(struct yaffs_dev *dev, int blockId, 
+               enum yaffs_block_state *state, u32 *seq_number)
 {
        unsigned chunkNo;
        struct yaffs_ext_tags tags;
@@ -215,31 +216,31 @@ struct yaffs_dev *
        yaffs_add_dev_from_geometry(const YCHAR *name,
                                        const ynandif_Geometry *geometry)
 {
-       YCHAR *clonedName = YMALLOC(sizeof(YCHAR) * (yaffs_strnlen(name,YAFFS_MAX_NAME_LENGTH)+1));
-       struct yaffs_dev *dev = YMALLOC(sizeof(struct yaffs_dev));
+       YCHAR *clonedName = malloc(sizeof(YCHAR) * (strnlen(name,YAFFS_MAX_NAME_LENGTH)+1));
+       struct yaffs_dev *dev = malloc(sizeof(struct yaffs_dev));
 
        if(dev && clonedName){
                memset(dev,0,sizeof(struct yaffs_dev));
-               yaffs_strcpy(clonedName,name);
+               strcpy(clonedName,name);
 
                dev->param.name = clonedName;
-               dev->param.write_chunk_tags_fn  = ynandif_WriteChunkWithTagsToNAND;
+               dev->param.write_chunk_tags_fn = ynandif_WriteChunkWithTagsToNAND;
                dev->param.read_chunk_tags_fn = ynandif_ReadChunkWithTagsFromNAND;
-               dev->param.erase_fn          = ynandif_EraseBlockInNAND;
-               dev->param.initialise_flash_fn            = ynandif_InitialiseNAND;
-               dev->param.query_block_fn            = ynandif_QueryNANDBlock;
-               dev->param.bad_block_fn          = ynandif_MarkNANDBlockBad;
-               dev->param.n_caches                        = 20;
-               dev->param.start_block                = geometry->start_block;
-               dev->param.end_block                  = geometry->end_block;
-               dev->param.total_bytes_per_chunk                   = geometry->dataSize;
-               dev->param.spare_bytes_per_chunk                   = geometry->spareSize;
-               dev->param.inband_tags                             = geometry->inband_tags;
-               dev->param.chunks_per_block                = geometry->pagesPerBlock;
-               dev->param.use_nand_ecc                            = geometry->hasECC;
-               dev->param.is_yaffs2                               = geometry->useYaffs2;
-               dev->param.n_reserved_blocks               = 5;
-               dev->driver_context                        = (void *)geometry;
+               dev->param.erase_fn = ynandif_EraseBlockInNAND;
+               dev->param.initialise_flash_fn = ynandif_InitialiseNAND;
+               dev->param.query_block_fn = ynandif_QueryNANDBlock;
+               dev->param.bad_block_fn = ynandif_MarkNANDBlockBad;
+               dev->param.n_caches = 20;
+               dev->param.start_block = geometry->start_block;
+               dev->param.end_block   = geometry->end_block;
+               dev->param.total_bytes_per_chunk  = geometry->dataSize;
+               dev->param.spare_bytes_per_chunk  = geometry->spareSize;
+               dev->param.inband_tags            = geometry->inband_tags;
+               dev->param.chunks_per_block       = geometry->pagesPerBlock;
+               dev->param.use_nand_ecc           = geometry->hasECC;
+               dev->param.is_yaffs2              = geometry->useYaffs2;
+               dev->param.n_reserved_blocks      = 5;
+               dev->driver_context               = (void *)geometry;
 
                yaffs_add_device(dev);
 
@@ -247,9 +248,10 @@ struct yaffs_dev *
        }
 
        if(dev)
-               YFREE(dev);
+               free(dev);
        if(clonedName)
-               YFREE(clonedName);
+               free(clonedName);
 
        return NULL;
 }
+
index 64bd94f..e3bc19d 100644 (file)
@@ -405,7 +405,7 @@ int yaffsfs_CheckNameLength(const char *name)
 {
        int retVal = 0;         
 
-       int nameLength = yaffs_strnlen(name,YAFFS_MAX_NAME_LENGTH+1);
+       int nameLength = strnlen(name,YAFFS_MAX_NAME_LENGTH+1);
                
        if(nameLength == 0){
                yaffsfs_SetError(-ENOENT);
@@ -440,7 +440,7 @@ static int yaffsfs_alt_dir_path(const YCHAR *path, YCHAR **ret_path)
         */
        if(path_length > 0 && 
                yaffsfs_IsPathDivider(path[path_length-1])){
-               alt_path = YMALLOC(path_length + 1);
+               alt_path = kmalloc(path_length + 1, 0);
                if(!alt_path)
                        return -1;
                strcpy(alt_path, path);
@@ -650,11 +650,11 @@ static struct yaffs_obj *yaffsfs_DoFindDirectory(struct yaffs_obj *startDir,
                        /* got to the end of the string */
                        return dir;
                else{
-                       if(yaffs_strcmp(str,_Y(".")) == 0)
+                       if(strcmp(str,_Y(".")) == 0)
                        {
                                /* Do nothing */
                        }
-                       else if(yaffs_strcmp(str,_Y("..")) == 0)
+                       else if(strcmp(str,_Y("..")) == 0)
                                dir = dir->parent;
                        else{
                                dir = yaffs_find_by_name(dir,str);
@@ -1421,7 +1421,7 @@ int yaffsfs_DoUnlink(const YCHAR *path,int isDirectory)
                yaffsfs_SetError(-ELOOP);
        else if(!dir)
                yaffsfs_SetError(-ENOENT);
-       else if(yaffs_strncmp(name,_Y("."),2) == 0)
+       else if(strncmp(name,_Y("."),2) == 0)
                yaffsfs_SetError(-EINVAL);
        else if(!obj)
                yaffsfs_SetError(-ENOENT);
@@ -1509,7 +1509,7 @@ int yaffs_rename(const YCHAR *oldPath, const YCHAR *newPath)
        } else if(oldLoop || newLoop) {
                yaffsfs_SetError(-ELOOP);
                rename_allowed = 0;
-       } else if (olddir && oldname && yaffs_strncmp(oldname, _Y("."),2) == 0){
+       } else if (olddir && oldname && strncmp(oldname, _Y("."),2) == 0){
                yaffsfs_SetError(-EINVAL);
                rename_allowed = 0;
        }else if(!olddir || !newdir || !obj) {
@@ -1550,7 +1550,7 @@ int yaffs_rename(const YCHAR *oldPath, const YCHAR *newPath)
        yaffsfs_Unlock();
 
        if(alt_newpath)
-               YFREE(alt_newpath);
+               kfree(alt_newpath);
 
        return (result == YAFFS_FAIL) ? -1 : 0;
 }
@@ -2279,7 +2279,7 @@ int yaffs_mkdir(const YCHAR *path, mode_t mode)
                yaffsfs_SetError(-ELOOP);
        else if(!parent)
                yaffsfs_SetError(-ENOENT);
-       else if(yaffs_strnlen(name,5) == 0){
+       else if(strnlen(name,5) == 0){
                /* Trying to make the root itself */
                yaffsfs_SetError(-EEXIST);
        } else if(parent->my_dev->read_only)
@@ -2297,7 +2297,7 @@ int yaffs_mkdir(const YCHAR *path, mode_t mode)
        yaffsfs_Unlock();
 
        if(alt_path)
-               YFREE(alt_path);
+               kfree(alt_path);
 
        return retVal;
 }
@@ -2325,7 +2325,7 @@ int yaffs_rmdir(const YCHAR *path)
                path = alt_path;
        result =  yaffsfs_DoUnlink(path,1);
        if(alt_path)
-               YFREE(alt_path);
+               kfree(alt_path);
        return result;
 }
 
@@ -2349,7 +2349,7 @@ int yaffs_mount2(const YCHAR *path,int read_only)
                return -1;
        }
 
-       T(YAFFS_TRACE_MOUNT,(TSTR("yaffs: Mounting %s" TENDSTR),path));
+       yaffs_trace(YAFFS_TRACE_MOUNT,"yaffs: Mounting %s",path);
 
        if(yaffsfs_CheckPath(path) < 0){
                yaffsfs_SetError(-ENAMETOOLONG);
@@ -2758,14 +2758,14 @@ yaffs_DIR *yaffs_opendir(const YCHAR *dirname)
                yaffsfs_SetError(-ENOTDIR);
        else {
 
-               dsc = YMALLOC(sizeof(yaffsfs_DirectorySearchContext));
+               dsc = kmalloc(sizeof(yaffsfs_DirectorySearchContext), 0);
                dir = (yaffs_DIR *)dsc;
 
                if(dsc){
                        memset(dsc,0,sizeof(yaffsfs_DirectorySearchContext));
                         dsc->magic = YAFFS_MAGIC;
                         dsc->dirObj = obj;
-                        yaffs_strncpy(dsc->name,dirname,NAME_MAX);
+                        strncpy(dsc->name,dirname,NAME_MAX);
                         INIT_LIST_HEAD(&dsc->others);
 
                         if(!search_contexts.next)
@@ -2796,10 +2796,10 @@ struct yaffs_dirent *yaffs_readdir(yaffs_DIR *dirp)
                        dsc->de.d_dont_use = (unsigned)dsc->nextReturn;
                        dsc->de.d_off = dsc->offset++;
                        yaffs_get_obj_name(dsc->nextReturn,dsc->de.d_name,NAME_MAX);
-                       if(yaffs_strnlen(dsc->de.d_name,NAME_MAX+1) == 0)
+                       if(strnlen(dsc->de.d_name,NAME_MAX+1) == 0)
                        {
                                /* this should not happen! */
-                               yaffs_strcpy(dsc->de.d_name,_Y("zz"));
+                               strcpy(dsc->de.d_name,_Y("zz"));
                        }
                        dsc->de.d_reclen = sizeof(struct yaffs_dirent);
                        retVal = &dsc->de;
@@ -2840,7 +2840,7 @@ int yaffs_closedir(yaffs_DIR *dirp)
         yaffsfs_Lock();
         dsc->magic = 0;
         list_del(&dsc->others); /* unhook from list */
-        YFREE(dsc);
+        kfree(dsc);
         yaffsfs_Unlock();
         return 0;
 }
@@ -2875,7 +2875,7 @@ int yaffs_symlink(const YCHAR *oldpath, const YCHAR *newpath)
                yaffsfs_SetError(-ENOTDIR);
        else if(loop)
                yaffsfs_SetError(-ELOOP);
-       else if( !parent || yaffs_strnlen(name,5) < 1)
+       else if( !parent || strnlen(name,5) < 1)
                yaffsfs_SetError(-ENOENT);
        else if(parent->my_dev->read_only)
                yaffsfs_SetError(-EROFS);
@@ -2923,7 +2923,7 @@ int yaffs_readlink(const YCHAR *path, YCHAR *buf, int bufsiz)
        else {
                YCHAR *alias = obj->variant.symlink_variant.alias;
                memset(buf,0,bufsiz);
-               yaffs_strncpy(buf,alias,bufsiz - 1);
+               strncpy(buf,alias,bufsiz - 1);
                retVal = 0;
        }
        yaffsfs_Unlock();
index ceaa6c8..63cd6d8 100644 (file)
 #define YCHAR char
 #define YUCHAR unsigned char
 #define _Y(x) x
-#define yaffs_strcat(a,b)    strcat(a,b)
-#define yaffs_strcpy(a,b)    strcpy(a,b)
-#define yaffs_strncpy(a,b,c) strncpy(a,b,c)
-#define yaffs_strncmp(a,b,c) strncmp(a,b,c)
-#define yaffs_strnlen(s,m)          strnlen(s,m)
-#define yaffs_sprintf       sprintf
-#define yaffs_toupper(a)     toupper(a)
 
 #define hweight8(x)    yaffs_hweight8(x)
 #define hweight32(x)   yaffs_hweight32(x)
 void yaffs_qsort(void *aa, size_t n, size_t es,
         int (*cmp)(const void *, const void *));
 
-#define yaffs_sort(base, n, sz, cmp_fn) yaffs_qsort(base, n, sz, cmp_fn)
+#define sort(base, n, sz, cmp_fn, swp) yaffs_qsort(base, n, sz, cmp_fn)
         
 #define YAFFS_PATH_DIVIDERS  "/"
 
-#ifdef NO_Y_INLINE
-#define Y_INLINE
+#ifdef NO_inline
+#define inline
 #else
-#define Y_INLINE __inline__
+#define inline __inline__
 #endif
 
-#define YMALLOC(x) yaffs_malloc(x)
-#define YFREE(x)   free(x)
-#define YMALLOC_ALT(x) yaffs_malloc(x)
-#define YFREE_ALT(x)   free(x)
+#define kmalloc(x,flags) yaffs_malloc(x)
+#define kfree(x)   yaffs_free(x)
+#define vmalloc(x) yaffs_malloc(x)
+#define vfree(x) yaffs_free(x)
 
-#define YMALLOC_DMA(x) yaffs_malloc(x)
+#define cond_resched()  do {} while(0)
 
-#define YYIELD()  do {} while(0)
-
-
-
-//#define YINFO(s) YPRINTF(( __FILE__ " %d %s\n",__LINE__,s))
-//#define YALERT(s) YINFO(s)
-
-
-#define TENDSTR "\n"
-#define TSTR(x) x
-#define TCONT(x) x
-#define TOUT(p) printf p
+#define yaffs_trace(msk, fmt, ...) do { \
+       if(yaffs_trace_mask & ((msk) | YAFFS_TRACE_ALWAYS)) \
+               printf("yaffs: " fmt "\n", ##__VA_ARGS__); \
+} while(0)
 
 
 #define YAFFS_LOSTNFOUND_NAME          "lost+found"
 #define YAFFS_LOSTNFOUND_PREFIX                "obj"
-//#define YPRINTF(x) printf x
 
 #include "yaffscfg.h"
 
@@ -93,9 +77,6 @@ void yaffs_qsort(void *aa, size_t n, size_t es,
 #define YAFFS_ROOT_MODE                                0666
 #define YAFFS_LOSTNFOUND_MODE          0666
 
-#define yaffs_sum_cmp(x,y) ((x) == (y))
-#define yaffs_strcmp(a,b) strcmp(a,b)
-
 #include "yaffs_list.h"
 
 #include "yaffsfs.h"
index 543c129..4208e80 100644 (file)
 #ifndef __YPORTENV_H__
 #define __YPORTENV_H__
 
-/*
- * Define the MTD version in terms of Linux Kernel versions
- * This allows yaffs to be used independantly of the kernel
- * as well as with it.
- */
 
+/* Definition of types */
+typedef unsigned char u8;
+typedef unsigned short u16;
+typedef unsigned u32;
 
-#if defined CONFIG_YAFFS_WINCE
 
-#include "ywinceenv.h"
+#ifndef WIN32
+#include <sys/stat.h>
+#endif
 
 
-#elif defined CONFIG_YAFFS_DIRECT
+#ifdef CONFIG_YAFFS_PROVIDE_DEFS
+/* File types */
 
-/* Direct interface */
-#include "ydirectenv.h"
 
-#elif defined CONFIG_YAFFS_UTIL
+#define DT_UNKNOWN     0
+#define DT_FIFO                1
+#define DT_CHR         2
+#define DT_DIR         4
+#define DT_BLK         6
+#define DT_REG         8
+#define DT_LNK         10
+#define DT_SOCK                12
+#define DT_WHT         14
+
+
+#ifndef WIN32
+#include <sys/stat.h>
+#endif
+
+/*
+ * Attribute flags.
+ * These are or-ed together to select what has been changed.
+ */
+#define ATTR_MODE      1
+#define ATTR_UID       2
+#define ATTR_GID       4
+#define ATTR_SIZE      8
+#define ATTR_ATIME     16
+#define ATTR_MTIME     32
+#define ATTR_CTIME     64
 
-/* Stuff for YAFFS utilities */
+struct iattr {
+       unsigned int ia_valid;
+       unsigned ia_mode;
+       unsigned ia_uid;
+       unsigned ia_gid;
+       unsigned ia_size;
+       unsigned ia_atime;
+       unsigned ia_mtime;
+       unsigned ia_ctime;
+       unsigned int ia_attr_flags;
+};
 
-#include "stdlib.h"
-#include "stdio.h"
-#include "string.h"
+#endif
 
 
-#define YMALLOC(x) malloc(x)
-#define YFREE(x)   free(x)
-#define YMALLOC_ALT(x) malloc(x)
-#define YFREE_ALT(x) free(x)
 
-#define YCHAR char
-#define YUCHAR unsigned char
-#define _Y(x)     x
-#define yaffs_strcat(a, b)     strcat(a, b)
-#define yaffs_strcpy(a, b)     strcpy(a, b)
-#define yaffs_strncpy(a, b, c) strncpy(a, b, c)
-#define yaffs_strnlen(s,m)            strnlen(s,m)
-#define yaffs_sprintf         sprintf
-#define yaffs_toupper(a)       toupper(a)
+#if defined CONFIG_YAFFS_WINCE
 
-#define Y_INLINE inline
+#include "ywinceenv.h"
 
-/* #define YINFO(s) YPRINTF(( __FILE__ " %d %s\n",__LINE__,s)) */
-/* #define YALERT(s) YINFO(s) */
 
-#define TENDSTR "\n"
-#define TSTR(x) x
-#define TOUT(p) printf p
+#elif defined CONFIG_YAFFS_DIRECT
 
-#define YAFFS_LOSTNFOUND_NAME          "lost+found"
-#define YAFFS_LOSTNFOUND_PREFIX                "obj"
-/* #define YPRINTF(x) printf x */
+/* Direct interface */
+#include "ydirectenv.h"
 
-#define YAFFS_ROOT_MODE                        0755
-#define YAFFS_LOSTNFOUND_MODE          0700
+#elif defined CONFIG_YAFFS_UTIL
 
-#define yaffs_sum_cmp(x, y) ((x) == (y))
-#define yaffs_strcmp(a, b) strcmp(a, b)
+#include "yutilsenv.h"
 
 #else
 /* Should have specified a configuration type */
 
 #ifndef YBUG
 #define YBUG() do {\
-       T(YAFFS_TRACE_BUG,\
-               (TSTR("==>> yaffs bug: " __FILE__ " %d" TENDSTR),\
-               __LINE__));\
+       yaffs_trace(YAFFS_TRACE_BUG,\
+               "==>> yaffs bug: " __FILE__ " %d",\
+               __LINE__);\
        Y_DUMP_STACK();\
 } while (0)
 #endif
 
-
-#endif
-
-/*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
- *
- * Copyright (C) 2002-2010 Aleph One Ltd.
- *   for Toby Churchill Ltd and Brightstar Engineering
- *
- * Created by Charles Manning <charles@aleph1.co.uk>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License version 2.1 as
- * published by the Free Software Foundation.
- *
- * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL.
- */
-
-/*
- * This file is just holds extra declarations of macros that would normally
- * be provided in the Linux kernel. These macros have been written from
- * scratch but are functionally equivalent to the Linux ones.
- *
- */
-
-#ifndef __EXTRAS_H__
-#define __EXTRAS_H__
-
-
-/* Definition of types */
-typedef unsigned char u8;
-typedef unsigned short u16;
-typedef unsigned u32;
-
-
-#ifndef WIN32
-#include <sys/stat.h>
-#endif
-
-
-#ifdef CONFIG_YAFFS_PROVIDE_DEFS
-/* File types */
-
-
-#define DT_UNKNOWN     0
-#define DT_FIFO                1
-#define DT_CHR         2
-#define DT_DIR         4
-#define DT_BLK         6
-#define DT_REG         8
-#define DT_LNK         10
-#define DT_SOCK                12
-#define DT_WHT         14
-
-
-#ifndef WIN32
-#include <sys/stat.h>
-#endif
-
-/*
- * Attribute flags.  These should be or-ed together to figure out what
- * has been changed!
- */
-#define ATTR_MODE      1
-#define ATTR_UID       2
-#define ATTR_GID       4
-#define ATTR_SIZE      8
-#define ATTR_ATIME     16
-#define ATTR_MTIME     32
-#define ATTR_CTIME     64
-
-struct iattr {
-       unsigned int ia_valid;
-       unsigned ia_mode;
-       unsigned ia_uid;
-       unsigned ia_gid;
-       unsigned ia_size;
-       unsigned ia_atime;
-       unsigned ia_mtime;
-       unsigned ia_ctime;
-       unsigned int ia_attr_flags;
-};
-
-#endif
-
-
-
 #endif
index b538776..395f4ea 100644 (file)
@@ -67,7 +67,7 @@ void yaffs_deinit_raw_tnodes_and_objs(struct yaffs_dev *dev)
                        YBUG();
                }
 
-               YFREE(allocator);
+               kfree(allocator);
 
        } else {
                T(YAFFS_TRACE_ALWAYS,
@@ -114,7 +114,7 @@ void yaffs_init_raw_tnodes_and_objs(struct yaffs_dev *dev)
        else if(mount_id >= 10){
                T(YAFFS_TRACE_ALWAYS,(TSTR("Bad mount_id %u\n"),mount_id));
        } else {
-                allocator = YMALLOC(sizeof(yaffs_Allocator));
+                allocator = kmalloc(sizeof(yaffs_Allocator));
                 memset(allocator,0,sizeof(yaffs_Allocator));
                 dev->allocator = allocator;
 
index b9fe31e..f9cd5be 100644 (file)
@@ -16,7 +16,7 @@
 #include "yaffs_trace.h"
 #include "yportenv.h"
 
-#ifdef CONFIG_YAFFS_YMALLOC_ALLOCATOR
+#ifdef CONFIG_YAFFS_KMALLOC_ALLOCATOR
 
 void yaffs_deinit_raw_tnodes_and_objs(struct yaffs_dev *dev)
 {
@@ -30,13 +30,13 @@ void yaffs_init_raw_tnodes_and_objs(struct yaffs_dev *dev)
 
 struct yaffs_tnode *yaffs_alloc_raw_tnode(struct yaffs_dev *dev)
 {
-       return (struct yaffs_tnode *)YMALLOC(dev->tnode_size);
+       return (struct yaffs_tnode *)kmalloc(dev->tnode_size, GFP_NOFS);
 }
 
 void yaffs_free_raw_tnode(struct yaffs_dev *dev, struct yaffs_tnode *tn)
 {
        dev = dev;
-       YFREE(tn);
+       kfree(tn);
 }
 
 void yaffs_init_raw_objs(struct yaffs_dev *dev)
@@ -52,14 +52,14 @@ void yaffs_deinit_raw_objs(struct yaffs_dev *dev)
 struct yaffs_obj *yaffs_alloc_raw_obj(struct yaffs_dev *dev)
 {
        dev = dev;
-       return (struct yaffs_obj *)YMALLOC(sizeof(struct yaffs_obj));
+       return (struct yaffs_obj *)kmalloc(sizeof(struct yaffs_obj));
 }
 
 void yaffs_free_raw_obj(struct yaffs_dev *dev, struct yaffs_obj *obj)
 {
 
        dev = dev;
-       YFREE(obj);
+       kfree(obj);
 }
 
 #else
@@ -103,8 +103,8 @@ static void yaffs_deinit_raw_tnodes(struct yaffs_dev *dev)
        while (allocator->alloc_tnode_list) {
                tmp = allocator->alloc_tnode_list->next;
 
-               YFREE(allocator->alloc_tnode_list->tnodes);
-               YFREE(allocator->alloc_tnode_list);
+               kfree(allocator->alloc_tnode_list->tnodes);
+               kfree(allocator->alloc_tnode_list);
                allocator->alloc_tnode_list = tmp;
 
        }
@@ -149,12 +149,12 @@ static int yaffs_create_tnodes(struct yaffs_dev *dev, int n_tnodes)
 
        /* make these things */
 
-       new_tnodes = YMALLOC(n_tnodes * dev->tnode_size);
+       new_tnodes = kmalloc(n_tnodes * dev->tnode_size, GFP_NOFS);
        mem = (u8 *) new_tnodes;
 
        if (!new_tnodes) {
-               T(YAFFS_TRACE_ERROR,
-                 (TSTR("yaffs: Could not allocate Tnodes" TENDSTR)));
+               yaffs_trace(YAFFS_TRACE_ERROR,
+                       "yaffs: Could not allocate Tnodes");
                return YAFFS_FAIL;
        }
 
@@ -177,11 +177,10 @@ static int yaffs_create_tnodes(struct yaffs_dev *dev, int n_tnodes)
         * but it just means we can't free this bunch of tnodes later.
         */
 
-       tnl = YMALLOC(sizeof(struct yaffs_tnode_list));
+       tnl = kmalloc(sizeof(struct yaffs_tnode_list), GFP_NOFS);
        if (!tnl) {
-               T(YAFFS_TRACE_ERROR,
-                 (TSTR
-                  ("yaffs: Could not add tnodes to management list" TENDSTR)));
+               yaffs_trace(YAFFS_TRACE_ERROR,
+                       "Could not add tnodes to management list");
                return YAFFS_FAIL;
        } else {
                tnl->tnodes = new_tnodes;
@@ -189,7 +188,7 @@ static int yaffs_create_tnodes(struct yaffs_dev *dev, int n_tnodes)
                allocator->alloc_tnode_list = tnl;
        }
 
-       T(YAFFS_TRACE_ALLOCATE, (TSTR("yaffs: Tnodes added" TENDSTR)));
+       yaffs_trace(YAFFS_TRACE_ALLOCATE,"Tnodes added");
 
        return YAFFS_OK;
 }
@@ -261,8 +260,8 @@ static void yaffs_deinit_raw_objs(struct yaffs_dev *dev)
 
        while (allocator->allocated_obj_list) {
                tmp = allocator->allocated_obj_list->next;
-               YFREE(allocator->allocated_obj_list->objects);
-               YFREE(allocator->allocated_obj_list);
+               kfree(allocator->allocated_obj_list->objects);
+               kfree(allocator->allocated_obj_list);
 
                allocator->allocated_obj_list = tmp;
        }
@@ -289,20 +288,20 @@ static int yaffs_create_free_objs(struct yaffs_dev *dev, int n_obj)
                return YAFFS_OK;
 
        /* make these things */
-       new_objs = YMALLOC(n_obj * sizeof(struct yaffs_obj));
-       list = YMALLOC(sizeof(struct yaffs_obj_list));
+       new_objs = kmalloc(n_obj * sizeof(struct yaffs_obj), GFP_NOFS);
+       list = kmalloc(sizeof(struct yaffs_obj_list), GFP_NOFS);
 
        if (!new_objs || !list) {
                if (new_objs) {
-                       YFREE(new_objs);
+                       kfree(new_objs);
                        new_objs = NULL;
                }
                if (list) {
-                       YFREE(list);
+                       kfree(list);
                        list = NULL;
                }
-               T(YAFFS_TRACE_ALLOCATE,
-                 (TSTR("yaffs: Could not allocate more objects" TENDSTR)));
+               yaffs_trace(YAFFS_TRACE_ALLOCATE,
+                       "Could not allocate more objects");
                return YAFFS_FAIL;
        }
 
@@ -371,7 +370,7 @@ void yaffs_deinit_raw_tnodes_and_objs(struct yaffs_dev *dev)
                yaffs_deinit_raw_tnodes(dev);
                yaffs_deinit_raw_objs(dev);
 
-               YFREE(dev->allocator);
+               kfree(dev->allocator);
                dev->allocator = NULL;
        } else {
                YBUG();
@@ -383,7 +382,7 @@ void yaffs_init_raw_tnodes_and_objs(struct yaffs_dev *dev)
        struct yaffs_allocator *allocator;
 
        if (!dev->allocator) {
-               allocator = YMALLOC(sizeof(struct yaffs_allocator));
+               allocator = kmalloc(sizeof(struct yaffs_allocator), GFP_NOFS);
                if (allocator) {
                        dev->allocator = allocator;
                        yaffs_init_raw_tnodes(dev);
index 241c08a..9b47d37 100644 (file)
@@ -64,7 +64,7 @@ loff_t yaffs_get_file_size(struct yaffs_obj *obj)
                alias = obj->variant.symlink_variant.alias;
                if (!alias)
                        return 0;
-               return yaffs_strnlen(alias, YAFFS_MAX_ALIAS_LENGTH);
+               return strnlen(alias, YAFFS_MAX_ALIAS_LENGTH);
        default:
                return 0;
        }
index b254266..7df42cd 100644 (file)
  * Chunk bitmap manipulations
  */
 
-static Y_INLINE u8 *yaffs_block_bits(struct yaffs_dev *dev, int blk)
+static inline u8 *yaffs_block_bits(struct yaffs_dev *dev, int blk)
 {
        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));
+               yaffs_trace(YAFFS_TRACE_ERROR,
+                       "BlockBits block %d is not valid",
+                       blk);
                YBUG();
        }
        return dev->chunk_bits +
@@ -33,9 +33,9 @@ void yaffs_verify_chunk_bit_id(struct yaffs_dev *dev, int blk, int chunk)
 {
        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));
+               yaffs_trace(YAFFS_TRACE_ERROR,
+                       "Chunk Id (%d:%d) invalid",
+                       blk, chunk);
                YBUG();
        }
 }
index 02b8ce6..4e40f43 100644 (file)
@@ -18,8 +18,8 @@ static int yaffs2_checkpt_space_ok(struct yaffs_dev *dev)
 {
        int blocks_avail = dev->n_erased_blocks - dev->param.n_reserved_blocks;
 
-       T(YAFFS_TRACE_CHECKPOINT,
-         (TSTR("checkpt blocks available = %d" TENDSTR), blocks_avail));
+       yaffs_trace(YAFFS_TRACE_CHECKPOINT,
+               "checkpt blocks_avail = %d", blocks_avail);
 
        return (blocks_avail <= 0) ? 0 : 1;
 }
@@ -30,15 +30,15 @@ static int yaffs_checkpt_erase(struct yaffs_dev *dev)
 
        if (!dev->param.erase_fn)
                return 0;
-       T(YAFFS_TRACE_CHECKPOINT, (TSTR("checking blocks %d to %d" TENDSTR),
-                                  dev->internal_start_block,
-                                  dev->internal_end_block));
+       yaffs_trace(YAFFS_TRACE_CHECKPOINT,
+               "checking blocks %d to %d",
+               dev->internal_start_block, dev->internal_end_block);
 
        for (i = dev->internal_start_block; i <= dev->internal_end_block; i++) {
                struct yaffs_block_info *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));
+                       yaffs_trace(YAFFS_TRACE_CHECKPOINT,
+                       "erasing checkpt block %d", i);
 
                        dev->n_erasures++;
 
@@ -65,11 +65,10 @@ static void yaffs2_checkpt_find_erased_block(struct yaffs_dev *dev)
 {
        int i;
        int blocks_avail = 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->n_erased_blocks, dev->param.n_reserved_blocks,
-          blocks_avail, dev->checkpt_next_block));
+       yaffs_trace(YAFFS_TRACE_CHECKPOINT,
+               "allocating checkpt block: erased %d reserved %d avail %d next %d ",
+               dev->n_erased_blocks, dev->param.n_reserved_blocks,
+               blocks_avail, dev->checkpt_next_block);
 
        if (dev->checkpt_next_block >= 0 &&
            dev->checkpt_next_block <= dev->internal_end_block &&
@@ -82,14 +81,13 @@ static void yaffs2_checkpt_find_erased_block(struct yaffs_dev *dev)
                        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));
+                               yaffs_trace(YAFFS_TRACE_CHECKPOINT,
+                                       "allocating checkpt block %d", i);
                                return;
                        }
                }
        }
-       T(YAFFS_TRACE_CHECKPOINT, (TSTR("out of checkpt blocks" TENDSTR)));
+       yaffs_trace(YAFFS_TRACE_CHECKPOINT, "out of checkpt blocks");
 
        dev->checkpt_next_block = -1;
        dev->checkpt_cur_block = -1;
@@ -100,9 +98,9 @@ static void yaffs2_checkpt_find_block(struct yaffs_dev *dev)
        int i;
        struct yaffs_ext_tags tags;
 
-       T(YAFFS_TRACE_CHECKPOINT,
-         (TSTR("find next checkpt block: start:  blocks %d next %d" TENDSTR),
-          dev->blocks_in_checkpt, dev->checkpt_next_block));
+       yaffs_trace(YAFFS_TRACE_CHECKPOINT,
+               "find next checkpt block: start:  blocks %d next %d",
+               dev->blocks_in_checkpt, dev->checkpt_next_block);
 
        if (dev->blocks_in_checkpt < dev->checkpt_max_blocks)
                for (i = dev->checkpt_next_block; i <= dev->internal_end_block;
@@ -112,11 +110,10 @@ static void yaffs2_checkpt_find_block(struct yaffs_dev *dev)
 
                        dev->param.read_chunk_tags_fn(dev, realigned_chunk,
                                                      NULL, &tags);
-                       T(YAFFS_TRACE_CHECKPOINT,
-                         (TSTR
-                          ("find next checkpt block: search: block %d oid %d seq %d eccr %d"
-                           TENDSTR), i, tags.obj_id, tags.seq_number,
-                          tags.ecc_result));
+                       yaffs_trace(YAFFS_TRACE_CHECKPOINT,
+                               "find next checkpt block: search: block %d oid %d seq %d eccr %d",
+                               i, tags.obj_id, tags.seq_number,
+                               tags.ecc_result);
 
                        if (tags.seq_number == YAFFS_SEQUENCE_CHECKPOINT_DATA) {
                                /* Right kind of block */
@@ -125,14 +122,13 @@ static void yaffs2_checkpt_find_block(struct yaffs_dev *dev)
                                dev->checkpt_block_list[dev->
                                                        blocks_in_checkpt] = i;
                                dev->blocks_in_checkpt++;
-                               T(YAFFS_TRACE_CHECKPOINT,
-                                 (TSTR("found checkpt block %d" TENDSTR), i));
+                               yaffs_trace(YAFFS_TRACE_CHECKPOINT,
+                                       "found checkpt block %d", i);
                                return;
                        }
                }
 
-       T(YAFFS_TRACE_CHECKPOINT,
-         (TSTR("found no more checkpt blocks" TENDSTR)));
+       yaffs_trace(YAFFS_TRACE_CHECKPOINT, "found no more checkpt blocks");
 
        dev->checkpt_next_block = -1;
        dev->checkpt_cur_block = -1;
@@ -154,7 +150,7 @@ int yaffs2_checkpt_open(struct yaffs_dev *dev, int writing)
 
        if (!dev->checkpt_buffer)
                dev->checkpt_buffer =
-                   YMALLOC_DMA(dev->param.total_bytes_per_chunk);
+                   kmalloc(dev->param.total_bytes_per_chunk, GFP_NOFS);
        if (!dev->checkpt_buffer)
                return 0;
 
@@ -182,7 +178,7 @@ int yaffs2_checkpt_open(struct yaffs_dev *dev, int writing)
                    (dev->internal_end_block - dev->internal_start_block) / 16 +
                    2;
                dev->checkpt_block_list =
-                   YMALLOC(sizeof(int) * dev->checkpt_max_blocks);
+                   kmalloc(sizeof(int) * dev->checkpt_max_blocks, GFP_NOFS);
                if (!dev->checkpt_block_list)
                        return 0;
 
@@ -234,11 +230,10 @@ static int yaffs2_checkpt_flush_buffer(struct yaffs_dev *dev)
            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),
-          chunk, dev->checkpt_cur_block, dev->checkpt_cur_chunk, tags.obj_id,
-          tags.chunk_id));
+       yaffs_trace(YAFFS_TRACE_CHECKPOINT,
+               "checkpoint wite buffer nand %d(%d:%d) objid %d chId %d",
+               chunk, dev->checkpt_cur_block, dev->checkpt_cur_chunk,
+               tags.obj_id, tags.chunk_id);
 
        realigned_chunk = chunk - dev->chunk_offset;
 
@@ -387,7 +382,7 @@ int yaffs_checkpt_close(struct yaffs_dev *dev)
                                /* Todo this looks odd... */
                        }
                }
-               YFREE(dev->checkpt_block_list);
+               kfree(dev->checkpt_block_list);
                dev->checkpt_block_list = NULL;
        }
 
@@ -395,12 +390,12 @@ int yaffs_checkpt_close(struct yaffs_dev *dev)
            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->checkpt_byte_count));
+       yaffs_trace(YAFFS_TRACE_CHECKPOINT,"checkpoint byte count %d",
+               dev->checkpt_byte_count);
 
        if (dev->checkpt_buffer) {
                /* free the buffer */
-               YFREE(dev->checkpt_buffer);
+               kfree(dev->checkpt_buffer);
                dev->checkpt_buffer = NULL;
                return 1;
        } else {
@@ -412,9 +407,9 @@ int yaffs2_checkpt_invalidate_stream(struct yaffs_dev *dev)
 {
        /* Erase the checkpoint data */
 
-       T(YAFFS_TRACE_CHECKPOINT,
-         (TSTR("checkpoint invalidate of %d blocks" TENDSTR),
-          dev->blocks_in_checkpt));
+       yaffs_trace(YAFFS_TRACE_CHECKPOINT,
+               "checkpoint invalidate of %d blocks",
+               dev->blocks_in_checkpt);
 
        return yaffs_checkpt_erase(dev);
 }
index 108c361..d87acbd 100644 (file)
 #include "yaffs_trace.h"
 
 /* Function to manipulate block info */
-static Y_INLINE struct yaffs_block_info *yaffs_get_block_info(struct yaffs_dev
+static inline struct yaffs_block_info *yaffs_get_block_info(struct yaffs_dev
                                                              *dev, int blk)
 {
        if (blk < dev->internal_start_block || blk > dev->internal_end_block) {
-               T(YAFFS_TRACE_ERROR,
-                 (TSTR
-                  ("**>> yaffs: get_block_info block %d is not valid" TENDSTR),
-                  blk));
+               yaffs_trace(YAFFS_TRACE_ERROR,
+                       "**>> yaffs: get_block_info block %d is not valid",
+                       blk);
                YBUG();
        }
        return &dev->block_info[blk - dev->internal_start_block];
index c56e060..f4ae9de 100644 (file)
 
 #include "yaffs_ecc.h"
 
-/* Robustification (if it ever comes about...) */
-static void yaffs_retire_block(struct yaffs_dev *dev, int flash_block);
-static void yaffs_handle_chunk_wr_error(struct yaffs_dev *dev, int nand_chunk,
-                                       int erased_ok);
-static void yaffs_handle_chunk_wr_ok(struct yaffs_dev *dev, int nand_chunk,
-                                    const u8 * data,
-                                    const struct yaffs_ext_tags *tags);
-static void yaffs_handle_chunk_update(struct yaffs_dev *dev, int nand_chunk,
-                                     const struct yaffs_ext_tags *tags);
-
-/* Other local prototypes */
-static void yaffs_update_parent(struct yaffs_obj *obj);
-static int yaffs_unlink_obj(struct yaffs_obj *obj);
-static int yaffs_obj_cache_dirty(struct yaffs_obj *obj);
-
-static int yaffs_write_new_chunk(struct yaffs_dev *dev,
-                                const u8 * buffer,
-                                struct yaffs_ext_tags *tags, int use_reserver);
-
-static struct yaffs_obj *yaffs_new_obj(struct yaffs_dev *dev, int number,
-                                      enum yaffs_obj_type type);
-
-static int yaffs_apply_xattrib_mod(struct yaffs_obj *obj, char *buffer,
-                                  struct yaffs_xattr_mod *xmod);
-
-static void yaffs_remove_obj_from_dir(struct yaffs_obj *obj);
-static int yaffs_generic_obj_del(struct yaffs_obj *in);
-
-static int yaffs_check_chunk_erased(struct yaffs_dev *dev, int nand_chunk);
-
-static int yaffs_unlink_worker(struct yaffs_obj *obj);
-
-static int yaffs_tags_match(const struct yaffs_ext_tags *tags, int obj_id,
-                           int chunk_obj);
-
-static int yaffs_alloc_chunk(struct yaffs_dev *dev, int use_reserver,
-                            struct yaffs_block_info **block_ptr);
-
-static void yaffs_check_obj_details_loaded(struct yaffs_obj *in);
+/* Forward declarations */
 
-static void yaffs_invalidate_whole_cache(struct yaffs_obj *in);
-static void yaffs_invalidate_chunk_cache(struct yaffs_obj *object,
-                                        int chunk_id);
-
-static int yaffs_find_chunk_in_file(struct yaffs_obj *in, int inode_chunk,
-                                   struct yaffs_ext_tags *tags);
+static int yaffs_wr_data_obj(struct yaffs_obj *in, int inode_chunk,
+                            const u8 * buffer, int n_bytes, int use_reserve);
 
-static int yaffs_verify_chunk_written(struct yaffs_dev *dev,
-                                     int nand_chunk,
-                                     const u8 * data,
-                                     struct yaffs_ext_tags *tags);
 
-static void yaffs_load_name_from_oh(struct yaffs_dev *dev, YCHAR * name,
-                                   const YCHAR * oh_name, int buff_size);
-static void yaffs_load_oh_from_name(struct yaffs_dev *dev, YCHAR * oh_name,
-                                   const YCHAR * name);
 
 /* Function to calculate chunk and offset */
 
@@ -186,7 +136,7 @@ static int yaffs_init_tmp_buffers(struct yaffs_dev *dev)
        for (i = 0; buf && i < YAFFS_N_TEMP_BUFFERS; i++) {
                dev->temp_buffer[i].line = 0;   /* not in use */
                dev->temp_buffer[i].buffer = buf =
-                   YMALLOC_DMA(dev->param.total_bytes_per_chunk);
+                   kmalloc(dev->param.total_bytes_per_chunk, GFP_NOFS);
        }
 
        return buf ? YAFFS_OK : YAFFS_FAIL;
@@ -214,14 +164,11 @@ u8 *yaffs_get_temp_buffer(struct yaffs_dev * dev, int line_no)
                }
        }
 
-       T(YAFFS_TRACE_BUFFERS,
-         (TSTR("Out of temp buffers at line %d, other held by lines:"),
-          line_no));
+       yaffs_trace(YAFFS_TRACE_BUFFERS,
+               "Out of temp buffers at line %d, other held by lines:",
+               line_no);
        for (i = 0; i < YAFFS_N_TEMP_BUFFERS; i++)
-               T(YAFFS_TRACE_BUFFERS,
-                 (TSTR(" %d "), dev->temp_buffer[i].line));
-
-       T(YAFFS_TRACE_BUFFERS, (TSTR(" " TENDSTR)));
+               yaffs_trace(YAFFS_TRACE_BUFFERS," %d", dev->temp_buffer[i].line);
 
        /*
         * If we got here then we have to allocate an unmanaged one
@@ -229,7 +176,7 @@ u8 *yaffs_get_temp_buffer(struct yaffs_dev * dev, int line_no)
         */
 
        dev->unmanaged_buffer_allocs++;
-       return YMALLOC(dev->data_bytes_per_chunk);
+       return kmalloc(dev->data_bytes_per_chunk, GFP_NOFS);
 
 }
 
@@ -248,10 +195,10 @@ void yaffs_release_temp_buffer(struct yaffs_dev *dev, u8 * buffer, int line_no)
 
        if (buffer) {
                /* assume it is an unmanaged one. */
-               T(YAFFS_TRACE_BUFFERS,
-                 (TSTR("Releasing unmanaged temp buffer in line %d" TENDSTR),
-                  line_no));
-               YFREE(buffer);
+               yaffs_trace(YAFFS_TRACE_BUFFERS,
+                 "Releasing unmanaged temp buffer in line %d",
+                  line_no);
+               kfree(buffer);
                dev->unmanaged_buffer_deallocs++;
        }
 
@@ -277,11 +224,70 @@ int yaffs_is_managed_tmp_buffer(struct yaffs_dev *dev, const u8 * buffer)
        if (buffer == dev->checkpt_buffer)
                return 1;
 
-       T(YAFFS_TRACE_ALWAYS,
-         (TSTR("yaffs: unmaged buffer detected.\n" TENDSTR)));
+       yaffs_trace(YAFFS_TRACE_ALWAYS,
+         "yaffs: unmaged buffer detected.");
        return 0;
 }
 
+/*
+ * Functions for robustisizing TODO
+ *
+ */
+
+static void yaffs_handle_chunk_wr_ok(struct yaffs_dev *dev, int nand_chunk,
+                                    const u8 * data,
+                                    const struct yaffs_ext_tags *tags)
+{
+       dev = dev;
+       nand_chunk = nand_chunk;
+       data = data;
+       tags = tags;
+}
+
+static void yaffs_handle_chunk_update(struct yaffs_dev *dev, int nand_chunk,
+                                     const struct yaffs_ext_tags *tags)
+{
+       dev = dev;
+       nand_chunk = nand_chunk;
+       tags = tags;
+}
+
+void yaffs_handle_chunk_error(struct yaffs_dev *dev,
+                             struct yaffs_block_info *bi)
+{
+       if (!bi->gc_prioritise) {
+               bi->gc_prioritise = 1;
+               dev->has_pending_prioritised_gc = 1;
+               bi->chunk_error_strikes++;
+
+               if (bi->chunk_error_strikes > 3) {
+                       bi->needs_retiring = 1; /* Too many stikes, so retire this */
+                       yaffs_trace(YAFFS_TRACE_ALWAYS, "yaffs: Block struck out");
+
+               }
+       }
+}
+
+static void yaffs_handle_chunk_wr_error(struct yaffs_dev *dev, int nand_chunk,
+                                       int erased_ok)
+{
+       int flash_block = nand_chunk / dev->param.chunks_per_block;
+       struct yaffs_block_info *bi = yaffs_get_block_info(dev, flash_block);
+
+       yaffs_handle_chunk_error(dev, bi);
+
+       if (erased_ok) {
+               /* Was an actual write failure, so mark the block for retirement  */
+               bi->needs_retiring = 1;
+               yaffs_trace(YAFFS_TRACE_ERROR | YAFFS_TRACE_BAD_BLOCKS,
+                 "**>> Block %d needs retiring", flash_block);
+       }
+
+       /* Delete the chunk */
+       yaffs_chunk_del(dev, nand_chunk, 1, __LINE__);
+       yaffs_skip_rest_of_block(dev);
+}
+
 /*
  * Verification code
  */
@@ -290,7 +296,7 @@ int yaffs_is_managed_tmp_buffer(struct yaffs_dev *dev, const u8 * buffer)
  *  Simple hash function. Needs to have a reasonable spread
  */
 
-static Y_INLINE int yaffs_hash_fn(int n)
+static inline int yaffs_hash_fn(int n)
 {
        n = abs(n);
        return n % YAFFS_NOBJECT_BUCKETS;
@@ -338,9 +344,9 @@ static int yaffs_check_chunk_erased(struct yaffs_dev *dev, int nand_chunk)
        if (tags.ecc_result > YAFFS_ECC_RESULT_NO_ERROR)
                retval = YAFFS_FAIL;
 
-       if (!yaffs_check_ff(data, dev->data_bytes_per_chunk) || tags.chunk_used) {
-               T(YAFFS_TRACE_NANDACCESS,
-                 (TSTR("Chunk %d not erased" TENDSTR), nand_chunk));
+       if (!yaffs_check_ff(data, dev->data_bytes_per_chunk) ||
+               tags.chunk_used) {
+               yaffs_trace(YAFFS_TRACE_NANDACCESS, "Chunk %d not erased", nand_chunk);
                retval = YAFFS_FAIL;
        }
 
@@ -372,6 +378,148 @@ static int yaffs_verify_chunk_written(struct yaffs_dev *dev,
        return retval;
 }
 
+
+int yaffs_check_alloc_available(struct yaffs_dev *dev, int n_chunks)
+{
+       int reserved_chunks;
+       int reserved_blocks = dev->param.n_reserved_blocks;
+       int checkpt_blocks;
+
+       checkpt_blocks = yaffs_calc_checkpt_blocks_required(dev);
+
+       reserved_chunks =
+           ((reserved_blocks + checkpt_blocks) * dev->param.chunks_per_block);
+
+       return (dev->n_free_chunks > (reserved_chunks + n_chunks));
+}
+
+static int yaffs_find_alloc_block(struct yaffs_dev *dev)
+{
+       int i;
+
+       struct yaffs_block_info *bi;
+
+       if (dev->n_erased_blocks < 1) {
+               /* Hoosterman we've got a problem.
+                * Can't get space to gc
+                */
+               yaffs_trace(YAFFS_TRACE_ERROR,
+                 "yaffs tragedy: no more erased blocks" );
+
+               return -1;
+       }
+
+       /* Find an empty block. */
+
+       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;
+               }
+
+               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--;
+                       yaffs_trace(YAFFS_TRACE_ALLOCATE,
+                         "Allocated block %d, seq  %d, %d left" ,
+                          dev->alloc_block_finder, dev->seq_number,
+                          dev->n_erased_blocks);
+                       return dev->alloc_block_finder;
+               }
+       }
+
+       yaffs_trace(YAFFS_TRACE_ALWAYS,
+               "yaffs tragedy: no more erased blocks, but there should have been %d",
+               dev->n_erased_blocks);
+
+       return -1;
+}
+
+static int yaffs_alloc_chunk(struct yaffs_dev *dev, int use_reserver,
+                            struct yaffs_block_info **block_ptr)
+{
+       int ret_val;
+       struct yaffs_block_info *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 (!use_reserver && !yaffs_check_alloc_available(dev, 1)) {
+               /* Not enough space to allocate unless we're allowed to use the reserve. */
+               return -1;
+       }
+
+       if (dev->n_erased_blocks < dev->param.n_reserved_blocks
+           && dev->alloc_page == 0)
+               yaffs_trace(YAFFS_TRACE_ALLOCATE, "Allocating reserve");
+
+       /* Next page please.... */
+       if (dev->alloc_block >= 0) {
+               bi = yaffs_get_block_info(dev, dev->alloc_block);
+
+               ret_val = (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);
+
+               dev->alloc_page++;
+
+               dev->n_free_chunks--;
+
+               /* 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;
+               }
+
+               if (block_ptr)
+                       *block_ptr = bi;
+
+               return ret_val;
+       }
+
+       yaffs_trace(YAFFS_TRACE_ERROR, "!!!!!!!!! Allocator out !!!!!!!!!!!!!!!!!" );
+
+       return -1;
+}
+
+static int yaffs_get_erased_chunks(struct yaffs_dev *dev)
+{
+       int n;
+
+       n = dev->n_erased_blocks * dev->param.chunks_per_block;
+
+       if (dev->alloc_block > 0)
+               n += (dev->param.chunks_per_block - dev->alloc_page);
+
+       return n;
+
+}
+
+/*
+ * 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(struct yaffs_dev *dev)
+{
+       if (dev->alloc_block > 0) {
+               struct yaffs_block_info *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;
+               }
+       }
+}
+
 static int yaffs_write_new_chunk(struct yaffs_dev *dev,
                                 const u8 * data,
                                 struct yaffs_ext_tags *tags, int use_reserver)
@@ -425,9 +573,9 @@ static int yaffs_write_new_chunk(struct yaffs_dev *dev,
                if (!bi->skip_erased_check) {
                        erased_ok = yaffs_check_chunk_erased(dev, chunk);
                        if (erased_ok != YAFFS_OK) {
-                               T(YAFFS_TRACE_ERROR,
-                                 (TSTR("**>> yaffs chunk %d was not erased"
-                                       TENDSTR), chunk));
+                               yaffs_trace(YAFFS_TRACE_ERROR,
+                                 "**>> yaffs chunk %d was not erased",
+                                 chunk);
 
                                /* If not erased, delete this one,
                                 * skip rest of block and
@@ -463,10 +611,9 @@ static int yaffs_write_new_chunk(struct yaffs_dev *dev,
                chunk = -1;
 
        if (attempts > 1) {
-               T(YAFFS_TRACE_ERROR,
-                 (TSTR("**>> yaffs write required %d attempts" TENDSTR),
-                  attempts));
-
+               yaffs_trace(YAFFS_TRACE_ERROR,
+                       "**>> yaffs write required %d attempts",
+                       attempts);
                dev->n_retired_writes += (attempts - 1);
        }
 
@@ -487,10 +634,9 @@ static void yaffs_retire_block(struct yaffs_dev *dev, int flash_block)
 
        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), flash_block));
+                       yaffs_trace(YAFFS_TRACE_ALWAYS,
+                               "yaffs: Failed to mark bad and erase block %d",
+                               flash_block);
                } else {
                        struct yaffs_ext_tags tags;
                        int chunk_id =
@@ -505,11 +651,9 @@ static void yaffs_retire_block(struct yaffs_dev *dev, int flash_block)
                                                           dev->chunk_offset,
                                                           buffer,
                                                           &tags) != YAFFS_OK)
-                               T(YAFFS_TRACE_ALWAYS,
-                                 (TSTR
-                                  ("yaffs: Failed to "
-                                   TCONT("write bad block marker to block %d")
-                                   TENDSTR), flash_block));
+                               yaffs_trace(YAFFS_TRACE_ALWAYS,
+                                       "yaffs: Failed to write bad block marker to block %d",
+                                       flash_block);
 
                        yaffs_release_temp_buffer(dev, buffer, __LINE__);
                }
@@ -522,98 +666,38 @@ static void yaffs_retire_block(struct yaffs_dev *dev, int flash_block)
        dev->n_retired_blocks++;
 }
 
-/*
- * Functions for robustisizing TODO
- *
- */
+/*---------------- Name handling functions ------------*/
 
-static void yaffs_handle_chunk_wr_ok(struct yaffs_dev *dev, int nand_chunk,
-                                    const u8 * data,
-                                    const struct yaffs_ext_tags *tags)
+static u16 yaffs_calc_name_sum(const YCHAR * name)
 {
-       dev = dev;
-       nand_chunk = nand_chunk;
-       data = data;
-       tags = tags;
+       u16 sum = 0;
+       u16 i = 1;
+
+       const YUCHAR *bname = (const YUCHAR *)name;
+       if (bname) {
+               while ((*bname) && (i < (YAFFS_MAX_NAME_LENGTH / 2))) {
+
+                       /* 0x1f mask is case insensitive */
+                       sum += ((*bname) & 0x1f) * i;
+                       i++;
+                       bname++;
+               }
+       }
+       return sum;
 }
 
-static void yaffs_handle_chunk_update(struct yaffs_dev *dev, int nand_chunk,
-                                     const struct yaffs_ext_tags *tags)
+void yaffs_set_obj_name(struct yaffs_obj *obj, const YCHAR * name)
 {
-       dev = dev;
-       nand_chunk = nand_chunk;
-       tags = tags;
-}
-
-void yaffs_handle_chunk_error(struct yaffs_dev *dev,
-                             struct yaffs_block_info *bi)
-{
-       if (!bi->gc_prioritise) {
-               bi->gc_prioritise = 1;
-               dev->has_pending_prioritised_gc = 1;
-               bi->chunk_error_strikes++;
-
-               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)));
-
-               }
-       }
-}
-
-static void yaffs_handle_chunk_wr_error(struct yaffs_dev *dev, int nand_chunk,
-                                       int erased_ok)
-{
-       int flash_block = nand_chunk / dev->param.chunks_per_block;
-       struct yaffs_block_info *bi = yaffs_get_block_info(dev, flash_block);
-
-       yaffs_handle_chunk_error(dev, bi);
-
-       if (erased_ok) {
-               /* Was an actual write failure, so mark the block for retirement  */
-               bi->needs_retiring = 1;
-               T(YAFFS_TRACE_ERROR | YAFFS_TRACE_BAD_BLOCKS,
-                 (TSTR("**>> Block %d needs retiring" TENDSTR), flash_block));
-       }
-
-       /* Delete the chunk */
-       yaffs_chunk_del(dev, nand_chunk, 1, __LINE__);
-       yaffs_skip_rest_of_block(dev);
-}
-
-/*---------------- Name handling functions ------------*/
-
-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))) {
-
-                       /* 0x1f mask is case insensitive */
-                       sum += ((*bname) & 0x1f) * i;
-                       i++;
-                       bname++;
-               }
-       }
-       return sum;
-}
-
-void yaffs_set_obj_name(struct yaffs_obj *obj, const YCHAR * name)
-{
-#ifndef CONFIG_YAFFS_NO_SHORT_NAMES
-       memset(obj->short_name, 0, sizeof(obj->short_name));
-       if (name && 
-               yaffs_strnlen(name, YAFFS_SHORT_NAME_LENGTH + 1) <=
-           YAFFS_SHORT_NAME_LENGTH)
-               yaffs_strcpy(obj->short_name, name);
-       else
-               obj->short_name[0] = _Y('\0');
-#endif
-       obj->sum = yaffs_calc_name_sum(name);
+#ifndef CONFIG_YAFFS_NO_SHORT_NAMES
+       memset(obj->short_name, 0, sizeof(obj->short_name));
+       if (name && 
+               strnlen(name, YAFFS_SHORT_NAME_LENGTH + 1) <=
+           YAFFS_SHORT_NAME_LENGTH)
+               strcpy(obj->short_name, name);
+       else
+               obj->short_name[0] = _Y('\0');
+#endif
+       obj->sum = yaffs_calc_name_sum(name);
 }
 
 void yaffs_set_obj_name_from_oh(struct yaffs_obj *obj,
@@ -827,8 +911,7 @@ struct yaffs_tnode *yaffs_add_find_tnode_0(struct yaffs_dev *dev,
                                file_struct->top = tn;
                                file_struct->top_level++;
                        } else {
-                               T(YAFFS_TRACE_ERROR,
-                                 (TSTR("yaffs: no more tnodes" TENDSTR)));
+                               yaffs_trace(YAFFS_TRACE_ERROR, "yaffs: no more tnodes");
                                return NULL;
                        }
                }
@@ -884,6 +967,14 @@ struct yaffs_tnode *yaffs_add_find_tnode_0(struct yaffs_dev *dev,
        return tn;
 }
 
+static int yaffs_tags_match(const struct yaffs_ext_tags *tags, int obj_id,
+                           int chunk_obj)
+{
+       return (tags->chunk_id == chunk_obj &&
+               tags->obj_id == obj_id && !tags->is_deleted) ? 1 : 0;
+
+}
+
 static int yaffs_find_chunk_in_group(struct yaffs_dev *dev, int the_chunk,
                                     struct yaffs_ext_tags *tags, int obj_id,
                                     int inode_chunk)
@@ -911,12 +1002,198 @@ static int yaffs_find_chunk_in_group(struct yaffs_dev *dev, int the_chunk,
        return -1;
 }
 
+static int yaffs_find_chunk_in_file(struct yaffs_obj *in, int inode_chunk,
+                                   struct yaffs_ext_tags *tags)
+{
+       /*Get the Tnode, then get the level 0 offset chunk offset */
+       struct yaffs_tnode *tn;
+       int the_chunk = -1;
+       struct yaffs_ext_tags local_tags;
+       int ret_val = -1;
+
+       struct yaffs_dev *dev = in->my_dev;
+
+       if (!tags) {
+               /* Passed a NULL, so use our own tags space */
+               tags = &local_tags;
+       }
+
+       tn = yaffs_find_tnode_0(dev, &in->variant.file_variant, inode_chunk);
+
+       if (tn) {
+               the_chunk = yaffs_get_group_base(dev, tn, inode_chunk);
+
+               ret_val =
+                   yaffs_find_chunk_in_group(dev, the_chunk, tags, in->obj_id,
+                                             inode_chunk);
+       }
+       return ret_val;
+}
+
+static int yaffs_find_del_file_chunk(struct yaffs_obj *in, int inode_chunk,
+                                    struct yaffs_ext_tags *tags)
+{
+       /* Get the Tnode, then get the level 0 offset chunk offset */
+       struct yaffs_tnode *tn;
+       int the_chunk = -1;
+       struct yaffs_ext_tags local_tags;
+
+       struct yaffs_dev *dev = in->my_dev;
+       int ret_val = -1;
+
+       if (!tags) {
+               /* Passed a NULL, so use our own tags space */
+               tags = &local_tags;
+       }
+
+       tn = yaffs_find_tnode_0(dev, &in->variant.file_variant, inode_chunk);
+
+       if (tn) {
+
+               the_chunk = yaffs_get_group_base(dev, tn, inode_chunk);
+
+               ret_val =
+                   yaffs_find_chunk_in_group(dev, the_chunk, tags, in->obj_id,
+                                             inode_chunk);
+
+               /* Delete the entry in the filestructure (if found) */
+               if (ret_val != -1)
+                       yaffs_load_tnode_0(dev, tn, inode_chunk, 0);
+       }
+
+       return ret_val;
+}
+
+int yaffs_put_chunk_in_file(struct yaffs_obj *in, int inode_chunk,
+                           int nand_chunk, int in_scan)
+{
+       /* NB in_scan is zero unless scanning.
+        * For forward scanning, in_scan is > 0;
+        * for backward scanning in_scan is < 0
+        *
+        * nand_chunk = 0 is a dummy insert to make sure the tnodes are there.
+        */
+
+       struct yaffs_tnode *tn;
+       struct yaffs_dev *dev = in->my_dev;
+       int existing_cunk;
+       struct yaffs_ext_tags existing_tags;
+       struct yaffs_ext_tags new_tags;
+       unsigned existing_serial, new_serial;
+
+       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 (!in_scan) {
+                       yaffs_trace(YAFFS_TRACE_ERROR,
+                               "yaffs tragedy:attempt to put data chunk into a non-file"
+                               );
+                       YBUG();
+               }
+
+               yaffs_chunk_del(dev, nand_chunk, 1, __LINE__);
+               return YAFFS_OK;
+       }
+
+       tn = yaffs_add_find_tnode_0(dev,
+                                   &in->variant.file_variant,
+                                   inode_chunk, NULL);
+       if (!tn)
+               return YAFFS_FAIL;
+
+       if (!nand_chunk)
+               /* Dummy insert, bail now */
+               return YAFFS_OK;
+
+       existing_cunk = yaffs_get_group_base(dev, tn, inode_chunk);
+
+       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
+                * chunk should ever be affected.
+                *
+                * 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.
+                */
+
+               if (existing_cunk > 0) {
+                       /* 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:
+                        *
+                        * Backwards scanning YAFFS2: The old one is what we use, dump the new one.
+                        * 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 (in_scan > 0) {
+                               /* Only do this for forward scanning */
+                               yaffs_rd_chunk_tags_nand(dev,
+                                                        nand_chunk,
+                                                        NULL, &new_tags);
+
+                               /* Do a proper find */
+                               existing_cunk =
+                                   yaffs_find_chunk_in_file(in, inode_chunk,
+                                                            &existing_tags);
+                       }
+
+                       if (existing_cunk <= 0) {
+                               /*Hoosterman - how did this happen? */
+
+                               yaffs_trace(YAFFS_TRACE_ERROR,
+                                       "yaffs tragedy: existing chunk < 0 in scan"
+                                       );
+
+                       }
+
+                       /* NB The deleted flags should be false, otherwise the chunks will
+                        * not be loaded during a scan
+                        */
+
+                       if (in_scan > 0) {
+                               new_serial = new_tags.serial_number;
+                               existing_serial = existing_tags.serial_number;
+                       }
+
+                       if ((in_scan > 0) &&
+                           (existing_cunk <= 0 ||
+                            ((existing_serial + 1) & 3) == new_serial)) {
+                               /* Forward scanning.
+                                * Use new
+                                * Delete the old one and drop through to update the tnode
+                                */
+                               yaffs_chunk_del(dev, existing_cunk, 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_chunk_del(dev, nand_chunk, 1, __LINE__);
+                               return YAFFS_OK;
+                       }
+               }
+
+       }
+
+       if (existing_cunk == 0)
+               in->n_data_chunks++;
+
+       yaffs_load_tnode_0(dev, tn, inode_chunk, nand_chunk);
+
+       return YAFFS_OK;
+}
+
 static void yaffs_soft_del_chunk(struct yaffs_dev *dev, int chunk)
 {
        struct yaffs_block_info *the_block;
        unsigned block_no;
 
-       T(YAFFS_TRACE_DELETION, (TSTR("soft delete chunk %d" TENDSTR), chunk));
+       yaffs_trace(YAFFS_TRACE_DELETION, "soft delete chunk %d", chunk);
 
        block_no = chunk / dev->param.chunks_per_block;
        the_block = yaffs_get_block_info(dev, block_no);
@@ -991,18 +1268,459 @@ static int yaffs_soft_del_worker(struct yaffs_obj *in, struct yaffs_tnode *tn,
 
 }
 
-static void yaffs_soft_del_file(struct yaffs_obj *obj)
+static void yaffs_remove_obj_from_dir(struct yaffs_obj *obj)
 {
-       if (obj->deleted &&
+       struct yaffs_dev *dev = obj->my_dev;
+       struct yaffs_obj *parent;
+
+       yaffs_verify_obj_in_dir(obj);
+       parent = obj->parent;
+
+       yaffs_verify_dir(parent);
+
+       if (dev && dev->param.remove_obj_fn)
+               dev->param.remove_obj_fn(obj);
+
+       list_del_init(&obj->siblings);
+       obj->parent = NULL;
+
+       yaffs_verify_dir(parent);
+}
+
+void yaffs_add_obj_to_dir(struct yaffs_obj *directory, struct yaffs_obj *obj)
+{
+       if (!directory) {
+               yaffs_trace(YAFFS_TRACE_ALWAYS,
+                       "tragedy: Trying to add an object to a null pointer directory"
+                       );
+               YBUG();
+               return;
+       }
+       if (directory->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) {
+               yaffs_trace(YAFFS_TRACE_ALWAYS,
+                       "tragedy: Trying to add an object to a non-directory"
+                       );
+               YBUG();
+       }
+
+       if (obj->siblings.prev == NULL) {
+               /* Not initialised */
+               YBUG();
+       }
+
+       yaffs_verify_dir(directory);
+
+       yaffs_remove_obj_from_dir(obj);
+
+       /* Now add it */
+       list_add(&obj->siblings, &directory->variant.dir_variant.children);
+       obj->parent = directory;
+
+       if (directory == obj->my_dev->unlinked_dir
+           || directory == obj->my_dev->del_dir) {
+               obj->unlinked = 1;
+               obj->my_dev->n_unlinked_files++;
+               obj->rename_allowed = 0;
+       }
+
+       yaffs_verify_dir(directory);
+       yaffs_verify_obj_in_dir(obj);
+}
+
+static int yaffs_change_obj_name(struct yaffs_obj *obj,
+                                struct yaffs_obj *new_dir,
+                                const YCHAR * new_name, int force, int shadows)
+{
+       int unlink_op;
+       int del_op;
+
+       struct yaffs_obj *existing_target;
+
+       if (new_dir == NULL)
+               new_dir = obj->parent;  /* use the old directory */
+
+       if (new_dir->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) {
+               yaffs_trace(YAFFS_TRACE_ALWAYS,
+                       "tragedy: yaffs_change_obj_name: new_dir is not a directory"
+                       );
+               YBUG();
+       }
+
+       /* TODO: Do we need this different handling for YAFFS2 and YAFFS1?? */
+       if (obj->my_dev->param.is_yaffs2)
+               unlink_op = (new_dir == obj->my_dev->unlinked_dir);
+       else
+               unlink_op = (new_dir == obj->my_dev->unlinked_dir
+                            && obj->variant_type == YAFFS_OBJECT_TYPE_FILE);
+
+       del_op = (new_dir == obj->my_dev->del_dir);
+
+       existing_target = yaffs_find_by_name(new_dir, new_name);
+
+       /* 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 ((unlink_op ||
+            del_op ||
+            force ||
+            (shadows > 0) ||
+            !existing_target) &&
+           new_dir->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY) {
+               yaffs_set_obj_name(obj, new_name);
+               obj->dirty = 1;
+
+               yaffs_add_obj_to_dir(new_dir, obj);
+
+               if (unlink_op)
+                       obj->unlinked = 1;
+
+               /* If it is a deletion then we mark it as a shrink for gc purposes. */
+               if (yaffs_update_oh(obj, new_name, 0, del_op, shadows, NULL) >=
+                   0)
+                       return YAFFS_OK;
+       }
+
+       return YAFFS_FAIL;
+}
+
+/*------------------------ Short Operations Cache ----------------------------------------
+ *   In many situations where there is no high level buffering  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 and 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_obj_cache_dirty(struct yaffs_obj *obj)
+{
+       struct yaffs_dev *dev = obj->my_dev;
+       int i;
+       struct yaffs_cache *cache;
+       int n_caches = obj->my_dev->param.n_caches;
+
+       for (i = 0; i < n_caches; i++) {
+               cache = &dev->cache[i];
+               if (cache->object == obj && cache->dirty)
+                       return 1;
+       }
+
+       return 0;
+}
+
+static void yaffs_flush_file_cache(struct yaffs_obj *obj)
+{
+       struct yaffs_dev *dev = obj->my_dev;
+       int lowest = -99;       /* Stop compiler whining. */
+       int i;
+       struct yaffs_cache *cache;
+       int chunk_written = 0;
+       int n_caches = obj->my_dev->param.n_caches;
+
+       if (n_caches > 0) {
+               do {
+                       cache = NULL;
+
+                       /* Find the dirty cache for this object with the lowest chunk id. */
+                       for (i = 0; i < n_caches; 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;
+                                       }
+                               }
+                       }
+
+                       if (cache && !cache->locked) {
+                               /* Write it out and free it up */
+
+                               chunk_written =
+                                   yaffs_wr_data_obj(cache->object,
+                                                     cache->chunk_id,
+                                                     cache->data,
+                                                     cache->n_bytes, 1);
+                               cache->dirty = 0;
+                               cache->object = NULL;
+                       }
+
+               } while (cache && chunk_written > 0);
+
+               if (cache)
+                       /* Hoosterman, disk full while writing cache out. */
+                       yaffs_trace(YAFFS_TRACE_ERROR,
+                               "yaffs tragedy: no space during cache write");
+
+       }
+
+}
+
+/*yaffs_flush_whole_cache(dev)
+ *
+ *
+ */
+
+void yaffs_flush_whole_cache(struct yaffs_dev *dev)
+{
+       struct yaffs_obj *obj;
+       int n_caches = dev->param.n_caches;
+       int i;
+
+       /* Find a dirty object in the cache and flush it...
+        * until there are no further dirty objects.
+        */
+       do {
+               obj = NULL;
+               for (i = 0; i < n_caches && !obj; i++) {
+                       if (dev->cache[i].object && dev->cache[i].dirty)
+                               obj = dev->cache[i].object;
+
+               }
+               if (obj)
+                       yaffs_flush_file_cache(obj);
+
+       } while (obj);
+
+}
+
+/* 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 struct yaffs_cache *yaffs_grab_chunk_worker(struct yaffs_dev *dev)
+{
+       int i;
+
+       if (dev->param.n_caches > 0) {
+               for (i = 0; i < dev->param.n_caches; i++) {
+                       if (!dev->cache[i].object)
+                               return &dev->cache[i];
+               }
+       }
+
+       return NULL;
+}
+
+static struct yaffs_cache *yaffs_grab_chunk_cache(struct yaffs_dev *dev)
+{
+       struct yaffs_cache *cache;
+       struct yaffs_obj *the_obj;
+       int usage;
+       int i;
+       int pushout;
+
+       if (dev->param.n_caches > 0) {
+               /* Try find a non-dirty one... */
+
+               cache = yaffs_grab_chunk_worker(dev);
+
+               if (!cache) {
+                       /* They were all dirty, find the last recently used object and flush
+                        * its cache, then  find again.
+                        * NB what's here is not very accurate, we actually flush the object
+                        * the last recently used page.
+                        */
+
+                       /* With locking we can't assume we can use entry zero */
+
+                       the_obj = NULL;
+                       usage = -1;
+                       cache = NULL;
+                       pushout = -1;
+
+                       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;
+                                       the_obj = dev->cache[i].object;
+                                       cache = &dev->cache[i];
+                                       pushout = i;
+                               }
+                       }
+
+                       if (!cache || cache->dirty) {
+                               /* Flush and try again */
+                               yaffs_flush_file_cache(the_obj);
+                               cache = yaffs_grab_chunk_worker(dev);
+                       }
+
+               }
+               return cache;
+       } else {
+               return NULL;
+        }
+}
+
+/* Find a cached chunk */
+static struct yaffs_cache *yaffs_find_chunk_cache(const struct yaffs_obj *obj,
+                                                 int chunk_id)
+{
+       struct yaffs_dev *dev = obj->my_dev;
+       int i;
+       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->cache[i];
+                       }
+               }
+       }
+       return NULL;
+}
+
+/* Mark the chunk for the least recently used algorithym */
+static void yaffs_use_cache(struct yaffs_dev *dev, struct yaffs_cache *cache,
+                           int is_write)
+{
+
+       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.n_caches; i++)
+                               dev->cache[i].last_use = 0;
+
+                       dev->cache_last_use = 0;
+               }
+
+               dev->cache_last_use++;
+
+               cache->last_use = dev->cache_last_use;
+
+               if (is_write)
+                       cache->dirty = 1;
+       }
+}
+
+/* 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_invalidate_chunk_cache(struct yaffs_obj *object, int chunk_id)
+{
+       if (object->my_dev->param.n_caches > 0) {
+               struct yaffs_cache *cache =
+                   yaffs_find_chunk_cache(object, chunk_id);
+
+               if (cache)
+                       cache->object = NULL;
+       }
+}
+
+/* Invalidate all the cache pages associated with this object
+ * Do this whenever ther file is deleted or resized.
+ */
+static void yaffs_invalidate_whole_cache(struct yaffs_obj *in)
+{
+       int i;
+       struct yaffs_dev *dev = in->my_dev;
+
+       if (dev->param.n_caches > 0) {
+               /* Invalidate it. */
+               for (i = 0; i < dev->param.n_caches; i++) {
+                       if (dev->cache[i].object == in)
+                               dev->cache[i].object = NULL;
+               }
+       }
+}
+
+static void yaffs_unhash_obj(struct yaffs_obj *obj)
+{
+       int bucket;
+       struct yaffs_dev *dev = obj->my_dev;
+
+       /* If it is still linked into the bucket list, free from the list */
+       if (!list_empty(&obj->hash_link)) {
+               list_del_init(&obj->hash_link);
+               bucket = yaffs_hash_fn(obj->obj_id);
+               dev->obj_bucket[bucket].count--;
+       }
+}
+
+/*  FreeObject frees up a Object and puts it back on the free list */
+static void yaffs_free_obj(struct yaffs_obj *obj)
+{
+       struct yaffs_dev *dev = obj->my_dev;
+
+       yaffs_trace(YAFFS_TRACE_OS, "FreeObject %p inode %p",
+               obj, obj->my_inode);
+
+       if (!obj)
+               YBUG();
+       if (obj->parent)
+               YBUG();
+       if (!list_empty(&obj->siblings))
+               YBUG();
+
+       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;
+       }
+
+       yaffs_unhash_obj(obj);
+
+       yaffs_free_raw_obj(dev, obj);
+       dev->n_obj--;
+       dev->checkpoint_blocks_required = 0;    /* force recalculation */
+}
+
+void yaffs_handle_defered_free(struct yaffs_obj *obj)
+{
+       if (obj->defered_free)
+               yaffs_free_obj(obj);
+}
+
+static int yaffs_generic_obj_del(struct yaffs_obj *in)
+{
+
+       /* First off, invalidate the file's data in the cache, without flushing. */
+       yaffs_invalidate_whole_cache(in);
+
+       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_change_obj_name(in, in->my_dev->del_dir, _Y("deleted"), 0,
+                                     0);
+
+       }
+
+       yaffs_remove_obj_from_dir(in);
+       yaffs_chunk_del(in->my_dev, in->hdr_chunk, 1, __LINE__);
+       in->hdr_chunk = 0;
+
+       yaffs_free_obj(in);
+       return YAFFS_OK;
+
+}
+
+static void yaffs_soft_del_file(struct yaffs_obj *obj)
+{
+       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 */
+                       /* 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_trace(YAFFS_TRACE_TRACING,
+                               "yaffs: Deleting empty file %d",
+                               obj->obj_id);
                        yaffs_generic_obj_del(obj);
                } else {
                        yaffs_soft_del_worker(obj,
@@ -1162,91 +1880,6 @@ static struct yaffs_obj *yaffs_alloc_empty_obj(struct yaffs_dev *dev)
        return obj;
 }
 
-static struct yaffs_obj *yaffs_create_fake_dir(struct yaffs_dev *dev,
-                                              int number, u32 mode)
-{
-
-       struct yaffs_obj *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(struct yaffs_obj *obj)
-{
-       int bucket;
-       struct yaffs_dev *dev = obj->my_dev;
-
-       /* If it is still linked into the bucket list, free from the list */
-       if (!list_empty(&obj->hash_link)) {
-               list_del_init(&obj->hash_link);
-               bucket = yaffs_hash_fn(obj->obj_id);
-               dev->obj_bucket[bucket].count--;
-       }
-}
-
-/*  FreeObject frees up a Object and puts it back on the free list */
-static void yaffs_free_obj(struct yaffs_obj *obj)
-{
-       struct yaffs_dev *dev = obj->my_dev;
-
-       T(YAFFS_TRACE_OS,
-         (TSTR("FreeObject %p inode %p" TENDSTR), obj, obj->my_inode));
-
-       if (!obj)
-               YBUG();
-       if (obj->parent)
-               YBUG();
-       if (!list_empty(&obj->siblings))
-               YBUG();
-
-       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;
-       }
-
-       yaffs_unhash_obj(obj);
-
-       yaffs_free_raw_obj(dev, obj);
-       dev->n_obj--;
-       dev->checkpoint_blocks_required = 0;    /* force recalculation */
-}
-
-void yaffs_handle_defered_free(struct yaffs_obj *obj)
-{
-       if (obj->defered_free)
-               yaffs_free_obj(obj);
-}
-
-static void yaffs_init_tnodes_and_objs(struct yaffs_dev *dev)
-{
-       int i;
-
-       dev->n_obj = 0;
-       dev->n_tnodes = 0;
-
-       yaffs_init_raw_tnodes_and_objs(dev);
-
-       for (i = 0; i < YAFFS_NOBJECT_BUCKETS; i++) {
-               INIT_LIST_HEAD(&dev->obj_bucket[i].list);
-               dev->obj_bucket[i].count = 0;
-       }
-}
-
 static int yaffs_find_nice_bucket(struct yaffs_dev *dev)
 {
        int i;
@@ -1392,6 +2025,43 @@ struct yaffs_obj *yaffs_new_obj(struct yaffs_dev *dev, int number,
        return the_obj;
 }
 
+static struct yaffs_obj *yaffs_create_fake_dir(struct yaffs_dev *dev,
+                                              int number, u32 mode)
+{
+
+       struct yaffs_obj *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_init_tnodes_and_objs(struct yaffs_dev *dev)
+{
+       int i;
+
+       dev->n_obj = 0;
+       dev->n_tnodes = 0;
+
+       yaffs_init_raw_tnodes_and_objs(dev);
+
+       for (i = 0; i < YAFFS_NOBJECT_BUCKETS; i++) {
+               INIT_LIST_HEAD(&dev->obj_bucket[i].list);
+               dev->obj_bucket[i].count = 0;
+       }
+}
+
 struct yaffs_obj *yaffs_find_or_create_by_number(struct yaffs_dev *dev,
                                                 int number,
                                                 enum yaffs_obj_type type)
@@ -1413,17 +2083,80 @@ YCHAR *yaffs_clone_str(const YCHAR * str)
        YCHAR *new_str = NULL;
        int len;
 
-       if (!str)
-               str = _Y("");
+       if (!str)
+               str = _Y("");
+
+       len = strnlen(str, YAFFS_MAX_ALIAS_LENGTH);
+       new_str = kmalloc((len + 1) * sizeof(YCHAR), GFP_NOFS);
+       if (new_str) {
+               strncpy(new_str, str, len);
+               new_str[len] = 0;
+       }
+       return new_str;
+
+}
+/*
+ *yaffs_update_parent() handles fixing a directories mtime and ctime when a new
+ * link (ie. name) is created or deleted in the directory.
+ *
+ * ie.
+ *   create dir/a : update dir's mtime/ctime
+ *   rm dir/a:   update dir's mtime/ctime
+ *   modify dir/a: don't update dir's mtimme/ctime
+ *
+ * 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_update_dirty_dirs must be
+ * called periodically.
+ */
+
+static void yaffs_update_parent(struct yaffs_obj *obj)
+{
+       struct yaffs_dev *dev;
+       if (!obj)
+               return;
+       dev = obj->my_dev;
+       obj->dirty = 1;
+       yaffs_load_current_time(obj, 0, 1);
+       if (dev->param.defered_dir_update) {
+               struct list_head *link = &obj->variant.dir_variant.dirty;
+
+               if (list_empty(link)) {
+                       list_add(link, &dev->dirty_dirs);
+                       yaffs_trace(YAFFS_TRACE_BACKGROUND,
+                         "Added object %d to dirty directories",
+                          obj->obj_id);
+               }
+
+       } else {
+               yaffs_update_oh(obj, NULL, 0, 0, 0, NULL);
+        }
+}
+
+void yaffs_update_dirty_dirs(struct yaffs_dev *dev)
+{
+       struct list_head *link;
+       struct yaffs_obj *obj;
+       struct yaffs_dir_var *d_s;
+       union yaffs_obj_var *o_v;
+
+       yaffs_trace(YAFFS_TRACE_BACKGROUND, "Update dirty directories");
+
+       while (!list_empty(&dev->dirty_dirs)) {
+               link = dev->dirty_dirs.next;
+               list_del_init(link);
+
+               d_s = list_entry(link, struct yaffs_dir_var, dirty);
+               o_v = list_entry(d_s, union yaffs_obj_var, dir_variant);
+               obj = list_entry(o_v, struct yaffs_obj, variant);
 
-       len = yaffs_strnlen(str, YAFFS_MAX_ALIAS_LENGTH);
-       new_str = YMALLOC((len + 1) * sizeof(YCHAR));
-       if (new_str) {
-               yaffs_strncpy(new_str, str, len);
-               new_str[len] = 0;
-       }
-       return new_str;
+               yaffs_trace(YAFFS_TRACE_BACKGROUND, "Update directory %d",
+                       obj->obj_id);
 
+               if (obj->dirty)
+                       yaffs_update_oh(obj, NULL, 0, 0, 0, NULL);
+       }
 }
 
 /*
@@ -1461,7 +2194,7 @@ static struct yaffs_obj *yaffs_create_obj(enum yaffs_obj_type type,
 
        if (!in) {
                if (str)
-                       YFREE(str);
+                       kfree(str);
                return NULL;
        }
 
@@ -1561,141 +2294,7 @@ struct yaffs_obj *yaffs_link_obj(struct yaffs_obj *parent, const YCHAR * name,
 
 }
 
-static int yaffs_change_obj_name(struct yaffs_obj *obj,
-                                struct yaffs_obj *new_dir,
-                                const YCHAR * new_name, int force, int shadows)
-{
-       int unlink_op;
-       int del_op;
-
-       struct yaffs_obj *existing_target;
-
-       if (new_dir == NULL)
-               new_dir = obj->parent;  /* use the old directory */
-
-       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();
-       }
-
-       /* TODO: Do we need this different handling for YAFFS2 and YAFFS1?? */
-       if (obj->my_dev->param.is_yaffs2)
-               unlink_op = (new_dir == obj->my_dev->unlinked_dir);
-       else
-               unlink_op = (new_dir == obj->my_dev->unlinked_dir
-                            && obj->variant_type == YAFFS_OBJECT_TYPE_FILE);
-
-       del_op = (new_dir == obj->my_dev->del_dir);
-
-       existing_target = yaffs_find_by_name(new_dir, new_name);
-
-       /* 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 ((unlink_op ||
-            del_op ||
-            force ||
-            (shadows > 0) ||
-            !existing_target) &&
-           new_dir->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY) {
-               yaffs_set_obj_name(obj, new_name);
-               obj->dirty = 1;
-
-               yaffs_add_obj_to_dir(new_dir, obj);
-
-               if (unlink_op)
-                       obj->unlinked = 1;
-
-               /* If it is a deletion then we mark it as a shrink for gc purposes. */
-               if (yaffs_update_oh(obj, new_name, 0, del_op, shadows, NULL) >=
-                   0)
-                       return YAFFS_OK;
-       }
-
-       return YAFFS_FAIL;
-}
-
-
-/* Note:
- * If old_name is NULL then we take old_dir as the object to be renamed.
- */
-int yaffs_rename_obj(struct yaffs_obj *old_dir, const YCHAR * old_name,
-                    struct yaffs_obj *new_dir, const YCHAR * new_name)
-{
-       struct yaffs_obj *obj = NULL;
-       struct yaffs_obj *existing_target = NULL;
-       int force = 0;
-       int result;
-       struct yaffs_dev *dev;
-
-       if (!old_dir || old_dir->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY)
-               YBUG();
-       if (!new_dir || new_dir->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY)
-               YBUG();
-
-       dev = old_dir->my_dev;
-
-#ifdef CONFIG_YAFFS_CASE_INSENSITIVE
-       /* Special case for case insemsitive systems.
-        * 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 && 
-               old_name && new_name && 
-               yaffs_strcmp(old_name, new_name) == 0)
-               force = 1;
-#endif
-
-       if (yaffs_strnlen(new_name, YAFFS_MAX_NAME_LENGTH + 1) >
-           YAFFS_MAX_NAME_LENGTH)
-               /* ENAMETOOLONG */
-               return YAFFS_FAIL;
-
-       if(old_name)
-               obj = yaffs_find_by_name(old_dir, old_name);
-       else{
-               obj = old_dir;
-               old_dir = obj->parent;
-       }
-
-
-       if (obj && obj->rename_allowed) {
-
-               /* Now do the handling for an existing target, if there is one */
-
-               existing_target = yaffs_find_by_name(new_dir, new_name);
-               if (yaffs_is_non_empty_dir(existing_target)){
-                       return YAFFS_FAIL;      /* ENOTEMPTY */
-               } else if (existing_target && existing_target != 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,
-                                             existing_target->obj_id);
-                       existing_target->is_shadowed = 1;
-                       yaffs_unlink_obj(existing_target);
-                       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 YAFFS_FAIL;
-}
 
 /*------------------------- Block Management and Page Allocation ----------------*/
 
@@ -1709,22 +2308,24 @@ static int yaffs_init_blocks(struct yaffs_dev *dev)
        dev->alloc_block = -1;  /* force it to get a new one */
 
        /* If the first allocation strategy fails, thry the alternate one */
-       dev->block_info = YMALLOC(n_blocks * sizeof(struct yaffs_block_info));
+       dev->block_info =
+               kmalloc(n_blocks * sizeof(struct yaffs_block_info), GFP_NOFS);
        if (!dev->block_info) {
                dev->block_info =
-                   YMALLOC_ALT(n_blocks * sizeof(struct yaffs_block_info));
+                   vmalloc(n_blocks * sizeof(struct yaffs_block_info));
                dev->block_info_alt = 1;
        } else {
                dev->block_info_alt = 0;
         }
 
        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 * n_blocks);
+               /* Set up dynamic blockinfo stuff. Round up bytes. */
+               dev->chunk_bit_stride = (dev->param.chunks_per_block + 7) / 8;
+               dev->chunk_bits =
+                       kmalloc(dev->chunk_bit_stride * n_blocks, GFP_NOFS);
                if (!dev->chunk_bits) {
                        dev->chunk_bits =
-                           YMALLOC_ALT(dev->chunk_bit_stride * n_blocks);
+                           vmalloc(dev->chunk_bit_stride * n_blocks);
                        dev->chunk_bits_alt = 1;
                } else {
                        dev->chunk_bits_alt = 0;
@@ -1744,18 +2345,18 @@ static int yaffs_init_blocks(struct yaffs_dev *dev)
 static void yaffs_deinit_blocks(struct yaffs_dev *dev)
 {
        if (dev->block_info_alt && dev->block_info)
-               YFREE_ALT(dev->block_info);
+               vfree(dev->block_info);
        else if (dev->block_info)
-               YFREE(dev->block_info);
+               kfree(dev->block_info);
 
        dev->block_info_alt = 0;
 
        dev->block_info = NULL;
 
        if (dev->chunk_bits_alt && dev->chunk_bits)
-               YFREE_ALT(dev->chunk_bits);
+               vfree(dev->chunk_bits);
        else if (dev->chunk_bits)
-               YFREE(dev->chunk_bits);
+               kfree(dev->chunk_bits);
        dev->chunk_bits_alt = 0;
        dev->chunk_bits = NULL;
 }
@@ -1770,10 +2371,10 @@ void yaffs_block_became_dirty(struct yaffs_dev *dev, int block_no)
         * If the block has had a data failure, then retire it.
         */
 
-       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" : ""));
+       yaffs_trace(YAFFS_TRACE_GC | YAFFS_TRACE_ERASE,
+               "yaffs_block_became_dirty block %d state %d %s",
+               block_no, bi->block_state,
+               (bi->needs_retiring) ? "needs retiring" : "");
 
        yaffs2_clear_oldest_dirty_seq(dev, bi);
 
@@ -1794,8 +2395,8 @@ void yaffs_block_became_dirty(struct yaffs_dev *dev, int block_no)
                erased_ok = yaffs_erase_block(dev, block_no);
                if (!erased_ok) {
                        dev->n_erase_failures++;
-                       T(YAFFS_TRACE_ERROR | YAFFS_TRACE_BAD_BLOCKS,
-                         (TSTR("**>> Erasure failed %d" TENDSTR), block_no));
+                       yaffs_trace(YAFFS_TRACE_ERROR | YAFFS_TRACE_BAD_BLOCKS,
+                         "**>> Erasure failed %d", block_no);
                }
        }
 
@@ -1805,185 +2406,38 @@ void yaffs_block_became_dirty(struct yaffs_dev *dev, int block_no)
                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));
-                       }
-               }
-       }
-
-       if (erased_ok) {
-               /* 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);
-
-               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 int yaffs_find_alloc_block(struct yaffs_dev *dev)
-{
-       int i;
-
-       struct yaffs_block_info *bi;
-
-       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)));
-
-               return -1;
-       }
-
-       /* Find an empty block. */
-
-       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;
-               }
-
-               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;
-               }
-       }
-
-       T(YAFFS_TRACE_ALWAYS,
-         (TSTR
-          ("yaffs tragedy: no more erased blocks, but there should have been %d"
-           TENDSTR), dev->n_erased_blocks));
-
-       return -1;
-}
-
-/*
- * 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(struct yaffs_dev *dev, int n_chunks)
-{
-       int reserved_chunks;
-       int reserved_blocks = dev->param.n_reserved_blocks;
-       int checkpt_blocks;
-
-       checkpt_blocks = yaffs_calc_checkpt_blocks_required(dev);
-
-       reserved_chunks =
-           ((reserved_blocks + checkpt_blocks) * dev->param.chunks_per_block);
-
-       return (dev->n_free_chunks > (reserved_chunks + n_chunks));
-}
-
-static int yaffs_alloc_chunk(struct yaffs_dev *dev, int use_reserver,
-                            struct yaffs_block_info **block_ptr)
-{
-       int ret_val;
-       struct yaffs_block_info *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 (!use_reserver && !yaffs_check_alloc_available(dev, 1)) {
-               /* Not enough space to allocate unless we're allowed to use the reserve. */
-               return -1;
-       }
-
-       if (dev->n_erased_blocks < dev->param.n_reserved_blocks
-           && dev->alloc_page == 0) {
-               T(YAFFS_TRACE_ALLOCATE, (TSTR("Allocating reserve" TENDSTR)));
-       }
-
-       /* Next page please.... */
-       if (dev->alloc_block >= 0) {
-               bi = yaffs_get_block_info(dev, dev->alloc_block);
-
-               ret_val = (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);
-
-               dev->alloc_page++;
-
-               dev->n_free_chunks--;
-
-               /* 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;
+                           (dev, block_no * dev->param.chunks_per_block + i)) {
+                               yaffs_trace(YAFFS_TRACE_ERROR,
+                                       ">>Block %d erasure supposedly OK, but chunk %d not erased",
+                                       block_no, i);
+                       }
                }
-
-               if (block_ptr)
-                       *block_ptr = bi;
-
-               return ret_val;
        }
 
-       T(YAFFS_TRACE_ERROR,
-         (TSTR("!!!!!!!!! Allocator out !!!!!!!!!!!!!!!!!" TENDSTR)));
+       if (erased_ok) {
+               /* 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;      /* Clean, so no need to check */
+               bi->gc_prioritise = 0;
+               yaffs_clear_chunk_bits(dev, block_no);
 
-       return -1;
+               yaffs_trace(YAFFS_TRACE_ERASE,
+                       "Erased block %d", block_no);
+       } else {
+               /* We lost a block of free space */
+               dev->n_free_chunks -= dev->param.chunks_per_block;
+               yaffs_retire_block(dev, block_no);
+               yaffs_trace(YAFFS_TRACE_ERROR | YAFFS_TRACE_BAD_BLOCKS,
+                       "**>> Block %d retired", block_no);
+       }
 }
 
-static int yaffs_get_erased_chunks(struct yaffs_dev *dev)
-{
-       int n;
-
-       n = dev->n_erased_blocks * dev->param.chunks_per_block;
-
-       if (dev->alloc_block > 0)
-               n += (dev->param.chunks_per_block - dev->alloc_page);
-
-       return n;
-
-}
 
-/*
- * 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(struct yaffs_dev *dev)
-{
-       if (dev->alloc_block > 0) {
-               struct yaffs_block_info *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;
-               }
-       }
-}
 
 static int yaffs_gc_block(struct yaffs_dev *dev, int block, int whole_block)
 {
@@ -2007,11 +2461,10 @@ static int yaffs_gc_block(struct yaffs_dev *dev, int block, int whole_block)
 
        is_checkpt_block = (bi->block_state == YAFFS_BLOCK_STATE_CHECKPOINT);
 
-       T(YAFFS_TRACE_TRACING,
-         (TSTR
-          ("Collecting block %d, in use %d, shrink %d, whole_block %d"
-           TENDSTR), block, bi->pages_in_use, bi->has_shrink_hdr,
-          whole_block));
+       yaffs_trace(YAFFS_TRACE_TRACING,
+               "Collecting block %d, in use %d, shrink %d, whole_block %d",
+               block, bi->pages_in_use, bi->has_shrink_hdr,
+               whole_block);
 
        /*yaffs_verify_free_chunks(dev); */
 
@@ -2023,10 +2476,9 @@ static int yaffs_gc_block(struct yaffs_dev *dev, int block, int whole_block)
        dev->gc_disable = 1;
 
        if (is_checkpt_block || !yaffs_still_some_chunks(dev, block)) {
-               T(YAFFS_TRACE_TRACING,
-                 (TSTR
-                  ("Collecting block %d that has no chunks in use" TENDSTR),
-                  block));
+               yaffs_trace(YAFFS_TRACE_TRACING,
+                       "Collecting block %d that has no chunks in use",
+                       block);
                yaffs_block_became_dirty(dev, block);
        } else {
 
@@ -2057,11 +2509,10 @@ static int yaffs_gc_block(struct yaffs_dev *dev, int block, int whole_block)
 
                                object = yaffs_find_by_number(dev, tags.obj_id);
 
-                               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));
+                               yaffs_trace(YAFFS_TRACE_GC_DETAIL,
+                                       "Collecting chunk in block %d, %d %d %d ",
+                                       dev->gc_chunk, tags.obj_id,
+                                       tags.chunk_id, tags.n_bytes);
 
                                if (object && !yaffs_skip_verification(dev)) {
                                        if (tags.chunk_id == 0)
@@ -2076,22 +2527,21 @@ static int yaffs_gc_block(struct yaffs_dev *dev, int block, int whole_block)
                                                     NULL);
 
                                        if (old_chunk != matching_chunk)
-                                               T(YAFFS_TRACE_ERROR,
-                                                 (TSTR
-                                                  ("gc: page in gc mismatch: %d %d %d %d"
-                                                   TENDSTR), old_chunk,
-                                                  matching_chunk, tags.obj_id,
-                                                  tags.chunk_id));
+                                               yaffs_trace(YAFFS_TRACE_ERROR,
+                                                       "gc: page in gc mismatch: %d %d %d %d",
+                                                       old_chunk,
+                                                       matching_chunk,
+                                                       tags.obj_id,
+                                                       tags.chunk_id);
 
                                }
 
                                if (!object) {
-                                       T(YAFFS_TRACE_ERROR,
-                                         (TSTR
-                                          ("page %d in gc has no object: %d %d %d "
-                                           TENDSTR), old_chunk,
-                                          tags.obj_id, tags.chunk_id,
-                                          tags.n_bytes));
+                                       yaffs_trace(YAFFS_TRACE_ERROR,
+                                               "page %d in gc has no object: %d %d %d ",
+                                               old_chunk,
+                                               tags.obj_id, tags.chunk_id,
+                                               tags.n_bytes);
                                }
 
                                if (object &&
@@ -2241,10 +2691,9 @@ static int yaffs_gc_block(struct yaffs_dev *dev, int block, int whole_block)
                                                 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_trace(YAFFS_TRACE_GC,
+                                       "yaffs: About to finally delete object %d",
+                                       object->obj_id);
                                yaffs_generic_obj_del(object);
                                object->my_dev->n_deleted_files--;
                        }
@@ -2252,12 +2701,10 @@ static int yaffs_gc_block(struct yaffs_dev *dev, int block, int whole_block)
                }
 
                chunks_after = yaffs_get_erased_chunks(dev);
-               if (chunks_before >= chunks_after) {
-                       T(YAFFS_TRACE_GC,
-                         (TSTR
-                          ("gc did not increase free chunks before %d after %d"
-                           TENDSTR), chunks_before, chunks_after));
-               }
+               if (chunks_before >= chunks_after)
+                       yaffs_trace(YAFFS_TRACE_GC,
+                               "gc did not increase free chunks before %d after %d",
+                               chunks_before, chunks_after);
                dev->gc_block = 0;
                dev->gc_chunk = 0;
                dev->n_clean_ups = 0;
@@ -2400,12 +2847,11 @@ static unsigned yaffs_find_gc_block(struct yaffs_dev *dev,
        }
 
        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));
+               yaffs_trace(YAFFS_TRACE_GC,
+                       "GC Selected block %d with %d free, prioritised:%d",
+                       selected,
+                       dev->param.chunks_per_block - dev->gc_pages_in_use,
+                       prioritised);
 
                dev->n_gc_blocks++;
                if (background)
@@ -2418,12 +2864,11 @@ static unsigned yaffs_find_gc_block(struct yaffs_dev *dev,
                        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" : ""));
+               yaffs_trace(YAFFS_TRACE_GC,
+                       "GC none: finder %d skip %d threshold %d dirtiest %d using %d oldest %d%s",
+                       dev->gc_block_finder, dev->gc_not_done, threshold,
+                       dev->gc_dirtiest, dev->gc_pages_in_use,
+                       dev->oldest_dirty_block, background ? " bg" : "");
        }
 
        return selected;
@@ -2508,244 +2953,44 @@ static int yaffs_check_gc(struct yaffs_dev *dev, int background)
                        dev->all_gcs++;
                        if (!aggressive)
                                dev->passive_gc_count++;
-
-                       T(YAFFS_TRACE_GC,
-                         (TSTR
-                          ("yaffs: GC n_erased_blocks %d aggressive %d"
-                           TENDSTR), dev->n_erased_blocks, aggressive));
-
-                       gc_ok = yaffs_gc_block(dev, dev->gc_block, aggressive);
-               }
-
-               if (dev->n_erased_blocks < (dev->param.n_reserved_blocks)
-                   && dev->gc_block > 0) {
-                       T(YAFFS_TRACE_GC,
-                         (TSTR
-                          ("yaffs: GC !!!no reclaim!!! n_erased_blocks %d after try %d block %d"
-                           TENDSTR), dev->n_erased_blocks, max_tries,
-                          dev->gc_block));
-               }
-       } while ((dev->n_erased_blocks < dev->param.n_reserved_blocks) &&
-                (dev->gc_block > 0) && (max_tries < 2));
-
-       return aggressive ? gc_ok : YAFFS_OK;
-}
-
-/*
- * 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_bg_gc(struct yaffs_dev *dev, unsigned urgency)
-{
-       int erased_chunks = dev->n_erased_blocks * dev->param.chunks_per_block;
-
-       T(YAFFS_TRACE_BACKGROUND, (TSTR("Background gc %u" TENDSTR), urgency));
-
-       yaffs_check_gc(dev, 1);
-       return erased_chunks > dev->n_free_chunks / 2;
-}
-
-/*-------------------------  TAGS --------------------------------*/
-
-static int yaffs_tags_match(const struct yaffs_ext_tags *tags, int obj_id,
-                           int chunk_obj)
-{
-       return (tags->chunk_id == chunk_obj &&
-               tags->obj_id == obj_id && !tags->is_deleted) ? 1 : 0;
-
-}
-
-/*-------------------- Data file manipulation -----------------*/
-
-static int yaffs_find_chunk_in_file(struct yaffs_obj *in, int inode_chunk,
-                                   struct yaffs_ext_tags *tags)
-{
-       /*Get the Tnode, then get the level 0 offset chunk offset */
-       struct yaffs_tnode *tn;
-       int the_chunk = -1;
-       struct yaffs_ext_tags local_tags;
-       int ret_val = -1;
-
-       struct yaffs_dev *dev = in->my_dev;
-
-       if (!tags) {
-               /* Passed a NULL, so use our own tags space */
-               tags = &local_tags;
-       }
-
-       tn = yaffs_find_tnode_0(dev, &in->variant.file_variant, inode_chunk);
-
-       if (tn) {
-               the_chunk = yaffs_get_group_base(dev, tn, inode_chunk);
-
-               ret_val =
-                   yaffs_find_chunk_in_group(dev, the_chunk, tags, in->obj_id,
-                                             inode_chunk);
-       }
-       return ret_val;
-}
-
-static int yaffs_find_del_file_chunk(struct yaffs_obj *in, int inode_chunk,
-                                    struct yaffs_ext_tags *tags)
-{
-       /* Get the Tnode, then get the level 0 offset chunk offset */
-       struct yaffs_tnode *tn;
-       int the_chunk = -1;
-       struct yaffs_ext_tags local_tags;
-
-       struct yaffs_dev *dev = in->my_dev;
-       int ret_val = -1;
-
-       if (!tags) {
-               /* Passed a NULL, so use our own tags space */
-               tags = &local_tags;
-       }
-
-       tn = yaffs_find_tnode_0(dev, &in->variant.file_variant, inode_chunk);
-
-       if (tn) {
-
-               the_chunk = yaffs_get_group_base(dev, tn, inode_chunk);
-
-               ret_val =
-                   yaffs_find_chunk_in_group(dev, the_chunk, tags, in->obj_id,
-                                             inode_chunk);
-
-               /* Delete the entry in the filestructure (if found) */
-               if (ret_val != -1)
-                       yaffs_load_tnode_0(dev, tn, inode_chunk, 0);
-       }
-
-       return ret_val;
-}
-
-int yaffs_put_chunk_in_file(struct yaffs_obj *in, int inode_chunk,
-                           int nand_chunk, int in_scan)
-{
-       /* NB in_scan is zero unless scanning.
-        * For forward scanning, in_scan is > 0;
-        * for backward scanning in_scan is < 0
-        *
-        * nand_chunk = 0 is a dummy insert to make sure the tnodes are there.
-        */
-
-       struct yaffs_tnode *tn;
-       struct yaffs_dev *dev = in->my_dev;
-       int existing_cunk;
-       struct yaffs_ext_tags existing_tags;
-       struct yaffs_ext_tags new_tags;
-       unsigned existing_serial, new_serial;
-
-       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 (!in_scan) {
-                       T(YAFFS_TRACE_ERROR,
-                         (TSTR
-                          ("yaffs tragedy:attempt to put data chunk into a non-file"
-                           TENDSTR)));
-                       YBUG();
-               }
-
-               yaffs_chunk_del(dev, nand_chunk, 1, __LINE__);
-               return YAFFS_OK;
-       }
-
-       tn = yaffs_add_find_tnode_0(dev,
-                                   &in->variant.file_variant,
-                                   inode_chunk, NULL);
-       if (!tn)
-               return YAFFS_FAIL;
-
-       if (!nand_chunk)
-               /* Dummy insert, bail now */
-               return YAFFS_OK;
-
-       existing_cunk = yaffs_get_group_base(dev, tn, inode_chunk);
-
-       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
-                * chunk should ever be affected.
-                *
-                * 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.
-                */
-
-               if (existing_cunk > 0) {
-                       /* 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:
-                        *
-                        * Backwards scanning YAFFS2: The old one is what we use, dump the new one.
-                        * 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 (in_scan > 0) {
-                               /* Only do this for forward scanning */
-                               yaffs_rd_chunk_tags_nand(dev,
-                                                        nand_chunk,
-                                                        NULL, &new_tags);
-
-                               /* Do a proper find */
-                               existing_cunk =
-                                   yaffs_find_chunk_in_file(in, inode_chunk,
-                                                            &existing_tags);
-                       }
-
-                       if (existing_cunk <= 0) {
-                               /*Hoosterman - how did this happen? */
-
-                               T(YAFFS_TRACE_ERROR,
-                                 (TSTR
-                                  ("yaffs tragedy: existing chunk < 0 in scan"
-                                   TENDSTR)));
-
-                       }
-
-                       /* NB The deleted flags should be false, otherwise the chunks will
-                        * not be loaded during a scan
-                        */
-
-                       if (in_scan > 0) {
-                               new_serial = new_tags.serial_number;
-                               existing_serial = existing_tags.serial_number;
-                       }
-
-                       if ((in_scan > 0) &&
-                           (existing_cunk <= 0 ||
-                            ((existing_serial + 1) & 3) == new_serial)) {
-                               /* Forward scanning.
-                                * Use new
-                                * Delete the old one and drop through to update the tnode
-                                */
-                               yaffs_chunk_del(dev, existing_cunk, 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_chunk_del(dev, nand_chunk, 1, __LINE__);
-                               return YAFFS_OK;
-                       }
+
+                       yaffs_trace(YAFFS_TRACE_GC,
+                               "yaffs: GC n_erased_blocks %d aggressive %d",
+                               dev->n_erased_blocks, aggressive);
+
+                       gc_ok = yaffs_gc_block(dev, dev->gc_block, aggressive);
                }
 
-       }
+               if (dev->n_erased_blocks < (dev->param.n_reserved_blocks)
+                   && dev->gc_block > 0) {
+                       yaffs_trace(YAFFS_TRACE_GC,
+                               "yaffs: GC !!!no reclaim!!! n_erased_blocks %d after try %d block %d",
+                               dev->n_erased_blocks, max_tries,
+                               dev->gc_block);
+               }
+       } while ((dev->n_erased_blocks < dev->param.n_reserved_blocks) &&
+                (dev->gc_block > 0) && (max_tries < 2));
 
-       if (existing_cunk == 0)
-               in->n_data_chunks++;
+       return aggressive ? gc_ok : YAFFS_OK;
+}
 
-       yaffs_load_tnode_0(dev, tn, inode_chunk, nand_chunk);
+/*
+ * 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_bg_gc(struct yaffs_dev *dev, unsigned urgency)
+{
+       int erased_chunks = dev->n_erased_blocks * dev->param.chunks_per_block;
 
-       return YAFFS_OK;
+       yaffs_trace(YAFFS_TRACE_BACKGROUND, "Background gc %u", urgency);
+
+       yaffs_check_gc(dev, 1);
+       return erased_chunks > dev->n_free_chunks / 2;
 }
 
+/*-------------------- Data file manipulation -----------------*/
+
 static int yaffs_rd_data_obj(struct yaffs_obj *in, int inode_chunk, u8 * buffer)
 {
        int nand_chunk = yaffs_find_chunk_in_file(in, inode_chunk, NULL);
@@ -2754,9 +2999,9 @@ static int yaffs_rd_data_obj(struct yaffs_obj *in, int inode_chunk, u8 * buffer)
                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),
-                  nand_chunk));
+               yaffs_trace(YAFFS_TRACE_NANDACCESS,
+                       "Chunk %d not found zero instead",
+                       nand_chunk);
                /* get sane (zero) data if you read a hole */
                memset(buffer, 0, in->my_dev->data_bytes_per_chunk);
                return 0;
@@ -2780,15 +3025,16 @@ void yaffs_chunk_del(struct yaffs_dev *dev, int chunk_id, int mark_flash,
        page = chunk_id % dev->param.chunks_per_block;
 
        if (!yaffs_check_chunk_bit(dev, block, page))
-               T(YAFFS_TRACE_VERIFY,
-                 (TSTR("Deleting invalid chunk %d" TENDSTR), chunk_id));
+               yaffs_trace(YAFFS_TRACE_VERIFY,
+                       "Deleting invalid chunk %d", 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));
+       yaffs_trace(YAFFS_TRACE_DELETION,
+               "line %d delete of chunk %d",
+               lyn, chunk_id);
 
        if (!dev->param.is_yaffs2 && mark_flash &&
            bi->block_state != YAFFS_BLOCK_STATE_COLLECTING) {
@@ -2864,9 +3110,9 @@ static int yaffs_wr_data_obj(struct yaffs_obj *in, int inode_chunk,
        new_tags.n_bytes = n_bytes;
 
        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));
+               yaffs_trace(YAFFS_TRACE_ERROR,
+                 "Writing %d bytes to chunk!!!!!!!!!",
+                  n_bytes);
                YBUG();
        }
 
@@ -2885,6 +3131,241 @@ static int yaffs_wr_data_obj(struct yaffs_obj *in, int inode_chunk,
 
 }
 
+
+
+static int yaffs_do_xattrib_mod(struct yaffs_obj *obj, int set,
+                               const YCHAR * name, const void *value, int size,
+                               int flags)
+{
+       struct yaffs_xattr_mod xmod;
+
+       int result;
+
+       xmod.set = set;
+       xmod.name = name;
+       xmod.data = value;
+       xmod.size = size;
+       xmod.flags = flags;
+       xmod.result = -ENOSPC;
+
+       result = yaffs_update_oh(obj, NULL, 0, 0, 0, &xmod);
+
+       if (result > 0)
+               return xmod.result;
+       else
+               return -ENOSPC;
+}
+
+static int yaffs_apply_xattrib_mod(struct yaffs_obj *obj, char *buffer,
+                                  struct yaffs_xattr_mod *xmod)
+{
+       int retval = 0;
+       int x_offs = sizeof(struct yaffs_obj_hdr);
+       struct yaffs_dev *dev = obj->my_dev;
+       int x_size = dev->data_bytes_per_chunk - sizeof(struct yaffs_obj_hdr);
+
+       char *x_buffer = buffer + x_offs;
+
+       if (xmod->set)
+               retval =
+                   nval_set(x_buffer, x_size, xmod->name, xmod->data,
+                            xmod->size, xmod->flags);
+       else
+               retval = nval_del(x_buffer, x_size, xmod->name);
+
+       obj->has_xattr = nval_hasvalues(x_buffer, x_size);
+       obj->xattr_known = 1;
+
+       xmod->result = retval;
+
+       return retval;
+}
+
+static int yaffs_do_xattrib_fetch(struct yaffs_obj *obj, const YCHAR * name,
+                                 void *value, int size)
+{
+       char *buffer = NULL;
+       int result;
+       struct yaffs_ext_tags tags;
+       struct yaffs_dev *dev = obj->my_dev;
+       int x_offs = sizeof(struct yaffs_obj_hdr);
+       int x_size = dev->data_bytes_per_chunk - sizeof(struct yaffs_obj_hdr);
+
+       char *x_buffer;
+
+       int retval = 0;
+
+       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->xattr_known && !obj->has_xattr) {
+               if (name)
+                       return -ENODATA;
+               else
+                       return 0;
+       }
+
+       buffer = (char *)yaffs_get_temp_buffer(dev, __LINE__);
+       if (!buffer)
+               return -ENOMEM;
+
+       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->xattr_known) {
+                       obj->has_xattr = nval_hasvalues(x_buffer, x_size);
+                       obj->xattr_known = 1;
+               }
+
+               if (name)
+                       retval = nval_get(x_buffer, x_size, name, value, size);
+               else
+                       retval = nval_list(x_buffer, x_size, value, size);
+       }
+       yaffs_release_temp_buffer(dev, (u8 *) buffer, __LINE__);
+       return retval;
+}
+
+int yaffs_set_xattrib(struct yaffs_obj *obj, const YCHAR * name,
+                     const void *value, int size, int flags)
+{
+       return yaffs_do_xattrib_mod(obj, 1, name, value, size, flags);
+}
+
+int yaffs_remove_xattrib(struct yaffs_obj *obj, const YCHAR * name)
+{
+       return yaffs_do_xattrib_mod(obj, 0, name, NULL, 0, 0);
+}
+
+int yaffs_get_xattrib(struct yaffs_obj *obj, const YCHAR * name, void *value,
+                     int size)
+{
+       return yaffs_do_xattrib_fetch(obj, name, value, size);
+}
+
+int yaffs_list_xattrib(struct yaffs_obj *obj, char *buffer, int size)
+{
+       return yaffs_do_xattrib_fetch(obj, NULL, buffer, size);
+}
+
+static void yaffs_check_obj_details_loaded(struct yaffs_obj *in)
+{
+       u8 *chunk_data;
+       struct yaffs_obj_hdr *oh;
+       struct yaffs_dev *dev;
+       struct yaffs_ext_tags tags;
+       int result;
+       int alloc_failed = 0;
+
+       if (!in)
+               return;
+
+       dev = in->my_dev;
+
+       if (in->lazy_loaded && in->hdr_chunk > 0) {
+               in->lazy_loaded = 0;
+               chunk_data = yaffs_get_temp_buffer(dev, __LINE__);
+
+               result =
+                   yaffs_rd_chunk_tags_nand(dev, in->hdr_chunk, chunk_data,
+                                            &tags);
+               oh = (struct yaffs_obj_hdr *)chunk_data;
+
+               in->yst_mode = oh->yst_mode;
+               yaffs_load_attribs(in, oh);
+               yaffs_set_obj_name_from_oh(in, oh);
+
+               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 */
+               }
+
+               yaffs_release_temp_buffer(dev, chunk_data, __LINE__);
+       }
+}
+
+static void yaffs_load_name_from_oh(struct yaffs_dev *dev, YCHAR * name,
+                                   const YCHAR * oh_name, int buff_size)
+{
+#ifdef CONFIG_YAFFS_AUTO_UNICODE
+       if (dev->param.auto_unicode) {
+               if (*oh_name) {
+                       /* It is an ASCII name, do an ASCII to
+                        * unicode conversion */
+                       const char *ascii_oh_name = (const char *)oh_name;
+                       int n = buff_size - 1;
+                       while (n > 0 && *ascii_oh_name) {
+                               *name = *ascii_oh_name;
+                               name++;
+                               ascii_oh_name++;
+                               n--;
+                       }
+               } else {
+                       strncpy(name, oh_name + 1, buff_size - 1);
+                }
+       } else {
+#else
+        {
+#endif
+               strncpy(name, oh_name, buff_size - 1);
+        }
+}
+
+static void yaffs_load_oh_from_name(struct yaffs_dev *dev, YCHAR * oh_name,
+                                   const YCHAR * name)
+{
+#ifdef CONFIG_YAFFS_AUTO_UNICODE
+
+       int is_ascii;
+       YCHAR *w;
+
+       if (dev->param.auto_unicode) {
+
+               is_ascii = 1;
+               w = name;
+
+               /* Figure out if the name will fit in ascii character set */
+               while (is_ascii && *w) {
+                       if ((*w) & 0xff00)
+                               is_ascii = 0;
+                       w++;
+               }
+
+               if (is_ascii) {
+                       /* It is an ASCII name, so do a unicode to ascii conversion */
+                       char *ascii_oh_name = (char *)oh_name;
+                       int n = YAFFS_MAX_NAME_LENGTH - 1;
+                       while (n > 0 && *name) {
+                               *ascii_oh_name = *name;
+                               name++;
+                               ascii_oh_name++;
+                               n--;
+                       }
+               } else {
+                       /* It is a unicode name, so save starting at the second YCHAR */
+                       *oh_name = 0;
+                       strncpy(oh_name + 1, name,
+                                     YAFFS_MAX_NAME_LENGTH - 2);
+               }
+       } else {
+#else
+        {
+#endif
+               strncpy(oh_name, name, YAFFS_MAX_NAME_LENGTH - 1);
+        }
+
+}
+
 /* UpdateObjectHeader updates the header on NAND for an object.
  * If name is not NULL, then that new name is used.
  */
@@ -2910,9 +3391,9 @@ int yaffs_update_oh(struct yaffs_obj *in, const YCHAR * name, int force,
 
        struct yaffs_obj_hdr *oh = NULL;
 
-       yaffs_strcpy(old_name, _Y("silly old name"));
+       strcpy(old_name, _Y("silly old name"));
 
-       if (!in->fake || in == dev->root_dir || /* The root_dir should also be saved */
+       if (!in->fake || in == dev->root_dir ||
            force || xmod) {
 
                yaffs_check_gc(dev, 0);
@@ -2981,7 +3462,7 @@ int yaffs_update_oh(struct yaffs_obj *in, const YCHAR * name, int force,
                        alias = in->variant.symlink_variant.alias;
                        if (!alias)
                                alias = _Y("no alias");
-                       yaffs_strncpy(oh->alias, alias, YAFFS_MAX_ALIAS_LENGTH);
+                       strncpy(oh->alias, alias, YAFFS_MAX_ALIAS_LENGTH);
                        oh->alias[YAFFS_MAX_ALIAS_LENGTH] = 0;
                        break;
                }
@@ -3024,282 +3505,27 @@ int yaffs_update_oh(struct yaffs_obj *in, const YCHAR * name, int force,
                        }
 
                        if (!yaffs_obj_cache_dirty(in))
-                               in->dirty = 0;
-
-                       /* 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,
-                                                         new_chunk_id /
-                                                         in->my_dev->param.
-                                                         chunks_per_block);
-                               bi->has_shrink_hdr = 1;
-                       }
-
-               }
-
-               ret_val = new_chunk_id;
-
-       }
-
-       if (buffer)
-               yaffs_release_temp_buffer(dev, buffer, __LINE__);
-
-       return ret_val;
-}
-
-/*------------------------ Short Operations Cache ----------------------------------------
- *   In many situations where there is no high level buffering  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 and 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_obj_cache_dirty(struct yaffs_obj *obj)
-{
-       struct yaffs_dev *dev = obj->my_dev;
-       int i;
-       struct yaffs_cache *cache;
-       int n_caches = obj->my_dev->param.n_caches;
-
-       for (i = 0; i < n_caches; i++) {
-               cache = &dev->cache[i];
-               if (cache->object == obj && cache->dirty)
-                       return 1;
-       }
-
-       return 0;
-}
-
-static void yaffs_flush_file_cache(struct yaffs_obj *obj)
-{
-       struct yaffs_dev *dev = obj->my_dev;
-       int lowest = -99;       /* Stop compiler whining. */
-       int i;
-       struct yaffs_cache *cache;
-       int chunk_written = 0;
-       int n_caches = obj->my_dev->param.n_caches;
-
-       if (n_caches > 0) {
-               do {
-                       cache = NULL;
-
-                       /* Find the dirty cache for this object with the lowest chunk id. */
-                       for (i = 0; i < n_caches; 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;
-                                       }
-                               }
-                       }
-
-                       if (cache && !cache->locked) {
-                               /* Write it out and free it up */
-
-                               chunk_written =
-                                   yaffs_wr_data_obj(cache->object,
-                                                     cache->chunk_id,
-                                                     cache->data,
-                                                     cache->n_bytes, 1);
-                               cache->dirty = 0;
-                               cache->object = NULL;
-                       }
-
-               } while (cache && chunk_written > 0);
-
-               if (cache) {
-                       /* Hoosterman, disk full while writing cache out. */
-                       T(YAFFS_TRACE_ERROR,
-                         (TSTR
-                          ("yaffs tragedy: no space during cache write"
-                           TENDSTR)));
-
-               }
-       }
-
-}
-
-/*yaffs_flush_whole_cache(dev)
- *
- *
- */
-
-void yaffs_flush_whole_cache(struct yaffs_dev *dev)
-{
-       struct yaffs_obj *obj;
-       int n_caches = dev->param.n_caches;
-       int i;
-
-       /* Find a dirty object in the cache and flush it...
-        * until there are no further dirty objects.
-        */
-       do {
-               obj = NULL;
-               for (i = 0; i < n_caches && !obj; i++) {
-                       if (dev->cache[i].object && dev->cache[i].dirty)
-                               obj = dev->cache[i].object;
-
-               }
-               if (obj)
-                       yaffs_flush_file_cache(obj);
-
-       } while (obj);
-
-}
-
-/* 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 struct yaffs_cache *yaffs_grab_chunk_worker(struct yaffs_dev *dev)
-{
-       int i;
-
-       if (dev->param.n_caches > 0) {
-               for (i = 0; i < dev->param.n_caches; i++) {
-                       if (!dev->cache[i].object)
-                               return &dev->cache[i];
-               }
-       }
-
-       return NULL;
-}
-
-static struct yaffs_cache *yaffs_grab_chunk_cache(struct yaffs_dev *dev)
-{
-       struct yaffs_cache *cache;
-       struct yaffs_obj *the_obj;
-       int usage;
-       int i;
-       int pushout;
-
-       if (dev->param.n_caches > 0) {
-               /* Try find a non-dirty one... */
-
-               cache = yaffs_grab_chunk_worker(dev);
-
-               if (!cache) {
-                       /* They were all dirty, find the last recently used object and flush
-                        * its cache, then  find again.
-                        * NB what's here is not very accurate, we actually flush the object
-                        * the last recently used page.
-                        */
-
-                       /* With locking we can't assume we can use entry zero */
-
-                       the_obj = NULL;
-                       usage = -1;
-                       cache = NULL;
-                       pushout = -1;
-
-                       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;
-                                       the_obj = dev->cache[i].object;
-                                       cache = &dev->cache[i];
-                                       pushout = i;
-                               }
-                       }
-
-                       if (!cache || cache->dirty) {
-                               /* Flush and try again */
-                               yaffs_flush_file_cache(the_obj);
-                               cache = yaffs_grab_chunk_worker(dev);
-                       }
-
-               }
-               return cache;
-       } else {
-               return NULL;
-        }
-}
-
-/* Find a cached chunk */
-static struct yaffs_cache *yaffs_find_chunk_cache(const struct yaffs_obj *obj,
-                                                 int chunk_id)
-{
-       struct yaffs_dev *dev = obj->my_dev;
-       int i;
-       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->cache[i];
-                       }
-               }
-       }
-       return NULL;
-}
-
-/* Mark the chunk for the least recently used algorithym */
-static void yaffs_use_cache(struct yaffs_dev *dev, struct yaffs_cache *cache,
-                           int is_write)
-{
-
-       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.n_caches; i++)
-                               dev->cache[i].last_use = 0;
-
-                       dev->cache_last_use = 0;
-               }
-
-               dev->cache_last_use++;
-
-               cache->last_use = dev->cache_last_use;
-
-               if (is_write)
-                       cache->dirty = 1;
-       }
-}
-
-/* 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_invalidate_chunk_cache(struct yaffs_obj *object, int chunk_id)
-{
-       if (object->my_dev->param.n_caches > 0) {
-               struct yaffs_cache *cache =
-                   yaffs_find_chunk_cache(object, chunk_id);
-
-               if (cache)
-                       cache->object = NULL;
-       }
-}
+                               in->dirty = 0;
 
-/* Invalidate all the cache pages associated with this object
- * Do this whenever ther file is deleted or resized.
- */
-static void yaffs_invalidate_whole_cache(struct yaffs_obj *in)
-{
-       int i;
-       struct yaffs_dev *dev = in->my_dev;
+                       /* 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,
+                                                         new_chunk_id /
+                                                         in->my_dev->param.
+                                                         chunks_per_block);
+                               bi->has_shrink_hdr = 1;
+                       }
 
-       if (dev->param.n_caches > 0) {
-               /* Invalidate it. */
-               for (i = 0; i < dev->param.n_caches; i++) {
-                       if (dev->cache[i].object == in)
-                               dev->cache[i].object = NULL;
                }
+
+               ret_val = new_chunk_id;
+
        }
+
+       if (buffer)
+               yaffs_release_temp_buffer(dev, buffer, __LINE__);
+
+       return ret_val;
 }
 
 /*--------------------- File read/write ------------------------
@@ -3425,10 +3651,9 @@ int yaffs_do_file_wr(struct yaffs_obj *in, const u8 * buffer, loff_t offset,
 
                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));
+                       yaffs_trace(YAFFS_TRACE_ERROR,
+                               "AddrToChunk of offset %d gives chunk %d start %d",
+                               (int)offset, chunk, start);
                }
                chunk++;        /* File pos to chunk in file offset */
 
@@ -3612,10 +3837,9 @@ static void yaffs_prune_chunks(struct yaffs_obj *in, int new_size)
                            || 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));
+                               yaffs_trace(YAFFS_TRACE_ALWAYS,
+                                       "Found daft chunk_id %d for %d",
+                                       chunk_id, i);
                        } else {
                                in->n_data_chunks--;
                                yaffs_chunk_del(dev, chunk_id, 1, __LINE__);
@@ -3639,7 +3863,7 @@ void yaffs_resize_file_down(struct yaffs_obj *obj, loff_t new_size)
                int last_chunk = 1 + new_full;
                u8 *local_buffer = yaffs_get_temp_buffer(dev, __LINE__);
 
-               /* Got to read and rewrite the last chunk with its new size and zero pad */
+               /* Rewrite the last chunk with its new size and zero pad */
                yaffs_rd_data_obj(obj, last_chunk, local_buffer);
                memset(local_buffer + new_partial, 0,
                       dev->data_bytes_per_chunk - new_partial);
@@ -3715,27 +3939,6 @@ int yaffs_flush_file(struct yaffs_obj *in, int update_time, int data_sync)
 
 }
 
-static int yaffs_generic_obj_del(struct yaffs_obj *in)
-{
-
-       /* First off, invalidate the file's data in the cache, without flushing. */
-       yaffs_invalidate_whole_cache(in);
-
-       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_change_obj_name(in, in->my_dev->del_dir, _Y("deleted"), 0,
-                                     0);
-
-       }
-
-       yaffs_remove_obj_from_dir(in);
-       yaffs_chunk_del(in->my_dev, in->hdr_chunk, 1, __LINE__);
-       in->hdr_chunk = 0;
-
-       yaffs_free_obj(in);
-       return YAFFS_OK;
-
-}
 
 /* yaffs_del_file deletes the whole file data
  * and the inode associated with the file.
@@ -3755,9 +3958,9 @@ static int yaffs_unlink_file_if_needed(struct yaffs_obj *in)
                ret_val =
                    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->obj_id));
+               yaffs_trace(YAFFS_TRACE_TRACING,
+                       "yaffs: immediate deletion of file %d",
+                       in->obj_id);
                in->deleted = 1;
                in->my_dev->n_deleted_files++;
                if (dev->param.disable_soft_del || dev->param.is_yaffs2)
@@ -3826,7 +4029,7 @@ static int yaffs_del_dir(struct yaffs_obj *obj)
 static int yaffs_del_symlink(struct yaffs_obj *in)
 {
        if (in->variant.symlink_variant.alias)
-               YFREE(in->variant.symlink_variant.alias);
+               kfree(in->variant.symlink_variant.alias);
        in->variant.symlink_variant.alias = NULL;
 
        return yaffs_generic_obj_del(in);
@@ -3850,10 +4053,9 @@ int yaffs_del_obj(struct yaffs_obj *obj)
                break;
        case YAFFS_OBJECT_TYPE_DIRECTORY:
                if (!list_empty(&obj->variant.dir_variant.dirty)) {
-                       T(YAFFS_TRACE_BACKGROUND,
-                         (TSTR
-                          ("Remove object %d from dirty directories" TENDSTR),
-                          obj->obj_id));
+                       yaffs_trace(YAFFS_TRACE_BACKGROUND,
+                               "Remove object %d from dirty directories",
+                               obj->obj_id);
                        list_del_init(&obj->variant.dir_variant.dirty);
                }
                return yaffs_del_dir(obj);
@@ -3971,6 +4173,82 @@ int yaffs_unlinker(struct yaffs_obj *dir, const YCHAR * name)
        return yaffs_unlink_obj(obj);
 }
 
+/* Note:
+ * If old_name is NULL then we take old_dir as the object to be renamed.
+ */
+int yaffs_rename_obj(struct yaffs_obj *old_dir, const YCHAR * old_name,
+                    struct yaffs_obj *new_dir, const YCHAR * new_name)
+{
+       struct yaffs_obj *obj = NULL;
+       struct yaffs_obj *existing_target = NULL;
+       int force = 0;
+       int result;
+       struct yaffs_dev *dev;
+
+       if (!old_dir || old_dir->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY)
+               YBUG();
+       if (!new_dir || new_dir->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY)
+               YBUG();
+
+       dev = old_dir->my_dev;
+
+#ifdef CONFIG_YAFFS_CASE_INSENSITIVE
+       /* Special case for case insemsitive systems.
+        * 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 && 
+               old_name && new_name && 
+               strcmp(old_name, new_name) == 0)
+               force = 1;
+#endif
+
+       if (strnlen(new_name, YAFFS_MAX_NAME_LENGTH + 1) >
+           YAFFS_MAX_NAME_LENGTH)
+               /* ENAMETOOLONG */
+               return YAFFS_FAIL;
+
+       if(old_name)
+               obj = yaffs_find_by_name(old_dir, old_name);
+       else{
+               obj = old_dir;
+               old_dir = obj->parent;
+       }
+
+
+       if (obj && obj->rename_allowed) {
+
+               /* Now do the handling for an existing target, if there is one */
+
+               existing_target = yaffs_find_by_name(new_dir, new_name);
+               if (yaffs_is_non_empty_dir(existing_target)){
+                       return YAFFS_FAIL;      /* ENOTEMPTY */
+               } else if (existing_target && existing_target != 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,
+                                             existing_target->obj_id);
+                       existing_target->is_shadowed = 1;
+                       yaffs_unlink_obj(existing_target);
+                       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 YAFFS_FAIL;
+}
+
 /*----------------------- Initialisation Scanning ---------------------- */
 
 void yaffs_handle_shadowed_obj(struct yaffs_dev *dev, int obj_id,
@@ -4140,219 +4418,54 @@ static void yaffs_fix_hanging_objs(struct yaffs_dev *dev)
                                                hanging = 1;
                                }
                                if (hanging) {
-                                       T(YAFFS_TRACE_SCAN,
-                                         (TSTR
-                                          ("Hanging object %d moved to lost and found"
-                                           TENDSTR), obj->obj_id));
+                                       yaffs_trace(YAFFS_TRACE_SCAN,
+                                               "Hanging object %d moved to lost and found",
+                                               obj->obj_id);
                                        yaffs_add_obj_to_dir(dev->lost_n_found,
                                                             obj);
                                }
-                       }
-               }
-       }
-}
-
-/*
- * Delete directory contents for cleaning up lost and found.
- */
-static void yaffs_del_dir_contents(struct yaffs_obj *dir)
-{
-       struct yaffs_obj *obj;
-       struct list_head *lh;
-       struct list_head *n;
-
-       if (dir->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY)
-               YBUG();
-
-       list_for_each_safe(lh, n, &dir->variant.dir_variant.children) {
-               if (lh) {
-                       obj = list_entry(lh, struct yaffs_obj, 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->obj_id));
-
-                       /* Need to use UnlinkObject since Delete would not handle
-                        * hardlinked objects correctly.
-                        */
-                       yaffs_unlink_obj(obj);
-               }
-       }
-
-}
-
-static void yaffs_empty_l_n_f(struct yaffs_dev *dev)
-{
-       yaffs_del_dir_contents(dev->lost_n_found);
-}
-
-static void yaffs_check_obj_details_loaded(struct yaffs_obj *in)
-{
-       u8 *chunk_data;
-       struct yaffs_obj_hdr *oh;
-       struct yaffs_dev *dev;
-       struct yaffs_ext_tags tags;
-       int result;
-       int alloc_failed = 0;
-
-       if (!in)
-               return;
-
-       dev = in->my_dev;
-
-       if (in->lazy_loaded && in->hdr_chunk > 0) {
-               in->lazy_loaded = 0;
-               chunk_data = yaffs_get_temp_buffer(dev, __LINE__);
-
-               result =
-                   yaffs_rd_chunk_tags_nand(dev, in->hdr_chunk, chunk_data,
-                                            &tags);
-               oh = (struct yaffs_obj_hdr *)chunk_data;
-
-               in->yst_mode = oh->yst_mode;
-               yaffs_load_attribs(in, oh);
-               yaffs_set_obj_name_from_oh(in, oh);
-
-               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 */
-               }
-
-               yaffs_release_temp_buffer(dev, chunk_data, __LINE__);
-       }
-}
-
-/*------------------------------  Directory Functions ----------------------------- */
-
-/*
- *yaffs_update_parent() handles fixing a directories mtime and ctime when a new
- * link (ie. name) is created or deleted in the directory.
- *
- * ie.
- *   create dir/a : update dir's mtime/ctime
- *   rm dir/a:   update dir's mtime/ctime
- *   modify dir/a: don't update dir's mtimme/ctime
- *
- * 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_update_dirty_dirs must be
- * called periodically.
- */
-
-static void yaffs_update_parent(struct yaffs_obj *obj)
-{
-       struct yaffs_dev *dev;
-       if (!obj)
-               return;
-       dev = obj->my_dev;
-       obj->dirty = 1;
-       yaffs_load_current_time(obj, 0, 1);
-       if (dev->param.defered_dir_update) {
-               struct list_head *link = &obj->variant.dir_variant.dirty;
-
-               if (list_empty(link)) {
-                       list_add(link, &dev->dirty_dirs);
-                       T(YAFFS_TRACE_BACKGROUND,
-                         (TSTR("Added object %d to dirty directories" TENDSTR),
-                          obj->obj_id));
-               }
-
-       } else {
-               yaffs_update_oh(obj, NULL, 0, 0, 0, NULL);
-        }
-}
-
-void yaffs_update_dirty_dirs(struct yaffs_dev *dev)
-{
-       struct list_head *link;
-       struct yaffs_obj *obj;
-       struct yaffs_dir_var *d_s;
-       union yaffs_obj_var *o_v;
-
-       T(YAFFS_TRACE_BACKGROUND, (TSTR("Update dirty directories" TENDSTR)));
-
-       while (!list_empty(&dev->dirty_dirs)) {
-               link = dev->dirty_dirs.next;
-               list_del_init(link);
-
-               d_s = list_entry(link, struct yaffs_dir_var, dirty);
-               o_v = list_entry(d_s, union yaffs_obj_var, dir_variant);
-               obj = list_entry(o_v, struct yaffs_obj, variant);
-
-               T(YAFFS_TRACE_BACKGROUND,
-                 (TSTR("Update directory %d" TENDSTR), obj->obj_id));
-
-               if (obj->dirty)
-                       yaffs_update_oh(obj, NULL, 0, 0, 0, NULL);
+                       }
+               }
        }
 }
 
-static void yaffs_remove_obj_from_dir(struct yaffs_obj *obj)
+/*
+ * Delete directory contents for cleaning up lost and found.
+ */
+static void yaffs_del_dir_contents(struct yaffs_obj *dir)
 {
-       struct yaffs_dev *dev = obj->my_dev;
-       struct yaffs_obj *parent;
+       struct yaffs_obj *obj;
+       struct list_head *lh;
+       struct list_head *n;
 
-       yaffs_verify_obj_in_dir(obj);
-       parent = obj->parent;
+       if (dir->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY)
+               YBUG();
 
-       yaffs_verify_dir(parent);
+       list_for_each_safe(lh, n, &dir->variant.dir_variant.children) {
+               if (lh) {
+                       obj = list_entry(lh, struct yaffs_obj, siblings);
+                       if (obj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY)
+                               yaffs_del_dir_contents(obj);
 
-       if (dev && dev->param.remove_obj_fn)
-               dev->param.remove_obj_fn(obj);
+                       yaffs_trace(YAFFS_TRACE_SCAN,
+                               "Deleting lost_found object %d",
+                               obj->obj_id);
 
-       list_del_init(&obj->siblings);
-       obj->parent = NULL;
+                       /* Need to use UnlinkObject since Delete would not handle
+                        * hardlinked objects correctly.
+                        */
+                       yaffs_unlink_obj(obj);
+               }
+       }
 
-       yaffs_verify_dir(parent);
 }
 
-void yaffs_add_obj_to_dir(struct yaffs_obj *directory, struct yaffs_obj *obj)
+static void yaffs_empty_l_n_f(struct yaffs_dev *dev)
 {
-       if (!directory) {
-               T(YAFFS_TRACE_ALWAYS,
-                 (TSTR
-                  ("tragedy: Trying to add an object to a null pointer directory"
-                   TENDSTR)));
-               YBUG();
-               return;
-       }
-       if (directory->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) {
-               T(YAFFS_TRACE_ALWAYS,
-                 (TSTR
-                  ("tragedy: Trying to add an object to a non-directory"
-                   TENDSTR)));
-               YBUG();
-       }
-
-       if (obj->siblings.prev == NULL) {
-               /* Not initialised */
-               YBUG();
-       }
-
-       yaffs_verify_dir(directory);
-
-       yaffs_remove_obj_from_dir(obj);
-
-       /* Now add it */
-       list_add(&obj->siblings, &directory->variant.dir_variant.children);
-       obj->parent = directory;
-
-       if (directory == obj->my_dev->unlinked_dir
-           || directory == obj->my_dev->del_dir) {
-               obj->unlinked = 1;
-               obj->my_dev->n_unlinked_files++;
-               obj->rename_allowed = 0;
-       }
-
-       yaffs_verify_dir(directory);
-       yaffs_verify_obj_in_dir(obj);
+       yaffs_del_dir_contents(dev->lost_n_found);
 }
 
+
 struct yaffs_obj *yaffs_find_by_name(struct yaffs_obj *directory,
                                     const YCHAR * name)
 {
@@ -4367,16 +4480,16 @@ struct yaffs_obj *yaffs_find_by_name(struct yaffs_obj *directory,
                return NULL;
 
        if (!directory) {
-               T(YAFFS_TRACE_ALWAYS,
-                 (TSTR
-                  ("tragedy: yaffs_find_by_name: null pointer directory"
-                   TENDSTR)));
+               yaffs_trace(YAFFS_TRACE_ALWAYS,
+                       "tragedy: yaffs_find_by_name: null pointer directory"
+                       );
                YBUG();
                return NULL;
        }
        if (directory->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) {
-               T(YAFFS_TRACE_ALWAYS,
-                 (TSTR("tragedy: yaffs_find_by_name: non-directory" TENDSTR)));
+               yaffs_trace(YAFFS_TRACE_ALWAYS,
+                       "tragedy: yaffs_find_by_name: non-directory"
+                       );
                YBUG();
        }
 
@@ -4393,16 +4506,16 @@ struct yaffs_obj *yaffs_find_by_name(struct yaffs_obj *directory,
 
                        /* Special case for lost-n-found */
                        if (l->obj_id == YAFFS_OBJECTID_LOSTNFOUND) {
-                               if (!yaffs_strcmp(name, YAFFS_LOSTNFOUND_NAME))
+                               if (!strcmp(name, YAFFS_LOSTNFOUND_NAME))
                                        return l;
-                       } else if (yaffs_sum_cmp(l->sum, sum)
+                       } else if (l->sum == sum
                                   || l->hdr_chunk <= 0) {
                                /* LostnFound chunk called Objxxx
                                 * Do a real check
                                 */
                                yaffs_get_obj_name(l, buffer,
                                                   YAFFS_MAX_NAME_LENGTH + 1);
-                               if (yaffs_strncmp
+                               if (strncmp
                                    (name, buffer, YAFFS_MAX_NAME_LENGTH) == 0)
                                        return l;
                        }
@@ -4449,7 +4562,7 @@ static void yaffs_fix_null_name(struct yaffs_obj *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) {
+       if (strnlen(name, YAFFS_MAX_NAME_LENGTH) == 0) {
                YCHAR local_name[20];
                YCHAR num_string[20];
                YCHAR *x = &num_string[19];
@@ -4461,83 +4574,12 @@ static void yaffs_fix_null_name(struct yaffs_obj *obj, YCHAR * name,
                        v /= 10;
                }
                /* make up a name */
-               yaffs_strcpy(local_name, YAFFS_LOSTNFOUND_PREFIX);
-               yaffs_strcat(local_name, x);
-               yaffs_strncpy(name, local_name, buffer_size - 1);
+               strcpy(local_name, YAFFS_LOSTNFOUND_PREFIX);
+               strcat(local_name, x);
+               strncpy(name, local_name, buffer_size - 1);
        }
 }
 
-static void yaffs_load_name_from_oh(struct yaffs_dev *dev, YCHAR * name,
-                                   const YCHAR * oh_name, int buff_size)
-{
-#ifdef CONFIG_YAFFS_AUTO_UNICODE
-       if (dev->param.auto_unicode) {
-               if (*oh_name) {
-                       /* It is an ASCII name, so do an ASCII to unicode conversion */
-                       const char *ascii_oh_name = (const char *)oh_name;
-                       int n = buff_size - 1;
-                       while (n > 0 && *ascii_oh_name) {
-                               *name = *ascii_oh_name;
-                               name++;
-                               ascii_oh_name++;
-                               n--;
-                       }
-               } else {
-                       yaffs_strncpy(name, oh_name + 1, buff_size - 1);
-                }
-       } else {
-#else
-        {
-#endif
-               yaffs_strncpy(name, oh_name, buff_size - 1);
-        }
-}
-
-static void yaffs_load_oh_from_name(struct yaffs_dev *dev, YCHAR * oh_name,
-                                   const YCHAR * name)
-{
-#ifdef CONFIG_YAFFS_AUTO_UNICODE
-
-       int is_ascii;
-       YCHAR *w;
-
-       if (dev->param.auto_unicode) {
-
-               is_ascii = 1;
-               w = name;
-
-               /* Figure out if the name will fit in ascii character set */
-               while (is_ascii && *w) {
-                       if ((*w) & 0xff00)
-                               is_ascii = 0;
-                       w++;
-               }
-
-               if (is_ascii) {
-                       /* It is an ASCII name, so do a unicode to ascii conversion */
-                       char *ascii_oh_name = (char *)oh_name;
-                       int n = YAFFS_MAX_NAME_LENGTH - 1;
-                       while (n > 0 && *name) {
-                               *ascii_oh_name = *name;
-                               name++;
-                               ascii_oh_name++;
-                               n--;
-                       }
-               } else {
-                       /* It is a unicode name, so save starting at the second YCHAR */
-                       *oh_name = 0;
-                       yaffs_strncpy(oh_name + 1, name,
-                                     YAFFS_MAX_NAME_LENGTH - 2);
-               }
-       } else {
-#else
-        {
-#endif
-               yaffs_strncpy(oh_name, name, YAFFS_MAX_NAME_LENGTH - 1);
-        }
-
-}
-
 int yaffs_get_obj_name(struct yaffs_obj *obj, YCHAR * name, int buffer_size)
 {
        memset(name, 0, buffer_size * sizeof(YCHAR));
@@ -4545,11 +4587,11 @@ int yaffs_get_obj_name(struct yaffs_obj *obj, YCHAR * name, int buffer_size)
        yaffs_check_obj_details_loaded(obj);
 
        if (obj->obj_id == YAFFS_OBJECTID_LOSTNFOUND) {
-               yaffs_strncpy(name, YAFFS_LOSTNFOUND_NAME, buffer_size - 1);
+               strncpy(name, YAFFS_LOSTNFOUND_NAME, buffer_size - 1);
        }
 #ifndef CONFIG_YAFFS_NO_SHORT_NAMES
        else if (obj->short_name[0]) {
-               yaffs_strcpy(name, obj->short_name);
+               strcpy(name, obj->short_name);
        }
 #endif
        else if (obj->hdr_chunk > 0) {
@@ -4573,7 +4615,7 @@ int yaffs_get_obj_name(struct yaffs_obj *obj, YCHAR * name, int buffer_size)
 
        yaffs_fix_null_name(obj, name, buffer_size);
 
-       return yaffs_strnlen(name, YAFFS_MAX_NAME_LENGTH);
+       return strnlen(name, YAFFS_MAX_NAME_LENGTH);
 }
 
 int yaffs_get_obj_length(struct yaffs_obj *obj)
@@ -4586,7 +4628,7 @@ int yaffs_get_obj_length(struct yaffs_obj *obj)
        if (obj->variant_type == YAFFS_OBJECT_TYPE_SYMLINK) {
                if (!obj->variant.symlink_variant.alias)
                        return 0;
-               return yaffs_strnlen(obj->variant.symlink_variant.alias,
+               return strnlen(obj->variant.symlink_variant.alias,
                                     YAFFS_MAX_ALIAS_LENGTH);
        } else {
                /* Only a directory should drop through to here */
@@ -4656,130 +4698,7 @@ YCHAR *yaffs_get_symlink_alias(struct yaffs_obj *obj)
                return yaffs_clone_str(_Y(""));
 }
 
-static int yaffs_do_xattrib_mod(struct yaffs_obj *obj, int set,
-                               const YCHAR * name, const void *value, int size,
-                               int flags)
-{
-       struct yaffs_xattr_mod xmod;
-
-       int result;
-
-       xmod.set = set;
-       xmod.name = name;
-       xmod.data = value;
-       xmod.size = size;
-       xmod.flags = flags;
-       xmod.result = -ENOSPC;
-
-       result = yaffs_update_oh(obj, NULL, 0, 0, 0, &xmod);
-
-       if (result > 0)
-               return xmod.result;
-       else
-               return -ENOSPC;
-}
-
-static int yaffs_apply_xattrib_mod(struct yaffs_obj *obj, char *buffer,
-                                  struct yaffs_xattr_mod *xmod)
-{
-       int retval = 0;
-       int x_offs = sizeof(struct yaffs_obj_hdr);
-       struct yaffs_dev *dev = obj->my_dev;
-       int x_size = dev->data_bytes_per_chunk - sizeof(struct yaffs_obj_hdr);
-
-       char *x_buffer = buffer + x_offs;
-
-       if (xmod->set)
-               retval =
-                   nval_set(x_buffer, x_size, xmod->name, xmod->data,
-                            xmod->size, xmod->flags);
-       else
-               retval = nval_del(x_buffer, x_size, xmod->name);
-
-       obj->has_xattr = nval_hasvalues(x_buffer, x_size);
-       obj->xattr_known = 1;
-
-       xmod->result = retval;
-
-       return retval;
-}
-
-static int yaffs_do_xattrib_fetch(struct yaffs_obj *obj, const YCHAR * name,
-                                 void *value, int size)
-{
-       char *buffer = NULL;
-       int result;
-       struct yaffs_ext_tags tags;
-       struct yaffs_dev *dev = obj->my_dev;
-       int x_offs = sizeof(struct yaffs_obj_hdr);
-       int x_size = dev->data_bytes_per_chunk - sizeof(struct yaffs_obj_hdr);
-
-       char *x_buffer;
-
-       int retval = 0;
-
-       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->xattr_known && !obj->has_xattr) {
-               if (name)
-                       return -ENODATA;
-               else
-                       return 0;
-       }
-
-       buffer = (char *)yaffs_get_temp_buffer(dev, __LINE__);
-       if (!buffer)
-               return -ENOMEM;
-
-       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->xattr_known) {
-                       obj->has_xattr = nval_hasvalues(x_buffer, x_size);
-                       obj->xattr_known = 1;
-               }
-
-               if (name)
-                       retval = nval_get(x_buffer, x_size, name, value, size);
-               else
-                       retval = nval_list(x_buffer, x_size, value, size);
-       }
-       yaffs_release_temp_buffer(dev, (u8 *) buffer, __LINE__);
-       return retval;
-}
-
-int yaffs_set_xattrib(struct yaffs_obj *obj, const YCHAR * name,
-                     const void *value, int size, int flags)
-{
-       return yaffs_do_xattrib_mod(obj, 1, name, value, size, flags);
-}
-
-int yaffs_remove_xattrib(struct yaffs_obj *obj, const YCHAR * name)
-{
-       return yaffs_do_xattrib_mod(obj, 0, name, NULL, 0, 0);
-}
-
-int yaffs_get_xattrib(struct yaffs_obj *obj, const YCHAR * name, void *value,
-                     int size)
-{
-       return yaffs_do_xattrib_fetch(obj, name, value, size);
-}
-
-int yaffs_list_xattrib(struct yaffs_obj *obj, char *buffer, int size)
-{
-       return yaffs_do_xattrib_fetch(obj, NULL, buffer, size);
-}
-
-/*---------------------------- Initialisation code -------------------------------------- */
+/*--------------------------- Initialisation code -------------------------- */
 
 static int yaffs_check_dev_fns(const struct yaffs_dev *dev)
 {
@@ -4846,13 +4765,14 @@ int yaffs_guts_initialise(struct yaffs_dev *dev)
        unsigned x;
        int bits;
 
-       T(YAFFS_TRACE_TRACING,
-         (TSTR("yaffs: yaffs_guts_initialise()" TENDSTR)));
+       yaffs_trace(YAFFS_TRACE_TRACING, "yaffs: yaffs_guts_initialise()" );
 
        /* Check stuff that must be set */
 
        if (!dev) {
-               T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: Need a device" TENDSTR)));
+               yaffs_trace(YAFFS_TRACE_ALWAYS,
+                       "yaffs: Need a device"
+                       );
                return YAFFS_FAIL;
        }
 
@@ -4873,18 +4793,29 @@ int yaffs_guts_initialise(struct yaffs_dev *dev)
 
        /* Check geometry parameters. */
 
-       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, inband_tags %d "
-                   TENDSTR), dev->param.total_bytes_per_chunk,
-                  dev->param.is_yaffs2 ? "2" : "", dev->param.inband_tags));
+       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 */
+               yaffs_trace(YAFFS_TRACE_ALWAYS,
+                       "NAND geometry problems: chunk size %d, type is yaffs%s, inband_tags %d ",
+                       dev->param.total_bytes_per_chunk,
+                       dev->param.is_yaffs2 ? "2" : "",
+                       dev->param.inband_tags);
                return YAFFS_FAIL;
        }
 
        if (yaffs_init_nand(dev) != YAFFS_OK) {
-               T(YAFFS_TRACE_ALWAYS,
-                 (TSTR("yaffs: InitialiseNAND failed" TENDSTR)));
+               yaffs_trace(YAFFS_TRACE_ALWAYS, "InitialiseNAND failed");
                return YAFFS_FAIL;
        }
 
@@ -4899,16 +4830,14 @@ int yaffs_guts_initialise(struct yaffs_dev *dev)
        /* Got the right mix of functions? */
        if (!yaffs_check_dev_fns(dev)) {
                /* Function missing */
-               T(YAFFS_TRACE_ALWAYS,
-                 (TSTR
-                  ("yaffs: device function(s) missing or wrong\n" TENDSTR)));
+               yaffs_trace(YAFFS_TRACE_ALWAYS,
+                       "device function(s) missing or wrong");
 
                return YAFFS_FAIL;
        }
 
        if (dev->is_mounted) {
-               T(YAFFS_TRACE_ALWAYS,
-                 (TSTR("yaffs: device already mounted\n" TENDSTR)));
+               yaffs_trace(YAFFS_TRACE_ALWAYS, "device already mounted");
                return YAFFS_FAIL;
        }
 
@@ -4975,8 +4904,7 @@ int yaffs_guts_initialise(struct yaffs_dev *dev)
                 * the chunk group size > chunks per block.
                 * This can be remedied by using larger "virtual blocks".
                 */
-               T(YAFFS_TRACE_ALWAYS,
-                 (TSTR("yaffs: chunk group too large\n" TENDSTR)));
+               yaffs_trace(YAFFS_TRACE_ALWAYS, "chunk group too large");
 
                return YAFFS_FAIL;
        }
@@ -5022,7 +4950,7 @@ int yaffs_guts_initialise(struct yaffs_dev *dev)
                if (dev->param.n_caches > YAFFS_MAX_SHORT_OP_CACHES)
                        dev->param.n_caches = YAFFS_MAX_SHORT_OP_CACHES;
 
-               dev->cache = YMALLOC(cache_bytes);
+               dev->cache = kmalloc(cache_bytes, GFP_NOFS);
 
                buf = (u8 *) dev->cache;
 
@@ -5034,7 +4962,7 @@ int yaffs_guts_initialise(struct yaffs_dev *dev)
                        dev->cache[i].last_use = 0;
                        dev->cache[i].dirty = 0;
                        dev->cache[i].data = buf =
-                           YMALLOC_DMA(dev->param.total_bytes_per_chunk);
+                           kmalloc(dev->param.total_bytes_per_chunk, GFP_NOFS);
                }
                if (!buf)
                        init_failed = 1;
@@ -5046,7 +4974,8 @@ int yaffs_guts_initialise(struct yaffs_dev *dev)
 
        if (!init_failed) {
                dev->gc_cleanup_list =
-                   YMALLOC(dev->param.chunks_per_block * sizeof(u32));
+                   kmalloc(dev->param.chunks_per_block * sizeof(u32),
+                                       GFP_NOFS);
                if (!dev->gc_cleanup_list)
                        init_failed = 1;
        }
@@ -5067,10 +4996,9 @@ int yaffs_guts_initialise(struct yaffs_dev *dev)
                if (dev->param.is_yaffs2) {
                        if (yaffs2_checkpt_restore(dev)) {
                                yaffs_check_obj_details_loaded(dev->root_dir);
-                               T(YAFFS_TRACE_CHECKPOINT | YAFFS_TRACE_MOUNT,
-                                 (TSTR
-                                  ("yaffs: restored from checkpoint"
-                                   TENDSTR)));
+                               yaffs_trace(YAFFS_TRACE_CHECKPOINT | YAFFS_TRACE_MOUNT,
+                                       "yaffs: restored from checkpoint"
+                                       );
                        } else {
 
                                /* Clean up the mess caused by an aborted checkpoint load
@@ -5112,8 +5040,8 @@ int yaffs_guts_initialise(struct yaffs_dev *dev)
 
        if (init_failed) {
                /* Clean up the mess */
-               T(YAFFS_TRACE_TRACING,
-                 (TSTR("yaffs: yaffs_guts_initialise() aborted.\n" TENDSTR)));
+               yaffs_trace(YAFFS_TRACE_TRACING,
+                 "yaffs: yaffs_guts_initialise() aborted.");
 
                yaffs_deinitialise(dev);
                return YAFFS_FAIL;
@@ -5135,8 +5063,8 @@ int yaffs_guts_initialise(struct yaffs_dev *dev)
        if (!dev->is_checkpointed && dev->blocks_in_checkpt > 0)
                yaffs2_checkpt_invalidate(dev);
 
-       T(YAFFS_TRACE_TRACING,
-         (TSTR("yaffs: yaffs_guts_initialise() done.\n" TENDSTR)));
+       yaffs_trace(YAFFS_TRACE_TRACING,
+         "yaffs: yaffs_guts_initialise() done.");
        return YAFFS_OK;
 
 }
@@ -5152,18 +5080,18 @@ void yaffs_deinitialise(struct yaffs_dev *dev)
 
                        for (i = 0; i < dev->param.n_caches; i++) {
                                if (dev->cache[i].data)
-                                       YFREE(dev->cache[i].data);
+                                       kfree(dev->cache[i].data);
                                dev->cache[i].data = NULL;
                        }
 
-                       YFREE(dev->cache);
+                       kfree(dev->cache);
                        dev->cache = NULL;
                }
 
-               YFREE(dev->gc_cleanup_list);
+               kfree(dev->gc_cleanup_list);
 
                for (i = 0; i < YAFFS_N_TEMP_BUFFERS; i++)
-                       YFREE(dev->temp_buffer[i].buffer);
+                       kfree(dev->temp_buffer[i].buffer);
 
                dev->is_mounted = 0;
 
index c3ea8c9..603dc97 100644 (file)
@@ -137,9 +137,9 @@ int nandmtd1_write_chunk_tags(struct yaffs_dev *dev,
 
        retval = mtd->write_oob(mtd, addr, &ops);
        if (retval) {
-               T(YAFFS_TRACE_MTD,
-                 (TSTR("write_oob failed, chunk %d, mtd error %d" TENDSTR),
-                  nand_chunk, retval));
+               yaffs_trace(YAFFS_TRACE_MTD,
+                       "write_oob failed, chunk %d, mtd error %d",
+                       nand_chunk, retval);
        }
        return retval ? YAFFS_FAIL : YAFFS_OK;
 }
@@ -198,11 +198,10 @@ int nandmtd1_read_chunk_tags(struct yaffs_dev *dev,
         * Check status and determine ECC result.
         */
        retval = mtd->read_oob(mtd, addr, &ops);
-       if (retval) {
-               T(YAFFS_TRACE_MTD,
-                 (TSTR("read_oob failed, chunk %d, mtd error %d" TENDSTR),
-                  nand_chunk, retval));
-       }
+       if (retval)
+               yaffs_trace(YAFFS_TRACE_MTD,
+                       "read_oob failed, chunk %d, mtd error %d",
+                       nand_chunk, retval);
 
        switch (retval) {
        case 0:
@@ -286,8 +285,7 @@ int nandmtd1_mark_block_bad(struct yaffs_dev *dev, int block_no)
        int blocksize = dev->param.chunks_per_block * dev->data_bytes_per_chunk;
        int retval;
 
-       T(YAFFS_TRACE_BAD_BLOCKS,
-         (TSTR("marking block %d bad" TENDSTR), block_no));
+       yaffs_trace(YAFFS_TRACE_BAD_BLOCKS, "marking block %d bad", block_no);
 
        retval = mtd->block_markbad(mtd, (loff_t) blocksize * block_no);
        return (retval) ? YAFFS_FAIL : YAFFS_OK;
@@ -304,10 +302,9 @@ static int nandmtd1_test_prerequists(struct mtd_info *mtd)
        int oobavail = mtd->ecclayout->oobavail;
 
        if (oobavail < YTAG1_SIZE) {
-               T(YAFFS_TRACE_ERROR,
-                 (TSTR
-                  ("mtd device has only %d bytes for tags, need %d" TENDSTR),
-                  oobavail, YTAG1_SIZE));
+               yaffs_trace(YAFFS_TRACE_ERROR,
+                       "mtd device has only %d bytes for tags, need %d",
+                       oobavail, YTAG1_SIZE);
                return YAFFS_FAIL;
        }
        return YAFFS_OK;
@@ -342,8 +339,9 @@ int nandmtd1_query_block(struct yaffs_dev *dev, int block_no,
        retval = nandmtd1_read_chunk_tags(dev, chunk_num, NULL, &etags);
        etags.block_bad = (mtd->block_isbad) (mtd, addr);
        if (etags.block_bad) {
-               T(YAFFS_TRACE_BAD_BLOCKS,
-                 (TSTR("block %d is marked bad" TENDSTR), block_no));
+               yaffs_trace(YAFFS_TRACE_BAD_BLOCKS,
+                       "block %d is marked bad",
+                       block_no);
                state = YAFFS_BLOCK_STATE_DEAD;
        } else if (etags.ecc_result != YAFFS_ECC_RESULT_NO_ERROR) {
                /* bad tags, need to look more closely */
index a0bc04f..5108369 100644 (file)
@@ -111,9 +111,9 @@ int nandmtd1_write_chunk_tags(struct yaffs_dev *dev,
 
        retval = mtd->write_oob(mtd, addr, &ops);
        if (retval) {
-               T(YAFFS_TRACE_MTD,
-                 (TSTR("write_oob failed, chunk %d, mtd error %d" TENDSTR),
-                  nand_chunk, retval));
+               yaffs_trace(YAFFS_TRACE_MTD,
+                       "write_oob failed, chunk %d, mtd error %d",
+                       nand_chunk, retval);
        }
        return retval ? YAFFS_FAIL : YAFFS_OK;
 }
@@ -167,9 +167,9 @@ int nandmtd1_read_chunk_tags(struct yaffs_dev *dev,
         */
        retval = mtd->read_oob(mtd, addr, &ops);
        if (retval) {
-               T(YAFFS_TRACE_MTD,
-                 (TSTR("read_oob failed, chunk %d, mtd error %d" TENDSTR),
-                  nand_chunk, retval));
+               yaffs_trace(YAFFS_TRACE_MTD,
+                       "read_oob failed, chunk %d, mtd error %d",
+                       nand_chunk, retval);
        }
 
        switch (retval) {
@@ -254,8 +254,8 @@ int nandmtd1_mark_block_bad(struct yaffs_dev *dev, int block_no)
        int blocksize = dev->param.chunks_per_block * dev->data_bytes_per_chunk;
        int retval;
 
-       T(YAFFS_TRACE_BAD_BLOCKS,
-         (TSTR("marking block %d bad" TENDSTR), block_no));
+       yaffs_trace(YAFFS_TRACE_BAD_BLOCKS,
+               "marking block %d bad", block_no);
 
        retval = mtd->block_markbad(mtd, (loff_t) blocksize * block_no);
        return (retval) ? YAFFS_FAIL : YAFFS_OK;
@@ -272,10 +272,9 @@ static int nandmtd1_test_prerequists(struct mtd_info *mtd)
        int oobavail = mtd->ecclayout->oobavail;
 
        if (oobavail < YTAG1_SIZE) {
-               T(YAFFS_TRACE_ERROR,
-                 (TSTR
-                  ("mtd device has only %d bytes for tags, need %d" TENDSTR),
-                  oobavail, YTAG1_SIZE));
+               yaffs_trace(YAFFS_TRACE_ERROR,
+                       "mtd device has only %d bytes for tags, need %d",
+                       oobavail, YTAG1_SIZE);
                return YAFFS_FAIL;
        }
        return YAFFS_OK;
@@ -310,8 +309,8 @@ int nandmtd1_query_block(struct yaffs_dev *dev, int block_no,
        retval = nandmtd1_read_chunk_tags(dev, chunk_num, NULL, &etags);
        etags.block_bad = (mtd->block_isbad) (mtd, addr);
        if (etags.block_bad) {
-               T(YAFFS_TRACE_BAD_BLOCKS,
-                 (TSTR("block %d is marked bad" TENDSTR), block_no));
+               yaffs_trace(YAFFS_TRACE_BAD_BLOCKS,
+                       "block %d is marked bad", block_no);
                state = YAFFS_BLOCK_STATE_DEAD;
        } else if (etags.ecc_result != YAFFS_ECC_RESULT_NO_ERROR) {
                /* bad tags, need to look more closely */
index 26609f7..9dcccb8 100644 (file)
@@ -51,10 +51,9 @@ int nandmtd2_write_chunk_tags(struct yaffs_dev *dev, int nand_chunk,
        void *packed_tags_ptr =
            dev->param.no_tags_ecc ? (void *)&pt.t : (void *)&pt;
 
-       T(YAFFS_TRACE_MTD,
-         (TSTR
-          ("nandmtd2_write_chunk_tags chunk %d data %p tags %p"
-           TENDSTR), nand_chunk, data, tags));
+       yaffs_trace(YAFFS_TRACE_MTD,
+               "nandmtd2_write_chunk_tags chunk %d data %p tags %p",
+               nand_chunk, data, tags);
 
        addr = ((loff_t) nand_chunk) * dev->param.total_bytes_per_chunk;
 
@@ -122,10 +121,9 @@ int nandmtd2_read_chunk_tags(struct yaffs_dev *dev, int nand_chunk,
        void *packed_tags_ptr =
            dev->param.no_tags_ecc ? (void *)&pt.t : (void *)&pt;
 
-       T(YAFFS_TRACE_MTD,
-         (TSTR
-          ("nandmtd2_read_chunk_tags chunk %d data %p tags %p"
-           TENDSTR), nand_chunk, data, tags));
+       yaffs_trace(YAFFS_TRACE_MTD,
+               "nandmtd2_read_chunk_tags chunk %d data %p tags %p",
+               nand_chunk, data, tags);
 
        if (dev->param.inband_tags) {
 
@@ -170,8 +168,8 @@ int nandmtd2_read_chunk_tags(struct yaffs_dev *dev, int nand_chunk,
                if (tags) {
                        struct yaffs_packed_tags2_tags_only *pt2tp;
                        pt2tp =
-                           (struct yaffs_packed_tags2_tags_only *)&data[dev->
-                                                                        data_bytes_per_chunk];
+                               (struct yaffs_packed_tags2_tags_only *)
+                               &data[dev->data_bytes_per_chunk];
                        yaffs_unpack_tags2_tags_only(tags, pt2tp);
                }
        } else {
@@ -206,8 +204,9 @@ int nandmtd2_mark_block_bad(struct yaffs_dev *dev, int block_no)
 {
        struct mtd_info *mtd = yaffs_dev_to_mtd(dev);
        int retval;
-       T(YAFFS_TRACE_MTD,
-         (TSTR("nandmtd2_mark_block_bad %d" TENDSTR), block_no));
+       yaffs_trace(YAFFS_TRACE_MTD,
+               "nandmtd2_mark_block_bad %d",
+               block_no);
 
        retval =
            mtd->block_markbad(mtd,
@@ -227,14 +226,14 @@ int nandmtd2_query_block(struct yaffs_dev *dev, int block_no,
        struct mtd_info *mtd = yaffs_dev_to_mtd(dev);
        int retval;
 
-       T(YAFFS_TRACE_MTD, (TSTR("nandmtd2_query_block %d" TENDSTR), block_no));
+       yaffs_trace(YAFFS_TRACE_MTD, "nandmtd2_query_block %d", block_no);
        retval =
            mtd->block_isbad(mtd,
                             block_no * dev->param.chunks_per_block *
                             dev->param.total_bytes_per_chunk);
 
        if (retval) {
-               T(YAFFS_TRACE_MTD, (TSTR("block is bad" TENDSTR)));
+               yaffs_trace(YAFFS_TRACE_MTD, "block is bad");
 
                *state = YAFFS_BLOCK_STATE_DEAD;
                *seq_number = 0;
@@ -251,11 +250,13 @@ int nandmtd2_query_block(struct yaffs_dev *dev, int block_no,
                        *state = YAFFS_BLOCK_STATE_EMPTY;
                }
        }
-       T(YAFFS_TRACE_MTD,
-         (TSTR("block is bad seq %d state %d" TENDSTR), *seq_number, *state));
+       yaffs_trace(YAFFS_TRACE_MTD,
+               "block is bad seq %d state %d",
+               *seq_number, *state);
 
        if (retval == 0)
                return YAFFS_OK;
        else
                return YAFFS_FAIL;
 }
+
index 0835078..d1643df 100644 (file)
@@ -47,10 +47,9 @@ int nandmtd2_write_chunk_tags(struct yaffs_dev *dev, int nand_chunk,
        void *packed_tags_ptr =
            dev->param.no_tags_ecc ? (void *)&pt.t : (void *)&pt;
 
-       T(YAFFS_TRACE_MTD,
-         (TSTR
-          ("nandmtd2_write_chunk_tags chunk %d data %p tags %p"
-           TENDSTR), nand_chunk, data, tags));
+       yaffs_trace(YAFFS_TRACE_MTD,
+               "nandmtd2_write_chunk_tags chunk %d data %p tags %p",
+               nand_chunk, data, tags);
 
        addr = ((loff_t) nand_chunk) * dev->param.total_bytes_per_chunk;
 
@@ -104,10 +103,9 @@ int nandmtd2_read_chunk_tags(struct yaffs_dev *dev, int nand_chunk,
        void *packed_tags_ptr =
            dev->param.no_tags_ecc ? (void *)&pt.t : (void *)&pt;
 
-       T(YAFFS_TRACE_MTD,
-         (TSTR
-          ("nandmtd2_read_chunk_tags chunk %d data %p tags %p"
-           TENDSTR), nand_chunk, data, tags));
+       yaffs_trace(YAFFS_TRACE_MTD,
+               "nandmtd2_read_chunk_tags chunk %d data %p tags %p",
+               nand_chunk, data, tags);
 
        if (dev->param.inband_tags) {
 
@@ -171,8 +169,8 @@ int nandmtd2_mark_block_bad(struct yaffs_dev *dev, int block_no)
 {
        struct mtd_info *mtd = yaffs_dev_to_mtd(dev);
        int retval;
-       T(YAFFS_TRACE_MTD,
-         (TSTR("nandmtd2_mark_block_bad %d" TENDSTR), block_no));
+       yaffs_trace(YAFFS_TRACE_MTD,
+               "nandmtd2_mark_block_bad %d", block_no);
 
        retval =
            mtd->block_markbad(mtd,
@@ -192,14 +190,14 @@ int nandmtd2_query_block(struct yaffs_dev *dev, int block_no,
        struct mtd_info *mtd = yaffs_dev_to_mtd(dev);
        int retval;
 
-       T(YAFFS_TRACE_MTD, (TSTR("nandmtd2_query_block %d" TENDSTR), block_no));
+       yaffs_trace(YAFFS_TRACE_MTD, "nandmtd2_query_block %d", block_no);
        retval =
            mtd->block_isbad(mtd,
                             block_no * dev->param.chunks_per_block *
                             dev->param.total_bytes_per_chunk);
 
        if (retval) {
-               T(YAFFS_TRACE_MTD, (TSTR("block is bad" TENDSTR)));
+               yaffs_trace(YAFFS_TRACE_MTD, "block is bad");
 
                *state = YAFFS_BLOCK_STATE_DEAD;
                *seq_number = 0;
@@ -216,11 +214,12 @@ int nandmtd2_query_block(struct yaffs_dev *dev, int block_no,
                        *state = YAFFS_BLOCK_STATE_EMPTY;
                }
        }
-       T(YAFFS_TRACE_MTD,
-         (TSTR("block is bad seq %d state %d" TENDSTR), *seq_number, *state));
+       yaffs_trace(YAFFS_TRACE_MTD,
+               "block is bad seq %d state %d", *seq_number, *state);
 
        if (retval == 0)
                return YAFFS_OK;
        else
                return YAFFS_FAIL;
 }
+
index d8c548a..daa36f9 100644 (file)
@@ -37,7 +37,7 @@ static int nval_find(const char *xb, int xb_size, const YCHAR * name,
 
        memcpy(&size, xb, sizeof(int));
        while (size > 0 && (size < xb_size) && (pos + size < xb_size)) {
-               if (yaffs_strncmp
+               if (strncmp
                    ((YCHAR *) (xb + pos + sizeof(int)), name, size) == 0) {
                        if (exist_size)
                                *exist_size = size;
@@ -90,7 +90,7 @@ int nval_set(char *xb, int xb_size, const YCHAR * name, const char *buf,
             int bsize, int flags)
 {
        int pos;
-       int namelen = yaffs_strnlen(name, xb_size);
+       int namelen = strnlen(name, xb_size);
        int reclen;
        int size_exist = 0;
        int space;
@@ -120,7 +120,7 @@ int nval_set(char *xb, int xb_size, const YCHAR * name, const char *buf,
 
        memcpy(xb + pos, &reclen, sizeof(int));
        pos += sizeof(int);
-       yaffs_strncpy((YCHAR *) (xb + pos), name, reclen);
+       strncpy((YCHAR *) (xb + pos), name, reclen);
        pos += (namelen + 1);
        memcpy(xb + pos, buf, bsize);
        return 0;
@@ -172,7 +172,7 @@ int nval_list(const char *xb, int xb_size, char *buf, int bsize)
               && !filled) {
                pos += sizeof(int);
                size -= sizeof(int);
-               name_len = yaffs_strnlen((YCHAR *) (xb + pos), size);
+               name_len = strnlen((YCHAR *) (xb + pos), size);
                if (ncopied + name_len + 1 < bsize) {
                        memcpy(buf, xb + pos, name_len * sizeof(YCHAR));
                        buf += name_len;
index 84ab0f0..e816cab 100644 (file)
@@ -63,15 +63,14 @@ int yaffs_wr_chunk_tags_nand(struct yaffs_dev *dev,
                tags->seq_number = dev->seq_number;
                tags->chunk_used = 1;
                if (!yaffs_validate_tags(tags)) {
-                       T(YAFFS_TRACE_ERROR,
-                         (TSTR("Writing uninitialised tags" TENDSTR)));
+                       yaffs_trace(YAFFS_TRACE_ERROR, "Writing uninitialised tags");
                        YBUG();
                }
-               T(YAFFS_TRACE_WRITE,
-                 (TSTR("Writing chunk %d tags %d %d" TENDSTR), nand_chunk,
-                  tags->obj_id, tags->chunk_id));
+               yaffs_trace(YAFFS_TRACE_WRITE,
+                       "Writing chunk %d tags %d %d",
+                       nand_chunk, tags->obj_id, tags->chunk_id);
        } else {
-               T(YAFFS_TRACE_ERROR, (TSTR("Writing with no tags" TENDSTR)));
+               yaffs_trace(YAFFS_TRACE_ERROR, "Writing with no tags");
                YBUG();
        }
 
index 6c12aed..8e7fea3 100644 (file)
@@ -41,9 +41,9 @@
 static void yaffs_dump_packed_tags2_tags_only(const struct
                                              yaffs_packed_tags2_tags_only *ptt)
 {
-       T(YAFFS_TRACE_MTD,
-         (TSTR("packed tags obj %d chunk %d byte %d seq %d" TENDSTR),
-          ptt->obj_id, ptt->chunk_id, ptt->n_bytes, ptt->seq_number));
+       yaffs_trace(YAFFS_TRACE_MTD,
+               "packed tags obj %d chunk %d byte %d seq %d",
+               ptt->obj_id, ptt->chunk_id, ptt->n_bytes, ptt->seq_number);
 }
 
 static void yaffs_dump_packed_tags2(const struct yaffs_packed_tags2 *pt)
@@ -53,12 +53,11 @@ static void yaffs_dump_packed_tags2(const struct yaffs_packed_tags2 *pt)
 
 static void yaffs_dump_tags2(const struct 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->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));
+       yaffs_trace(YAFFS_TRACE_MTD,
+               "ext.tags eccres %d blkbad %d chused %d obj %d chunk%d byte %d del %d ser %d seq %d",
+               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);
 
 }
 
index a35e0f3..7578075 100644 (file)
@@ -132,9 +132,9 @@ static int yaffs_wr_nand(struct yaffs_dev *dev,
                         struct yaffs_spare *spare)
 {
        if (nand_chunk < dev->param.start_block * dev->param.chunks_per_block) {
-               T(YAFFS_TRACE_ERROR,
-                 (TSTR("**>> yaffs chunk %d is not valid" TENDSTR),
-                  nand_chunk));
+               yaffs_trace(YAFFS_TRACE_ERROR,
+                       "**>> yaffs chunk %d is not valid",
+                       nand_chunk);
                return YAFFS_FAIL;
        }
 
@@ -175,30 +175,26 @@ static int yaffs_rd_chunk_nand(struct yaffs_dev *dev,
                                              calc_ecc);
 
                        if (ecc_result1 > 0) {
-                               T(YAFFS_TRACE_ERROR,
-                                 (TSTR
-                                  ("**>>yaffs ecc error fix performed on chunk %d:0"
-                                   TENDSTR), nand_chunk));
+                               yaffs_trace(YAFFS_TRACE_ERROR,
+                                       "**>>yaffs ecc error fix performed on chunk %d:0",
+                                       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), nand_chunk));
+                               yaffs_trace(YAFFS_TRACE_ERROR,
+                                       "**>>yaffs ecc error unfixed on chunk %d:0",
+                                       nand_chunk);
                                dev->n_ecc_unfixed++;
                        }
 
                        if (ecc_result2 > 0) {
-                               T(YAFFS_TRACE_ERROR,
-                                 (TSTR
-                                  ("**>>yaffs ecc error fix performed on chunk %d:1"
-                                   TENDSTR), nand_chunk));
+                               yaffs_trace(YAFFS_TRACE_ERROR,
+                                       "**>>yaffs ecc error fix performed on chunk %d:1",
+                                       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), nand_chunk));
+                               yaffs_trace(YAFFS_TRACE_ERROR,
+                                       "**>>yaffs ecc error unfixed on chunk %d:1",
+                                       nand_chunk);
                                dev->n_ecc_unfixed++;
                        }
 
@@ -227,27 +223,23 @@ static int yaffs_rd_chunk_nand(struct yaffs_dev *dev,
                memcpy(spare, &nspare, sizeof(struct yaffs_spare));
                if (data && correct_errors) {
                        if (nspare.eccres1 > 0) {
-                               T(YAFFS_TRACE_ERROR,
-                                 (TSTR
-                                  ("**>>mtd ecc error fix performed on chunk %d:0"
-                                   TENDSTR), nand_chunk));
+                               yaffs_trace(YAFFS_TRACE_ERROR,
+                                       "**>>mtd ecc error fix performed on chunk %d:0",
+                                       nand_chunk);
                        } else if (nspare.eccres1 < 0) {
-                               T(YAFFS_TRACE_ERROR,
-                                 (TSTR
-                                  ("**>>mtd ecc error unfixed on chunk %d:0"
-                                   TENDSTR), nand_chunk));
+                               yaffs_trace(YAFFS_TRACE_ERROR,
+                                       "**>>mtd ecc error unfixed on chunk %d:0",
+                                       nand_chunk);
                        }
 
                        if (nspare.eccres2 > 0) {
-                               T(YAFFS_TRACE_ERROR,
-                                 (TSTR
-                                  ("**>>mtd ecc error fix performed on chunk %d:1"
-                                   TENDSTR), nand_chunk));
+                               yaffs_trace(YAFFS_TRACE_ERROR,
+                                       "**>>mtd ecc error fix performed on chunk %d:1",
+                                       nand_chunk);
                        } else if (nspare.eccres2 < 0) {
-                               T(YAFFS_TRACE_ERROR,
-                                 (TSTR
-                                  ("**>>mtd ecc error unfixed on chunk %d:1"
-                                   TENDSTR), nand_chunk));
+                               yaffs_trace(YAFFS_TRACE_ERROR,
+                                       "**>>mtd ecc error unfixed on chunk %d:1",
+                                       nand_chunk);
                        }
 
                        if (nspare.eccres1 || nspare.eccres2) {
@@ -279,8 +271,9 @@ static void yaffs_handle_rd_data_error(struct yaffs_dev *dev, int nand_chunk)
        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), flash_block));
+       yaffs_trace(YAFFS_TRACE_ERROR | YAFFS_TRACE_BAD_BLOCKS,
+               "**>>Block %d marked for retirement",
+               flash_block);
 
        /* TODO:
         * Just do a garbage collection on the affected block
index 8f632ff..6273dbf 100644 (file)
@@ -54,6 +54,4 @@ extern unsigned int yaffs_wr_attempts;
 #define YAFFS_TRACE_BUG                        0x80000000
 #define YAFFS_TRACE_ALWAYS             0xF0000000
 
-#define T(mask, p) do { if ((mask) & (yaffs_trace_mask | YAFFS_TRACE_ALWAYS)) TOUT(p); } while (0)
-
 #endif
index fee3a1e..738c7f6 100644 (file)
@@ -59,17 +59,17 @@ void yaffs_verify_blk(struct yaffs_dev *dev, struct yaffs_block_info *bi, int n)
 
        /* Report illegal runtime states */
        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));
+               yaffs_trace(YAFFS_TRACE_VERIFY,
+                       "Block %d has undefined state %d",
+                       n, bi->block_state);
 
        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,
-                  block_state_name[bi->block_state]));
+               yaffs_trace(YAFFS_TRACE_VERIFY,
+                       "Block %d has bad run-state %s",
+                       n, block_state_name[bi->block_state]);
        }
 
        /* Check pages in use and soft deletions are legal */
@@ -81,18 +81,16 @@ void yaffs_verify_blk(struct yaffs_dev *dev, struct yaffs_block_info *bi, int n)
            || bi->soft_del_pages < 0
            || bi->soft_del_pages > dev->param.chunks_per_block
            || actually_used < 0 || actually_used > 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));
+               yaffs_trace(YAFFS_TRACE_VERIFY,
+                       "Block %d has illegal values pages_in_used %d soft_del_pages %d",
+                       n, bi->pages_in_use, bi->soft_del_pages);
 
        /* Check chunk bitmap legal */
        in_use = yaffs_count_chunk_bits(dev, n);
        if (in_use != 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, in_use));
+               yaffs_trace(YAFFS_TRACE_VERIFY,
+                       "Block %d has inconsistent values pages_in_use %d counted chunk bits %d",
+                       n, bi->pages_in_use, in_use);
 
 }
 
@@ -105,10 +103,9 @@ void yaffs_verify_collected_blk(struct yaffs_dev *dev,
 
        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->block_state));
+               yaffs_trace(YAFFS_TRACE_ERROR,
+                       "Block %d is in state %d after gc, should be erased",
+                       n, bi->block_state);
        }
 }
 
@@ -133,38 +130,36 @@ void yaffs_verify_blocks(struct yaffs_dev *dev)
                        illegal_states++;
        }
 
-       T(YAFFS_TRACE_VERIFY, (TSTR("" TENDSTR)));
-       T(YAFFS_TRACE_VERIFY, (TSTR("Block summary" TENDSTR)));
+       yaffs_trace(YAFFS_TRACE_VERIFY, "Block summary");
 
-       T(YAFFS_TRACE_VERIFY,
-         (TSTR("%d blocks have illegal states" TENDSTR), illegal_states));
+       yaffs_trace(YAFFS_TRACE_VERIFY,
+               "%d blocks have illegal states",
+               illegal_states);
        if (state_count[YAFFS_BLOCK_STATE_ALLOCATING] > 1)
-               T(YAFFS_TRACE_VERIFY,
-                 (TSTR("Too many allocating blocks" TENDSTR)));
+               yaffs_trace(YAFFS_TRACE_VERIFY,
+                       "Too many allocating blocks");
 
        for (i = 0; i < YAFFS_NUMBER_OF_BLOCK_STATES; i++)
-               T(YAFFS_TRACE_VERIFY,
-                 (TSTR("%s %d blocks" TENDSTR),
-                  block_state_name[i], state_count[i]));
+               yaffs_trace(YAFFS_TRACE_VERIFY,
+                       "%s %d blocks",
+                       block_state_name[i], state_count[i]);
 
        if (dev->blocks_in_checkpt != state_count[YAFFS_BLOCK_STATE_CHECKPOINT])
-               T(YAFFS_TRACE_VERIFY,
-                 (TSTR("Checkpoint block count wrong dev %d count %d" TENDSTR),
-                  dev->blocks_in_checkpt,
-                  state_count[YAFFS_BLOCK_STATE_CHECKPOINT]));
+               yaffs_trace(YAFFS_TRACE_VERIFY,
+                       "Checkpoint block count wrong dev %d count %d",
+                       dev->blocks_in_checkpt,
+                       state_count[YAFFS_BLOCK_STATE_CHECKPOINT]);
 
        if (dev->n_erased_blocks != state_count[YAFFS_BLOCK_STATE_EMPTY])
-               T(YAFFS_TRACE_VERIFY,
-                 (TSTR("Erased block count wrong dev %d count %d" TENDSTR),
-                  dev->n_erased_blocks, state_count[YAFFS_BLOCK_STATE_EMPTY]));
+               yaffs_trace(YAFFS_TRACE_VERIFY,
+                       "Erased block count wrong dev %d count %d",
+                       dev->n_erased_blocks,
+                       state_count[YAFFS_BLOCK_STATE_EMPTY]);
 
        if (state_count[YAFFS_BLOCK_STATE_COLLECTING] > 1)
-               T(YAFFS_TRACE_VERIFY,
-                 (TSTR("Too many collecting blocks %d (max is 1)" TENDSTR),
-                  state_count[YAFFS_BLOCK_STATE_COLLECTING]));
-
-       T(YAFFS_TRACE_VERIFY, (TSTR("" TENDSTR)));
-
+               yaffs_trace(YAFFS_TRACE_VERIFY,
+                       "Too many collecting blocks %d (max is 1)",
+                       state_count[YAFFS_BLOCK_STATE_COLLECTING]);
 }
 
 /*
@@ -178,22 +173,22 @@ void yaffs_verify_oh(struct yaffs_obj *obj, struct yaffs_obj_hdr *oh,
                return;
 
        if (!(tags && obj && oh)) {
-               T(YAFFS_TRACE_VERIFY,
-                 (TSTR("Verifying object header tags %p obj %p oh %p" TENDSTR),
-                  tags, obj, oh));
+               yaffs_trace(YAFFS_TRACE_VERIFY,
+                       "Verifying object header tags %p obj %p oh %p",
+                       tags, obj, oh);
                return;
        }
 
        if (oh->type <= YAFFS_OBJECT_TYPE_UNKNOWN ||
            oh->type > YAFFS_OBJECT_TYPE_MAX)
-               T(YAFFS_TRACE_VERIFY,
-                 (TSTR("Obj %d header type is illegal value 0x%x" TENDSTR),
-                  tags->obj_id, oh->type));
+               yaffs_trace(YAFFS_TRACE_VERIFY,
+                       "Obj %d header type is illegal value 0x%x",
+                       tags->obj_id, oh->type);
 
        if (tags->obj_id != obj->obj_id)
-               T(YAFFS_TRACE_VERIFY,
-                 (TSTR("Obj %d header mismatch obj_id %d" TENDSTR),
-                  tags->obj_id, obj->obj_id));
+               yaffs_trace(YAFFS_TRACE_VERIFY,
+                       "Obj %d header mismatch obj_id %d",
+                       tags->obj_id, obj->obj_id);
 
        /*
         * Check that the object's parent ids match if parent_check requested.
@@ -202,28 +197,28 @@ void yaffs_verify_oh(struct yaffs_obj *obj, struct yaffs_obj_hdr *oh,
         */
 
        if (parent_check && tags->obj_id > 1 && !obj->parent)
-               T(YAFFS_TRACE_VERIFY,
-                 (TSTR
-                  ("Obj %d header mismatch parent_id %d obj->parent is NULL"
-                   TENDSTR), tags->obj_id, oh->parent_obj_id));
+               yaffs_trace(YAFFS_TRACE_VERIFY,
+                       "Obj %d header mismatch parent_id %d obj->parent is NULL",
+                       tags->obj_id, oh->parent_obj_id);
 
        if (parent_check && obj->parent &&
            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 parent_id %d parent_obj_id %d"
-                   TENDSTR), tags->obj_id, oh->parent_obj_id,
-                  obj->parent->obj_id));
+               yaffs_trace(YAFFS_TRACE_VERIFY,
+                       "Obj %d header mismatch parent_id %d parent_obj_id %d",
+                       tags->obj_id, oh->parent_obj_id,
+                       obj->parent->obj_id);
 
        if (tags->obj_id > 1 && oh->name[0] == 0)       /* Null name */
-               T(YAFFS_TRACE_VERIFY,
-                 (TSTR("Obj %d header name is NULL" TENDSTR), obj->obj_id));
+               yaffs_trace(YAFFS_TRACE_VERIFY,
+                       "Obj %d header name is NULL",
+                       obj->obj_id);
 
        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->obj_id));
+               yaffs_trace(YAFFS_TRACE_VERIFY,
+                       "Obj %d header name is 0xFF",
+                       obj->obj_id);
 }
 
 void yaffs_verify_file(struct yaffs_obj *obj)
@@ -273,16 +268,13 @@ void yaffs_verify_file(struct yaffs_obj *obj)
                if (tn) {
                        u32 the_chunk = yaffs_get_group_base(dev, tn, i);
                        if (the_chunk > 0) {
-                               /* T(~0,(TSTR("verifying (%d:%d) %d"TENDSTR),obj_id,i,the_chunk)); */
                                yaffs_rd_chunk_tags_nand(dev, the_chunk, 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, the_chunk,
-                                          tags.obj_id, tags.chunk_id));
-                               }
+                               if (tags.obj_id != obj_id || tags.chunk_id != i)
+                               yaffs_trace(YAFFS_TRACE_VERIFY,
+                                       "Object %d chunk_id %d NAND mismatch chunk %d tags (%d:%d)",
+                                        obj_id, i, the_chunk,
+                                        tags.obj_id, tags.chunk_id);
                        }
                }
        }
@@ -348,13 +340,12 @@ void yaffs_verify_obj(struct yaffs_obj *obj)
                                  obj->hdr_chunk % dev->param.chunks_per_block);
        chunk_wrongly_deleted = chunk_in_range && !chunk_valid;
 
-       if (!obj->fake && (!chunk_id_ok || chunk_wrongly_deleted)) {
-               T(YAFFS_TRACE_VERIFY,
-                 (TSTR("Obj %d has chunk_id %d %s %s" TENDSTR),
-                  obj->obj_id, obj->hdr_chunk,
-                  chunk_id_ok ? "" : ",out of range",
-                  chunk_wrongly_deleted ? ",marked as deleted" : ""));
-       }
+       if (!obj->fake && (!chunk_id_ok || chunk_wrongly_deleted))
+               yaffs_trace(YAFFS_TRACE_VERIFY,
+                       "Obj %d has chunk_id %d %s %s",
+                       obj->obj_id, obj->hdr_chunk,
+                       chunk_id_ok ? "" : ",out of range",
+                       chunk_wrongly_deleted ? ",marked as deleted" : "");
 
        if (chunk_valid && !yaffs_skip_nand_verification(dev)) {
                struct yaffs_ext_tags tags;
@@ -372,18 +363,17 @@ void yaffs_verify_obj(struct yaffs_obj *obj)
 
        /* Verify it has a parent */
        if (obj && !obj->fake && (!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->obj_id, obj->parent));
+               yaffs_trace(YAFFS_TRACE_VERIFY,
+                       "Obj %d has parent pointer %p which does not look like an object",
+                       obj->obj_id, obj->parent);
        }
 
        /* Verify parent is a 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->obj_id, obj->parent->variant_type));
+               yaffs_trace(YAFFS_TRACE_VERIFY,
+                       "Obj %d's parent is not a directory (type %d)",
+                       obj->obj_id, obj->parent->variant_type);
        }
 
        switch (obj->variant_type) {
@@ -404,9 +394,9 @@ void yaffs_verify_obj(struct yaffs_obj *obj)
                break;
        case YAFFS_OBJECT_TYPE_UNKNOWN:
        default:
-               T(YAFFS_TRACE_VERIFY,
-                 (TSTR("Obj %d has illegaltype %d" TENDSTR),
-                  obj->obj_id, obj->variant_type));
+               yaffs_trace(YAFFS_TRACE_VERIFY,
+                       "Obj %d has illegaltype %d",
+                  obj->obj_id, obj->variant_type);
                break;
        }
 }
@@ -441,7 +431,7 @@ void yaffs_verify_obj_in_dir(struct yaffs_obj *obj)
        int count = 0;
 
        if (!obj) {
-               T(YAFFS_TRACE_ALWAYS, (TSTR("No object to verify" TENDSTR)));
+               yaffs_trace(YAFFS_TRACE_ALWAYS, "No object to verify");
                YBUG();
                return;
        }
@@ -450,15 +440,13 @@ void yaffs_verify_obj_in_dir(struct yaffs_obj *obj)
                return;
 
        if (!obj->parent) {
-               T(YAFFS_TRACE_ALWAYS,
-                 (TSTR("Object does not have parent" TENDSTR)));
+               yaffs_trace(YAFFS_TRACE_ALWAYS, "Object does not have parent" );
                YBUG();
                return;
        }
 
        if (obj->parent->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) {
-               T(YAFFS_TRACE_ALWAYS,
-                 (TSTR("Parent is not directory" TENDSTR)));
+               yaffs_trace(YAFFS_TRACE_ALWAYS, "Parent is not directory");
                YBUG();
        }
 
@@ -474,8 +462,9 @@ void yaffs_verify_obj_in_dir(struct yaffs_obj *obj)
        }
 
        if (count != 1) {
-               T(YAFFS_TRACE_ALWAYS,
-                 (TSTR("Object in directory %d times" TENDSTR), count));
+               yaffs_trace(YAFFS_TRACE_ALWAYS,
+                       "Object in directory %d times",
+                       count);
                YBUG();
        }
 }
@@ -494,9 +483,9 @@ void yaffs_verify_dir(struct yaffs_obj *directory)
                return;
 
        if (directory->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) {
-               T(YAFFS_TRACE_ALWAYS,
-                 (TSTR("Directory has wrong type: %d" TENDSTR),
-                  directory->variant_type));
+               yaffs_trace(YAFFS_TRACE_ALWAYS,
+                       "Directory has wrong type: %d",
+                       directory->variant_type);
                YBUG();
        }
 
@@ -506,10 +495,9 @@ void yaffs_verify_dir(struct yaffs_obj *directory)
                if (lh) {
                        list_obj = list_entry(lh, struct yaffs_obj, siblings);
                        if (list_obj->parent != directory) {
-                               T(YAFFS_TRACE_ALWAYS,
-                                 (TSTR
-                                  ("Object in directory list has wrong parent %p"
-                                   TENDSTR), list_obj->parent));
+                               yaffs_trace(YAFFS_TRACE_ALWAYS,
+                                       "Object in directory list has wrong parent %p",
+                                       list_obj->parent);
                                YBUG();
                        }
                        yaffs_verify_obj_in_dir(list_obj);
@@ -532,9 +520,9 @@ void yaffs_verify_free_chunks(struct yaffs_dev *dev)
        difference = dev->n_free_chunks - counted;
 
        if (difference) {
-               T(YAFFS_TRACE_ALWAYS,
-                 (TSTR("Freechunks verification failure %d %d %d" TENDSTR),
-                  dev->n_free_chunks, counted, difference));
+               yaffs_trace(YAFFS_TRACE_ALWAYS,
+                       "Freechunks verification failure %d %d %d",
+                       dev->n_free_chunks, counted, difference);
                yaffs_free_verification_failures++;
        }
 }
@@ -544,3 +532,4 @@ int yaffs_verify_file_sane(struct yaffs_obj *in)
        in = in;
        return YAFFS_OK;
 }
+
index 8aa3fd4..85df2d7 100644 (file)
@@ -507,14 +507,14 @@ static unsigned yaffs_gc_control_callback(struct yaffs_dev *dev)
 
 static void yaffs_gross_lock(struct yaffs_dev *dev)
 {
-       T(YAFFS_TRACE_LOCK, (TSTR("yaffs locking %p\n"), current));
+       yaffs_trace(YAFFS_TRACE_LOCK, "yaffs locking %p", current);
        mutex_lock(&(yaffs_dev_to_lc(dev)->gross_lock));
-       T(YAFFS_TRACE_LOCK, (TSTR("yaffs locked %p\n"), current));
+       yaffs_trace(YAFFS_TRACE_LOCK, "yaffs locked %p", current);
 }
 
 static void yaffs_gross_unlock(struct yaffs_dev *dev)
 {
-       T(YAFFS_TRACE_LOCK, (TSTR("yaffs unlocking %p\n"), current));
+       yaffs_trace(YAFFS_TRACE_LOCK, "yaffs unlocking %p", current);
        mutex_unlock(&(yaffs_dev_to_lc(dev)->gross_lock));
 }
 
@@ -623,7 +623,7 @@ static struct yaffs_search_context *yaffs_new_search(struct yaffs_obj *dir)
 {
        struct yaffs_dev *dev = dir->my_dev;
        struct yaffs_search_context *sc =
-           YMALLOC(sizeof(struct yaffs_search_context));
+           kmalloc(sizeof(struct yaffs_search_context), GFP_NOFS);
        if (sc) {
                sc->dir_obj = dir;
                sc->dev = dev;
@@ -646,7 +646,7 @@ static void yaffs_search_end(struct yaffs_search_context *sc)
 {
        if (sc) {
                list_del(&sc->others);
-               YFREE(sc);
+               kfree(sc);
        }
 }
 
@@ -793,9 +793,8 @@ static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry)
        if (current != yaffs_dev_to_lc(dev)->readdir_process)
                yaffs_gross_lock(dev);
 
-       T(YAFFS_TRACE_OS,
-         (TSTR("yaffs_lookup for %d:%s\n"),
-          yaffs_inode_to_obj(dir)->obj_id, dentry->d_name.name));
+       yaffs_trace(YAFFS_TRACE_OS,"yaffs_lookup for %d:%s",
+               yaffs_inode_to_obj(dir)->obj_id, dentry->d_name.name);
 
        obj = yaffs_find_by_name(yaffs_inode_to_obj(dir), dentry->d_name.name);
 
@@ -806,26 +805,12 @@ static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry)
                yaffs_gross_unlock(dev);
 
        if (obj) {
-               T(YAFFS_TRACE_OS,
-                 (TSTR("yaffs_lookup found %d\n"), obj->obj_id));
+               yaffs_trace(YAFFS_TRACE_OS,
+                       "yaffs_lookup found %d", obj->obj_id);
 
                inode = yaffs_get_inode(dir->i_sb, obj->yst_mode, 0, obj);
-
-               if (inode) {
-                       T(YAFFS_TRACE_OS, (TSTR("yaffs_loookup dentry \n")));
-/* #if 0 asserted by NCB for 2.5/6 compatability - falls through to
- * d_add even if NULL inode */
-#if 0
-                       /*dget(dentry); // try to solve directory bug */
-                       d_add(dentry, inode);
-
-                       /* return dentry; */
-                       return NULL;
-#endif
-               }
-
        } else {
-               T(YAFFS_TRACE_OS, (TSTR("yaffs_lookup not found\n")));
+               yaffs_trace(YAFFS_TRACE_OS, "yaffs_lookup not found");
 
        }
 
@@ -843,9 +828,9 @@ static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry)
  */
 static void yaffs_put_inode(struct inode *inode)
 {
-       T(YAFFS_TRACE_OS,
-         (TSTR("yaffs_put_inode: ino %d, count %d\n"), (int)inode->i_ino,
-          atomic_read(&inode->i_count)));
+       yaffs_trace(YAFFS_TRACE_OS,
+               "yaffs_put_inode: ino %d, count %d"),
+               (int)inode->i_ino, atomic_read(&inode->i_count);
 
 }
 #endif
@@ -878,10 +863,10 @@ static void yaffs_evict_inode(struct inode *inode)
 
        obj = yaffs_inode_to_obj(inode);
 
-       T(YAFFS_TRACE_OS,
-         (TSTR("yaffs_evict_inode: ino %d, count %d %s\n"), (int)inode->i_ino,
-          atomic_read(&inode->i_count),
-          obj ? "object exists" : "null object"));
+       yaffs_trace(YAFFS_TRACE_OS,
+               "yaffs_evict_inode: ino %d, count %d %s",
+               (int)inode->i_ino, atomic_read(&inode->i_count),
+               obj ? "object exists" : "null object"));
 
        if (!inode->i_nlink && !is_bad_inode(inode))
                deleteme = 1;
@@ -900,7 +885,6 @@ static void yaffs_evict_inode(struct inode *inode)
                yaffs_unstitch_obj(inode, obj);
                yaffs_gross_unlock(dev);
        }
-
 }
 #else
 
@@ -918,10 +902,10 @@ static void yaffs_clear_inode(struct inode *inode)
 
        obj = yaffs_inode_to_obj(inode);
 
-       T(YAFFS_TRACE_OS,
-         (TSTR("yaffs_clear_inode: ino %d, count %d %s\n"), (int)inode->i_ino,
-          atomic_read(&inode->i_count),
-          obj ? "object exists" : "null object"));
+       yaffs_trace(YAFFS_TRACE_OS,
+               "yaffs_clear_inode: ino %d, count %d %s",
+               (int)inode->i_ino, atomic_read(&inode->i_count),
+               obj ? "object exists" : "null object");
 
        if (obj) {
                dev = obj->my_dev;
@@ -942,10 +926,10 @@ static void yaffs_delete_inode(struct inode *inode)
        struct yaffs_obj *obj = yaffs_inode_to_obj(inode);
        struct yaffs_dev *dev;
 
-       T(YAFFS_TRACE_OS,
-         (TSTR("yaffs_delete_inode: ino %d, count %d %s\n"), (int)inode->i_ino,
-          atomic_read(&inode->i_count),
-          obj ? "object exists" : "null object"));
+       yaffs_trace(YAFFS_TRACE_OS,
+               "yaffs_delete_inode: ino %d, count %d %s",
+               (int)inode->i_ino, atomic_read(&inode->i_count),
+               obj ? "object exists" : "null object");
 
        if (obj) {
                dev = obj->my_dev;
@@ -970,9 +954,10 @@ static int yaffs_file_flush(struct file *file)
 
        struct yaffs_dev *dev = obj->my_dev;
 
-       T(YAFFS_TRACE_OS,
-         (TSTR("yaffs_file_flush object %d (%s)\n"), obj->obj_id,
-          obj->dirty ? "dirty" : "clean"));
+       yaffs_trace(YAFFS_TRACE_OS,
+               "yaffs_file_flush object %d (%s)",
+               obj->obj_id,
+               obj->dirty ? "dirty" : "clean");
 
        yaffs_gross_lock(dev);
 
@@ -993,10 +978,10 @@ static int yaffs_readpage_nolock(struct file *f, struct page *pg)
 
        struct yaffs_dev *dev;
 
-       T(YAFFS_TRACE_OS,
-         (TSTR("yaffs_readpage_nolock at %08x, size %08x\n"),
-          (unsigned)(pg->index << PAGE_CACHE_SHIFT),
-          (unsigned)PAGE_CACHE_SIZE));
+       yaffs_trace(YAFFS_TRACE_OS,
+               "yaffs_readpage_nolock at %08x, size %08x",
+               (unsigned)(pg->index << PAGE_CACHE_SHIFT),
+               (unsigned)PAGE_CACHE_SIZE);
 
        obj = yaffs_dentry_to_obj(f->f_dentry);
 
@@ -1033,7 +1018,7 @@ static int yaffs_readpage_nolock(struct file *f, struct page *pg)
        flush_dcache_page(pg);
        kunmap(pg);
 
-       T(YAFFS_TRACE_OS, (TSTR("yaffs_readpage_nolock done\n")));
+       yaffs_trace(YAFFS_TRACE_OS, "yaffs_readpage_nolock done");
        return ret;
 }
 
@@ -1048,9 +1033,9 @@ static int yaffs_readpage(struct file *f, struct page *pg)
 {
        int ret;
 
-       T(YAFFS_TRACE_OS, (TSTR("yaffs_readpage\n")));
+       yaffs_trace(YAFFS_TRACE_OS, "yaffs_readpage");
        ret = yaffs_readpage_unlock(f, pg);
-       T(YAFFS_TRACE_OS, (TSTR("yaffs_readpage done\n")));
+       yaffs_trace(YAFFS_TRACE_OS, "yaffs_readpage done");
        return ret;
 }
 
@@ -1087,13 +1072,12 @@ static int yaffs_writepage(struct page *page)
                n_bytes = i_size & (PAGE_CACHE_SIZE - 1);
 
                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),
-                          (unsigned)inode->i_size));
-                       T(YAFFS_TRACE_OS,
-                         (TSTR("                -> don't care!!\n")));
+                       yaffs_trace(YAFFS_TRACE_OS,
+                               "yaffs_writepage at %08x, inode size = %08x!!",
+                               (unsigned)(page->index << PAGE_CACHE_SHIFT),
+                               (unsigned)inode->i_size);
+                       yaffs_trace(YAFFS_TRACE_OS,
+                               "                -> don't care!!");
 
                        zero_user_segment(page, 0, PAGE_CACHE_SIZE);
                        set_page_writeback(page);
@@ -1114,21 +1098,21 @@ static int yaffs_writepage(struct page *page)
        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), n_bytes));
-       T(YAFFS_TRACE_OS,
-         (TSTR("writepag0: obj = %05x, ino = %05x\n"),
-          (int)obj->variant.file_variant.file_size, (int)inode->i_size));
+       yaffs_trace(YAFFS_TRACE_OS,
+               "yaffs_writepage at %08x, size %08x",
+               (unsigned)(page->index << PAGE_CACHE_SHIFT), n_bytes);
+       yaffs_trace(YAFFS_TRACE_OS,
+               "writepag0: obj = %05x, ino = %05x",
+               (int)obj->variant.file_variant.file_size, (int)inode->i_size);
 
        n_written = yaffs_wr_file(obj, buffer,
                                  page->index << PAGE_CACHE_SHIFT, n_bytes, 0);
 
        yaffs_touch_super(dev);
 
-       T(YAFFS_TRACE_OS,
-         (TSTR("writepag1: obj = %05x, ino = %05x\n"),
-          (int)obj->variant.file_variant.file_size, (int)inode->i_size));
+       yaffs_trace(YAFFS_TRACE_OS,
+               "writepag1: obj = %05x, ino = %05x",
+               (int)obj->variant.file_variant.file_size, (int)inode->i_size);
 
        yaffs_gross_unlock(dev);
 
@@ -1164,9 +1148,9 @@ static int yaffs_write_begin(struct file *filp, struct address_space *mapping,
                ret = -ENOMEM;
                goto out;
        }
-       T(YAFFS_TRACE_OS,
-         (TSTR("start yaffs_write_begin index %d(%x) uptodate %d\n"),
-          (int)index, (int)index, Page_Uptodate(pg) ? 1 : 0));
+       yaffs_trace(YAFFS_TRACE_OS,
+               "start yaffs_write_begin index %d(%x) uptodate %d",
+               (int)index, (int)index, Page_Uptodate(pg) ? 1 : 0);
 
        /* Get fs space */
        space_held = yaffs_hold_space(filp);
@@ -1185,13 +1169,13 @@ static int yaffs_write_begin(struct file *filp, struct address_space *mapping,
                goto out;
 
        /* Happy path return */
-       T(YAFFS_TRACE_OS, (TSTR("end yaffs_write_begin - ok\n")));
+       yaffs_trace(YAFFS_TRACE_OS, "end yaffs_write_begin - ok");
 
        return 0;
 
 out:
-       T(YAFFS_TRACE_OS,
-         (TSTR("end yaffs_write_begin fail returning %d\n"), ret));
+       yaffs_trace(YAFFS_TRACE_OS,
+               "end yaffs_write_begin fail returning %d", ret);
        if (space_held)
                yaffs_release_space(filp);
        if (pg) {
@@ -1206,7 +1190,7 @@ out:
 static int yaffs_prepare_write(struct file *f, struct page *pg,
                               unsigned offset, unsigned to)
 {
-       T(YAFFS_TRACE_OS, (TSTR("yaffs_prepair_write\n")));
+       yaffs_trace(YAFFS_TRACE_OS, "yaffs_prepair_write");
 
        if (!Page_Uptodate(pg))
                return yaffs_readpage_nolock(f, pg);
@@ -1226,19 +1210,17 @@ static int yaffs_write_end(struct file *filp, struct address_space *mapping,
        kva = kmap(pg);
        addr = kva + offset_into_page;
 
-       T(YAFFS_TRACE_OS,
-         ("yaffs_write_end addr %p pos %x n_bytes %d\n",
-          addr, (unsigned)pos, copied));
+       yaffs_trace(YAFFS_TRACE_OS,
+               "yaffs_write_end addr %p pos %x n_bytes %d",
+               addr, (unsigned)pos, copied);
 
        ret = yaffs_file_write(filp, addr, copied, &pos);
 
        if (ret != copied) {
-               T(YAFFS_TRACE_OS,
-                 (TSTR("yaffs_write_end not same size ret %d  copied %d\n"),
-                  ret, copied));
+               yaffs_trace(YAFFS_TRACE_OS,
+                       "yaffs_write_end not same size ret %d  copied %d",
+                       ret, copied);
                SetPageError(pg);
-       } else {
-               /* Nothing */
        }
 
        kunmap(pg);
@@ -1267,27 +1249,23 @@ static int yaffs_commit_write(struct file *f, struct page *pg, unsigned offset,
 
        saddr = (unsigned)addr;
 
-       T(YAFFS_TRACE_OS,
-         (TSTR("yaffs_commit_write addr %x pos %x n_bytes %d\n"),
-          saddr, spos, n_bytes));
+       yaffs_trace(YAFFS_TRACE_OS,
+               "yaffs_commit_write addr %x pos %x n_bytes %d",
+               saddr, spos, n_bytes);
 
        n_written = yaffs_file_write(f, addr, n_bytes, &pos);
 
        if (n_written != n_bytes) {
-               T(YAFFS_TRACE_OS,
-                 (TSTR
-                  ("yaffs_commit_write not same size n_written %d  n_bytes %d\n"),
-                  n_written, n_bytes));
+               yaffs_trace(YAFFS_TRACE_OS,
+                       "yaffs_commit_write not same size n_written %d  n_bytes %d",
+                       n_written, n_bytes);
                SetPageError(pg);
-       } else {
-               /* Nothing */
        }
-
        kunmap(pg);
 
-       T(YAFFS_TRACE_OS,
-         (TSTR("yaffs_commit_write returning %d\n"),
-          n_written == n_bytes ? 0 : n_written));
+       yaffs_trace(YAFFS_TRACE_OS,
+               "yaffs_commit_write returning %d",
+               n_written == n_bytes ? 0 : n_written);
 
        return n_written == n_bytes ? 0 : n_written;
 }
@@ -1359,11 +1337,10 @@ static void yaffs_fill_inode_from_obj(struct inode *inode,
 
                inode->i_nlink = yaffs_get_obj_link_count(obj);
 
-               T(YAFFS_TRACE_OS,
-                 (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)));
+               yaffs_trace(YAFFS_TRACE_OS,
+                       "yaffs_fill_inode mode %x uid %d gid %d size %d count %d",
+                       inode->i_mode, inode->i_uid, inode->i_gid,
+                       (int)inode->i_size, atomic_read(&inode->i_count));
 
                switch (obj->yst_mode & S_IFMT) {
                default:        /* fifo, device or socket */
@@ -1395,8 +1372,8 @@ static void yaffs_fill_inode_from_obj(struct inode *inode,
                obj->my_inode = inode;
 
        } else {
-               T(YAFFS_TRACE_OS,
-                 (TSTR("yaffs_fill_inode invalid parameters\n")));
+               yaffs_trace(YAFFS_TRACE_OS,
+                       "yaffs_fill_inode invalid parameters");
        }
 
 }
@@ -1407,21 +1384,21 @@ struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev,
        struct inode *inode;
 
        if (!sb) {
-               T(YAFFS_TRACE_OS,
-                 (TSTR("yaffs_get_inode for NULL super_block!!\n")));
+               yaffs_trace(YAFFS_TRACE_OS,
+                       "yaffs_get_inode for NULL super_block!!");
                return NULL;
 
        }
 
        if (!obj) {
-               T(YAFFS_TRACE_OS,
-                 (TSTR("yaffs_get_inode for NULL object!!\n")));
+               yaffs_trace(YAFFS_TRACE_OS,
+                       "yaffs_get_inode for NULL object!!");
                return NULL;
 
        }
 
-       T(YAFFS_TRACE_OS,
-         (TSTR("yaffs_get_inode for object %d\n"), obj->obj_id));
+       yaffs_trace(YAFFS_TRACE_OS,
+               "yaffs_get_inode for object %d", obj->obj_id);
 
        inode = Y_IGET(sb, obj->obj_id);
        if (IS_ERR(inode))
@@ -1456,21 +1433,20 @@ static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n,
                ipos = *pos;
 
        if (!obj)
-               T(YAFFS_TRACE_OS,
-                 (TSTR("yaffs_file_write: hey obj is null!\n")));
+               yaffs_trace(YAFFS_TRACE_OS,
+                       "yaffs_file_write: hey obj is null!");
        else
-               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->obj_id, ipos, ipos));
+               yaffs_trace(YAFFS_TRACE_OS,
+                       "yaffs_file_write about to write writing %u(%x) bytes to object %d at %d(%x)",
+                       (unsigned)n, (unsigned)n, obj->obj_id, ipos, ipos);
 
        n_written = yaffs_wr_file(obj, buf, ipos, n, 0);