yaffs More symbol changes
authorCharles Manning <cdhmanning@gmail.com>
Wed, 6 Oct 2010 02:55:06 +0000 (15:55 +1300)
committerCharles Manning <cdhmanning@gmail.com>
Wed, 6 Oct 2010 22:14:38 +0000 (11:14 +1300)
Signed-off-by: Charles Manning <cdhmanning@gmail.com>
22 files changed:
direct/basic-test/yaffs_norif1.c
direct/basic-test/yaffs_ramdisk.c
direct/basic-test/yaffs_ramdisk.h
direct/basic-test/yaffscfg.c
direct/basic-test/yaffscfg2k.c
direct/basic-test/ynorsim.c
direct/basic-test/ynorsim.h
direct/basic-test/yramsim.c
direct/tests/nor_stress.c
direct/yaffsfs.c
utils/mkyaffs2image.c
utils/mkyaffsimage.c
yaffs_allocator.c
yaffs_allocator.h
yaffs_guts.c
yaffs_guts.h
yaffs_linux_allocator.c
yaffs_tagscompat.c
yaffs_verify.c
yaffs_vfs.c
yaffs_vfs_multi.c
yaffs_yaffs2.c

index ff86747..4fcf971 100644 (file)
@@ -70,12 +70,12 @@ const char *yaffs_norif1_c_version = "$Id: yaffs_norif1.c,v 1.6 2010-02-18 01:18
 
 /* Compile this for a simulation */
 #include "ynorsim.h"
-#define ynorif1_FlashInit() ynorsim_Initialise()
-#define ynorif1_FlashDeinit() ynorsim_Shutdown()
-#define ynorif1_FlashWrite32(addr,buf,nwords) ynorsim_Write32(addr,buf,nwords) 
-#define ynorif1_FlashRead32(addr,buf,nwords) ynorsim_Read32(addr,buf,nwords) 
-#define ynorif1_FlashEraseBlock(addr) ynorsim_EraseBlock(addr)
-#define DEVICE_BASE     ynorsim_GetBase()
+#define ynorif1_FlashInit() ynorsim_initialise()
+#define ynorif1_FlashDeinit() ynorsim_shutdown()
+#define ynorif1_FlashWrite32(addr,buf,nwords) ynorsim_wr32(addr,buf,nwords) 
+#define ynorif1_FlashRead32(addr,buf,nwords) ynorsim_rd32(addr,buf,nwords) 
+#define ynorif1_FlashEraseBlock(addr) ynorsim_erase(addr)
+#define DEVICE_BASE     ynorsim_get_base()
 #else
 
 /* Compile this for running on blob, hacked for yaffs access */
index 0b47adf..9ca963b 100644 (file)
@@ -43,23 +43,23 @@ const char *yaffs_ramdisk_c_version = "$Id: yaffs_ramdisk.c,v 1.6 2010-01-11 04:
 typedef struct 
 {
        __u8 data[528]; // Data + spare
-} yramdisk_Page;
+} yramdisk_page;
 
 typedef struct
 {
-       yramdisk_Page page[32]; // The pages in the block
+       yramdisk_page page[32]; // The pages in the block
        
-} yramdisk_Block;
+} yramdisk_block;
 
 
 
 typedef struct
 {
-       yramdisk_Block **block;
+       yramdisk_block **block;
        int nBlocks;
-} yramdisk_Device;
+} yramdisk_device;
 
-static yramdisk_Device ramdisk;
+static yramdisk_device ramdisk;
 
 static int  CheckInit(yaffs_Device *dev)
 {
@@ -80,7 +80,7 @@ static int  CheckInit(yaffs_Device *dev)
        
        ramdisk.nBlocks = (SIZE_IN_MB * 1024 * 1024)/(16 * 1024);
        
-       ramdisk.block = YMALLOC(sizeof(yramdisk_Block *) * ramdisk.nBlocks);
+       ramdisk.block = YMALLOC(sizeof(yramdisk_block *) * ramdisk.nBlocks);
        
        if(!ramdisk.block) return 0;
        
@@ -91,13 +91,13 @@ static int  CheckInit(yaffs_Device *dev)
        
        for(i=0; i <ramdisk.nBlocks && !fail; i++)
        {
-               if((ramdisk.block[i] = YMALLOC(sizeof(yramdisk_Block))) == 0)
+               if((ramdisk.block[i] = YMALLOC(sizeof(yramdisk_block))) == 0)
                {
                        fail = 1;
                }
                else
                {
-                       yramdisk_EraseBlockInNAND(dev,i);
+                       yramdisk_erase(dev,i);
                        nAllocated++;
                }
        }
@@ -119,7 +119,7 @@ static int  CheckInit(yaffs_Device *dev)
        return 1;
 }
 
-int yramdisk_WriteChunkWithTagsToNAND(yaffs_Device *dev,int chunkInNAND,const __u8 *data, const yaffs_ExtendedTags *tags)
+int yramdisk_wr_chunk(yaffs_Device *dev,int chunkInNAND,const __u8 *data, const yaffs_ExtendedTags *tags)
 {
        int blk;
        int pg;
@@ -150,7 +150,7 @@ int yramdisk_WriteChunkWithTagsToNAND(yaffs_Device *dev,int chunkInNAND,const __
 }
 
 
-int yramdisk_ReadChunkWithTagsFromNAND(yaffs_Device *dev,int chunkInNAND, __u8 *data, yaffs_ExtendedTags *tags)
+int yramdisk_rd_chunk(yaffs_Device *dev,int chunkInNAND, __u8 *data, yaffs_ExtendedTags *tags)
 {
        int blk;
        int pg;
@@ -181,7 +181,7 @@ int yramdisk_ReadChunkWithTagsFromNAND(yaffs_Device *dev,int chunkInNAND, __u8 *
 }
 
 
-int yramdisk_CheckChunkErased(yaffs_Device *dev,int chunkInNAND)
+int yramdisk_check_chunk_erased(yaffs_Device *dev,int chunkInNAND)
 {
        int blk;
        int pg;
@@ -206,7 +206,7 @@ int yramdisk_CheckChunkErased(yaffs_Device *dev,int chunkInNAND)
 
 }
 
-int yramdisk_EraseBlockInNAND(yaffs_Device *dev, int blockNumber)
+int yramdisk_erase(yaffs_Device *dev, int blockNumber)
 {
        
        CheckInit(dev);
@@ -218,13 +218,13 @@ int yramdisk_EraseBlockInNAND(yaffs_Device *dev, int blockNumber)
        }
        else
        {
-               memset(ramdisk.block[blockNumber],0xFF,sizeof(yramdisk_Block));
+               memset(ramdisk.block[blockNumber],0xFF,sizeof(yramdisk_block));
                return YAFFS_OK;
        }
        
 }
 
-int yramdisk_InitialiseNAND(yaffs_Device *dev)
+int yramdisk_initialise(yaffs_Device *dev)
 {
        //dev->useNANDECC = 1; // force on useNANDECC which gets faked. 
                                                 // This saves us doing ECC checks.
index cc62fd7..772743e 100644 (file)
 
 
 #include "yaffs_guts.h"
-int yramdisk_EraseBlockInNAND(yaffs_Device *dev, int blockNumber);
-int yramdisk_WriteChunkWithTagsToNAND(yaffs_Device *dev,int chunkInNAND,const __u8 *data, const yaffs_ExtendedTags *tags);
-int yramdisk_ReadChunkWithTagsFromNAND(yaffs_Device *dev,int chunkInNAND, __u8 *data, yaffs_ExtendedTags *tags);
-int yramdisk_InitialiseNAND(yaffs_Device *dev);
-int yramdisk_MarkNANDBlockBad(yaffs_Device *dev,int blockNumber);
-int yramdisk_QueryNANDBlock(yaffs_Device *dev, int blockNo, yaffs_BlockState *state, int *sequenceNumber);
+int yramdisk_erase(yaffs_Device *dev, int blockNumber);
+int yramdisk_wr_chunk(yaffs_Device *dev,int chunkInNAND,const __u8 *data, const yaffs_ExtendedTags *tags);
+int yramdisk_rd_chunk(yaffs_Device *dev,int chunkInNAND, __u8 *data, yaffs_ExtendedTags *tags);
+int yramdisk_initialise(yaffs_Device *dev);
+int yramdisk_mark_block_bad(yaffs_Device *dev,int blockNumber);
+int yramdisk_query_block(yaffs_Device *dev, int blockNo, yaffs_BlockState *state, int *sequenceNumber);
 #endif
index 7d510b2..c2ac04f 100644 (file)
@@ -107,10 +107,10 @@ int yaffs_start_up(void)
        ramDev.useNANDECC = 1;
        ramDev.nShortOpCaches = 0;      // Disable caching on this device.
        ramDev.genericDevice = (void *) 0;      // Used to identify the device in fstat.
-       ramDev.writeChunkWithTagsToNAND = yramdisk_WriteChunkWithTagsToNAND;
-       ramDev.readChunkWithTagsFromNAND = yramdisk_ReadChunkWithTagsFromNAND;
-       ramDev.eraseBlockInNAND = yramdisk_EraseBlockInNAND;
-       ramDev.initialiseNAND = yramdisk_InitialiseNAND;
+       ramDev.writeChunkWithTagsToNAND = yramdisk_wr_chunk;
+       ramDev.readChunkWithTagsFromNAND = yramdisk_rd_chunk;
+       ramDev.eraseBlockInNAND = yramdisk_erase;
+       ramDev.initialiseNAND = yramdisk_initialise;
 
        // /boot
        bootDev.nDataBytesPerChunk = 512;
index 4aa97a3..57ec4a9 100644 (file)
@@ -128,10 +128,10 @@ int yaffs_start_up(void)
        //ram1Dev.param.useNANDECC = 1;
        ram1Dev.param.nShortOpCaches = 0;       // Disable caching on this device.
        ram1Dev.driverContext = (void *) 0;     // Used to identify the device in fstat.
-       ram1Dev.param.writeChunkWithTagsToNAND = yramdisk_WriteChunkWithTagsToNAND;
-       ram1Dev.param.readChunkWithTagsFromNAND = yramdisk_ReadChunkWithTagsFromNAND;
-       ram1Dev.param.eraseBlockInNAND = yramdisk_EraseBlockInNAND;
-       ram1Dev.param.initialiseNAND = yramdisk_InitialiseNAND;
+       ram1Dev.param.writeChunkWithTagsToNAND = yramdisk_wr_chunk;
+       ram1Dev.param.readChunkWithTagsFromNAND = yramdisk_rd_chunk;
+       ram1Dev.param.eraseBlockInNAND = yramdisk_erase;
+       ram1Dev.param.initialiseNAND = yramdisk_initialise;
        
        yaffs_add_device(&ram1Dev);
 
index 0c691a6..17fedb7 100644 (file)
@@ -48,14 +48,14 @@ static void NorError(void)
   while(1){}
 }
 
-static void ynorsim_SaveImage(void)
+static void ynorsim_save_image(void)
 {
   int h = open(YNORSIM_FNAME, O_RDWR | O_CREAT | O_TRUNC, S_IREAD | S_IWRITE);
   write(h,word,sizeof(word));
   close(h);
 }
 
-static void ynorsim_RestoreImage(void)
+static void ynorsim_restore_image(void)
 {
   int h = open(YNORSIM_FNAME, O_RDONLY, S_IREAD | S_IWRITE);
   memset(word,0xFF,sizeof(word));
@@ -64,9 +64,9 @@ static void ynorsim_RestoreImage(void)
 }
 
 
-static void ynorsim_PowerFail(void)
+static void ynorsim_power_fail(void)
 {
-  ynorsim_SaveImage();
+  ynorsim_save_image();
   exit(1);
 }
 
@@ -76,7 +76,7 @@ static int nops_so_far;
 
 int ops_multiplier = 500;
 
-static void ynorsim_MaybePowerFail(void)
+static void ynorsim_maybe_power_fail(void)
 {
 
    nops_so_far++;
@@ -86,21 +86,21 @@ static void ynorsim_MaybePowerFail(void)
    if(simulate_power_failure &&
       remaining_ops < 1){
        printf("Simulated power failure after %d operations\n",nops_so_far);
-       ynorsim_PowerFail();
+       ynorsim_power_fail();
   }
 }
 
-static void ynorsim_Ready(void)
+static void ynorsim_ready(void)
 {
   if(initialised) 
     return;
   srand(random_seed);
   remaining_ops = 1000000000;
   remaining_ops = (rand() % 10000) * ops_multiplier * YNORSIM_BIT_CHANGES;
-  ynorsim_RestoreImage();
+  ynorsim_restore_image();
 }
 
-void ynorsim_Read32(__u32 *addr,__u32 *buf, int nwords)
+void ynorsim_rd32(__u32 *addr,__u32 *buf, int nwords)
 { 
    while(nwords > 0){
      *buf = *addr;
@@ -110,7 +110,7 @@ void ynorsim_Read32(__u32 *addr,__u32 *buf, int nwords)
    }
 }
 
-void ynorsim_WriteOneWord32(__u32 *addr,__u32 val)
+void ynorsim_wr_one_word32(__u32 *addr,__u32 val)
 {
   __u32 tmp;
   __u32 m;
@@ -128,43 +128,43 @@ void ynorsim_WriteOneWord32(__u32 *addr,__u32 val)
     if(!(m & val)){
       tmp &= ~m;
       *addr = tmp;
-      ynorsim_MaybePowerFail();
+      ynorsim_maybe_power_fail();
     }
        
   }
   
   *addr = tmp & val;
-  ynorsim_MaybePowerFail();
+  ynorsim_maybe_power_fail();
 }
 
-void ynorsim_Write32(__u32 *addr, __u32 *buf, int nwords)
+void ynorsim_wr32(__u32 *addr, __u32 *buf, int nwords)
 {
   while(nwords >0){
-    ynorsim_WriteOneWord32(addr,*buf);
+    ynorsim_wr_one_word32(addr,*buf);
     addr++;
     buf++;
     nwords--;
   }
 }
 
-void ynorsim_EraseBlock(__u32 *addr)
+void ynorsim_erase(__u32 *addr)
 {
   /* Todo... bit flipping */
   memset(addr,0xFF,YNORSIM_BLOCK_SIZE_U32 * 4);
 }
 
-void ynorsim_Initialise(void)
+void ynorsim_initialise(void)
 {
-  ynorsim_Ready();
+  ynorsim_ready();
 }
 
-void ynorsim_Shutdown(void)
+void ynorsim_shutdown(void)
 {
-  ynorsim_SaveImage();
+  ynorsim_save_image();
   initialised=0;
 }
 
-__u32 *ynorsim_GetBase(void)
+__u32 *ynorsim_get_base(void)
 {
   return word;
 }
index 2c70ad9..d7ec44f 100644 (file)
@@ -4,11 +4,11 @@
 
 #include "yaffs_guts.h"
 
-void ynorsim_Read32(__u32 *addr, __u32 *data, int nwords);
-void ynorsim_Write32(__u32 *addr, __u32 *data, int nwords);
-void ynorsim_EraseBlock(__u32 *addr);
-void ynorsim_Shutdown(void);
-void ynorsim_Initialise(void);
-__u32 * ynorsim_GetBase(void);
+void ynorsim_rd32(__u32 *addr, __u32 *data, int nwords);
+void ynorsim_wr32(__u32 *addr, __u32 *data, int nwords);
+void ynorsim_erase(__u32 *addr);
+void ynorsim_shutdown(void);
+void ynorsim_initialise(void);
+__u32 * ynorsim_get_base(void);
 
 #endif
index 9a7a72b..48509c7 100644 (file)
@@ -39,7 +39,7 @@ static void CheckInitialised(void)
 
 }
 
-static int yramsim_EraseBlockInternal(SimData *sim, unsigned blockId,int force)
+static int yramsim_erase_internal(SimData *sim, unsigned blockId,int force)
 {
        if(blockId < 0 || blockId >= sim->nBlocks){
                return 0;
@@ -62,7 +62,7 @@ static int yramsim_EraseBlockInternal(SimData *sim, unsigned blockId,int force)
 
 
 
-static int yramsim_Initialise(yaffs_Device *dev)
+static int yramsim_initialise(yaffs_Device *dev)
 {
        SimData *sim = DevToSim(dev);
        Block **blockList = sim->blockList;
@@ -70,12 +70,12 @@ static int yramsim_Initialise(yaffs_Device *dev)
 }
 
 
-static int yramsim_Deinitialise(yaffs_Device *dev)
+static int yramsim_deinitialise(yaffs_Device *dev)
 {
        return 1;
 }
 
-static int yramsim_ReadChunk (yaffs_Device *dev, unsigned pageId,
+static int yramsim_rd_chunk (yaffs_Device *dev, unsigned pageId,
                                          unsigned char *data, unsigned dataLength,
                                          unsigned char *spare, unsigned spareLength,
                                          int *eccStatus)
@@ -110,7 +110,7 @@ static int yramsim_ReadChunk (yaffs_Device *dev, unsigned pageId,
        return 1;
 }
 
-static int yramsim_WriteChunk (yaffs_Device *dev,unsigned pageId,
+static int yramsim_wr_chunk (yaffs_Device *dev,unsigned pageId,
                                           const unsigned char *data, unsigned dataLength,
                                           const unsigned char *spare, unsigned spareLength)
 {
@@ -142,15 +142,15 @@ static int yramsim_WriteChunk (yaffs_Device *dev,unsigned pageId,
 }
 
 
-static int yramsim_EraseBlock(yaffs_Device *dev,unsigned blockId)
+static int yramsim_erase(yaffs_Device *dev,unsigned blockId)
 {
        SimData *sim = DevToSim(dev);
 
        CheckInitialised();
-       return yramsim_EraseBlockInternal(sim,blockId,0);
+       return yramsim_erase_internal(sim,blockId,0);
 }
 
-static int yramsim_CheckBlockOk(yaffs_Device *dev,unsigned blockId)
+static int yramsim_check_block_ok(yaffs_Device *dev,unsigned blockId)
 {
        SimData *sim = DevToSim(dev);
        Block **blockList = sim->blockList;
@@ -161,7 +161,7 @@ static int yramsim_CheckBlockOk(yaffs_Device *dev,unsigned blockId)
        return blockList[blockId]->blockOk ? 1 : 0;
 }
 
-static int yramsim_MarkBlockBad(yaffs_Device *dev,unsigned blockId)
+static int yramsim_mark_block_bad(yaffs_Device *dev,unsigned blockId)
 {
        SimData *sim = DevToSim(dev);
        Block **blockList = sim->blockList;
@@ -175,7 +175,7 @@ static int yramsim_MarkBlockBad(yaffs_Device *dev,unsigned blockId)
 }
 
 
-static SimData *yramsim_AllocSimData(__u32 devId, __u32 nBlocks)
+static SimData *yramsim_alloc_sim_data(__u32 devId, __u32 nBlocks)
 {
        int ok = 1;
 
@@ -214,7 +214,7 @@ static SimData *yramsim_AllocSimData(__u32 devId, __u32 nBlocks)
                b=  malloc(sizeof(Block));
                if(b){
                        blockList[i] = b;
-                       yramsim_EraseBlockInternal(sim,i,1);
+                       yramsim_erase_internal(sim,i,1);
                }
                else
                        ok = 0;
@@ -243,7 +243,7 @@ struct yaffs_DeviceStruct *yramsim_CreateRamSim(const YCHAR *name,
        SimData *sim;
        ynandif_Geometry *g;
 
-       sim = yramsim_AllocSimData(devId, nBlocks);
+       sim = yramsim_alloc_sim_data(devId, nBlocks);
 
        g = YMALLOC(sizeof(ynandif_Geometry));
 
@@ -267,13 +267,13 @@ struct yaffs_DeviceStruct *yramsim_CreateRamSim(const YCHAR *name,
        g->hasECC = 1;
        g->inbandTags = 0;
        g->useYaffs2 = 1;
-       g->initialise = yramsim_Initialise;
-       g->deinitialise = yramsim_Deinitialise;
-       g->readChunk = yramsim_ReadChunk,
-       g->writeChunk = yramsim_WriteChunk,
-       g->eraseBlock = yramsim_EraseBlock,
-       g->checkBlockOk = yramsim_CheckBlockOk,
-       g->markBlockBad = yramsim_MarkBlockBad,
+       g->initialise = yramsim_initialise;
+       g->deinitialise = yramsim_deinitialise;
+       g->readChunk = yramsim_rd_chunk,
+       g->writeChunk = yramsim_wr_chunk,
+       g->eraseBlock = yramsim_erase,
+       g->checkBlockOk = yramsim_check_block_ok,
+       g->markBlockBad = yramsim_mark_block_bad,
        g->privateData = (void *)sim;
 
        return yaffs_add_dev_from_geometry(name,g);
index 6f6b4ce..20df837 100644 (file)
@@ -258,7 +258,7 @@ static void dump_directory_tree(const char *dname)
 
 static unsigned xx[XX_SIZE];
 
-static int yWriteFile(const char *fname, unsigned sz32)
+static int y_wr_file(const char *fname, unsigned sz32)
 {
        int h;
        int r;
@@ -317,7 +317,7 @@ WRITE_ERROR:
        
 }
 
-static int yVerifyFile(const char *fName)
+static int y_verify_file(const char *fName)
 {
        unsigned checksum = 0;
        unsigned totalSize;
@@ -400,7 +400,7 @@ static void DoUpdateMainFile(void)
         int sz32;
         sz32 = (myrand() % 1000)   + 20;
         
-       result = yWriteFile(fullTempMainName,sz32);
+       result = y_wr_file(fullTempMainName,sz32);
        FSX();
        if(!no_verification && result)
            FatalError(__LINE__);
@@ -414,7 +414,7 @@ static void DoVerifyMainFile(void)
         int result;
        if(no_verification)
                return;
-       result = yVerifyFile(fullMainName);
+       result = y_verify_file(fullMainName);
        if(result)
            FatalError(__LINE__);
 
index 7a53aa7..b8e49bb 100644 (file)
@@ -1102,7 +1102,7 @@ int yaffsfs_DoUnlink(const YCHAR *path,int isDirectory)
        else if(isDirectory && obj->variantType != YAFFS_OBJECT_TYPE_DIRECTORY)
                yaffsfs_SetError(-ENOTDIR);
        else {
-               result = yaffs_Unlink(dir,name);
+               result = yaffs_unlinker(dir,name);
 
                if(result == YAFFS_FAIL && isDirectory)
                        yaffsfs_SetError(-ENOTEMPTY);
index f40a657..ac658b1 100644 (file)
@@ -148,8 +148,8 @@ static int find_obj_in_list(dev_t dev, ino_t ino)
 static void little_to_big_endian(yaffs_Tags *tagsPtr)
 {
 #if 0 // FIXME NCB
-    yaffs_TagsUnion * tags = (yaffs_TagsUnion* )tagsPtr; // Work in bytes.
-    yaffs_TagsUnion   temp;
+    yaffs_tags_union_t * tags = (yaffs_tags_union_t* )tagsPtr; // Work in bytes.
+    yaffs_tags_union_t   temp;
 
     memset(&temp, 0, sizeof(temp));
     // Ick, I hate magic numbers.
index b7173eb..8a50da5 100644 (file)
@@ -139,7 +139,7 @@ static void yaffs_calc_ecc(const __u8 *data, yaffs_Spare *spare)
 static void yaffs_calc_tags_ecc(yaffs_Tags *tags)
 {
        // Todo don't do anything yet. Need to calculate ecc
-       unsigned char *b = ((yaffs_TagsUnion *)tags)->asBytes;
+       unsigned char *b = ((yaffs_tags_union_t *)tags)->asBytes;
        unsigned  i,j;
        unsigned  ecc = 0;
        unsigned bit = 0;
@@ -183,18 +183,18 @@ static void yaffs_calc_tags_ecc(yaffs_Tags *tags)
 }
 static void yaffs_load_tags_to_spare(yaffs_Spare *sparePtr, yaffs_Tags *tagsPtr)
 {
-       yaffs_TagsUnion *tu = (yaffs_TagsUnion *)tagsPtr;
+       yaffs_tags_union_t *tu = (yaffs_tags_union_t *)tagsPtr;
        
        //yaffs_calc_tags_ecc(tagsPtr);
        
-       sparePtr->tagByte0 = tu->asBytes[0];
-       sparePtr->tagByte1 = tu->asBytes[1];
-       sparePtr->tagByte2 = tu->asBytes[2];
-       sparePtr->tagByte3 = tu->asBytes[3];
-       sparePtr->tagByte4 = tu->asBytes[4];
-       sparePtr->tagByte5 = tu->asBytes[5];
-       sparePtr->tagByte6 = tu->asBytes[6];
-       sparePtr->tagByte7 = tu->asBytes[7];
+       sparePtr->tb0 = tu->asBytes[0];
+       sparePtr->tb1 = tu->asBytes[1];
+       sparePtr->tb2 = tu->asBytes[2];
+       sparePtr->tb3 = tu->asBytes[3];
+       sparePtr->tb4 = tu->asBytes[4];
+       sparePtr->tb5 = tu->asBytes[5];
+       sparePtr->tb6 = tu->asBytes[6];
+       sparePtr->tb7 = tu->asBytes[7];
 }
 
 /* This little function converts a little endian tag to a big endian tag.
@@ -203,8 +203,8 @@ static void yaffs_load_tags_to_spare(yaffs_Spare *sparePtr, yaffs_Tags *tagsPtr)
  */
 static void little_to_big_endian(yaffs_Tags *tagsPtr)
 {
-    yaffs_TagsUnion * tags = (yaffs_TagsUnion* )tagsPtr; // Work in bytes.
-    yaffs_TagsUnion   temp;
+    yaffs_tags_union_t * tags = (yaffs_tags_union_t* )tagsPtr; // Work in bytes.
+    yaffs_tags_union_t   temp;
 
     memset(&temp, 0, sizeof(temp));
     // Ick, I hate magic numbers.
index 41200ee..1501a8e 100644 (file)
@@ -31,12 +31,12 @@ void yaffs_init_raw_tnodes_and_objs(yaffs_Device *dev)
        dev = dev;
 }
 
-yaffs_Tnode *yaffs_alloc_raw_tnode(yaffs_Device *dev)
+yaffs_tnode_t *yaffs_alloc_raw_tnode(yaffs_Device *dev)
 {
-       return (yaffs_Tnode *)YMALLOC(dev->tnodeSize);
+       return (yaffs_tnode_t *)YMALLOC(dev->tnodeSize);
 }
 
-void yaffs_free_raw_tnode(yaffs_Device *dev, yaffs_Tnode *tn)
+void yaffs_free_raw_tnode(yaffs_Device *dev, yaffs_tnode_t *tn)
 {
        dev = dev;
        YFREE(tn);
@@ -68,12 +68,12 @@ void yaffs_free_raw_obj(yaffs_Device *dev, yaffs_Object *obj)
 
 #else
 
-struct yaffs_TnodeList_struct {
-       struct yaffs_TnodeList_struct *next;
-       yaffs_Tnode *tnodes;
+struct yaffs_tnode_list {
+       struct yaffs_tnode_list *next;
+       yaffs_tnode_t *tnodes;
 };
 
-typedef struct yaffs_TnodeList_struct yaffs_TnodeList;
+typedef struct yaffs_tnode_list yaffs_tnodelist_t;
 
 struct yaffs_ObjectList_struct {
        yaffs_Object *objects;
@@ -85,9 +85,9 @@ typedef struct yaffs_ObjectList_struct yaffs_ObjectList;
 
 struct yaffs_AllocatorStruct {
        int nTnodesCreated;
-       yaffs_Tnode *freeTnodes;
+       yaffs_tnode_t *freeTnodes;
        int nFreeTnodes;
-       yaffs_TnodeList *allocatedTnodeList;
+       yaffs_tnodelist_t *allocatedTnodeList;
 
        int nObjectsCreated;
        yaffs_Object *freeObjects;
@@ -104,7 +104,7 @@ static void yaffs_deinit_raw_tnodes(yaffs_Device *dev)
 
        yaffs_Allocator *allocator = (yaffs_Allocator *)dev->allocator;
 
-       yaffs_TnodeList *tmp;
+       yaffs_tnodelist_t *tmp;
 
        if(!allocator){
                YBUG();
@@ -142,11 +142,11 @@ static int yaffs_create_tnodes(yaffs_Device *dev, int nTnodes)
 {
        yaffs_Allocator *allocator = (yaffs_Allocator *)dev->allocator;
        int i;
-       yaffs_Tnode *newTnodes;
+       yaffs_tnode_t *newTnodes;
        __u8 *mem;
-       yaffs_Tnode *curr;
-       yaffs_Tnode *next;
-       yaffs_TnodeList *tnl;
+       yaffs_tnode_t *curr;
+       yaffs_tnode_t *next;
+       yaffs_tnodelist_t *tnl;
 
        if(!allocator){
                YBUG();
@@ -170,14 +170,14 @@ static int yaffs_create_tnodes(yaffs_Device *dev, int nTnodes)
 
        /* New hookup for wide tnodes */
        for (i = 0; i < nTnodes - 1; i++) {
-               curr = (yaffs_Tnode *) &mem[i * dev->tnodeSize];
-               next = (yaffs_Tnode *) &mem[(i+1) * dev->tnodeSize];
+               curr = (yaffs_tnode_t *) &mem[i * dev->tnodeSize];
+               next = (yaffs_tnode_t *) &mem[(i+1) * dev->tnodeSize];
                curr->internal[0] = next;
        }
 
-       curr = (yaffs_Tnode *) &mem[(nTnodes - 1) * dev->tnodeSize];
+       curr = (yaffs_tnode_t *) &mem[(nTnodes - 1) * dev->tnodeSize];
        curr->internal[0] = allocator->freeTnodes;
-       allocator->freeTnodes = (yaffs_Tnode *)mem;
+       allocator->freeTnodes = (yaffs_tnode_t *)mem;
 
        allocator->nFreeTnodes += nTnodes;
        allocator->nTnodesCreated += nTnodes;
@@ -187,7 +187,7 @@ static int yaffs_create_tnodes(yaffs_Device *dev, int nTnodes)
         * but it just means we can't free this bunch of tnodes later.
         */
 
-       tnl = YMALLOC(sizeof(yaffs_TnodeList));
+       tnl = YMALLOC(sizeof(yaffs_tnodelist_t));
        if (!tnl) {
                T(YAFFS_TRACE_ERROR,
                  (TSTR
@@ -205,10 +205,10 @@ static int yaffs_create_tnodes(yaffs_Device *dev, int nTnodes)
 }
 
 
-yaffs_Tnode *yaffs_alloc_raw_tnode(yaffs_Device *dev)
+yaffs_tnode_t *yaffs_alloc_raw_tnode(yaffs_Device *dev)
 {
        yaffs_Allocator *allocator = (yaffs_Allocator *)dev->allocator;
-       yaffs_Tnode *tn = NULL;
+       yaffs_tnode_t *tn = NULL;
 
        if(!allocator){
                YBUG();
@@ -229,7 +229,7 @@ yaffs_Tnode *yaffs_alloc_raw_tnode(yaffs_Device *dev)
 }
 
 /* FreeTnode frees up a tnode and puts it back on the free list */
-void yaffs_free_raw_tnode(yaffs_Device *dev, yaffs_Tnode *tn)
+void yaffs_free_raw_tnode(yaffs_Device *dev, yaffs_tnode_t *tn)
 {
        yaffs_Allocator *allocator = dev->allocator;
 
index 1212081..ec9e1c7 100644 (file)
@@ -21,8 +21,8 @@
 void yaffs_init_raw_tnodes_and_objs(yaffs_Device *dev);
 void yaffs_deinit_raw_tnodes_and_objs(yaffs_Device *dev);
 
-yaffs_Tnode *yaffs_alloc_raw_tnode(yaffs_Device *dev);
-void yaffs_free_raw_tnode(yaffs_Device *dev, yaffs_Tnode *tn);
+yaffs_tnode_t *yaffs_alloc_raw_tnode(yaffs_Device *dev);
+void yaffs_free_raw_tnode(yaffs_Device *dev, yaffs_tnode_t *tn);
 
 yaffs_Object *yaffs_alloc_raw_obj(yaffs_Device *dev);
 void yaffs_free_raw_obj(yaffs_Device *dev, yaffs_Object *obj);
index 358e464..8bb5ed7 100644 (file)
@@ -644,9 +644,9 @@ void yaffs_set_obj_name_from_oh(yaffs_Object *obj, const yaffs_ObjectHeader *oh)
  */
 
 
-yaffs_Tnode *yaffs_get_tnode(yaffs_Device *dev)
+yaffs_tnode_t *yaffs_get_tnode(yaffs_Device *dev)
 {
-       yaffs_Tnode *tn = yaffs_alloc_raw_tnode(dev);
+       yaffs_tnode_t *tn = yaffs_alloc_raw_tnode(dev);
        if (tn){
                memset(tn, 0, dev->tnodeSize);
                dev->nTnodes++;
@@ -658,7 +658,7 @@ yaffs_Tnode *yaffs_get_tnode(yaffs_Device *dev)
 }
 
 /* FreeTnode frees up a tnode and puts it back on the free list */
-static void yaffs_free_tnode(yaffs_Device *dev, yaffs_Tnode *tn)
+static void yaffs_free_tnode(yaffs_Device *dev, yaffs_tnode_t *tn)
 {
        yaffs_free_raw_tnode(dev,tn);
        dev->nTnodes--;
@@ -673,7 +673,7 @@ static void yaffs_deinit_tnodes_and_objs(yaffs_Device *dev)
 }
 
 
-void yaffs_load_tnode_0(yaffs_Device *dev, yaffs_Tnode *tn, unsigned pos,
+void yaffs_load_tnode_0(yaffs_Device *dev, yaffs_tnode_t *tn, unsigned pos,
                unsigned val)
 {
        __u32 *map = (__u32 *)tn;
@@ -703,7 +703,7 @@ void yaffs_load_tnode_0(yaffs_Device *dev, yaffs_Tnode *tn, unsigned pos,
        }
 }
 
-__u32 yaffs_get_group_base(yaffs_Device *dev, yaffs_Tnode *tn,
+__u32 yaffs_get_group_base(yaffs_Device *dev, yaffs_tnode_t *tn,
                unsigned pos)
 {
        __u32 *map = (__u32 *)tn;
@@ -740,11 +740,11 @@ __u32 yaffs_get_group_base(yaffs_Device *dev, yaffs_Tnode *tn,
  */
 
 /* FindLevel0Tnode finds the level 0 tnode, if one exists. */
-yaffs_Tnode *yaffs_find_tnode_0(yaffs_Device *dev,
+yaffs_tnode_t *yaffs_find_tnode_0(yaffs_Device *dev,
                                        yaffs_FileStructure *fStruct,
                                        __u32 chunkId)
 {
-       yaffs_Tnode *tn = fStruct->top;
+       yaffs_tnode_t *tn = fStruct->top;
        __u32 i;
        int requiredTallness;
        int level = fStruct->topLevel;
@@ -794,15 +794,15 @@ yaffs_Tnode *yaffs_find_tnode_0(yaffs_Device *dev,
  *  be plugged into the ttree.
  */
 
-yaffs_Tnode *yaffs_add_find_tnode_0(yaffs_Device *dev,
+yaffs_tnode_t *yaffs_add_find_tnode_0(yaffs_Device *dev,
                                        yaffs_FileStructure *fStruct,
                                        __u32 chunkId,
-                                       yaffs_Tnode *passedTn)
+                                       yaffs_tnode_t *passedTn)
 {
        int requiredTallness;
        int i;
        int l;
-       yaffs_Tnode *tn;
+       yaffs_tnode_t *tn;
 
        __u32 x;
 
@@ -924,7 +924,7 @@ static int yaffs_find_chunk_in_group(yaffs_Device *dev, int theChunk,
  * Returns 0 if it stopped early due to hitting the limit and the delete is incomplete.
  */
 
-static int yaffs_del_worker(yaffs_Object *in, yaffs_Tnode *tn, __u32 level,
+static int yaffs_del_worker(yaffs_Object *in, yaffs_tnode_t *tn, __u32 level,
                              int chunkOffset, int *limit)
 {
        int i;
@@ -1035,7 +1035,7 @@ static void yaffs_soft_del_chunk(yaffs_Device *dev, int chunk)
  * Thus, essentially this is the same as DeleteWorker except that the chunks are soft deleted.
  */
 
-static int yaffs_soft_del_worker(yaffs_Object *in, yaffs_Tnode *tn,
+static int yaffs_soft_del_worker(yaffs_Object *in, yaffs_tnode_t *tn,
                                  __u32 level, int chunkOffset)
 {
        int i;
@@ -1131,7 +1131,7 @@ static void yaffs_soft_del_file(yaffs_Object *obj)
  * If there is no data in a subtree then it is pruned.
  */
 
-static yaffs_Tnode *yaffs_prune_worker(yaffs_Device *dev, yaffs_Tnode *tn,
+static yaffs_tnode_t *yaffs_prune_worker(yaffs_Device *dev, yaffs_tnode_t *tn,
                                __u32 level, int del0)
 {
        int i;
@@ -1181,7 +1181,7 @@ static int yaffs_prune_tree(yaffs_Device *dev,
        int i;
        int hasData;
        int done = 0;
-       yaffs_Tnode *tn;
+       yaffs_tnode_t *tn;
 
        if (fStruct->topLevel > 0) {
                fStruct->top =
@@ -1440,7 +1440,7 @@ yaffs_Object *yaffs_new_obj(yaffs_Device *dev, int number,
                                    yaffs_ObjectType type)
 {
        yaffs_Object *theObject=NULL;
-       yaffs_Tnode *tn = NULL;
+       yaffs_tnode_t *tn = NULL;
 
        if (number < 0)
                number = yaffs_new_obj_id(dev);
@@ -1467,7 +1467,7 @@ yaffs_Object *yaffs_new_obj(yaffs_Device *dev, int number,
                yaffs_hash_obj(theObject);
                theObject->variantType = type;
 #ifdef CONFIG_YAFFS_WINCE
-               yfsd_WinFileTimeNow(theObject->win_atime);
+               yfsd_win_file_time_now(theObject->win_atime);
                theObject->win_ctime[0] = theObject->win_mtime[0] =
                    theObject->win_atime[0];
                theObject->win_ctime[1] = theObject->win_mtime[1] =
@@ -1592,7 +1592,7 @@ static yaffs_Object *yaffs_create_obj(yaffs_ObjectType type,
                in->yst_mode = mode;
 
 #ifdef CONFIG_YAFFS_WINCE
-               yfsd_WinFileTimeNow(in->win_atime);
+               yfsd_win_file_time_now(in->win_atime);
                in->win_ctime[0] = in->win_mtime[0] = in->win_atime[0];
                in->win_ctime[1] = in->win_mtime[1] = in->win_atime[1];
 
@@ -2660,7 +2660,7 @@ static int yaffs_find_chunk_in_file(yaffs_Object *in, int chunkInInode,
                                 yaffs_ExtendedTags *tags)
 {
        /*Get the Tnode, then get the level 0 offset chunk offset */
-       yaffs_Tnode *tn;
+       yaffs_tnode_t *tn;
        int theChunk = -1;
        yaffs_ExtendedTags localTags;
        int retVal = -1;
@@ -2688,7 +2688,7 @@ static int yaffs_find_del_file_chunk(yaffs_Object *in, int chunkInInode,
                                          yaffs_ExtendedTags *tags)
 {
        /* Get the Tnode, then get the level 0 offset chunk offset */
-       yaffs_Tnode *tn;
+       yaffs_tnode_t *tn;
        int theChunk = -1;
        yaffs_ExtendedTags localTags;
 
@@ -2729,7 +2729,7 @@ int yaffs_put_chunk_in_file(yaffs_Object *in, int chunkInInode,
         * chunkInNAND = 0 is a dummy insert to make sure the tnodes are there.
         */
 
-       yaffs_Tnode *tn;
+       yaffs_tnode_t *tn;
        yaffs_Device *dev = in->myDev;
        int existingChunk;
        yaffs_ExtendedTags existingTags;
@@ -3855,7 +3855,7 @@ int yaffs_flush_file(yaffs_Object *in, int updateTime, int dataSync)
                else {
                        if (updateTime) {
 #ifdef CONFIG_YAFFS_WINCE
-                               yfsd_WinFileTimeNow(in->win_mtime);
+                               yfsd_win_file_time_now(in->win_mtime);
 #else
 
                                in->yst_mtime = Y_CURRENT_TIME;
@@ -4116,7 +4116,7 @@ static int yaffs_unlink_obj(yaffs_Object *obj)
        return YAFFS_FAIL;
 
 }
-int yaffs_Unlink(yaffs_Object *dir, const YCHAR *name)
+int yaffs_unlinker(yaffs_Object *dir, const YCHAR *name)
 {
        yaffs_Object *obj;
 
@@ -5247,8 +5247,8 @@ int yaffs_guts_initialise(yaffs_Device *dev)
                dev->chunkGroupBits = bits - dev->tnodeWidth;
 
        dev->tnodeSize = (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8;
-       if(dev->tnodeSize < sizeof(yaffs_Tnode))
-               dev->tnodeSize = sizeof(yaffs_Tnode);
+       if(dev->tnodeSize < sizeof(yaffs_tnode_t))
+               dev->tnodeSize = sizeof(yaffs_tnode_t);
 
        dev->chunkGroupSize = 1 << dev->chunkGroupBits;
 
@@ -5533,9 +5533,9 @@ int yaffs_get_n_free_chunks(yaffs_Device *dev)
 static int yaffs_check_structures(void)
 {
 /*      yaffs_check_struct(yaffs_Tags,8,"yaffs_Tags"); */
-/*      yaffs_check_struct(yaffs_TagsUnion,8,"yaffs_TagsUnion"); */
+/*      yaffs_check_struct(yaffs_tags_union_t,8,"yaffs_tags_union_t"); */
 /*      yaffs_check_struct(yaffs_Spare,16,"yaffs_Spare"); */
-/*     yaffs_check_struct(yaffs_Tnode, 2 * YAFFS_NTNODES_LEVEL0, "yaffs_Tnode"); */
+/*     yaffs_check_struct(yaffs_tnode_t, 2 * YAFFS_NTNODES_LEVEL0, "yaffs_tnode_t"); */
 
 #ifndef CONFIG_YAFFS_WINCE
        yaffs_check_struct(yaffs_ObjectHeader, 512, "yaffs_ObjectHeader");
index 3a00d5b..b6cbb8b 100644 (file)
@@ -142,7 +142,7 @@ typedef struct {
 typedef union {
        yaffs_Tags asTags;
        __u8 asBytes[8];
-} yaffs_TagsUnion;
+} yaffs_tags_union_t;
 
 #endif
 
@@ -203,17 +203,17 @@ typedef struct {
 
 /* Spare structure for YAFFS1 */
 typedef struct {
-       __u8 tagByte0;
-       __u8 tagByte1;
-       __u8 tagByte2;
-       __u8 tagByte3;
+       __u8 tb0;
+       __u8 tb1;
+       __u8 tb2;
+       __u8 tb3;
        __u8 pageStatus;        /* set to 0 to delete the chunk */
        __u8 blockStatus;
-       __u8 tagByte4;
-       __u8 tagByte5;
+       __u8 tb4;
+       __u8 tb5;
        __u8 ecc1[3];
-       __u8 tagByte6;
-       __u8 tagByte7;
+       __u8 tb6;
+       __u8 tb7;
        __u8 ecc2[3];
 } yaffs_Spare;
 
@@ -350,12 +350,12 @@ typedef struct {
 
 /*--------------------------- Tnode -------------------------- */
 
-union yaffs_Tnode_union {
-       union yaffs_Tnode_union *internal[YAFFS_NTNODES_INTERNAL];
+union yaffs_tnode_union {
+       union yaffs_tnode_union *internal[YAFFS_NTNODES_INTERNAL];
 
 };
 
-typedef union yaffs_Tnode_union yaffs_Tnode;
+typedef union yaffs_tnode_union yaffs_tnode_t;
 
 
 /*------------------------  Object -----------------------------*/
@@ -371,7 +371,7 @@ typedef struct {
        __u32 scannedFileSize;
        __u32 shrinkSize;
        int topLevel;
-       yaffs_Tnode *top;
+       yaffs_tnode_t *top;
 } yaffs_FileStructure;
 
 typedef struct {
@@ -509,7 +509,7 @@ typedef struct {
        __u8 *buffer;
        int line;       /* track from whence this buffer was allocated */
        int maxLine;
-} yaffs_TempBuffer;
+} yaffs_buffer_t;
 
 /*----------------- Device ---------------------------------*/
 
@@ -730,7 +730,7 @@ struct yaffs_DeviceStruct {
        int nBackgroundDeletions;       /* Count of background deletions. */
 
        /* Temporary buffer management */
-       yaffs_TempBuffer tempBuffer[YAFFS_N_TEMP_BUFFERS];
+       yaffs_buffer_t tempBuffer[YAFFS_N_TEMP_BUFFERS];
        int maxTemp;
        int tempInUse;
        int unmanagedTempAllocations;
@@ -840,7 +840,7 @@ int yaffs_get_n_free_chunks(yaffs_Device *dev);
 int yaffs_rename_obj(yaffs_Object *oldDir, const YCHAR *oldName,
                       yaffs_Object *newDir, const YCHAR *newName);
 
-int yaffs_Unlink(yaffs_Object *dir, const YCHAR *name);
+int yaffs_unlinker(yaffs_Object *dir, const YCHAR *name);
 int yaffs_del_obj(yaffs_Object *obj);
 
 int yaffs_get_obj_name(yaffs_Object *obj, YCHAR *name, int buffSize);
@@ -907,7 +907,7 @@ yaffs_Object *yaffs_LostNFound(yaffs_Device *dev);
 
 #ifdef CONFIG_YAFFS_WINCE
 /* CONFIG_YAFFS_WINCE special stuff */
-void yfsd_WinFileTimeNow(__u32 target[2]);
+void yfsd_win_file_time_now(__u32 target[2]);
 #endif
 
 void yaffs_handle_defered_free(yaffs_Object *obj);
@@ -947,11 +947,11 @@ int yaffs_update_oh(yaffs_Object *in, const YCHAR *name,
 void yaffs_handle_shadowed_obj(yaffs_Device *dev, int objId,
                                int backwardScanning);
 int yaffs_check_alloc_available(yaffs_Device *dev, int nChunks);
-yaffs_Tnode *yaffs_get_tnode(yaffs_Device *dev);
-yaffs_Tnode *yaffs_add_find_tnode_0(yaffs_Device *dev,
+yaffs_tnode_t *yaffs_get_tnode(yaffs_Device *dev);
+yaffs_tnode_t *yaffs_add_find_tnode_0(yaffs_Device *dev,
                                        yaffs_FileStructure *fStruct,
                                        __u32 chunkId,
-                                       yaffs_Tnode *passedTn);
+                                       yaffs_tnode_t *passedTn);
 
 int yaffs_do_file_wr(yaffs_Object *in, const __u8 *buffer, loff_t offset,
                        int nBytes, int writeThrough);
@@ -960,10 +960,10 @@ void yaffs_skip_rest_of_block(yaffs_Device *dev);
 
 int yaffs_count_free_chunks(yaffs_Device *dev);
 
-yaffs_Tnode *yaffs_find_tnode_0(yaffs_Device *dev,
+yaffs_tnode_t *yaffs_find_tnode_0(yaffs_Device *dev,
                                yaffs_FileStructure *fStruct,
                                __u32 chunkId);
 
-__u32 yaffs_get_group_base(yaffs_Device *dev, yaffs_Tnode *tn, unsigned pos);
+__u32 yaffs_get_group_base(yaffs_Device *dev, yaffs_tnode_t *tn, unsigned pos);
 
 #endif
index 3fdcc18..a7984e2 100644 (file)
@@ -163,7 +163,7 @@ void yaffs_init_raw_tnodes_and_objs(yaffs_Device *dev)
 }
 
 
-yaffs_Tnode *yaffs_alloc_raw_tnode(yaffs_Device *dev)
+yaffs_tnode_t *yaffs_alloc_raw_tnode(yaffs_Device *dev)
 {
        yaffs_Allocator *allocator = dev->allocator;
        if(!allocator || !allocator->tnode_cache){
@@ -173,7 +173,7 @@ yaffs_Tnode *yaffs_alloc_raw_tnode(yaffs_Device *dev)
        return kmem_cache_alloc(allocator->tnode_cache, GFP_NOFS);
 }
 
-void yaffs_free_raw_tnode(yaffs_Device *dev, yaffs_Tnode *tn)
+void yaffs_free_raw_tnode(yaffs_Device *dev, yaffs_tnode_t *tn)
 {
        yaffs_Allocator *allocator = dev->allocator;
        kmem_cache_free(allocator->tnode_cache,tn);
index 71cac82..93d03ab 100644 (file)
@@ -66,7 +66,7 @@ void yaffs_calc_tags_ecc(yaffs_Tags *tags)
 {
        /* Calculate an ecc */
 
-       unsigned char *b = ((yaffs_TagsUnion *) tags)->asBytes;
+       unsigned char *b = ((yaffs_tags_union_t *) tags)->asBytes;
        unsigned i, j;
        unsigned ecc = 0;
        unsigned bit = 0;
@@ -95,7 +95,7 @@ int yaffs_check_tags_ecc(yaffs_Tags *tags)
 
        if (ecc && ecc <= 64) {
                /* TODO: Handle the failure better. Retire? */
-               unsigned char *b = ((yaffs_TagsUnion *) tags)->asBytes;
+               unsigned char *b = ((yaffs_tags_union_t *) tags)->asBytes;
 
                ecc--;
 
@@ -119,34 +119,34 @@ int yaffs_check_tags_ecc(yaffs_Tags *tags)
 static void yaffs_load_tags_to_spare(yaffs_Spare *sparePtr,
                                yaffs_Tags *tagsPtr)
 {
-       yaffs_TagsUnion *tu = (yaffs_TagsUnion *) tagsPtr;
+       yaffs_tags_union_t *tu = (yaffs_tags_union_t *) tagsPtr;
 
        yaffs_calc_tags_ecc(tagsPtr);
 
-       sparePtr->tagByte0 = tu->asBytes[0];
-       sparePtr->tagByte1 = tu->asBytes[1];
-       sparePtr->tagByte2 = tu->asBytes[2];
-       sparePtr->tagByte3 = tu->asBytes[3];
-       sparePtr->tagByte4 = tu->asBytes[4];
-       sparePtr->tagByte5 = tu->asBytes[5];
-       sparePtr->tagByte6 = tu->asBytes[6];
-       sparePtr->tagByte7 = tu->asBytes[7];
+       sparePtr->tb0 = tu->asBytes[0];
+       sparePtr->tb1 = tu->asBytes[1];
+       sparePtr->tb2 = tu->asBytes[2];
+       sparePtr->tb3 = tu->asBytes[3];
+       sparePtr->tb4 = tu->asBytes[4];
+       sparePtr->tb5 = tu->asBytes[5];
+       sparePtr->tb6 = tu->asBytes[6];
+       sparePtr->tb7 = tu->asBytes[7];
 }
 
 static void yaffs_get_tags_from_spare(yaffs_Device *dev, yaffs_Spare *sparePtr,
                                yaffs_Tags *tagsPtr)
 {
-       yaffs_TagsUnion *tu = (yaffs_TagsUnion *) tagsPtr;
+       yaffs_tags_union_t *tu = (yaffs_tags_union_t *) tagsPtr;
        int result;
 
-       tu->asBytes[0] = sparePtr->tagByte0;
-       tu->asBytes[1] = sparePtr->tagByte1;
-       tu->asBytes[2] = sparePtr->tagByte2;
-       tu->asBytes[3] = sparePtr->tagByte3;
-       tu->asBytes[4] = sparePtr->tagByte4;
-       tu->asBytes[5] = sparePtr->tagByte5;
-       tu->asBytes[6] = sparePtr->tagByte6;
-       tu->asBytes[7] = sparePtr->tagByte7;
+       tu->asBytes[0] = sparePtr->tb0;
+       tu->asBytes[1] = sparePtr->tb1;
+       tu->asBytes[2] = sparePtr->tb2;
+       tu->asBytes[3] = sparePtr->tb3;
+       tu->asBytes[4] = sparePtr->tb4;
+       tu->asBytes[5] = sparePtr->tb5;
+       tu->asBytes[6] = sparePtr->tb6;
+       tu->asBytes[7] = sparePtr->tb7;
 
        result = yaffs_check_tags_ecc(tagsPtr);
        if (result > 0)
@@ -376,14 +376,14 @@ static int yaffs_verify_cmp(const __u8 *d0, const __u8 *d1,
 {
 
        if (memcmp(d0, d1, YAFFS_BYTES_PER_CHUNK) != 0 ||
-           s0->tagByte0 != s1->tagByte0 ||
-           s0->tagByte1 != s1->tagByte1 ||
-           s0->tagByte2 != s1->tagByte2 ||
-           s0->tagByte3 != s1->tagByte3 ||
-           s0->tagByte4 != s1->tagByte4 ||
-           s0->tagByte5 != s1->tagByte5 ||
-           s0->tagByte6 != s1->tagByte6 ||
-           s0->tagByte7 != s1->tagByte7 ||
+           s0->tb0 != s1->tb0 ||
+           s0->tb1 != s1->tb1 ||
+           s0->tb2 != s1->tb2 ||
+           s0->tb3 != s1->tb3 ||
+           s0->tb4 != s1->tb4 ||
+           s0->tb5 != s1->tb5 ||
+           s0->tb6 != s1->tb6 ||
+           s0->tb7 != s1->tb7 ||
            s0->ecc1[0] != s1->ecc1[0] ||
            s0->ecc1[1] != s1->ecc1[1] ||
            s0->ecc1[2] != s1->ecc1[2] ||
index b231799..8285702 100644 (file)
@@ -218,7 +218,7 @@ void yaffs_verify_oh(yaffs_Object *obj, yaffs_ObjectHeader *oh, yaffs_ExtendedTa
 
 #if 0
 /* Not being used, but don't want to throw away yet */
-int yaffs_verify_tnode_worker(yaffs_Object *obj, yaffs_Tnode *tn,
+int yaffs_verify_tnode_worker(yaffs_Object *obj, yaffs_tnode_t *tn,
                                        __u32 level, int chunkOffset)
 {
        int i;
@@ -274,7 +274,7 @@ void yaffs_verify_file(yaffs_Object *obj)
        __u32 i;
        yaffs_Device *dev;
        yaffs_ExtendedTags tags;
-       yaffs_Tnode *tn;
+       yaffs_tnode_t *tn;
        __u32 objectId;
 
        if (!obj)
@@ -574,7 +574,7 @@ int yaffs_verify_file_sane(yaffs_Object *in)
        int fSize;
        int failed = 0;
        int objId;
-       yaffs_Tnode *tn;
+       yaffs_tnode_t *tn;
        yaffs_Tags localTags;
        yaffs_Tags *tags = &localTags;
        int theChunk;
index 5e18574..5f51070 100644 (file)
@@ -1405,7 +1405,7 @@ static int yaffs_unlink(struct inode *dir, struct dentry *dentry)
 
        yaffs_gross_lock(dev);
 
-       retVal = yaffs_Unlink(obj, dentry->d_name.name);
+       retVal = yaffs_unlinker(obj, dentry->d_name.name);
 
        if (retVal == YAFFS_OK) {
                dentry->d_inode->i_nlink--;
@@ -2196,7 +2196,7 @@ static int yaffs_parse_options(yaffs_options *options, const char *options_str)
        return error;
 }
 
-static struct super_block *yaffs_internal_read_super(int yaffsVersion,
+static struct super_block *yaffs_internal_read_super(int yaffs_version,
                                                struct super_block *sb,
                                                void *data, int silent)
 {
@@ -2257,7 +2257,7 @@ static struct super_block *yaffs_internal_read_super(int yaffsVersion,
        sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
 
        T(YAFFS_TRACE_OS,
-               (TSTR("yaffs_read_super: Using yaffs%d\n"), yaffsVersion));
+               (TSTR("yaffs_read_super: Using yaffs%d\n"), yaffs_version));
        T(YAFFS_TRACE_OS,
                (TSTR("yaffs_read_super: block size %d\n"),
                (int)(sb->s_blocksize)));
@@ -2301,22 +2301,22 @@ static struct super_block *yaffs_internal_read_super(int yaffsVersion,
 
 #ifdef CONFIG_YAFFS_AUTO_YAFFS2
 
-       if (yaffsVersion == 1 && WRITE_SIZE(mtd) >= 2048) {
+       if (yaffs_version == 1 && WRITE_SIZE(mtd) >= 2048) {
                T(YAFFS_TRACE_ALWAYS,
                        (TSTR("yaffs: auto selecting yaffs2\n")));
-               yaffsVersion = 2;
+               yaffs_version = 2;
        }
 
        /* Added NCB 26/5/2006 for completeness */
-       if (yaffsVersion == 2 && !options.inband_tags && WRITE_SIZE(mtd) == 512) {
+       if (yaffs_version == 2 && !options.inband_tags && WRITE_SIZE(mtd) == 512) {
                T(YAFFS_TRACE_ALWAYS,
                        (TSTR("yaffs: auto selecting yaffs1\n")));
-               yaffsVersion = 1;
+               yaffs_version = 1;
        }
 
 #endif
 
-       if (yaffsVersion == 2) {
+       if (yaffs_version == 2) {
                /* Check for version 2 style functions */
                if (!mtd->erase ||
                    !mtd->block_isbad ||
@@ -2456,7 +2456,7 @@ static struct super_block *yaffs_internal_read_super(int yaffsVersion,
                param->emptyLostAndFound = options.empty_lost_and_found;
 
        /* ... and the functions. */
-       if (yaffsVersion == 2) {
+       if (yaffs_version == 2) {
                param->writeChunkWithTagsToNAND =
                    nandmtd2_WriteChunkWithTagsToNAND;
                param->readChunkWithTagsFromNAND =
index e495153..a24e61f 100644 (file)
@@ -1805,7 +1805,7 @@ static int yaffs_unlink(struct inode *dir, struct dentry *dentry)
 
        yaffs_gross_lock(dev);
 
-       retVal = yaffs_Unlink(obj, dentry->d_name.name);
+       retVal = yaffs_unlinker(obj, dentry->d_name.name);
 
        if (retVal == YAFFS_OK) {
                dentry->d_inode->i_nlink--;
@@ -2677,7 +2677,7 @@ static int yaffs_parse_options(yaffs_options *options, const char *options_str)
        return error;
 }
 
-static struct super_block *yaffs_internal_read_super(int yaffsVersion,
+static struct super_block *yaffs_internal_read_super(int yaffs_version,
                                                struct super_block *sb,
                                                void *data, int silent)
 {
@@ -2741,7 +2741,7 @@ static struct super_block *yaffs_internal_read_super(int yaffsVersion,
        sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
 
        T(YAFFS_TRACE_OS,
-               (TSTR("yaffs_read_super: Using yaffs%d\n"), yaffsVersion));
+               (TSTR("yaffs_read_super: Using yaffs%d\n"), yaffs_version));
        T(YAFFS_TRACE_OS,
                (TSTR("yaffs_read_super: block size %d\n"),
                (int)(sb->s_blocksize)));
@@ -2789,22 +2789,22 @@ static struct super_block *yaffs_internal_read_super(int yaffsVersion,
 
 #ifdef CONFIG_YAFFS_AUTO_YAFFS2
 
-       if (yaffsVersion == 1 && WRITE_SIZE(mtd) >= 2048) {
+       if (yaffs_version == 1 && WRITE_SIZE(mtd) >= 2048) {
                T(YAFFS_TRACE_ALWAYS,
                        (TSTR("yaffs: auto selecting yaffs2\n")));
-               yaffsVersion = 2;
+               yaffs_version = 2;
        }
 
        /* Added NCB 26/5/2006 for completeness */
-       if (yaffsVersion == 2 && !options.inband_tags && WRITE_SIZE(mtd) == 512) {
+       if (yaffs_version == 2 && !options.inband_tags && WRITE_SIZE(mtd) == 512) {
                T(YAFFS_TRACE_ALWAYS,
                        (TSTR("yaffs: auto selecting yaffs1\n")));
-               yaffsVersion = 1;
+               yaffs_version = 1;
        }
 
 #endif
 
-       if (yaffsVersion == 2) {
+       if (yaffs_version == 2) {
                /* Check for version 2 style functions */
                if (!mtd->erase ||
                    !mtd->block_isbad ||
@@ -2958,7 +2958,7 @@ static struct super_block *yaffs_internal_read_super(int yaffsVersion,
                param->emptyLostAndFound = options.empty_lost_and_found;
 
        /* ... and the functions. */
-       if (yaffsVersion == 2) {
+       if (yaffs_version == 2) {
                param->writeChunkWithTagsToNAND =
                    nandmtd2_WriteChunkWithTagsToNAND;
                param->readChunkWithTagsFromNAND =
index 7d177b7..d108399 100644 (file)
@@ -451,7 +451,7 @@ static int taffs2_checkpt_obj_to_obj(yaffs_Object *obj, yaffs_CheckpointObject *
 
 
 
-static int yaffs2_checkpt_tnode_worker(yaffs_Object *in, yaffs_Tnode *tn,
+static int yaffs2_checkpt_tnode_worker(yaffs_Object *in, yaffs_tnode_t *tn,
                                        __u32 level, int chunkOffset)
 {
        int i;
@@ -505,7 +505,7 @@ static int yaffs2_rd_checkpt_tnodes(yaffs_Object *obj)
        int ok = 1;
        yaffs_Device *dev = obj->myDev;
        yaffs_FileStructure *fileStructPtr = &obj->variant.fileVariant;
-       yaffs_Tnode *tn;
+       yaffs_tnode_t *tn;
        int nread = 0;
 
        ok = (yaffs2_checkpt_rd(dev, &baseChunk, sizeof(baseChunk)) == sizeof(baseChunk));