yaffs: More clean up
authorCharles Manning <cdhmanning@gmail.com>
Mon, 1 Nov 2010 22:57:35 +0000 (11:57 +1300)
committerCharles Manning <cdhmanning@gmail.com>
Mon, 1 Nov 2010 22:57:35 +0000 (11:57 +1300)
Signed-off-by: Charles Manning <cdhmanning@gmail.com>
59 files changed:
direct/basic-test/dtest.c
direct/basic-test/yaffs_fileem.c
direct/basic-test/yaffs_fileem2k.c
direct/basic-test/yaffs_norif1.c
direct/basic-test/yaffs_norif1.h
direct/basic-test/yaffs_ramdisk.c
direct/basic-test/yaffs_ramdisk.h
direct/basic-test/yaffs_ramem2k.c
direct/basic-test/yaffscfg.c
direct/basic-test/yaffscfg2k.c
direct/basic-test/yramsim.c
direct/basic-test/yramsim.h
direct/yaffs_flashif.c
direct/yaffs_flashif.h
direct/yaffs_flashif2.h
direct/yaffs_nandemul2k.h
direct/yaffs_nandif.c
direct/yaffs_nandif.h
direct/yaffscfg.h
direct/yaffsfs.c
direct/yaffsfs.h
patches/yaffs_linux_allocator.c
patches/yaffs_mtdif2.c
utils/mkyaffs2image.c
utils/mkyaffsimage.c
yaffs_allocator.c
yaffs_allocator.h
yaffs_bitmap.c
yaffs_bitmap.h
yaffs_checkptrw.c
yaffs_checkptrw.h
yaffs_getblockinfo.h
yaffs_guts.c
yaffs_guts.h
yaffs_linux.h
yaffs_mtd1f1_single.c
yaffs_mtd1f2_single.c
yaffs_mtdif.c
yaffs_mtdif.h
yaffs_mtdif1.h
yaffs_mtdif2.h
yaffs_nand.c
yaffs_nand.h
yaffs_packedtags1.c
yaffs_packedtags1.h
yaffs_packedtags2.c
yaffs_packedtags2.h
yaffs_tagscompat.c
yaffs_tagscompat.h
yaffs_tagsvalidity.c
yaffs_tagsvalidity.h
yaffs_verify.c
yaffs_verify.h
yaffs_vfs_multi.c
yaffs_vfs_single.c
yaffs_yaffs1.c
yaffs_yaffs1.h
yaffs_yaffs2.c
yaffs_yaffs2.h

index a0106a9..e6a0a14 100644 (file)
@@ -2642,7 +2642,7 @@ void big_xattr_test(const char *mountpt)
 }
 
 
-void dump_dev_stats(yaffs_dev_t *dev, const char * str)
+void dump_dev_stats(struct yaffs_dev *dev, const char * str)
 {
        printf("%s\n",str);
        printf( "space free %d erased %d "
@@ -2658,7 +2658,7 @@ void test_flash_traffic(const char *mountpt)
        char name0[100];
        char name1[100];
        int i;
-       yaffs_dev_t *dev;
+       struct yaffs_dev *dev;
 
        yaffs_trace_mask = 0;
 
index 330e0dc..3a63aee 100644 (file)
@@ -62,7 +62,7 @@ typedef struct
 
 static yflash_Device filedisk;
 
-static int  CheckInit(yaffs_dev_t *dev)
+static int  CheckInit(struct yaffs_dev *dev)
 {
        static int initialised = 0;
        
@@ -118,7 +118,7 @@ static int  CheckInit(yaffs_dev_t *dev)
        return 1;
 }
 
-int yflash_WriteChunkToNAND(yaffs_dev_t *dev,int nand_chunk,const u8 *data, const yaffs_spare *spare)
+int yflash_WriteChunkToNAND(struct yaffs_dev *dev,int nand_chunk,const u8 *data, const yaffs_spare *spare)
 {
        int written;
 
@@ -148,7 +148,7 @@ int yflash_WriteChunkToNAND(yaffs_dev_t *dev,int nand_chunk,const u8 *data, cons
 }
 
 
-int yflash_ReadChunkFromNAND(yaffs_dev_t *dev,int nand_chunk, u8 *data, yaffs_spare *spare)
+int yflash_ReadChunkFromNAND(struct yaffs_dev *dev,int nand_chunk, u8 *data, yaffs_spare *spare)
 {
        int nread;
 
@@ -178,7 +178,7 @@ int yflash_ReadChunkFromNAND(yaffs_dev_t *dev,int nand_chunk, u8 *data, yaffs_sp
 }
 
 
-int yflash_EraseBlockInNAND(yaffs_dev_t *dev, int blockNumber)
+int yflash_EraseBlockInNAND(struct yaffs_dev *dev, int blockNumber)
 {
 
        int i;
@@ -208,7 +208,7 @@ int yflash_EraseBlockInNAND(yaffs_dev_t *dev, int blockNumber)
        
 }
 
-int yflash_InitialiseNAND(yaffs_dev_t *dev)
+int yflash_InitialiseNAND(struct yaffs_dev *dev)
 {
        
        return YAFFS_OK;
index 44a1e87..4667142 100644 (file)
@@ -171,7 +171,7 @@ int yflash2_GetNumberOfBlocks(void)
        return filedisk.nBlocks;
 }
 
-int yflash2_WriteChunkWithTagsToNAND(yaffs_dev_t *dev,int nand_chunk,const u8 *data, const yaffs_ext_tags *tags)
+int yflash2_WriteChunkWithTagsToNAND(struct yaffs_dev *dev,int nand_chunk,const u8 *data, const struct yaffs_ext_tags *tags)
 {
        int written;
        int pos;
@@ -255,8 +255,8 @@ int yflash2_WriteChunkWithTagsToNAND(yaffs_dev_t *dev,int nand_chunk,const u8 *d
                        if( 0 && dev->param.is_yaffs2)
                        {
                        
-                               written = write(h,tags,sizeof(yaffs_ext_tags));
-                               if(written != sizeof(yaffs_ext_tags)) return YAFFS_FAIL;
+                               written = write(h,tags,sizeof(struct yaffs_ext_tags));
+                               if(written != sizeof(struct yaffs_ext_tags)) return YAFFS_FAIL;
                        }
                        else
                        {
@@ -333,8 +333,8 @@ int yflash2_WriteChunkWithTagsToNAND(yaffs_dev_t *dev,int nand_chunk,const u8 *d
                        if( 0 && dev->param.is_yaffs2)
                        {
                        
-                               written = write(h,tags,sizeof(yaffs_ext_tags));
-                               if(written != sizeof(yaffs_ext_tags)) return YAFFS_FAIL;
+                               written = write(h,tags,sizeof(struct yaffs_ext_tags));
+                               if(written != sizeof(struct yaffs_ext_tags)) return YAFFS_FAIL;
                        }
                        else
                        {
@@ -388,7 +388,7 @@ static int fail320 = 1;
 
 static int failRead10 = 2;
 
-int yflash2_ReadChunkWithTagsFromNAND(yaffs_dev_t *dev,int nand_chunk, u8 *data, yaffs_ext_tags *tags)
+int yflash2_ReadChunkWithTagsFromNAND(struct yaffs_dev *dev,int nand_chunk, u8 *data, struct yaffs_ext_tags *tags)
 {
        int nread;
        int pos;
@@ -458,10 +458,10 @@ int yflash2_ReadChunkWithTagsFromNAND(yaffs_dev_t *dev,int nand_chunk, u8 *data,
 
                        if(0 && dev->param.is_yaffs2)
                        {
-                               nread= read(h,tags,sizeof(yaffs_ext_tags));
-                               if(nread != sizeof(yaffs_ext_tags))
+                               nread= read(h,tags,sizeof(struct yaffs_ext_tags));
+                               if(nread != sizeof(struct yaffs_ext_tags))
                                         retval =  YAFFS_FAIL;
-                               if(yaffs_check_all_ff((u8 *)tags,sizeof(yaffs_ext_tags)))
+                               if(yaffs_check_all_ff((u8 *)tags,sizeof(struct yaffs_ext_tags)))
                                {
                                        yaffs_init_tags(tags);
                                }
@@ -508,7 +508,7 @@ int yflash2_ReadChunkWithTagsFromNAND(yaffs_dev_t *dev,int nand_chunk, u8 *data,
 }
 
 
-int yflash2_MarkNANDBlockBad(struct yaffs_dev_s *dev, int block_no)
+int yflash2_MarkNANDBlockBad(struct yaffs_dev *dev, int block_no)
 {
        int written;
        int h;
@@ -529,7 +529,7 @@ int yflash2_MarkNANDBlockBad(struct yaffs_dev_s *dev, int block_no)
        
 }
 
-int yflash2_EraseBlockInNAND(yaffs_dev_t *dev, int blockNumber)
+int yflash2_EraseBlockInNAND(struct yaffs_dev *dev, int blockNumber)
 {
 
        int i;
@@ -570,7 +570,7 @@ int yflash2_EraseBlockInNAND(yaffs_dev_t *dev, int blockNumber)
        
 }
 
-int yflash2_InitialiseNAND(yaffs_dev_t *dev)
+int yflash2_InitialiseNAND(struct yaffs_dev *dev)
 {
        CheckInit();
        
@@ -580,9 +580,9 @@ int yflash2_InitialiseNAND(yaffs_dev_t *dev)
 
 
 
-int yflash2_QueryNANDBlock(struct yaffs_dev_s *dev, int block_no, yaffs_block_state_t *state, u32 *seq_number)
+int yflash2_QueryNANDBlock(struct yaffs_dev *dev, int block_no, yaffs_block_state_t *state, u32 *seq_number)
 {
-       yaffs_ext_tags tags;
+       struct yaffs_ext_tags tags;
        int chunkNo;
 
        *seq_number = 0;
index cde36a9..40039af 100644 (file)
@@ -88,7 +88,7 @@ const char *yaffs_norif1_c_version = "$Id: yaffs_norif1.c,v 1.6 2010-02-18 01:18
 #define DEVICE_BASE     (32 * 1024 * 1024)
 #endif
 
-u32 *Block2Addr(yaffs_dev_t *dev, int blockNumber)
+u32 *Block2Addr(struct yaffs_dev *dev, int blockNumber)
 {
        u32 addr;
        dev=dev;
@@ -99,7 +99,7 @@ u32 *Block2Addr(yaffs_dev_t *dev, int blockNumber)
        return (u32 *) addr;
 }
 
-u32 *Block2FormatAddr(yaffs_dev_t *dev,int blockNumber)
+u32 *Block2FormatAddr(struct yaffs_dev *dev,int blockNumber)
 {
        u32 addr;
 
@@ -108,7 +108,7 @@ u32 *Block2FormatAddr(yaffs_dev_t *dev,int blockNumber)
        
        return (u32 *)addr;
 }
-u32 *Chunk2DataAddr(yaffs_dev_t *dev,int chunk_id)
+u32 *Chunk2DataAddr(struct yaffs_dev *dev,int chunk_id)
 {
        unsigned block;
        unsigned chunkInBlock;
@@ -123,7 +123,7 @@ u32 *Chunk2DataAddr(yaffs_dev_t *dev,int chunk_id)
        return (u32 *)addr;
 }
 
-u32 *Chunk2SpareAddr(yaffs_dev_t *dev,int chunk_id)
+u32 *Chunk2SpareAddr(struct yaffs_dev *dev,int chunk_id)
 {
        unsigned block;
        unsigned chunkInBlock;
@@ -149,7 +149,7 @@ void ynorif1_AndBytes(u8*target, const u8   *src, int nbytes)
         }
 }
 
-int ynorif1_WriteChunkToNAND(yaffs_dev_t *dev,int nand_chunk,const u8 *data, const yaffs_spare *spare)
+int ynorif1_WriteChunkToNAND(struct yaffs_dev *dev,int nand_chunk,const u8 *data, const yaffs_spare *spare)
 {
         u32 *dataAddr = Chunk2DataAddr(dev,nand_chunk);
         u32 *spareAddr = Chunk2SpareAddr(dev,nand_chunk);
@@ -206,7 +206,7 @@ int ynorif1_WriteChunkToNAND(yaffs_dev_t *dev,int nand_chunk,const u8 *data, con
 
 }
 
-int ynorif1_ReadChunkFromNAND(yaffs_dev_t *dev,int nand_chunk, u8 *data, yaffs_spare *spare)
+int ynorif1_ReadChunkFromNAND(struct yaffs_dev *dev,int nand_chunk, u8 *data, yaffs_spare *spare)
 {
 
        u32 *dataAddr = Chunk2DataAddr(dev,nand_chunk);
@@ -236,7 +236,7 @@ int ynorif1_ReadChunkFromNAND(yaffs_dev_t *dev,int nand_chunk, u8 *data, yaffs_s
 
 }
 
-static int ynorif1_FormatBlock(yaffs_dev_t *dev, int blockNumber)
+static int ynorif1_FormatBlock(struct yaffs_dev *dev, int blockNumber)
 {
        u32 *blockAddr = Block2Addr(dev,blockNumber);
        u32 *formatAddr = Block2FormatAddr(dev,blockNumber);
@@ -248,7 +248,7 @@ static int ynorif1_FormatBlock(yaffs_dev_t *dev, int blockNumber)
        return YAFFS_OK;
 }
 
-static int ynorif1_UnformatBlock(yaffs_dev_t *dev, int blockNumber)
+static int ynorif1_UnformatBlock(struct yaffs_dev *dev, int blockNumber)
 {
        u32 *formatAddr = Block2FormatAddr(dev,blockNumber);
        u32 formatValue = 0;
@@ -258,7 +258,7 @@ static int ynorif1_UnformatBlock(yaffs_dev_t *dev, int blockNumber)
        return YAFFS_OK;
 }
 
-static int ynorif1_IsBlockFormatted(yaffs_dev_t *dev, int blockNumber)
+static int ynorif1_IsBlockFormatted(struct yaffs_dev *dev, int blockNumber)
 {
        u32 *formatAddr = Block2FormatAddr(dev,blockNumber);
        u32 formatValue;
@@ -269,7 +269,7 @@ static int ynorif1_IsBlockFormatted(yaffs_dev_t *dev, int blockNumber)
        return (formatValue == FORMAT_VALUE);
 }
 
-int ynorif1_EraseBlockInNAND(yaffs_dev_t *dev, int blockNumber)
+int ynorif1_EraseBlockInNAND(struct yaffs_dev *dev, int blockNumber)
 {
 
        if(blockNumber < 0 || blockNumber >= BLOCKS_IN_DEVICE)
@@ -286,7 +286,7 @@ int ynorif1_EraseBlockInNAND(yaffs_dev_t *dev, int blockNumber)
        
 }
 
-int ynorif1_InitialiseNAND(yaffs_dev_t *dev)
+int ynorif1_InitialiseNAND(struct yaffs_dev *dev)
 {
        int i;
        
@@ -300,7 +300,7 @@ int ynorif1_InitialiseNAND(yaffs_dev_t *dev)
        return YAFFS_OK;
 }
 
-int ynorif1_Deinitialise_flash_fn(yaffs_dev_t *dev)
+int ynorif1_Deinitialise_flash_fn(struct yaffs_dev *dev)
 {
        dev=dev;        
        ynorif1_FlashDeinit();
index 780b2d3..ad140e5 100644 (file)
 
 #include "yaffs_guts.h"
 
-int ynorif1_WriteChunkToNAND(yaffs_dev_t *dev,int nand_chunk,const u8 *data, const yaffs_spare *spare);
-int ynorif1_ReadChunkFromNAND(yaffs_dev_t *dev,int nand_chunk, u8 *data, yaffs_spare *spare);
-int ynorif1_EraseBlockInNAND(yaffs_dev_t *dev, int blockNumber);
-int ynorif1_InitialiseNAND(yaffs_dev_t *dev);
-int ynorif1_Deinitialise_flash_fn(yaffs_dev_t *dev);
+int ynorif1_WriteChunkToNAND(struct yaffs_dev *dev,int nand_chunk,const u8 *data, const yaffs_spare *spare);
+int ynorif1_ReadChunkFromNAND(struct yaffs_dev *dev,int nand_chunk, u8 *data, yaffs_spare *spare);
+int ynorif1_EraseBlockInNAND(struct yaffs_dev *dev, int blockNumber);
+int ynorif1_InitialiseNAND(struct yaffs_dev *dev);
+int ynorif1_Deinitialise_flash_fn(struct yaffs_dev *dev);
 
 #endif
 
index a65dcc8..e9fe6dc 100644 (file)
@@ -61,7 +61,7 @@ typedef struct
 
 static yramdisk_device ramdisk;
 
-static int  CheckInit(yaffs_dev_t *dev)
+static int  CheckInit(struct yaffs_dev *dev)
 {
        static int initialised = 0;
        
@@ -119,7 +119,7 @@ static int  CheckInit(yaffs_dev_t *dev)
        return 1;
 }
 
-int yramdisk_wr_chunk(yaffs_dev_t *dev,int nand_chunk,const u8 *data, const yaffs_ext_tags *tags)
+int yramdisk_wr_chunk(struct yaffs_dev *dev,int nand_chunk,const u8 *data, const struct yaffs_ext_tags *tags)
 {
        int blk;
        int pg;
@@ -150,7 +150,7 @@ int yramdisk_wr_chunk(yaffs_dev_t *dev,int nand_chunk,const u8 *data, const yaff
 }
 
 
-int yramdisk_rd_chunk(yaffs_dev_t *dev,int nand_chunk, u8 *data, yaffs_ext_tags *tags)
+int yramdisk_rd_chunk(struct yaffs_dev *dev,int nand_chunk, u8 *data, struct yaffs_ext_tags *tags)
 {
        int blk;
        int pg;
@@ -181,7 +181,7 @@ int yramdisk_rd_chunk(yaffs_dev_t *dev,int nand_chunk, u8 *data, yaffs_ext_tags
 }
 
 
-int yramdisk_check_chunk_erased(yaffs_dev_t *dev,int nand_chunk)
+int yramdisk_check_chunk_erased(struct yaffs_dev *dev,int nand_chunk)
 {
        int blk;
        int pg;
@@ -206,7 +206,7 @@ int yramdisk_check_chunk_erased(yaffs_dev_t *dev,int nand_chunk)
 
 }
 
-int yramdisk_erase(yaffs_dev_t *dev, int blockNumber)
+int yramdisk_erase(struct yaffs_dev *dev, int blockNumber)
 {
        
        CheckInit(dev);
@@ -224,7 +224,7 @@ int yramdisk_erase(yaffs_dev_t *dev, int blockNumber)
        
 }
 
-int yramdisk_initialise(yaffs_dev_t *dev)
+int yramdisk_initialise(struct yaffs_dev *dev)
 {
        //dev->use_nand_ecc = 1; // force on use_nand_ecc which gets faked. 
                                                 // This saves us doing ECC checks.
index 88134f6..c29efbe 100644 (file)
 
 
 #include "yaffs_guts.h"
-int yramdisk_erase(yaffs_dev_t *dev, int blockNumber);
-int yramdisk_wr_chunk(yaffs_dev_t *dev,int nand_chunk,const u8 *data, const yaffs_ext_tags *tags);
-int yramdisk_rd_chunk(yaffs_dev_t *dev,int nand_chunk, u8 *data, yaffs_ext_tags *tags);
-int yramdisk_initialise(yaffs_dev_t *dev);
-int yramdisk_mark_block_bad(yaffs_dev_t *dev,int blockNumber);
-int yramdisk_query_block(yaffs_dev_t *dev, int block_no, yaffs_block_state_t *state, int *seq_number);
+int yramdisk_erase(struct yaffs_dev *dev, int blockNumber);
+int yramdisk_wr_chunk(struct yaffs_dev *dev,int nand_chunk,const u8 *data, const struct yaffs_ext_tags *tags);
+int yramdisk_rd_chunk(struct yaffs_dev *dev,int nand_chunk, u8 *data, struct yaffs_ext_tags *tags);
+int yramdisk_initialise(struct yaffs_dev *dev);
+int yramdisk_mark_block_bad(struct yaffs_dev *dev,int blockNumber);
+int yramdisk_query_block(struct yaffs_dev *dev, int block_no, yaffs_block_state_t *state, int *seq_number);
 #endif
index 7028a82..bbfae31 100644 (file)
@@ -190,7 +190,7 @@ static int  CheckInit(void)
        return 1;
 }
 
-int nandemul2k_WriteChunkWithTagsToNAND(yaffs_dev_t *dev,int nand_chunk,const u8 *data, const yaffs_ext_tags *tags)
+int nandemul2k_WriteChunkWithTagsToNAND(struct yaffs_dev *dev,int nand_chunk,const u8 *data, const struct yaffs_ext_tags *tags)
 {
        int blk;
        int pg;
@@ -233,7 +233,7 @@ int nandemul2k_WriteChunkWithTagsToNAND(yaffs_dev_t *dev,int nand_chunk,const u8
 }
 
 
-int nandemul2k_ReadChunkWithTagsFromNAND(yaffs_dev_t *dev,int nand_chunk, u8 *data, yaffs_ext_tags *tags)
+int nandemul2k_ReadChunkWithTagsFromNAND(struct yaffs_dev *dev,int nand_chunk, u8 *data, struct yaffs_ext_tags *tags)
 {
        int blk;
        int pg;
@@ -263,7 +263,7 @@ int nandemul2k_ReadChunkWithTagsFromNAND(yaffs_dev_t *dev,int nand_chunk, u8 *da
 }
 
 
-static int nandemul2k_CheckChunkErased(yaffs_dev_t *dev,int nand_chunk)
+static int nandemul2k_CheckChunkErased(struct yaffs_dev *dev,int nand_chunk)
 {
        int blk;
        int pg;
@@ -287,7 +287,7 @@ static int nandemul2k_CheckChunkErased(yaffs_dev_t *dev,int nand_chunk)
 
 }
 
-int nandemul2k_EraseBlockInNAND(yaffs_dev_t *dev, int blockNumber)
+int nandemul2k_EraseBlockInNAND(struct yaffs_dev *dev, int blockNumber)
 {
        
        
@@ -307,13 +307,13 @@ int nandemul2k_EraseBlockInNAND(yaffs_dev_t *dev, int blockNumber)
        return YAFFS_OK;
 }
 
-int nandemul2k_InitialiseNAND(yaffs_dev_t *dev)
+int nandemul2k_InitialiseNAND(struct yaffs_dev *dev)
 {
        CheckInit();
        return YAFFS_OK;
 }
  
-int nandemul2k_MarkNANDBlockBad(struct yaffs_dev_s *dev, int block_no)
+int nandemul2k_MarkNANDBlockBad(struct yaffs_dev *dev, int block_no)
 {
        
        u8 *x;
@@ -327,9 +327,9 @@ int nandemul2k_MarkNANDBlockBad(struct yaffs_dev_s *dev, int block_no)
        
 }
 
-int nandemul2k_QueryNANDBlock(struct yaffs_dev_s *dev, int block_no, yaffs_block_state_t *state, u32  *seq_number)
+int nandemul2k_QueryNANDBlock(struct yaffs_dev *dev, int block_no, yaffs_block_state_t *state, u32  *seq_number)
 {
-       yaffs_ext_tags tags;
+       struct yaffs_ext_tags tags;
        int chunkNo;
 
        *seq_number = 0;
index 250a113..ce86587 100644 (file)
@@ -67,16 +67,16 @@ void yaffsfs_LocalInitialisation(void)
 // /boot 2MB boot disk (flash)
 // /flash 14MB flash disk (flash)
 // NB Though /boot and /flash occupy the same physical device they
-// are still disticnt "yaffs_dev_ts. You may think of these as "partitions"
+// are still disticnt "struct yaffs_devs. You may think of these as "partitions"
 // using non-overlapping areas in the same device.
 // 
 
 #include "yaffs_ramdisk.h"
 #include "yaffs_flashif.h"
 
-static yaffs_dev_t ramDev;
-static yaffs_dev_t bootDev;
-static yaffs_dev_t flashDev;
+static struct yaffs_dev ramDev;
+static struct yaffs_dev bootDev;
+static struct yaffs_dev flashDev;
 
 static yaffsfs_DeviceConfiguration yaffsfs_config[] = {
 
index b05952f..6f7d212 100644 (file)
@@ -106,9 +106,9 @@ void yaffsfs_LocalInitialisation(void)
 #include "yaffs_flashif2.h"
 #include "yaffs_nandemul2k.h"
 
-struct yaffs_dev_s ram1Dev;
-struct yaffs_dev_s flashDev;
-struct yaffs_dev_s m18_1Dev;
+struct yaffs_dev ram1Dev;
+struct yaffs_dev flashDev;
+struct yaffs_dev m18_1Dev;
 
 int yaffs_start_up(void)
 {
index 05437ff..9b50a39 100644 (file)
@@ -41,7 +41,7 @@ typedef struct {
 
 SimData *simDevs[N_RAM_SIM_DEVS];
 
-static SimData *DevToSim(yaffs_dev_t *dev)
+static SimData *DevToSim(struct yaffs_dev *dev)
 {
        ynandif_Geometry *geom = (ynandif_Geometry *)(dev->driver_context);
        SimData * sim = (SimData*)(geom->privateData);
@@ -77,7 +77,7 @@ static int yramsim_erase_internal(SimData *sim, unsigned blockId,int force)
 
 
 
-static int yramsim_initialise(yaffs_dev_t *dev)
+static int yramsim_initialise(struct yaffs_dev *dev)
 {
        SimData *sim = DevToSim(dev);
        Block **blockList = sim->blockList;
@@ -85,12 +85,12 @@ static int yramsim_initialise(yaffs_dev_t *dev)
 }
 
 
-static int yramsim_deinitialise(yaffs_dev_t *dev)
+static int yramsim_deinitialise(struct yaffs_dev *dev)
 {
        return 1;
 }
 
-static int yramsim_rd_chunk (yaffs_dev_t *dev, unsigned pageId,
+static int yramsim_rd_chunk (struct yaffs_dev *dev, unsigned pageId,
                                          unsigned char *data, unsigned dataLength,
                                          unsigned char *spare, unsigned spareLength,
                                          int *eccStatus)
@@ -125,7 +125,7 @@ static int yramsim_rd_chunk (yaffs_dev_t *dev, unsigned pageId,
        return 1;
 }
 
-static int yramsim_wr_chunk (yaffs_dev_t *dev,unsigned pageId,
+static int yramsim_wr_chunk (struct yaffs_dev *dev,unsigned pageId,
                                           const unsigned char *data, unsigned dataLength,
                                           const unsigned char *spare, unsigned spareLength)
 {
@@ -157,7 +157,7 @@ static int yramsim_wr_chunk (yaffs_dev_t *dev,unsigned pageId,
 }
 
 
-static int yramsim_erase(yaffs_dev_t *dev,unsigned blockId)
+static int yramsim_erase(struct yaffs_dev *dev,unsigned blockId)
 {
        SimData *sim = DevToSim(dev);
 
@@ -165,7 +165,7 @@ static int yramsim_erase(yaffs_dev_t *dev,unsigned blockId)
        return yramsim_erase_internal(sim,blockId,0);
 }
 
-static int yramsim_check_block_ok(yaffs_dev_t *dev,unsigned blockId)
+static int yramsim_check_block_ok(struct yaffs_dev *dev,unsigned blockId)
 {
        SimData *sim = DevToSim(dev);
        Block **blockList = sim->blockList;
@@ -176,7 +176,7 @@ static int yramsim_check_block_ok(yaffs_dev_t *dev,unsigned blockId)
        return blockList[blockId]->blockOk ? 1 : 0;
 }
 
-static int yramsim_mark_block_bad(yaffs_dev_t *dev,unsigned blockId)
+static int yramsim_mark_block_bad(struct yaffs_dev *dev,unsigned blockId)
 {
        SimData *sim = DevToSim(dev);
        Block **blockList = sim->blockList;
@@ -251,7 +251,7 @@ static SimData *yramsim_alloc_sim_data(u32 devId, u32 nBlocks)
 }
 
 
-struct yaffs_dev_s *yramsim_CreateRamSim(const YCHAR *name,
+struct yaffs_dev *yramsim_CreateRamSim(const YCHAR *name,
                                u32 devId, u32 nBlocks,
                                u32 start_block, u32 end_block)
 {
index d4e142f..b27b69f 100644 (file)
@@ -23,7 +23,7 @@
 
 #define N_RAM_SIM_DEVS  2
 
-struct yaffs_dev_s *yramsim_CreateRamSim(const YCHAR *name,
+struct yaffs_dev *yramsim_CreateRamSim(const YCHAR *name,
                                                u32 devId, u32 nBlocks,
                                                u32 start_block, u32 end_block);
 
index 6747bfc..5740bbe 100644 (file)
@@ -50,7 +50,7 @@ typedef struct
 
 static yflash_Device ramdisk;
 
-static int  CheckInit(yaffs_dev_t *dev)
+static int  CheckInit(struct yaffs_dev *dev)
 {
        static int initialised = 0;
        
@@ -108,7 +108,7 @@ static int  CheckInit(yaffs_dev_t *dev)
        return 1;
 }
 
-int yflash_WriteChunkWithTagsToNAND(yaffs_dev_t *dev,int nand_chunk,const u8 *data, yaffs_ext_tags *tags)
+int yflash_WriteChunkWithTagsToNAND(struct yaffs_dev *dev,int nand_chunk,const u8 *data, struct yaffs_ext_tags *tags)
 {
        int blk;
        int pg;
@@ -138,7 +138,7 @@ int yflash_WriteChunkWithTagsToNAND(yaffs_dev_t *dev,int nand_chunk,const u8 *da
 }
 
 
-int yflash_ReadChunkWithTagsFromNAND(yaffs_dev_t *dev,int nand_chunk, u8 *data, yaffs_tags_t *tags)
+int yflash_ReadChunkWithTagsFromNAND(struct yaffs_dev *dev,int nand_chunk, u8 *data, struct yaffs_tags *tags)
 {
        int blk;
        int pg;
@@ -167,7 +167,7 @@ int yflash_ReadChunkWithTagsFromNAND(yaffs_dev_t *dev,int nand_chunk, u8 *data,
 }
 
 
-int yflash_CheckChunkErased(yaffs_dev_t *dev,int nand_chunk)
+int yflash_CheckChunkErased(struct yaffs_dev *dev,int nand_chunk)
 {
        int blk;
        int pg;
@@ -192,7 +192,7 @@ int yflash_CheckChunkErased(yaffs_dev_t *dev,int nand_chunk)
 
 }
 
-int yflash_EraseBlockInNAND(yaffs_dev_t *dev, int blockNumber)
+int yflash_EraseBlockInNAND(struct yaffs_dev *dev, int blockNumber)
 {
        
        CheckInit(dev);
@@ -210,19 +210,19 @@ int yflash_EraseBlockInNAND(yaffs_dev_t *dev, int blockNumber)
        
 }
 
-int yflash_MarkNANDBlockBad(struct yaffs_dev_s *dev, int block_no)
+int yflash_MarkNANDBlockBad(struct yaffs_dev *dev, int block_no)
 {
        return YAFFS_OK;
        
 }
-int yflash_QueryNANDBlock(struct yaffs_dev_s *dev, int block_no, yaffs_block_state_t *state, int *seq_number)
+int yflash_QueryNANDBlock(struct yaffs_dev *dev, int block_no, yaffs_block_state_t *state, int *seq_number)
 {
        *state = YAFFS_BLOCK_STATE_EMPTY;
        *seq_number = 0;
 }
 
 
-int yflash_InitialiseNAND(yaffs_dev_t *dev)
+int yflash_InitialiseNAND(struct yaffs_dev *dev)
 {
        return YAFFS_OK;
 }
index ce7d968..a743147 100644 (file)
 
 
 #include "yaffs_guts.h"
-int yflash_EraseBlockInNAND(yaffs_dev_t *dev, int blockNumber);
-int yflash_WriteChunkToNAND(yaffs_dev_t *dev,int nand_chunk,const u8 *data, const yaffs_spare *spare);
-int yflash_WriteChunkWithTagsToNAND(yaffs_dev_t *dev,int nand_chunk,const u8 *data, const yaffs_ext_tags *tags);
-int yflash_ReadChunkFromNAND(yaffs_dev_t *dev,int nand_chunk, u8 *data, yaffs_spare *spare);
-int yflash_ReadChunkWithTagsFromNAND(yaffs_dev_t *dev,int nand_chunk, u8 *data, yaffs_ext_tags *tags);
-int yflash_InitialiseNAND(yaffs_dev_t *dev);
-int yflash_MarkNANDBlockBad(struct yaffs_dev_s *dev, int block_no);
-int yflash_QueryNANDBlock(struct yaffs_dev_s *dev, int block_no, yaffs_block_state_t *state, u32 *seq_number);
+int yflash_EraseBlockInNAND(struct yaffs_dev *dev, int blockNumber);
+int yflash_WriteChunkToNAND(struct yaffs_dev *dev,int nand_chunk,const u8 *data, const yaffs_spare *spare);
+int yflash_WriteChunkWithTagsToNAND(struct yaffs_dev *dev,int nand_chunk,const u8 *data, const struct yaffs_ext_tags *tags);
+int yflash_ReadChunkFromNAND(struct yaffs_dev *dev,int nand_chunk, u8 *data, yaffs_spare *spare);
+int yflash_ReadChunkWithTagsFromNAND(struct yaffs_dev *dev,int nand_chunk, u8 *data, struct yaffs_ext_tags *tags);
+int yflash_InitialiseNAND(struct yaffs_dev *dev);
+int yflash_MarkNANDBlockBad(struct yaffs_dev *dev, int block_no);
+int yflash_QueryNANDBlock(struct yaffs_dev *dev, int block_no, yaffs_block_state_t *state, u32 *seq_number);
 
 #endif
index 3b704af..2c1a7b9 100644 (file)
 
 
 #include "yaffs_guts.h"
-int yflash2_EraseBlockInNAND(yaffs_dev_t *dev, int blockNumber);
-int yflash2_WriteChunkToNAND(yaffs_dev_t *dev,int nand_chunk,const u8 *data, const yaffs_spare *spare);
-int yflash2_WriteChunkWithTagsToNAND(yaffs_dev_t *dev,int nand_chunk,const u8 *data, const yaffs_ext_tags *tags);
-int yflash2_ReadChunkFromNAND(yaffs_dev_t *dev,int nand_chunk, u8 *data, yaffs_spare *spare);
-int yflash2_ReadChunkWithTagsFromNAND(yaffs_dev_t *dev,int nand_chunk, u8 *data, yaffs_ext_tags *tags);
-int yflash2_EraseBlockInNAND(yaffs_dev_t *dev, int blockNumber);
-int yflash2_InitialiseNAND(yaffs_dev_t *dev);
-int yflash2_MarkNANDBlockBad(struct yaffs_dev_s *dev, int block_no);
-int yflash2_QueryNANDBlock(struct yaffs_dev_s *dev, int block_no, yaffs_block_state_t *state, u32 *seq_number);
+int yflash2_EraseBlockInNAND(struct yaffs_dev *dev, int blockNumber);
+int yflash2_WriteChunkToNAND(struct yaffs_dev *dev,int nand_chunk,const u8 *data, const yaffs_spare *spare);
+int yflash2_WriteChunkWithTagsToNAND(struct yaffs_dev *dev,int nand_chunk,const u8 *data, const struct yaffs_ext_tags *tags);
+int yflash2_ReadChunkFromNAND(struct yaffs_dev *dev,int nand_chunk, u8 *data, yaffs_spare *spare);
+int yflash2_ReadChunkWithTagsFromNAND(struct yaffs_dev *dev,int nand_chunk, u8 *data, struct yaffs_ext_tags *tags);
+int yflash2_EraseBlockInNAND(struct yaffs_dev *dev, int blockNumber);
+int yflash2_InitialiseNAND(struct yaffs_dev *dev);
+int yflash2_MarkNANDBlockBad(struct yaffs_dev *dev, int block_no);
+int yflash2_QueryNANDBlock(struct yaffs_dev *dev, int block_no, yaffs_block_state_t *state, u32 *seq_number);
 
 #endif
index 23d876b..670ef3b 100644 (file)
 
 #include "yaffs_guts.h"
 
-int nandemul2k_WriteChunkWithTagsToNAND(struct yaffs_dev_s *dev,
+int nandemul2k_WriteChunkWithTagsToNAND(struct yaffs_dev *dev,
                                        int nand_chunk, const u8 *data,
-                                       const yaffs_ext_tags *tags);
-int nandemul2k_ReadChunkWithTagsFromNAND(struct yaffs_dev_s *dev,
+                                       const struct yaffs_ext_tags *tags);
+int nandemul2k_ReadChunkWithTagsFromNAND(struct yaffs_dev *dev,
                                         int nand_chunk, u8 *data,
-                                        yaffs_ext_tags *tags);
-int nandemul2k_MarkNANDBlockBad(struct yaffs_dev_s *dev, int block_no);
-int nandemul2k_QueryNANDBlock(struct yaffs_dev_s *dev, int block_no,
+                                        struct yaffs_ext_tags *tags);
+int nandemul2k_MarkNANDBlockBad(struct yaffs_dev *dev, int block_no);
+int nandemul2k_QueryNANDBlock(struct yaffs_dev *dev, int block_no,
                              yaffs_block_state_t *state, u32 *seq_number);
-int nandemul2k_EraseBlockInNAND(struct yaffs_dev_s *dev,
+int nandemul2k_EraseBlockInNAND(struct yaffs_dev *dev,
                                int flash_block);
-int nandemul2k_InitialiseNAND(struct yaffs_dev_s *dev);
+int nandemul2k_InitialiseNAND(struct yaffs_dev *dev);
 int nandemul2k_GetBytesPerChunk(void);
 int nandemul2k_GetChunksPerBlock(void);
 int nandemul2k_GetNumberOfBlocks(void);
index 032017c..a05e901 100644 (file)
@@ -29,9 +29,9 @@
  * We assume that the data buffer is of size totalBytersPerChunk so that we can also
  * use it to load the tags.
  */
-int ynandif_WriteChunkWithTagsToNAND(yaffs_dev_t * dev, int nand_chunk,
+int ynandif_WriteChunkWithTagsToNAND(struct yaffs_dev * dev, int nand_chunk,
                                      const u8 * data,
-                                     const yaffs_ext_tags * tags)
+                                     const struct yaffs_ext_tags * tags)
 {
 
        int retval = 0;
@@ -70,8 +70,8 @@ int ynandif_WriteChunkWithTagsToNAND(yaffs_dev_t * dev, int nand_chunk,
        return retval;
 }
 
-int ynandif_ReadChunkWithTagsFromNAND(yaffs_dev_t * dev, int nand_chunk,
-                                      u8 * data, yaffs_ext_tags * tags)
+int ynandif_ReadChunkWithTagsFromNAND(struct yaffs_dev * dev, int nand_chunk,
+                                      u8 * data, struct yaffs_ext_tags * tags)
 {
        yaffs_packed_tags2 pt;
        int localData = 0;
@@ -139,14 +139,14 @@ int ynandif_ReadChunkWithTagsFromNAND(yaffs_dev_t * dev, int nand_chunk,
        return retval;
 }
 
-int ynandif_MarkNANDBlockBad(struct yaffs_dev_s *dev, int blockId)
+int ynandif_MarkNANDBlockBad(struct yaffs_dev *dev, int blockId)
 {
        ynandif_Geometry *geometry = (ynandif_Geometry *)(dev->driver_context);
 
        return geometry->markBlockBad(dev,blockId);
 }
 
-int ynandif_EraseBlockInNAND(struct yaffs_dev_s *dev, int blockId)
+int ynandif_EraseBlockInNAND(struct yaffs_dev *dev, int blockId)
 {
        ynandif_Geometry *geometry = (ynandif_Geometry *)(dev->driver_context);
 
@@ -155,17 +155,17 @@ int ynandif_EraseBlockInNAND(struct yaffs_dev_s *dev, int blockId)
 }
 
 
-static int ynandif_IsBlockOk(struct yaffs_dev_s *dev, int blockId)
+static int ynandif_IsBlockOk(struct yaffs_dev *dev, int blockId)
 {
        ynandif_Geometry *geometry = (ynandif_Geometry *)(dev->driver_context);
 
        return geometry->checkBlockOk(dev,blockId);
 }
 
-int ynandif_QueryNANDBlock(struct yaffs_dev_s *dev, int blockId, yaffs_block_state_t *state, u32 *seq_number)
+int ynandif_QueryNANDBlock(struct yaffs_dev *dev, int blockId, yaffs_block_state_t *state, u32 *seq_number)
 {
        unsigned chunkNo;
-       yaffs_ext_tags tags;
+       struct yaffs_ext_tags tags;
 
        *seq_number = 0;
        
@@ -193,7 +193,7 @@ int ynandif_QueryNANDBlock(struct yaffs_dev_s *dev, int blockId, yaffs_block_sta
 }
 
 
-int ynandif_InitialiseNAND(yaffs_dev_t *dev)
+int ynandif_InitialiseNAND(struct yaffs_dev *dev)
 {
        ynandif_Geometry *geometry = (ynandif_Geometry *)(dev->driver_context);
 
@@ -202,7 +202,7 @@ int ynandif_InitialiseNAND(yaffs_dev_t *dev)
        return YAFFS_OK;
 }
 
-int ynandif_Deinitialise_flash_fn(yaffs_dev_t *dev)
+int ynandif_Deinitialise_flash_fn(struct yaffs_dev *dev)
 {
        ynandif_Geometry *geometry = (ynandif_Geometry *)(dev->driver_context);
 
@@ -212,15 +212,15 @@ int ynandif_Deinitialise_flash_fn(yaffs_dev_t *dev)
 }
 
 
-struct yaffs_dev_s * 
+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_s *dev = YMALLOC(sizeof(struct yaffs_dev_s));
+       struct yaffs_dev *dev = YMALLOC(sizeof(struct yaffs_dev));
 
        if(dev && clonedName){
-               memset(dev,0,sizeof(struct yaffs_dev_s));
+               memset(dev,0,sizeof(struct yaffs_dev));
                yaffs_strcpy(clonedName,name);
 
                dev->param.name = clonedName;
index e7153aa..acf7e9b 100644 (file)
@@ -30,43 +30,43 @@ typedef struct {
        unsigned inband_tags;
        unsigned useYaffs2;
 
-       int (*initialise)(yaffs_dev_t *dev);
-       int (*deinitialise)(yaffs_dev_t *dev);
+       int (*initialise)(struct yaffs_dev *dev);
+       int (*deinitialise)(struct yaffs_dev *dev);
 
-       int (*readChunk) (yaffs_dev_t *dev,
+       int (*readChunk) (struct yaffs_dev *dev,
                                          unsigned pageId, 
                                          unsigned char *data, unsigned dataLength,
                                          unsigned char *spare, unsigned spareLength,
                                          int *eccStatus);
 // ECC status is set to 0 for OK, 1 for fixed, -1 for unfixed.
 
-       int (*writeChunk)(yaffs_dev_t *dev,
+       int (*writeChunk)(struct yaffs_dev *dev,
                                          unsigned pageId, 
                                          const unsigned char *data, unsigned dataLength,
                                          const unsigned char *spare, unsigned spareLength);
 
-       int (*eraseBlock)(yaffs_dev_t *dev, unsigned blockId);
+       int (*eraseBlock)(struct yaffs_dev *dev, unsigned blockId);
 
-       int (*checkBlockOk)(yaffs_dev_t *dev, unsigned blockId);
-       int (*markBlockBad)(yaffs_dev_t *dev, unsigned blockId);
+       int (*checkBlockOk)(struct yaffs_dev *dev, unsigned blockId);
+       int (*markBlockBad)(struct yaffs_dev *dev, unsigned blockId);
 
        void *privateData;
 
 } ynandif_Geometry;
 
-struct yaffs_dev_s * 
+struct yaffs_dev * 
        yaffs_add_dev_from_geometry(const YCHAR *name,
                                        const ynandif_Geometry *geometry);
 
 #if 0
 
-int ynandif_WriteChunkWithTagsToNAND(yaffs_dev_t *dev,int nand_chunk,const u8 *data, const yaffs_ext_tags *tags);
-int ynandif_ReadChunkWithTagsFromNAND(yaffs_dev_t *dev,int nand_chunk, u8 *data, yaffs_ext_tags *tags);
-int ynandif_EraseBlockInNAND(yaffs_dev_t *dev, int blockNumber);
-int ynandif_InitialiseNAND(yaffs_dev_t *dev);
-int ynandif_MarkNANDBlockBad(yaffs_dev_t *dev,int blockNumber);
-int ynandif_QueryNANDBlock(yaffs_dev_t *dev, int block_no, yaffs_block_state_t *state, u32 *seq_number);
-int ynandif_GetGeometry(yaffs_dev_t *dev, ynandif_Geometry *geometry);
+int ynandif_WriteChunkWithTagsToNAND(struct yaffs_dev *dev,int nand_chunk,const u8 *data, const struct yaffs_ext_tags *tags);
+int ynandif_ReadChunkWithTagsFromNAND(struct yaffs_dev *dev,int nand_chunk, u8 *data, struct yaffs_ext_tags *tags);
+int ynandif_EraseBlockInNAND(struct yaffs_dev *dev, int blockNumber);
+int ynandif_InitialiseNAND(struct yaffs_dev *dev);
+int ynandif_MarkNANDBlockBad(struct yaffs_dev *dev,int blockNumber);
+int ynandif_QueryNANDBlock(struct yaffs_dev *dev, int block_no, yaffs_block_state_t *state, u32 *seq_number);
+int ynandif_GetGeometry(struct yaffs_dev *dev, ynandif_Geometry *geometry);
 #endif
 
 
index 72687e2..3387802 100644 (file)
@@ -31,7 +31,7 @@
 
 typedef struct yaffsfs_DeviceConfigurationStruct {
        const YCHAR *prefix;
-       struct yaffs_dev_s *dev;
+       struct yaffs_dev *dev;
 } yaffsfs_DeviceConfiguration;
 
 
index c7b5ed2..30b1486 100644 (file)
@@ -31,8 +31,8 @@
 #define YAFFSFS_RW_SIZE  (1<<YAFFSFS_RW_SHIFT)
 
 /* Some forward references */
-static yaffs_obj_t *yaffsfs_FindObject(yaffs_obj_t *relativeDirectory, const YCHAR *path, int symDepth, int getEquiv);
-static void yaffsfs_RemoveObjectCallback(yaffs_obj_t *obj);
+static struct yaffs_obj *yaffsfs_FindObject(struct yaffs_obj *relativeDirectory, const YCHAR *path, int symDepth, int getEquiv);
+static void yaffsfs_RemoveObjectCallback(struct yaffs_obj *obj);
 
 unsigned int yaffs_wr_attempts;
 
@@ -49,7 +49,7 @@ unsigned int yaffs_wr_attempts;
 
 typedef struct {
        int count;      /* Number of handles accessing this inode */
-       yaffs_obj_t *iObj;
+       struct yaffs_obj *iObj;
 } yaffsfs_Inode;
 
 typedef struct{
@@ -102,7 +102,7 @@ yaffsfs_Inode *yaffsfs_GetInodePointer(int handle)
        return NULL;
 }
 
-yaffs_obj_t *yaffsfs_GetHandleObject(int handle)
+struct yaffs_obj *yaffsfs_GetHandleObject(int handle)
 {
        yaffsfs_Inode *in = yaffsfs_GetInodePointer(handle);
 
@@ -117,7 +117,7 @@ yaffs_obj_t *yaffsfs_GetHandleObject(int handle)
  * Find the inode entry for an object, if it exists.
  */
 
-static int yaffsfs_FindInodeIdForObject(yaffs_obj_t *obj)
+static int yaffsfs_FindInodeIdForObject(struct yaffs_obj *obj)
 {
        int i;
        int ret = -1;
@@ -137,7 +137,7 @@ static int yaffsfs_FindInodeIdForObject(yaffs_obj_t *obj)
  * yaffsfs_GetInodeIdForObject
  * Grab an inode entry when opening a new inode.
  */
-static int yaffsfs_GetInodeIdForObject(yaffs_obj_t *obj)
+static int yaffsfs_GetInodeIdForObject(struct yaffs_obj *obj)
 {
        int i;
        int ret;
@@ -166,7 +166,7 @@ static int yaffsfs_GetInodeIdForObject(yaffs_obj_t *obj)
 }
 
 
-static int yaffsfs_CountHandles(yaffs_obj_t *obj)
+static int yaffsfs_CountHandles(struct yaffs_obj *obj)
 {
        int i = yaffsfs_FindInodeIdForObject(obj);
 
@@ -178,7 +178,7 @@ static int yaffsfs_CountHandles(yaffs_obj_t *obj)
 
 static void yaffsfs_ReleaseInode(yaffsfs_Inode *in)
 {
-       yaffs_obj_t *obj;
+       struct yaffs_obj *obj;
        
        obj = in->iObj;
 
@@ -299,13 +299,13 @@ YLIST_HEAD(yaffsfs_deviceList);
  * Curveballs: Should match paths that end in '/' too
  * Curveball2 Might have "/x/ and "/x/y". Need to return the longest match
  */
-static yaffs_dev_t *yaffsfs_FindDevice(const YCHAR *path, YCHAR **restOfPath)
+static struct yaffs_dev *yaffsfs_FindDevice(const YCHAR *path, YCHAR **restOfPath)
 {
        struct ylist_head *cfg;
        const YCHAR *leftOver;
        const YCHAR *p;
-       yaffs_dev_t *retval = NULL;
-       yaffs_dev_t *dev = NULL;
+       struct yaffs_dev *retval = NULL;
+       struct yaffs_dev *dev = NULL;
        int thisMatchLength;
        int longestMatch = -1;
        int matching;
@@ -316,7 +316,7 @@ static yaffs_dev_t *yaffsfs_FindDevice(const YCHAR *path, YCHAR **restOfPath)
         * 2) Matches the longest.
         */
        ylist_for_each(cfg, &yaffsfs_deviceList){
-               dev = ylist_entry(cfg, yaffs_dev_t, dev_list);
+               dev = ylist_entry(cfg, struct yaffs_dev, dev_list);
                leftOver = path;
                p = dev->param.name;
                thisMatchLength = 0;
@@ -371,12 +371,12 @@ static yaffs_dev_t *yaffsfs_FindDevice(const YCHAR *path, YCHAR **restOfPath)
 }
 
 #if 0
-static yaffs_dev_t *yaffsfs_FindDevice(const YCHAR *path, YCHAR **restOfPath)
+static struct yaffs_dev *yaffsfs_FindDevice(const YCHAR *path, YCHAR **restOfPath)
 {
        yaffsfs_DeviceConfiguration *cfg = yaffsfs_configurationList;
        const YCHAR *leftOver;
        const YCHAR *p;
-       yaffs_dev_t *retval = NULL;
+       struct yaffs_dev *retval = NULL;
        int thisMatchLength;
        int longestMatch = -1;
 
@@ -413,10 +413,10 @@ static yaffs_dev_t *yaffsfs_FindDevice(const YCHAR *path, YCHAR **restOfPath)
 }
 #endif
 
-static yaffs_obj_t *yaffsfs_FindRoot(const YCHAR *path, YCHAR **restOfPath)
+static struct yaffs_obj *yaffsfs_FindRoot(const YCHAR *path, YCHAR **restOfPath)
 {
 
-       yaffs_dev_t *dev;
+       struct yaffs_dev *dev;
 
        dev= yaffsfs_FindDevice(path,restOfPath);
        if(dev && dev->is_mounted){
@@ -425,7 +425,7 @@ static yaffs_obj_t *yaffsfs_FindRoot(const YCHAR *path, YCHAR **restOfPath)
        return NULL;
 }
 
-static yaffs_obj_t *yaffsfs_FollowLink(yaffs_obj_t *obj,int symDepth)
+static struct yaffs_obj *yaffsfs_FollowLink(struct yaffs_obj *obj,int symDepth)
 {
 
        if(obj)
@@ -451,10 +451,10 @@ static yaffs_obj_t *yaffsfs_FollowLink(yaffs_obj_t *obj,int symDepth)
  *
  * eg. "/data/xx/ff" --> puts name="ff" and returns the directory "/data/xx"
  */
-static yaffs_obj_t *yaffsfs_DoFindDirectory(yaffs_obj_t *startDir,
+static struct yaffs_obj *yaffsfs_DoFindDirectory(struct yaffs_obj *startDir,
                                const YCHAR *path, YCHAR **name, int symDepth)
 {
-       yaffs_obj_t *dir;
+       struct yaffs_obj *dir;
        YCHAR *restOfPath;
        YCHAR str[YAFFS_MAX_NAME_LENGTH+1];
        int i;
@@ -514,7 +514,7 @@ static yaffs_obj_t *yaffsfs_DoFindDirectory(yaffs_obj_t *startDir,
        return NULL;
 }
 
-static yaffs_obj_t *yaffsfs_FindDirectory(yaffs_obj_t *relativeDirectory,
+static struct yaffs_obj *yaffsfs_FindDirectory(struct yaffs_obj *relativeDirectory,
                                        const YCHAR *path,YCHAR **name,int symDepth)
 {
        return yaffsfs_DoFindDirectory(relativeDirectory,path,name,symDepth);
@@ -523,10 +523,10 @@ static yaffs_obj_t *yaffsfs_FindDirectory(yaffs_obj_t *relativeDirectory,
 /*
  * yaffsfs_FindObject turns a path for an existing object into the object
  */
-static yaffs_obj_t *yaffsfs_FindObject(yaffs_obj_t *relativeDirectory, const YCHAR *path,int symDepth, int getEquiv)
+static struct yaffs_obj *yaffsfs_FindObject(struct yaffs_obj *relativeDirectory, const YCHAR *path,int symDepth, int getEquiv)
 {
-       yaffs_obj_t *dir;
-       yaffs_obj_t *obj;
+       struct yaffs_obj *dir;
+       struct yaffs_obj *obj;
        YCHAR *name;
 
        dir = yaffsfs_FindDirectory(relativeDirectory,path,&name,symDepth);
@@ -575,8 +575,8 @@ int yaffs_dup(int fd)
 
 int yaffs_open_sharing(const YCHAR *path, int oflag, int mode, int sharing)
 {
-       yaffs_obj_t *obj = NULL;
-       yaffs_obj_t *dir = NULL;
+       struct yaffs_obj *obj = NULL;
+       struct yaffs_obj *dir = NULL;
        YCHAR *name;
        int handle = -1;
        yaffsfs_Handle *yh = NULL;
@@ -817,7 +817,7 @@ int yaffs_close(int fd)
 int yaffsfs_do_read(int fd, void *vbuf, unsigned int nbyte, int isPread, int offset)
 {
        yaffsfs_Handle *h = NULL;
-       yaffs_obj_t *obj = NULL;
+       struct yaffs_obj *obj = NULL;
        int pos = 0;
        int startPos = 0;
        int nRead = 0;
@@ -913,7 +913,7 @@ int yaffs_pread(int fd, void *buf, unsigned int nbyte, unsigned int offset)
 int yaffsfs_do_write(int fd, const void *vbuf, unsigned int nbyte, int isPwrite, int offset)
 {
        yaffsfs_Handle *h = NULL;
-       yaffs_obj_t *obj = NULL;
+       struct yaffs_obj *obj = NULL;
        int pos = 0;
        int startPos = 0;
        int nWritten = 0;
@@ -1000,7 +1000,7 @@ int yaffs_pwrite(int fd, const void *buf, unsigned int nbyte, unsigned int offse
 
 int yaffs_truncate(const YCHAR *path,off_t new_size)
 {
-       yaffs_obj_t *obj = NULL;
+       struct yaffs_obj *obj = NULL;
        int result = YAFFS_FAIL;
 
        yaffsfs_Lock();
@@ -1025,7 +1025,7 @@ int yaffs_truncate(const YCHAR *path,off_t new_size)
 int yaffs_ftruncate(int fd, off_t new_size)
 {
        yaffsfs_Handle *h = NULL;
-       yaffs_obj_t *obj = NULL;
+       struct yaffs_obj *obj = NULL;
        int result = 0;
 
        yaffsfs_Lock();
@@ -1050,7 +1050,7 @@ int yaffs_ftruncate(int fd, off_t new_size)
 off_t yaffs_lseek(int fd, off_t offset, int whence)
 {
        yaffsfs_Handle *h = NULL;
-       yaffs_obj_t *obj = NULL;
+       struct yaffs_obj *obj = NULL;
        int pos = -1;
        int fSize = -1;
 
@@ -1088,8 +1088,8 @@ off_t yaffs_lseek(int fd, off_t offset, int whence)
 
 int yaffsfs_DoUnlink(const YCHAR *path,int isDirectory)
 {
-       yaffs_obj_t *dir = NULL;
-       yaffs_obj_t *obj = NULL;
+       struct yaffs_obj *dir = NULL;
+       struct yaffs_obj *obj = NULL;
        YCHAR *name;
        int result = YAFFS_FAIL;
 
@@ -1134,9 +1134,9 @@ int yaffs_unlink(const YCHAR *path)
 
 int yaffs_rename(const YCHAR *oldPath, const YCHAR *newPath)
 {
-       yaffs_obj_t *olddir = NULL;
-       yaffs_obj_t *newdir = NULL;
-       yaffs_obj_t *obj = NULL;
+       struct yaffs_obj *olddir = NULL;
+       struct yaffs_obj *newdir = NULL;
+       struct yaffs_obj *obj = NULL;
        YCHAR *oldname;
        YCHAR *newname;
        int result= YAFFS_FAIL;
@@ -1167,7 +1167,7 @@ int yaffs_rename(const YCHAR *oldPath, const YCHAR *newPath)
                 * Do this by tracing from the new directory back to the root, checking for obj
                 */
 
-               yaffs_obj_t *xx = newdir;
+               struct yaffs_obj *xx = newdir;
 
                while( rename_allowed && xx){
                        if(xx == obj)
@@ -1187,7 +1187,7 @@ int yaffs_rename(const YCHAR *oldPath, const YCHAR *newPath)
 }
 
 
-static int yaffsfs_DoStat(yaffs_obj_t *obj,struct yaffs_stat *buf)
+static int yaffsfs_DoStat(struct yaffs_obj *obj,struct yaffs_stat *buf)
 {
        int retVal = -1;
 
@@ -1231,7 +1231,7 @@ static int yaffsfs_DoStat(yaffs_obj_t *obj,struct yaffs_stat *buf)
 
 static int yaffsfs_DoStatOrLStat(const YCHAR *path, struct yaffs_stat *buf,int doLStat)
 {
-       yaffs_obj_t *obj;
+       struct yaffs_obj *obj;
 
        int retVal = -1;
 
@@ -1266,7 +1266,7 @@ int yaffs_lstat(const YCHAR *path, struct yaffs_stat *buf)
 
 int yaffs_fstat(int fd, struct yaffs_stat *buf)
 {
-       yaffs_obj_t *obj;
+       struct yaffs_obj *obj;
 
        int retVal = -1;
 
@@ -1290,7 +1290,7 @@ int yaffs_fstat(int fd, struct yaffs_stat *buf)
 
 static int yaffs_do_setxattr(const YCHAR *path, const char *name, const void *data, int size, int flags, int follow)
 {
-       yaffs_obj_t *obj;
+       struct yaffs_obj *obj;
 
        int retVal = -1;
 
@@ -1331,7 +1331,7 @@ int yaffs_lsetxattr(const YCHAR *path, const char *name, const void *data, int s
 
 int yaffs_fsetxattr(int fd, const char *name, const void *data, int size, int flags)
 {
-       yaffs_obj_t *obj;
+       struct yaffs_obj *obj;
 
        int retVal = -1;
 
@@ -1355,7 +1355,7 @@ int yaffs_fsetxattr(int fd, const char *name, const void *data, int size, int fl
 
 static int yaffs_do_getxattr(const YCHAR *path, const char *name, void *data, int size, int follow)
 {
-       yaffs_obj_t *obj;
+       struct yaffs_obj *obj;
 
        int retVal = -1;
 
@@ -1395,7 +1395,7 @@ int yaffs_lgetxattr(const YCHAR *path, const char *name, void *data, int size)
 
 int yaffs_fgetxattr(int fd, const char *name, void *data, int size)
 {
-       yaffs_obj_t *obj;
+       struct yaffs_obj *obj;
 
        int retVal = -1;
 
@@ -1419,7 +1419,7 @@ int yaffs_fgetxattr(int fd, const char *name, void *data, int size)
 
 static int yaffs_do_listxattr(const YCHAR *path, char *data, int size, int follow)
 {
-       yaffs_obj_t *obj;
+       struct yaffs_obj *obj;
 
        int retVal = -1;
 
@@ -1458,7 +1458,7 @@ int yaffs_llistxattr(const YCHAR *path, char *data, int size)
 
 int yaffs_flistxattr(int fd, char *data, int size)
 {
-       yaffs_obj_t *obj;
+       struct yaffs_obj *obj;
 
        int retVal = -1;
 
@@ -1482,7 +1482,7 @@ int yaffs_flistxattr(int fd, char *data, int size)
 
 static int yaffs_do_removexattr(const YCHAR *path, const char *name, int follow)
 {
-       yaffs_obj_t *obj;
+       struct yaffs_obj *obj;
 
        int retVal = -1;
 
@@ -1521,7 +1521,7 @@ int yaffs_lremovexattr(const YCHAR *path, const char *name)
 
 int yaffs_fremovexattr(int fd, const char *name)
 {
-       yaffs_obj_t *obj;
+       struct yaffs_obj *obj;
 
        int retVal = -1;
 
@@ -1547,7 +1547,7 @@ int yaffs_fremovexattr(int fd, const char *name)
 #ifdef CONFIG_YAFFS_WINCE
 int yaffs_get_wince_times(int fd, unsigned *wctime, unsigned *watime, unsigned *wmtime)
 {
-       yaffs_obj_t *obj;
+       struct yaffs_obj *obj;
 
        int retVal = -1;
 
@@ -1586,7 +1586,7 @@ int yaffs_set_wince_times(int fd,
                                                  const unsigned *watime, 
                                                   const unsigned *wmtime)
 {
-        yaffs_obj_t *obj;
+        struct yaffs_obj *obj;
         int result;
         int retVal = -1;
 
@@ -1623,7 +1623,7 @@ int yaffs_set_wince_times(int fd,
 #endif
 
 
-static int yaffsfs_DoChMod(yaffs_obj_t *obj,mode_t mode)
+static int yaffsfs_DoChMod(struct yaffs_obj *obj,mode_t mode)
 {
        int result = -1;
 
@@ -1642,7 +1642,7 @@ static int yaffsfs_DoChMod(yaffs_obj_t *obj,mode_t mode)
 
 int yaffs_access(const YCHAR *path, int amode)
 {
-       yaffs_obj_t *obj;
+       struct yaffs_obj *obj;
 
        int retval = 0;
 
@@ -1679,7 +1679,7 @@ int yaffs_access(const YCHAR *path, int amode)
 
 int yaffs_chmod(const YCHAR *path, mode_t mode)
 {
-       yaffs_obj_t *obj;
+       struct yaffs_obj *obj;
 
        int retVal = -1;
 
@@ -1703,7 +1703,7 @@ int yaffs_chmod(const YCHAR *path, mode_t mode)
 
 int yaffs_fchmod(int fd, mode_t mode)
 {
-       yaffs_obj_t *obj;
+       struct yaffs_obj *obj;
 
        int retVal = -1;
 
@@ -1725,8 +1725,8 @@ int yaffs_fchmod(int fd, mode_t mode)
 
 int yaffs_mkdir(const YCHAR *path, mode_t mode)
 {
-       yaffs_obj_t *parent = NULL;
-       yaffs_obj_t *dir = NULL;
+       struct yaffs_obj *parent = NULL;
+       struct yaffs_obj *dir = NULL;
        YCHAR *name;
        YCHAR *use_path = NULL;
        int path_length = 0;
@@ -1795,7 +1795,7 @@ int yaffs_mkdir(const YCHAR *path, mode_t mode)
 
 void * yaffs_getdev(const YCHAR *path)
 {
-       yaffs_dev_t *dev=NULL;
+       struct yaffs_dev *dev=NULL;
        YCHAR *dummy;
        dev = yaffsfs_FindDevice(path,&dummy);
        return (void *)dev;
@@ -1805,7 +1805,7 @@ int yaffs_mount2(const YCHAR *path,int read_only)
 {
        int retVal=-1;
        int result=YAFFS_FAIL;
-       yaffs_dev_t *dev=NULL;
+       struct yaffs_dev *dev=NULL;
        YCHAR *dummy;
 
        T(YAFFS_TRACE_ALWAYS,(TSTR("yaffs: Mounting %s" TENDSTR),path));
@@ -1845,7 +1845,7 @@ int yaffs_mount(const YCHAR *path)
 int yaffs_sync(const YCHAR *path)
 {
         int retVal=-1;
-        yaffs_dev_t *dev=NULL;
+        struct yaffs_dev *dev=NULL;
         YCHAR *dummy;
         
         yaffsfs_Lock();
@@ -1873,7 +1873,7 @@ int yaffs_sync(const YCHAR *path)
 int yaffs_remount(const YCHAR *path, int force, int read_only)
 {
         int retVal=-1;
-       yaffs_dev_t *dev=NULL;
+       struct yaffs_dev *dev=NULL;
        YCHAR *dummy;
 
        yaffsfs_Lock();
@@ -1913,7 +1913,7 @@ int yaffs_remount(const YCHAR *path, int force, int read_only)
 int yaffs_unmount2(const YCHAR *path, int force)
 {
         int retVal=-1;
-       yaffs_dev_t *dev=NULL;
+       struct yaffs_dev *dev=NULL;
        YCHAR *dummy;
 
        yaffsfs_Lock();
@@ -1961,7 +1961,7 @@ int yaffs_unmount(const YCHAR *path)
 loff_t yaffs_freespace(const YCHAR *path)
 {
        loff_t retVal=-1;
-       yaffs_dev_t *dev=NULL;
+       struct yaffs_dev *dev=NULL;
        YCHAR *dummy;
 
        yaffsfs_Lock();
@@ -1980,7 +1980,7 @@ loff_t yaffs_freespace(const YCHAR *path)
 loff_t yaffs_totalspace(const YCHAR *path)
 {
        loff_t retVal=-1;
-       yaffs_dev_t *dev=NULL;
+       struct yaffs_dev *dev=NULL;
        YCHAR *dummy;
 
        yaffsfs_Lock();
@@ -2000,7 +2000,7 @@ loff_t yaffs_totalspace(const YCHAR *path)
 int yaffs_inodecount(const YCHAR *path)
 {
        loff_t retVal= -1;
-       yaffs_dev_t *dev=NULL;
+       struct yaffs_dev *dev=NULL;
        YCHAR *dummy;
 
        yaffsfs_Lock();
@@ -2019,7 +2019,7 @@ int yaffs_inodecount(const YCHAR *path)
 }
 
 
-void yaffs_add_device(yaffs_dev_t *dev)
+void yaffs_add_device(struct yaffs_dev *dev)
 {
        dev->is_mounted = 0;
        dev->param.remove_obj_fn = yaffsfs_RemoveObjectCallback;
@@ -2030,7 +2030,7 @@ void yaffs_add_device(yaffs_dev_t *dev)
        ylist_add(&dev->dev_list,&yaffsfs_deviceList);
 }
 
-void yaffs_remove_device(yaffs_dev_t *dev)
+void yaffs_remove_device(struct yaffs_dev *dev)
 {
        ylist_del_init(&dev->dev_list);
 }
@@ -2052,8 +2052,8 @@ typedef struct
        u32 magic;
        yaffs_dirent de;                /* directory entry being used by this dsc */
        YCHAR name[NAME_MAX+1];         /* name of directory being searched */
-        yaffs_obj_t *dirObj;           /* ptr to directory being searched */
-        yaffs_obj_t *nextReturn;       /* obj to be returned by next readddir */
+        struct yaffs_obj *dirObj;           /* ptr to directory being searched */
+        struct yaffs_obj *nextReturn;       /* obj to be returned by next readddir */
         int offset;
         struct ylist_head others;       
 } yaffsfs_DirectorySearchContext;
@@ -2075,7 +2075,7 @@ static void yaffsfs_SetDirRewound(yaffsfs_DirectorySearchContext *dsc)
                 dsc->nextReturn = NULL;
            else
                 dsc->nextReturn = ylist_entry(dsc->dirObj->variant.dir_variant.children.next,
-                                                yaffs_obj_t,siblings);
+                                                struct yaffs_obj,siblings);
         } else {
                /* Hey someone isn't playing nice! */
        }
@@ -2096,14 +2096,14 @@ static void yaffsfs_DirAdvance(yaffsfs_DirectorySearchContext *dsc)
                    if( next == &dsc->dirObj->variant.dir_variant.children)
                         dsc->nextReturn = NULL; /* end of list */
                    else
-                        dsc->nextReturn = ylist_entry(next,yaffs_obj_t,siblings);
+                        dsc->nextReturn = ylist_entry(next,struct yaffs_obj,siblings);
            }
         } else {
                 /* Hey someone isn't playing nice! */
        }
 }
 
-static void yaffsfs_RemoveObjectCallback(yaffs_obj_t *obj)
+static void yaffsfs_RemoveObjectCallback(struct yaffs_obj *obj)
 {
 
         struct ylist_head *i;
@@ -2130,7 +2130,7 @@ static void yaffsfs_RemoveObjectCallback(yaffs_obj_t *obj)
 yaffs_DIR *yaffs_opendir(const YCHAR *dirname)
 {
        yaffs_DIR *dir = NULL;
-       yaffs_obj_t *obj = NULL;
+       struct yaffs_obj *obj = NULL;
        yaffsfs_DirectorySearchContext *dsc = NULL;
 
        yaffsfs_Lock();
@@ -2226,8 +2226,8 @@ int yaffs_closedir(yaffs_DIR *dirp)
 
 int yaffs_symlink(const YCHAR *oldpath, const YCHAR *newpath)
 {
-       yaffs_obj_t *parent = NULL;
-       yaffs_obj_t *obj;
+       struct yaffs_obj *parent = NULL;
+       struct yaffs_obj *obj;
        YCHAR *name;
        int retVal= -1;
        int mode = 0; /* ignore for now */
@@ -2257,7 +2257,7 @@ int yaffs_symlink(const YCHAR *oldpath, const YCHAR *newpath)
 
 int yaffs_readlink(const YCHAR *path, YCHAR *buf, int bufsiz)
 {
-       yaffs_obj_t *obj = NULL;
+       struct yaffs_obj *obj = NULL;
        int retVal;
 
 
@@ -2284,8 +2284,8 @@ int yaffs_readlink(const YCHAR *path, YCHAR *buf, int bufsiz)
 int yaffs_link(const YCHAR *oldpath, const YCHAR *newpath)
 {
        /* Creates a link called newpath to existing oldpath */
-       yaffs_obj_t *obj = NULL;
-       yaffs_obj_t *target = NULL;
+       struct yaffs_obj *obj = NULL;
+       struct yaffs_obj *target = NULL;
        int retVal = 0;
        int new_nameLength = 0;
 
@@ -2305,8 +2305,8 @@ int yaffs_link(const YCHAR *oldpath, const YCHAR *newpath)
                yaffsfs_SetError(-EEXIST);
                retVal = -1;
        } else {
-               yaffs_obj_t *newdir = NULL;
-               yaffs_obj_t *link = NULL;
+               struct yaffs_obj *newdir = NULL;
+               struct yaffs_obj *link = NULL;
 
                YCHAR *newname;
 
@@ -2359,7 +2359,7 @@ int yaffs_mknod(const YCHAR *pathname, mode_t mode, dev_t dev)
  */
 int yaffs_n_handles(const YCHAR *path)
 {
-       yaffs_obj_t *obj;
+       struct yaffs_obj *obj;
 
        obj = yaffsfs_FindObject(NULL,path,0,1);
 
@@ -2376,10 +2376,10 @@ int yaffs_dump_dev(const YCHAR *path)
 #if 0
        YCHAR *rest;
 
-       yaffs_obj_t *obj = yaffsfs_FindRoot(path,&rest);
+       struct yaffs_obj *obj = yaffsfs_FindRoot(path,&rest);
 
        if(obj){
-               yaffs_dev_t *dev = obj->my_dev;
+               struct yaffs_dev *dev = obj->my_dev;
 
                printf("\n"
                           "n_page_writes.......... %d\n"
index f766c72..d8a4d0f 100644 (file)
@@ -166,8 +166,8 @@ int yaffs_n_handles(const YCHAR *path);
 int yaffs_open_sharing(const YCHAR *path, int oflag, int mode, int shareMode) ;
 
 
-struct yaffs_dev_s;
-void yaffs_add_device(struct yaffs_dev_s *dev);
+struct yaffs_dev;
+void yaffs_add_device(struct yaffs_dev *dev);
 
 int yaffs_start_up(void);
 int yaffsfs_GetLastError(void);
index d0837f8..82ae3df 100644 (file)
@@ -42,7 +42,7 @@ typedef struct yaffs_AllocatorStruct yaffs_Allocator;
 
 int mount_id;
 
-void yaffs_deinit_raw_tnodes_and_objs(yaffs_dev_t *dev)
+void yaffs_deinit_raw_tnodes_and_objs(struct yaffs_dev *dev)
 {
        yaffs_Allocator *allocator = (yaffs_Allocator *)dev->allocator;
 
@@ -102,10 +102,10 @@ static void (*fake_ctor_list[10]) (void *) = {
        fake_ctor9,
 };
 
-void yaffs_init_raw_tnodes_and_objs(yaffs_dev_t *dev)
+void yaffs_init_raw_tnodes_and_objs(struct yaffs_dev *dev)
 {
        yaffs_Allocator *allocator;
-       unsigned mount_id = yaffs_dev_to_lc(dev)->mount_id;
+       unsigned mount_id = struct yaffs_devo_lc(dev)->mount_id;
 
        T(YAFFS_TRACE_ALLOCATE,(TSTR("Initialising yaffs allocator\n")));
 
@@ -147,7 +147,7 @@ void yaffs_init_raw_tnodes_and_objs(yaffs_dev_t *dev)
 
                allocator->object_cache = 
                        kmem_cache_create(allocator->object_name,
-                               sizeof(yaffs_obj_t),
+                               sizeof(struct yaffs_obj),
                                0, 0,
                                fake_ctor_list[mount_id]);
 
@@ -165,7 +165,7 @@ void yaffs_init_raw_tnodes_and_objs(yaffs_dev_t *dev)
 }
 
 
-yaffs_tnode_t *yaffs_alloc_raw_tnode(yaffs_dev_t *dev)
+yaffs_tnode_t *yaffs_alloc_raw_tnode(struct yaffs_dev *dev)
 {
        yaffs_Allocator *allocator = dev->allocator;
        if(!allocator || !allocator->tnode_cache){
@@ -175,13 +175,13 @@ yaffs_tnode_t *yaffs_alloc_raw_tnode(yaffs_dev_t *dev)
        return kmem_cache_alloc(allocator->tnode_cache, GFP_NOFS);
 }
 
-void yaffs_free_raw_tnode(yaffs_dev_t *dev, yaffs_tnode_t *tn)
+void yaffs_free_raw_tnode(struct yaffs_dev *dev, yaffs_tnode_t *tn)
 {
        yaffs_Allocator *allocator = dev->allocator;
        kmem_cache_free(allocator->tnode_cache,tn);
 }
 
-yaffs_obj_t *yaffs_alloc_raw_obj(yaffs_dev_t *dev)
+struct yaffs_obj *yaffs_alloc_raw_obj(struct yaffs_dev *dev)
 {
        yaffs_Allocator *allocator = dev->allocator;
        if(!allocator){
@@ -195,7 +195,7 @@ yaffs_obj_t *yaffs_alloc_raw_obj(yaffs_dev_t *dev)
        return kmem_cache_alloc(allocator->object_cache, GFP_NOFS);
 }
 
-void yaffs_free_raw_obj(yaffs_dev_t *dev, yaffs_obj_t *obj)
+void yaffs_free_raw_obj(struct yaffs_dev *dev, struct yaffs_obj *obj)
 {
        yaffs_Allocator *allocator = dev->allocator;
        kmem_cache_free(allocator->object_cache,obj);
index 019142b..1814843 100644 (file)
@@ -28,7 +28,7 @@ const char *yaffs_mtdif2_c_version =
 #include "yaffs_packedtags2.h"
 
 
-void nandmtd2_pt2buf(yaffs_dev_t *dev, yaffs_PackedTags2 *pt, int is_raw)
+void nandmtd2_pt2buf(struct yaffs_dev *dev, yaffs_PackedTags2 *pt, int is_raw)
 {
        struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice);
        u8 *ptab = (u8 *)pt; /* packed tags as bytes */
@@ -69,7 +69,7 @@ void nandmtd2_pt2buf(yaffs_dev_t *dev, yaffs_PackedTags2 *pt, int is_raw)
 
 }
 
-void nandmtd2_buf2pt(yaffs_dev_t *dev, yaffs_PackedTags2 *pt, int is_raw)
+void nandmtd2_buf2pt(struct yaffs_dev *dev, yaffs_PackedTags2 *pt, int is_raw)
 {
        struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice);
        int     i, j = 0, k, n;
@@ -107,9 +107,9 @@ void nandmtd2_buf2pt(yaffs_dev_t *dev, yaffs_PackedTags2 *pt, int is_raw)
                
 }
 
-int nandmtd2_WriteChunkWithTagsToNAND(yaffs_dev_t * dev, int nand_chunk,
+int nandmtd2_WriteChunkWithTagsToNAND(struct yaffs_dev * dev, int nand_chunk,
                                      const u8 * data,
-                                     const yaffs_ext_tags * tags)
+                                     const struct yaffs_ext_tags * tags)
 {
        struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice);
        size_t dummy;
@@ -149,8 +149,8 @@ int nandmtd2_WriteChunkWithTagsToNAND(yaffs_dev_t * dev, int nand_chunk,
                return YAFFS_FAIL;
 }
 
-int nandmtd2_ReadChunkWithTagsFromNAND(yaffs_dev_t * dev, int nand_chunk,
-                                      u8 * data, yaffs_ext_tags * tags)
+int nandmtd2_ReadChunkWithTagsFromNAND(struct yaffs_dev * dev, int nand_chunk,
+                                      u8 * data, struct yaffs_ext_tags * tags)
 {
        struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice);
        size_t dummy;
@@ -193,7 +193,7 @@ int nandmtd2_ReadChunkWithTagsFromNAND(yaffs_dev_t * dev, int nand_chunk,
                return YAFFS_FAIL;
 }
 
-int nandmtd2_MarkNANDBlockBad(struct yaffs_dev_s *dev, int block_no)
+int nandmtd2_MarkNANDBlockBad(struct yaffs_dev *dev, int block_no)
 {
        struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice);
        int retval;
@@ -212,7 +212,7 @@ int nandmtd2_MarkNANDBlockBad(struct yaffs_dev_s *dev, int block_no)
 
 }
 
-int nandmtd2_QueryNANDBlock(struct yaffs_dev_s *dev, int block_no,
+int nandmtd2_QueryNANDBlock(struct yaffs_dev *dev, int block_no,
                            yaffs_block_state_t * state, int *seq_number)
 {
        struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice);
@@ -231,7 +231,7 @@ int nandmtd2_QueryNANDBlock(struct yaffs_dev_s *dev, int block_no,
                *state = YAFFS_BLOCK_STATE_DEAD;
                *seq_number = 0;
        } else {
-               yaffs_ext_tags t;
+               struct yaffs_ext_tags t;
                nandmtd2_ReadChunkWithTagsFromNAND(dev,
                                                   block_no *
                                                   dev->chunks_per_block, NULL,
index 1890427..d54bcc5 100644 (file)
@@ -143,7 +143,7 @@ static int find_obj_in_list(dev_t dev, ino_t ino)
  * NOTE: The tag is not usable after this other than calculating the CRC
  * with.
  */
-static void little_to_big_endian(yaffs_ext_tags *tagsPtr)
+static void little_to_big_endian(struct yaffs_ext_tags *tagsPtr)
 {
 #if 0 // FIXME NCB
     yaffs_tags_union_t * tags = (yaffs_tags_union_t* )tagsPtr; // Work in bytes.
@@ -181,7 +181,7 @@ static void shuffle_oob(char *spareData, yaffs_packed_tags2 *pt)
 
 static int write_chunk(u8 *data, u32 id, u32 chunk_id, u32 n_bytes)
 {
-       yaffs_ext_tags t;
+       struct yaffs_ext_tags t;
        yaffs_packed_tags2 pt;
        char spareData[spareSize];
 
@@ -228,7 +228,7 @@ static int write_chunk(u8 *data, u32 id, u32 chunk_id, u32 n_bytes)
                      (((x) & 0xFF00) >> 8))
         
 // This one is easier, since the types are more standard. No funky shifts here.
-static void object_header_little_to_big_endian(yaffs_obj_header* oh)
+static void object_header_little_to_big_endian(struct yaffs_obj_hdr* oh)
 {
     int i;    
     oh->type = SWAP32(oh->type); // GCC makes enums 32 bits.
@@ -276,12 +276,12 @@ static void object_header_little_to_big_endian(yaffs_obj_header* oh)
 #endif
 }
 
-static int write_object_header(int id, yaffs_obj_type t, struct stat *s, int parent, const char *name, int equivalentObj, const char * alias)
+static int write_object_header(int id, enum yaffs_obj_type t, struct stat *s, int parent, const char *name, int equivalentObj, const char * alias)
 {
        u8 bytes[chunkSize];
        
        
-       yaffs_obj_header *oh = (yaffs_obj_header *)bytes;
+       struct yaffs_obj_hdr *oh = (struct yaffs_obj_hdr *)bytes;
        
        memset(bytes,0xff,sizeof(bytes));
        
index 5d74940..ffb0b5a 100644 (file)
@@ -136,7 +136,7 @@ static void yaffs_calc_ecc(const u8 *data, yaffs_spare *spare)
        yaffs_ecc_cacl(&data[256] , spare->ecc2);
 }
 
-static void yaffs_calc_tags_ecc(yaffs_tags_t *tags)
+static void yaffs_calc_tags_ecc(struct yaffs_tags *tags)
 {
        // Todo don't do anything yet. Need to calculate ecc
        unsigned char *b = ((yaffs_tags_union_t *)tags)->as_bytes;
@@ -181,7 +181,7 @@ static void yaffs_calc_tags_ecc(yaffs_tags_t *tags)
         b[7] |= ((ecc & 0x3F) << 2);
     }
 }
-static void yaffs_load_tags_to_spare(yaffs_spare *sparePtr, yaffs_tags_t *tagsPtr)
+static void yaffs_load_tags_to_spare(yaffs_spare *sparePtr, struct yaffs_tags *tagsPtr)
 {
        yaffs_tags_union_t *tu = (yaffs_tags_union_t *)tagsPtr;
        
@@ -201,7 +201,7 @@ static void yaffs_load_tags_to_spare(yaffs_spare *sparePtr, yaffs_tags_t *tagsPt
  * NOTE: The tag is not usable after this other than calculating the CRC
  * with.
  */
-static void little_to_big_endian(yaffs_tags_t *tagsPtr)
+static void little_to_big_endian(struct yaffs_tags *tagsPtr)
 {
     yaffs_tags_union_t * tags = (yaffs_tags_union_t* )tagsPtr; // Work in bytes.
     yaffs_tags_union_t   temp;
@@ -230,13 +230,13 @@ static void little_to_big_endian(yaffs_tags_t *tagsPtr)
 
 static int write_chunk(u8 *data, u32 obj_id, u32 chunk_id, u32 n_bytes)
 {
-       yaffs_tags_t t;
+       struct yaffs_tags t;
        yaffs_spare s;
 
        error = write(outFile,data,512);
        if(error < 0) return error;
 
-       memset(&t,0xff,sizeof (yaffs_tags_t));
+       memset(&t,0xff,sizeof (struct yaffs_tags));
        memset(&s,0xff,sizeof (yaffs_spare));
        
        t.chunk_id = chunk_id;
@@ -268,7 +268,7 @@ static int write_chunk(u8 *data, u32 obj_id, u32 chunk_id, u32 n_bytes)
                      (((x) & 0xFF00) >> 8))
         
 // This one is easier, since the types are more standard. No funky shifts here.
-static void object_header_little_to_big_endian(yaffs_obj_header* oh)
+static void object_header_little_to_big_endian(struct yaffs_obj_hdr* oh)
 {
     oh->type = SWAP32(oh->type); // GCC makes enums 32 bits.
     oh->parent_obj_id = SWAP32(oh->parent_obj_id); // int
@@ -325,12 +325,12 @@ static void object_header_little_to_big_endian(yaffs_obj_header* oh)
 #endif
 }
 
-static int write_object_header(int obj_id, yaffs_obj_type t, struct stat *s, int parent, const char *name, int equivalentObj, const char * alias)
+static int write_object_header(int obj_id, enum yaffs_obj_type t, struct stat *s, int parent, const char *name, int equivalentObj, const char * alias)
 {
        u8 bytes[512];
        
        
-       yaffs_obj_header *oh = (yaffs_obj_header *)bytes;
+       struct yaffs_obj_hdr *oh = (struct yaffs_obj_hdr *)bytes;
        
        memset(bytes,0xff,512);
        
index 6db9856..b304b67 100644 (file)
 
 #ifdef CONFIG_YAFFS_YMALLOC_ALLOCATOR
 
-void yaffs_deinit_raw_tnodes_and_objs(yaffs_dev_t *dev)
+void yaffs_deinit_raw_tnodes_and_objs(struct yaffs_dev *dev)
 {
        dev = dev;
 }
 
-void yaffs_init_raw_tnodes_and_objs(yaffs_dev_t *dev)
+void yaffs_init_raw_tnodes_and_objs(struct yaffs_dev *dev)
 {
        dev = dev;
 }
 
-yaffs_tnode_t *yaffs_alloc_raw_tnode(yaffs_dev_t *dev)
+yaffs_tnode_t *yaffs_alloc_raw_tnode(struct yaffs_dev *dev)
 {
        return (yaffs_tnode_t *)YMALLOC(dev->tnode_size);
 }
 
-void yaffs_free_raw_tnode(yaffs_dev_t *dev, yaffs_tnode_t *tn)
+void yaffs_free_raw_tnode(struct yaffs_dev *dev, yaffs_tnode_t *tn)
 {
        dev = dev;
        YFREE(tn);
 }
 
-void yaffs_init_raw_objs(yaffs_dev_t *dev)
+void yaffs_init_raw_objs(struct yaffs_dev *dev)
 {
        dev = dev;
 }
 
-void yaffs_deinit_raw_objs(yaffs_dev_t *dev)
+void yaffs_deinit_raw_objs(struct yaffs_dev *dev)
 {
        dev = dev;
 }
 
-yaffs_obj_t *yaffs_alloc_raw_obj(yaffs_dev_t *dev)
+struct yaffs_obj *yaffs_alloc_raw_obj(struct yaffs_dev *dev)
 {
        dev = dev;
-       return (yaffs_obj_t *) YMALLOC(sizeof(yaffs_obj_t));
+       return (struct yaffs_obj *) YMALLOC(sizeof(struct yaffs_obj));
 }
 
 
-void yaffs_free_raw_obj(yaffs_dev_t *dev, yaffs_obj_t *obj)
+void yaffs_free_raw_obj(struct yaffs_dev *dev, struct yaffs_obj *obj)
 {
 
        dev = dev;
@@ -75,7 +75,7 @@ struct yaffs_tnode_list {
 typedef struct yaffs_tnode_list yaffs_tnodelist_t;
 
 struct yaffs_obj_list_struct {
-       yaffs_obj_t *objects;
+       struct yaffs_obj *objects;
        struct yaffs_obj_list_struct *next;
 };
 
@@ -89,14 +89,14 @@ struct yaffs_allocator {
        yaffs_tnodelist_t *alloc_tnode_list;
 
        int n_obj_created;
-       yaffs_obj_t *free_objs;
+       struct yaffs_obj *free_objs;
        int n_free_objects;
 
        yaffs_obj_list *allocated_obj_list;
 };
 
 
-static void yaffs_deinit_raw_tnodes(yaffs_dev_t *dev)
+static void yaffs_deinit_raw_tnodes(struct yaffs_dev *dev)
 {
 
        struct yaffs_allocator *allocator = (struct yaffs_allocator *)dev->allocator;
@@ -122,7 +122,7 @@ static void yaffs_deinit_raw_tnodes(yaffs_dev_t *dev)
        allocator->n_tnodes_created = 0;
 }
 
-static void yaffs_init_raw_tnodes(yaffs_dev_t *dev)
+static void yaffs_init_raw_tnodes(struct yaffs_dev *dev)
 {
        struct yaffs_allocator *allocator = dev->allocator;
 
@@ -135,7 +135,7 @@ static void yaffs_init_raw_tnodes(yaffs_dev_t *dev)
                YBUG();
 }
 
-static int yaffs_create_tnodes(yaffs_dev_t *dev, int n_tnodes)
+static int yaffs_create_tnodes(struct yaffs_dev *dev, int n_tnodes)
 {
        struct yaffs_allocator *allocator = (struct yaffs_allocator *)dev->allocator;
        int i;
@@ -202,7 +202,7 @@ static int yaffs_create_tnodes(yaffs_dev_t *dev, int n_tnodes)
 }
 
 
-yaffs_tnode_t *yaffs_alloc_raw_tnode(yaffs_dev_t *dev)
+yaffs_tnode_t *yaffs_alloc_raw_tnode(struct yaffs_dev *dev)
 {
        struct yaffs_allocator *allocator = (struct yaffs_allocator *)dev->allocator;
        yaffs_tnode_t *tn = NULL;
@@ -226,7 +226,7 @@ yaffs_tnode_t *yaffs_alloc_raw_tnode(yaffs_dev_t *dev)
 }
 
 /* FreeTnode frees up a tnode and puts it back on the free list */
-void yaffs_free_raw_tnode(yaffs_dev_t *dev, yaffs_tnode_t *tn)
+void yaffs_free_raw_tnode(struct yaffs_dev *dev, yaffs_tnode_t *tn)
 {
        struct yaffs_allocator *allocator = dev->allocator;
 
@@ -245,7 +245,7 @@ void yaffs_free_raw_tnode(yaffs_dev_t *dev, yaffs_tnode_t *tn)
 
 
 
-static void yaffs_init_raw_objs(yaffs_dev_t *dev)
+static void yaffs_init_raw_objs(struct yaffs_dev *dev)
 {
        struct yaffs_allocator *allocator = dev->allocator;
 
@@ -257,7 +257,7 @@ static void yaffs_init_raw_objs(yaffs_dev_t *dev)
                YBUG();
 }
 
-static void yaffs_deinit_raw_objs(yaffs_dev_t *dev)
+static void yaffs_deinit_raw_objs(struct yaffs_dev *dev)
 {
        struct yaffs_allocator *allocator = dev->allocator;
        yaffs_obj_list *tmp;
@@ -281,12 +281,12 @@ static void yaffs_deinit_raw_objs(yaffs_dev_t *dev)
 }
 
 
-static int yaffs_create_free_objs(yaffs_dev_t *dev, int n_obj)
+static int yaffs_create_free_objs(struct yaffs_dev *dev, int n_obj)
 {
        struct yaffs_allocator *allocator = dev->allocator;
 
        int i;
-       yaffs_obj_t *new_objs;
+       struct yaffs_obj *new_objs;
        yaffs_obj_list *list;
 
        if(!allocator){
@@ -298,7 +298,7 @@ static int yaffs_create_free_objs(yaffs_dev_t *dev, int n_obj)
                return YAFFS_OK;
 
        /* make these things */
-       new_objs = YMALLOC(n_obj * sizeof(yaffs_obj_t));
+       new_objs = YMALLOC(n_obj * sizeof(struct yaffs_obj));
        list = YMALLOC(sizeof(yaffs_obj_list));
 
        if (!new_objs || !list) {
@@ -335,9 +335,9 @@ static int yaffs_create_free_objs(yaffs_dev_t *dev, int n_obj)
        return YAFFS_OK;
 }
 
-yaffs_obj_t *yaffs_alloc_raw_obj(yaffs_dev_t *dev)
+struct yaffs_obj *yaffs_alloc_raw_obj(struct yaffs_dev *dev)
 {
-       yaffs_obj_t *obj = NULL;
+       struct yaffs_obj *obj = NULL;
        struct yaffs_allocator *allocator = dev->allocator;
 
        if(!allocator) {
@@ -352,7 +352,7 @@ yaffs_obj_t *yaffs_alloc_raw_obj(yaffs_dev_t *dev)
        if (allocator->free_objs) {
                obj = allocator->free_objs;
                allocator->free_objs =
-                       (yaffs_obj_t *) (allocator->free_objs->siblings.next);
+                       (struct yaffs_obj *) (allocator->free_objs->siblings.next);
                allocator->n_free_objects--;
        }
 
@@ -360,7 +360,7 @@ yaffs_obj_t *yaffs_alloc_raw_obj(yaffs_dev_t *dev)
 }
 
 
-void yaffs_free_raw_obj(yaffs_dev_t *dev, yaffs_obj_t *obj)
+void yaffs_free_raw_obj(struct yaffs_dev *dev, struct yaffs_obj *obj)
 {
 
        struct yaffs_allocator *allocator = dev->allocator;
@@ -375,7 +375,7 @@ void yaffs_free_raw_obj(yaffs_dev_t *dev, yaffs_obj_t *obj)
        }
 }
 
-void yaffs_deinit_raw_tnodes_and_objs(yaffs_dev_t *dev)
+void yaffs_deinit_raw_tnodes_and_objs(struct yaffs_dev *dev)
 {
        if(dev->allocator){
                yaffs_deinit_raw_tnodes(dev);
@@ -387,7 +387,7 @@ void yaffs_deinit_raw_tnodes_and_objs(yaffs_dev_t *dev)
                YBUG();
 }
 
-void yaffs_init_raw_tnodes_and_objs(yaffs_dev_t *dev)
+void yaffs_init_raw_tnodes_and_objs(struct yaffs_dev *dev)
 {
        struct yaffs_allocator *allocator;
 
index 777f3b0..5b06840 100644 (file)
 
 #include "yaffs_guts.h"
 
-void yaffs_init_raw_tnodes_and_objs(yaffs_dev_t *dev);
-void yaffs_deinit_raw_tnodes_and_objs(yaffs_dev_t *dev);
+void yaffs_init_raw_tnodes_and_objs(struct yaffs_dev *dev);
+void yaffs_deinit_raw_tnodes_and_objs(struct yaffs_dev *dev);
 
-yaffs_tnode_t *yaffs_alloc_raw_tnode(yaffs_dev_t *dev);
-void yaffs_free_raw_tnode(yaffs_dev_t *dev, yaffs_tnode_t *tn);
+yaffs_tnode_t *yaffs_alloc_raw_tnode(struct yaffs_dev *dev);
+void yaffs_free_raw_tnode(struct yaffs_dev *dev, yaffs_tnode_t *tn);
 
-yaffs_obj_t *yaffs_alloc_raw_obj(yaffs_dev_t *dev);
-void yaffs_free_raw_obj(yaffs_dev_t *dev, yaffs_obj_t *obj);
+struct yaffs_obj *yaffs_alloc_raw_obj(struct yaffs_dev *dev);
+void yaffs_free_raw_obj(struct yaffs_dev *dev, struct yaffs_obj *obj);
 
 #endif
index 53712d1..d54a27a 100644 (file)
@@ -17,7 +17,7 @@
  * Chunk bitmap manipulations
  */
 
-static Y_INLINE u8 *yaffs_block_bits(yaffs_dev_t *dev, int blk)
+static Y_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,
@@ -29,7 +29,7 @@ static Y_INLINE u8 *yaffs_block_bits(yaffs_dev_t *dev, int blk)
                (dev->chunk_bit_stride * (blk - dev->internal_start_block));
 }
 
-void yaffs_verify_chunk_bit_id(yaffs_dev_t *dev, int blk, int chunk)
+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) {
@@ -40,14 +40,14 @@ void yaffs_verify_chunk_bit_id(yaffs_dev_t *dev, int blk, int chunk)
        }
 }
 
-void yaffs_clear_chunk_bits(yaffs_dev_t *dev, int blk)
+void yaffs_clear_chunk_bits(struct yaffs_dev *dev, int blk)
 {
        u8 *blk_bits = yaffs_block_bits(dev, blk);
 
        memset(blk_bits, 0, dev->chunk_bit_stride);
 }
 
-void yaffs_clear_chunk_bit(yaffs_dev_t *dev, int blk, int chunk)
+void yaffs_clear_chunk_bit(struct yaffs_dev *dev, int blk, int chunk)
 {
        u8 *blk_bits = yaffs_block_bits(dev, blk);
 
@@ -56,7 +56,7 @@ void yaffs_clear_chunk_bit(yaffs_dev_t *dev, int blk, int chunk)
        blk_bits[chunk / 8] &= ~(1 << (chunk & 7));
 }
 
-void yaffs_set_chunk_bit(yaffs_dev_t *dev, int blk, int chunk)
+void yaffs_set_chunk_bit(struct yaffs_dev *dev, int blk, int chunk)
 {
        u8 *blk_bits = yaffs_block_bits(dev, blk);
 
@@ -65,7 +65,7 @@ void yaffs_set_chunk_bit(yaffs_dev_t *dev, int blk, int chunk)
        blk_bits[chunk / 8] |= (1 << (chunk & 7));
 }
 
-int yaffs_check_chunk_bit(yaffs_dev_t *dev, int blk, int chunk)
+int yaffs_check_chunk_bit(struct yaffs_dev *dev, int blk, int chunk)
 {
        u8 *blk_bits = yaffs_block_bits(dev, blk);
        yaffs_verify_chunk_bit_id(dev, blk, chunk);
@@ -73,7 +73,7 @@ int yaffs_check_chunk_bit(yaffs_dev_t *dev, int blk, int chunk)
        return (blk_bits[chunk / 8] & (1 << (chunk & 7))) ? 1 : 0;
 }
 
-int yaffs_still_some_chunks(yaffs_dev_t *dev, int blk)
+int yaffs_still_some_chunks(struct yaffs_dev *dev, int blk)
 {
        u8 *blk_bits = yaffs_block_bits(dev, blk);
        int i;
@@ -85,7 +85,7 @@ int yaffs_still_some_chunks(yaffs_dev_t *dev, int blk)
        return 0;
 }
 
-int yaffs_count_chunk_bits(yaffs_dev_t *dev, int blk)
+int yaffs_count_chunk_bits(struct yaffs_dev *dev, int blk)
 {
        u8 *blk_bits = yaffs_block_bits(dev, blk);
        int i;
index ea755be..cf9ea58 100644 (file)
 
 #include "yaffs_guts.h"
 
-void yaffs_verify_chunk_bit_id(yaffs_dev_t *dev, int blk, int chunk);
-void yaffs_clear_chunk_bits(yaffs_dev_t *dev, int blk);
-void yaffs_clear_chunk_bit(yaffs_dev_t *dev, int blk, int chunk);
-void yaffs_set_chunk_bit(yaffs_dev_t *dev, int blk, int chunk);
-int yaffs_check_chunk_bit(yaffs_dev_t *dev, int blk, int chunk);
-int yaffs_still_some_chunks(yaffs_dev_t *dev, int blk);
-int yaffs_count_chunk_bits(yaffs_dev_t *dev, int blk);
+void yaffs_verify_chunk_bit_id(struct yaffs_dev *dev, int blk, int chunk);
+void yaffs_clear_chunk_bits(struct yaffs_dev *dev, int blk);
+void yaffs_clear_chunk_bit(struct yaffs_dev *dev, int blk, int chunk);
+void yaffs_set_chunk_bit(struct yaffs_dev *dev, int blk, int chunk);
+int yaffs_check_chunk_bit(struct yaffs_dev *dev, int blk, int chunk);
+int yaffs_still_some_chunks(struct yaffs_dev *dev, int blk);
+int yaffs_count_chunk_bits(struct yaffs_dev *dev, int blk);
 
 #endif
index 519f406..975546f 100644 (file)
@@ -14,7 +14,7 @@
 #include "yaffs_checkptrw.h"
 #include "yaffs_getblockinfo.h"
 
-static int yaffs2_checkpt_space_ok(yaffs_dev_t *dev)
+static int yaffs2_checkpt_space_ok(struct yaffs_dev *dev)
 {
        int blocks_avail = dev->n_erased_blocks - dev->param.n_reserved_blocks;
 
@@ -26,7 +26,7 @@ static int yaffs2_checkpt_space_ok(yaffs_dev_t *dev)
 }
 
 
-static int yaffs_checkpt_erase(yaffs_dev_t *dev)
+static int yaffs_checkpt_erase(struct yaffs_dev *dev)
 {
        int i;
 
@@ -59,7 +59,7 @@ static int yaffs_checkpt_erase(yaffs_dev_t *dev)
 }
 
 
-static void yaffs2_checkpt_find_erased_block(yaffs_dev_t *dev)
+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;
@@ -87,10 +87,10 @@ static void yaffs2_checkpt_find_erased_block(yaffs_dev_t *dev)
        dev->checkpt_cur_block = -1;
 }
 
-static void yaffs2_checkpt_find_block(yaffs_dev_t *dev)
+static void yaffs2_checkpt_find_block(struct yaffs_dev *dev)
 {
        int  i;
-       yaffs_ext_tags tags;
+       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));
@@ -123,7 +123,7 @@ static void yaffs2_checkpt_find_block(yaffs_dev_t *dev)
 }
 
 
-int yaffs2_checkpt_open(yaffs_dev_t *dev, int writing)
+int yaffs2_checkpt_open(struct yaffs_dev *dev, int writing)
 {
 
 
@@ -177,7 +177,7 @@ int yaffs2_checkpt_open(yaffs_dev_t *dev, int writing)
        return 1;
 }
 
-int yaffs2_get_checkpt_sum(yaffs_dev_t *dev, u32 *sum)
+int yaffs2_get_checkpt_sum(struct yaffs_dev *dev, u32 *sum)
 {
        u32 composite_sum;
        composite_sum =  (dev->checkpt_sum << 8) | (dev->checkpt_xor & 0xFF);
@@ -185,12 +185,12 @@ int yaffs2_get_checkpt_sum(yaffs_dev_t *dev, u32 *sum)
        return 1;
 }
 
-static int yaffs2_checkpt_flush_buffer(yaffs_dev_t *dev)
+static int yaffs2_checkpt_flush_buffer(struct yaffs_dev *dev)
 {
        int chunk;
        int realigned_chunk;
 
-       yaffs_ext_tags tags;
+       struct yaffs_ext_tags tags;
 
        if (dev->checkpt_cur_block < 0) {
                yaffs2_checkpt_find_erased_block(dev);
@@ -238,7 +238,7 @@ static int yaffs2_checkpt_flush_buffer(yaffs_dev_t *dev)
 }
 
 
-int yaffs2_checkpt_wr(yaffs_dev_t *dev, const void *data, int n_bytes)
+int yaffs2_checkpt_wr(struct yaffs_dev *dev, const void *data, int n_bytes)
 {
        int i = 0;
        int ok = 1;
@@ -273,11 +273,11 @@ int yaffs2_checkpt_wr(yaffs_dev_t *dev, const void *data, int n_bytes)
        return i;
 }
 
-int yaffs2_checkpt_rd(yaffs_dev_t *dev, void *data, int n_bytes)
+int yaffs2_checkpt_rd(struct yaffs_dev *dev, void *data, int n_bytes)
 {
        int i = 0;
        int ok = 1;
-       yaffs_ext_tags tags;
+       struct yaffs_ext_tags tags;
 
 
        int chunk;
@@ -347,7 +347,7 @@ int yaffs2_checkpt_rd(yaffs_dev_t *dev, void *data, int n_bytes)
        return  i;
 }
 
-int yaffs_checkpt_close(yaffs_dev_t *dev)
+int yaffs_checkpt_close(struct yaffs_dev *dev)
 {
 
        if (dev->checkpt_open_write) {
@@ -386,7 +386,7 @@ int yaffs_checkpt_close(yaffs_dev_t *dev)
                return 0;
 }
 
-int yaffs2_checkpt_invalidate_stream(yaffs_dev_t *dev)
+int yaffs2_checkpt_invalidate_stream(struct yaffs_dev *dev)
 {
        /* Erase the checkpoint data */
 
index 3e446a1..07ceb36 100644 (file)
 
 #include "yaffs_guts.h"
 
-int yaffs2_checkpt_open(yaffs_dev_t *dev, int writing);
+int yaffs2_checkpt_open(struct yaffs_dev *dev, int writing);
 
-int yaffs2_checkpt_wr(yaffs_dev_t *dev, const void *data, int n_bytes);
+int yaffs2_checkpt_wr(struct yaffs_dev *dev, const void *data, int n_bytes);
 
-int yaffs2_checkpt_rd(yaffs_dev_t *dev, void *data, int n_bytes);
+int yaffs2_checkpt_rd(struct yaffs_dev *dev, void *data, int n_bytes);
 
-int yaffs2_get_checkpt_sum(yaffs_dev_t *dev, u32 *sum);
+int yaffs2_get_checkpt_sum(struct yaffs_dev *dev, u32 *sum);
 
-int yaffs_checkpt_close(yaffs_dev_t *dev);
+int yaffs_checkpt_close(struct yaffs_dev *dev);
 
-int yaffs2_checkpt_invalidate_stream(yaffs_dev_t *dev);
+int yaffs2_checkpt_invalidate_stream(struct yaffs_dev *dev);
 
 
 #endif
index 1c43b6c..5c35795 100644 (file)
@@ -20,7 +20,7 @@
 #include "yaffs_trace.h"
 
 /* Function to manipulate block info */
-static Y_INLINE yaffs_block_info_t *yaffs_get_block_info(yaffs_dev_t * dev, int blk)
+static Y_INLINE yaffs_block_info_t *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,
index a88f4d0..06bb13c 100644 (file)
 
 
 /* Robustification (if it ever comes about...) */
-static void yaffs_retire_block(yaffs_dev_t *dev, int flash_block);
-static void yaffs_handle_chunk_wr_error(yaffs_dev_t *dev, int nand_chunk,
+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(yaffs_dev_t *dev, int nand_chunk,
+static void yaffs_handle_chunk_wr_ok(struct yaffs_dev *dev, int nand_chunk,
                                const u8 *data,
-                               const yaffs_ext_tags *tags);
-static void yaffs_handle_chunk_update(yaffs_dev_t *dev, int nand_chunk,
-                               const yaffs_ext_tags *tags);
+                               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(yaffs_obj_t *obj);
-static int yaffs_unlink_obj(yaffs_obj_t *obj);
-static int yaffs_obj_cache_dirty(yaffs_obj_t *obj);
+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(yaffs_dev_t *dev,
+static int yaffs_write_new_chunk(struct yaffs_dev *dev,
                                        const u8 *buffer,
-                                       yaffs_ext_tags *tags,
+                                       struct yaffs_ext_tags *tags,
                                        int use_reserver);
 
 
-static yaffs_obj_t *yaffs_new_obj(yaffs_dev_t *dev, int number,
-                                       yaffs_obj_type type);
+static struct yaffs_obj *yaffs_new_obj(struct yaffs_dev *dev, int number,
+                                       enum yaffs_obj_type type);
 
 
-static int yaffs_apply_xattrib_mod(yaffs_obj_t *obj, char *buffer, yaffs_xattr_mod *xmod);
+static int yaffs_apply_xattrib_mod(struct yaffs_obj *obj, char *buffer, yaffs_xattr_mod *xmod);
 
-static void yaffs_remove_obj_from_dir(yaffs_obj_t *obj);
+static void yaffs_remove_obj_from_dir(struct yaffs_obj *obj);
 static int yaffs_check_structures(void);
-static int yaffs_generic_obj_del(yaffs_obj_t *in);
+static int yaffs_generic_obj_del(struct yaffs_obj *in);
 
-static int yaffs_check_chunk_erased(struct yaffs_dev_s *dev,
+static int yaffs_check_chunk_erased(struct yaffs_dev *dev,
                                int nand_chunk);
 
-static int yaffs_unlink_worker(yaffs_obj_t *obj);
+static int yaffs_unlink_worker(struct yaffs_obj *obj);
 
-static int yaffs_tags_match(const yaffs_ext_tags *tags, int obj_id,
+static int yaffs_tags_match(const struct yaffs_ext_tags *tags, int obj_id,
                        int chunk_obj);
 
-static int yaffs_alloc_chunk(yaffs_dev_t *dev, int use_reserver,
+static int yaffs_alloc_chunk(struct yaffs_dev *dev, int use_reserver,
                                yaffs_block_info_t **block_ptr);
 
-static void yaffs_check_obj_details_loaded(yaffs_obj_t *in);
+static void yaffs_check_obj_details_loaded(struct yaffs_obj *in);
 
-static void yaffs_invalidate_whole_cache(yaffs_obj_t *in);
-static void yaffs_invalidate_chunk_cache(yaffs_obj_t *object, int chunk_id);
+static void yaffs_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(yaffs_obj_t *in, int inode_chunk,
-                               yaffs_ext_tags *tags);
+static int yaffs_find_chunk_in_file(struct yaffs_obj *in, int inode_chunk,
+                               struct yaffs_ext_tags *tags);
 
-static int yaffs_verify_chunk_written(yaffs_dev_t *dev,
+static int yaffs_verify_chunk_written(struct yaffs_dev *dev,
                                        int nand_chunk,
                                        const u8 *data,
-                                       yaffs_ext_tags *tags);
+                                       struct yaffs_ext_tags *tags);
 
 
-static void yaffs_load_name_from_oh(yaffs_dev_t *dev,YCHAR *name, const YCHAR *oh_name, int buff_size);
-static void yaffs_load_oh_from_name(yaffs_dev_t *dev,YCHAR *oh_name, const YCHAR *name);
+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 */
 
-static void yaffs_addr_to_chunk(yaffs_dev_t *dev, loff_t addr, int *chunk_out,
+static void yaffs_addr_to_chunk(struct yaffs_dev *dev, loff_t addr, int *chunk_out,
                u32 *offset_out)
 {
        int chunk;
@@ -181,7 +181,7 @@ static u32 calc_shifts(u32 x)
  * Temporary buffer manipulations.
  */
 
-static int yaffs_init_tmp_buffers(yaffs_dev_t *dev)
+static int yaffs_init_tmp_buffers(struct yaffs_dev *dev)
 {
        int i;
        u8 *buf = (u8 *)1;
@@ -197,7 +197,7 @@ static int yaffs_init_tmp_buffers(yaffs_dev_t *dev)
        return buf ? YAFFS_OK : YAFFS_FAIL;
 }
 
-u8 *yaffs_get_temp_buffer(yaffs_dev_t *dev, int line_no)
+u8 *yaffs_get_temp_buffer(struct yaffs_dev *dev, int line_no)
 {
        int i, j;
 
@@ -237,7 +237,7 @@ u8 *yaffs_get_temp_buffer(yaffs_dev_t *dev, int line_no)
 
 }
 
-void yaffs_release_temp_buffer(yaffs_dev_t *dev, u8 *buffer,
+void yaffs_release_temp_buffer(struct yaffs_dev *dev, u8 *buffer,
                                    int line_no)
 {
        int i;
@@ -265,7 +265,7 @@ void yaffs_release_temp_buffer(yaffs_dev_t *dev, u8 *buffer,
 /*
  * Determine if we have a managed buffer.
  */
-int yaffs_is_managed_tmp_buffer(yaffs_dev_t *dev, const u8 *buffer)
+int yaffs_is_managed_tmp_buffer(struct yaffs_dev *dev, const u8 *buffer)
 {
        int i;
 
@@ -309,12 +309,12 @@ static Y_INLINE int yaffs_hash_fn(int n)
  * Note that root might have a presence in NAND if permissions are set.
  */
 
-yaffs_obj_t *yaffs_root(yaffs_dev_t *dev)
+struct yaffs_obj *yaffs_root(struct yaffs_dev *dev)
 {
        return dev->root_dir;
 }
 
-yaffs_obj_t *yaffs_lost_n_found(yaffs_dev_t *dev)
+struct yaffs_obj *yaffs_lost_n_found(struct yaffs_dev *dev)
 {
        return dev->lost_n_found;
 }
@@ -335,12 +335,12 @@ int yaffs_check_ff(u8 *buffer, int n_bytes)
        return 1;
 }
 
-static int yaffs_check_chunk_erased(struct yaffs_dev_s *dev,
+static int yaffs_check_chunk_erased(struct yaffs_dev *dev,
                                int nand_chunk)
 {
        int retval = YAFFS_OK;
        u8 *data = yaffs_get_temp_buffer(dev, __LINE__);
-       yaffs_ext_tags tags;
+       struct yaffs_ext_tags tags;
        int result;
 
        result = yaffs_rd_chunk_tags_nand(dev, nand_chunk, data, &tags);
@@ -361,13 +361,13 @@ static int yaffs_check_chunk_erased(struct yaffs_dev_s *dev,
 }
 
 
-static int yaffs_verify_chunk_written(yaffs_dev_t *dev,
+static int yaffs_verify_chunk_written(struct yaffs_dev *dev,
                                        int nand_chunk,
                                        const u8 *data,
-                                       yaffs_ext_tags *tags)
+                                       struct yaffs_ext_tags *tags)
 {
        int retval = YAFFS_OK;
-       yaffs_ext_tags temp_tags;
+       struct yaffs_ext_tags temp_tags;
        u8 *buffer = yaffs_get_temp_buffer(dev,__LINE__);
        int result;
        
@@ -383,9 +383,9 @@ static int yaffs_verify_chunk_written(yaffs_dev_t *dev,
        return retval;
 }
 
-static int yaffs_write_new_chunk(struct yaffs_dev_s *dev,
+static int yaffs_write_new_chunk(struct yaffs_dev *dev,
                                        const u8 *data,
-                                       yaffs_ext_tags *tags,
+                                       struct yaffs_ext_tags *tags,
                                        int use_reserver)
 {
        int attempts = 0;
@@ -491,7 +491,7 @@ static int yaffs_write_new_chunk(struct yaffs_dev_s *dev,
  * Block retiring for handling a broken block.
  */
 
-static void yaffs_retire_block(yaffs_dev_t *dev, int flash_block)
+static void yaffs_retire_block(struct yaffs_dev *dev, int flash_block)
 {
        yaffs_block_info_t *bi = yaffs_get_block_info(dev, flash_block);
 
@@ -505,7 +505,7 @@ static void yaffs_retire_block(yaffs_dev_t *dev, int flash_block)
                                "yaffs: Failed to mark bad and erase block %d"
                                TENDSTR), flash_block));
                } else {
-                       yaffs_ext_tags tags;
+                       struct yaffs_ext_tags tags;
                        int chunk_id = flash_block * dev->param.chunks_per_block;
 
                        u8 *buffer = yaffs_get_temp_buffer(dev, __LINE__);
@@ -535,9 +535,9 @@ static void yaffs_retire_block(yaffs_dev_t *dev, int flash_block)
  *
  */
 
-static void yaffs_handle_chunk_wr_ok(yaffs_dev_t *dev, int nand_chunk,
+static void yaffs_handle_chunk_wr_ok(struct yaffs_dev *dev, int nand_chunk,
                                const u8 *data,
-                               const yaffs_ext_tags *tags)
+                               const struct yaffs_ext_tags *tags)
 {
        dev=dev;
        nand_chunk=nand_chunk;
@@ -545,15 +545,15 @@ static void yaffs_handle_chunk_wr_ok(yaffs_dev_t *dev, int nand_chunk,
        tags=tags;
 }
 
-static void yaffs_handle_chunk_update(yaffs_dev_t *dev, int nand_chunk,
-                               const yaffs_ext_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(yaffs_dev_t *dev, yaffs_block_info_t *bi)
+void yaffs_handle_chunk_error(struct yaffs_dev *dev, yaffs_block_info_t *bi)
 {
        if (!bi->gc_prioritise) {
                bi->gc_prioritise = 1;
@@ -568,7 +568,7 @@ void yaffs_handle_chunk_error(yaffs_dev_t *dev, yaffs_block_info_t *bi)
        }
 }
 
-static void yaffs_handle_chunk_wr_error(yaffs_dev_t *dev, int nand_chunk,
+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;
@@ -609,7 +609,7 @@ static u16 yaffs_calc_name_sum(const YCHAR *name)
        return sum;
 }
 
-void yaffs_set_obj_name(yaffs_obj_t *obj, const YCHAR *name)
+void yaffs_set_obj_name(struct yaffs_obj *obj, const YCHAR *name)
 {
 #ifdef CONFIG_YAFFS_SHORT_NAMES_IN_RAM
        memset(obj->short_name, 0, sizeof(YCHAR) * (YAFFS_SHORT_NAME_LENGTH+1));
@@ -621,7 +621,7 @@ void yaffs_set_obj_name(yaffs_obj_t *obj, const YCHAR *name)
        obj->sum = yaffs_calc_name_sum(name);
 }
 
-void yaffs_set_obj_name_from_oh(yaffs_obj_t *obj, const yaffs_obj_header *oh)
+void yaffs_set_obj_name_from_oh(struct yaffs_obj *obj, const struct yaffs_obj_hdr *oh)
 {
 #ifdef CONFIG_YAFFS_AUTO_UNICODE
        YCHAR tmp_name[YAFFS_MAX_NAME_LENGTH+1];
@@ -641,7 +641,7 @@ void yaffs_set_obj_name_from_oh(yaffs_obj_t *obj, const yaffs_obj_header *oh)
  */
 
 
-yaffs_tnode_t *yaffs_get_tnode(yaffs_dev_t *dev)
+yaffs_tnode_t *yaffs_get_tnode(struct yaffs_dev *dev)
 {
        yaffs_tnode_t *tn = yaffs_alloc_raw_tnode(dev);
        if (tn){
@@ -655,14 +655,14 @@ yaffs_tnode_t *yaffs_get_tnode(yaffs_dev_t *dev)
 }
 
 /* FreeTnode frees up a tnode and puts it back on the free list */
-static void yaffs_free_tnode(yaffs_dev_t *dev, yaffs_tnode_t *tn)
+static void yaffs_free_tnode(struct yaffs_dev *dev, yaffs_tnode_t *tn)
 {
        yaffs_free_raw_tnode(dev,tn);
        dev->n_tnodes--;
        dev->checkpoint_blocks_required = 0; /* force recalculation*/
 }
 
-static void yaffs_deinit_tnodes_and_objs(yaffs_dev_t *dev)
+static void yaffs_deinit_tnodes_and_objs(struct yaffs_dev *dev)
 {
        yaffs_deinit_raw_tnodes_and_objs(dev);
        dev->n_obj = 0;
@@ -670,7 +670,7 @@ static void yaffs_deinit_tnodes_and_objs(yaffs_dev_t *dev)
 }
 
 
-void yaffs_load_tnode_0(yaffs_dev_t *dev, yaffs_tnode_t *tn, unsigned pos,
+void yaffs_load_tnode_0(struct yaffs_dev *dev, yaffs_tnode_t *tn, unsigned pos,
                unsigned val)
 {
        u32 *map = (u32 *)tn;
@@ -700,7 +700,7 @@ void yaffs_load_tnode_0(yaffs_dev_t *dev, yaffs_tnode_t *tn, unsigned pos,
        }
 }
 
-u32 yaffs_get_group_base(yaffs_dev_t *dev, yaffs_tnode_t *tn,
+u32 yaffs_get_group_base(struct yaffs_dev *dev, yaffs_tnode_t *tn,
                unsigned pos)
 {
        u32 *map = (u32 *)tn;
@@ -737,7 +737,7 @@ u32 yaffs_get_group_base(yaffs_dev_t *dev, yaffs_tnode_t *tn,
  */
 
 /* FindLevel0Tnode finds the level 0 tnode, if one exists. */
-yaffs_tnode_t *yaffs_find_tnode_0(yaffs_dev_t *dev,
+yaffs_tnode_t *yaffs_find_tnode_0(struct yaffs_dev *dev,
                                        yaffs_file_s *file_struct,
                                        u32 chunk_id)
 {
@@ -791,7 +791,7 @@ yaffs_tnode_t *yaffs_find_tnode_0(yaffs_dev_t *dev,
  *  be plugged into the ttree.
  */
 
-yaffs_tnode_t *yaffs_add_find_tnode_0(yaffs_dev_t *dev,
+yaffs_tnode_t *yaffs_add_find_tnode_0(struct yaffs_dev *dev,
                                        yaffs_file_s *file_struct,
                                        u32 chunk_id,
                                        yaffs_tnode_t *passed_tn)
@@ -887,8 +887,8 @@ yaffs_tnode_t *yaffs_add_find_tnode_0(yaffs_dev_t *dev,
        return tn;
 }
 
-static int yaffs_find_chunk_in_group(yaffs_dev_t *dev, int the_chunk,
-                               yaffs_ext_tags *tags, int obj_id,
+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)
 {
        int j;
@@ -914,7 +914,7 @@ static int yaffs_find_chunk_in_group(yaffs_dev_t *dev, int the_chunk,
 }
 
 
-static void yaffs_soft_del_chunk(yaffs_dev_t *dev, int chunk)
+static void yaffs_soft_del_chunk(struct yaffs_dev *dev, int chunk)
 {
        yaffs_block_info_t *the_block;
        unsigned block_no;
@@ -936,13 +936,13 @@ static void yaffs_soft_del_chunk(yaffs_dev_t *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_obj_t *in, yaffs_tnode_t *tn,
+static int yaffs_soft_del_worker(struct yaffs_obj *in, yaffs_tnode_t *tn,
                                  u32 level, int chunk_offset)
 {
        int i;
        int the_chunk;
        int all_done = 1;
-       yaffs_dev_t *dev = in->my_dev;
+       struct yaffs_dev *dev = in->my_dev;
 
        if (tn) {
                if (level > 0) {
@@ -994,7 +994,7 @@ static int yaffs_soft_del_worker(yaffs_obj_t *in, yaffs_tnode_t *tn,
 
 }
 
-static void yaffs_soft_del_file(yaffs_obj_t *obj)
+static void yaffs_soft_del_file(struct yaffs_obj *obj)
 {
        if (obj->deleted &&
            obj->variant_type == YAFFS_OBJECT_TYPE_FILE && !obj->soft_del) {
@@ -1032,7 +1032,7 @@ static void yaffs_soft_del_file(yaffs_obj_t *obj)
  * If there is no data in a subtree then it is pruned.
  */
 
-static yaffs_tnode_t *yaffs_prune_worker(yaffs_dev_t *dev, yaffs_tnode_t *tn,
+static yaffs_tnode_t *yaffs_prune_worker(struct yaffs_dev *dev, yaffs_tnode_t *tn,
                                u32 level, int del0)
 {
        int i;
@@ -1076,7 +1076,7 @@ static yaffs_tnode_t *yaffs_prune_worker(yaffs_dev_t *dev, yaffs_tnode_t *tn,
 
 }
 
-static int yaffs_prune_tree(yaffs_dev_t *dev,
+static int yaffs_prune_tree(struct yaffs_dev *dev,
                                yaffs_file_s *file_struct)
 {
        int i;
@@ -1121,16 +1121,16 @@ static int yaffs_prune_tree(yaffs_dev_t *dev,
 
 
 /* AllocateEmptyObject gets us a clean Object. Tries to make allocate more if we run out */
-static yaffs_obj_t *yaffs_alloc_empty_obj(yaffs_dev_t *dev)
+static struct yaffs_obj *yaffs_alloc_empty_obj(struct yaffs_dev *dev)
 {
-       yaffs_obj_t *obj = yaffs_alloc_raw_obj(dev);
+       struct yaffs_obj *obj = yaffs_alloc_raw_obj(dev);
 
        if (obj) {
                dev->n_obj++;
 
                /* Now sweeten it up... */
 
-               memset(obj, 0, sizeof(yaffs_obj_t));
+               memset(obj, 0, sizeof(struct yaffs_obj));
                obj->being_created = 1;
 
                obj->my_dev = dev;
@@ -1162,11 +1162,11 @@ static yaffs_obj_t *yaffs_alloc_empty_obj(yaffs_dev_t *dev)
        return obj;
 }
 
-static yaffs_obj_t *yaffs_create_fake_dir(yaffs_dev_t *dev, int number,
+static struct yaffs_obj *yaffs_create_fake_dir(struct yaffs_dev *dev, int number,
                                               u32 mode)
 {
 
-       yaffs_obj_t *obj =
+       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... */
@@ -1183,10 +1183,10 @@ static yaffs_obj_t *yaffs_create_fake_dir(yaffs_dev_t *dev, int number,
 
 }
 
-static void yaffs_unhash_obj(yaffs_obj_t *obj)
+static void yaffs_unhash_obj(struct yaffs_obj *obj)
 {
        int bucket;
-       yaffs_dev_t *dev = obj->my_dev;
+       struct yaffs_dev *dev = obj->my_dev;
 
        /* If it is still linked into the bucket list, free from the list */
        if (!ylist_empty(&obj->hash_link)) {
@@ -1197,9 +1197,9 @@ static void yaffs_unhash_obj(yaffs_obj_t *obj)
 }
 
 /*  FreeObject frees up a Object and puts it back on the free list */
-static void yaffs_free_obj(yaffs_obj_t *obj)
+static void yaffs_free_obj(struct yaffs_obj *obj)
 {
-       yaffs_dev_t *dev = obj->my_dev;
+       struct yaffs_dev *dev = obj->my_dev;
 
        T(YAFFS_TRACE_OS, (TSTR("FreeObject %p inode %p"TENDSTR), obj, obj->my_inode));
 
@@ -1227,13 +1227,13 @@ static void yaffs_free_obj(yaffs_obj_t *obj)
 }
 
 
-void yaffs_handle_defered_free(yaffs_obj_t *obj)
+void yaffs_handle_defered_free(struct yaffs_obj *obj)
 {
        if (obj->defered_free)
                yaffs_free_obj(obj);
 }
 
-static void yaffs_init_tnodes_and_objs(yaffs_dev_t *dev)
+static void yaffs_init_tnodes_and_objs(struct yaffs_dev *dev)
 {
        int i;
 
@@ -1248,7 +1248,7 @@ static void yaffs_init_tnodes_and_objs(yaffs_dev_t *dev)
        }
 }
 
-static int yaffs_find_nice_bucket(yaffs_dev_t *dev)
+static int yaffs_find_nice_bucket(struct yaffs_dev *dev)
 {
        int i;
        int l = 999;
@@ -1272,7 +1272,7 @@ static int yaffs_find_nice_bucket(yaffs_dev_t *dev)
        return l;
 }
 
-static int yaffs_new_obj_id(yaffs_dev_t *dev)
+static int yaffs_new_obj_id(struct yaffs_dev *dev)
 {
        int bucket = yaffs_find_nice_bucket(dev);
 
@@ -1293,7 +1293,7 @@ static int yaffs_new_obj_id(yaffs_dev_t *dev)
                if (1 || dev->obj_bucket[bucket].count > 0) {
                        ylist_for_each(i, &dev->obj_bucket[bucket].list) {
                                /* If there is already one in the list */
-                               if (i && ylist_entry(i, yaffs_obj_t,
+                               if (i && ylist_entry(i, struct yaffs_obj,
                                                hash_link)->obj_id == n) {
                                        found = 0;
                                }
@@ -1304,25 +1304,25 @@ static int yaffs_new_obj_id(yaffs_dev_t *dev)
        return n;
 }
 
-static void yaffs_hash_obj(yaffs_obj_t *in)
+static void yaffs_hash_obj(struct yaffs_obj *in)
 {
        int bucket = yaffs_hash_fn(in->obj_id);
-       yaffs_dev_t *dev = in->my_dev;
+       struct yaffs_dev *dev = in->my_dev;
 
        ylist_add(&in->hash_link, &dev->obj_bucket[bucket].list);
        dev->obj_bucket[bucket].count++;
 }
 
-yaffs_obj_t *yaffs_find_by_number(yaffs_dev_t *dev, u32 number)
+struct yaffs_obj *yaffs_find_by_number(struct yaffs_dev *dev, u32 number)
 {
        int bucket = yaffs_hash_fn(number);
        struct ylist_head *i;
-       yaffs_obj_t *in;
+       struct yaffs_obj *in;
 
        ylist_for_each(i, &dev->obj_bucket[bucket].list) {
                /* Look if it is in the list */
                if (i) {
-                       in = ylist_entry(i, yaffs_obj_t, hash_link);
+                       in = ylist_entry(i, struct yaffs_obj, hash_link);
                        if (in->obj_id == number) {
 
                                /* Don't tell the VFS about this one if it is defered free */
@@ -1337,10 +1337,10 @@ yaffs_obj_t *yaffs_find_by_number(yaffs_dev_t *dev, u32 number)
        return NULL;
 }
 
-yaffs_obj_t *yaffs_new_obj(yaffs_dev_t *dev, int number,
-                                   yaffs_obj_type type)
+struct yaffs_obj *yaffs_new_obj(struct yaffs_dev *dev, int number,
+                                   enum yaffs_obj_type type)
 {
-       yaffs_obj_t *the_obj=NULL;
+       struct yaffs_obj *the_obj=NULL;
        yaffs_tnode_t *tn = NULL;
 
        if (number < 0)
@@ -1407,11 +1407,11 @@ yaffs_obj_t *yaffs_new_obj(yaffs_dev_t *dev, int number,
        return the_obj;
 }
 
-yaffs_obj_t *yaffs_find_or_create_by_number(yaffs_dev_t *dev,
+struct yaffs_obj *yaffs_find_or_create_by_number(struct yaffs_dev *dev,
                                                int number,
-                                               yaffs_obj_type type)
+                                               enum yaffs_obj_type type)
 {
-       yaffs_obj_t *the_obj = NULL;
+       struct yaffs_obj *the_obj = NULL;
 
        if (number > 0)
                the_obj = yaffs_find_by_number(dev, number);
@@ -1449,19 +1449,19 @@ YCHAR *yaffs_clone_str(const YCHAR *str)
  * rdev only has meaning for devices (a subset of special objects)
  */
 
-static yaffs_obj_t *yaffs_create_obj(yaffs_obj_type type,
-                                      yaffs_obj_t *parent,
+static struct yaffs_obj *yaffs_create_obj(enum yaffs_obj_type type,
+                                      struct yaffs_obj *parent,
                                       const YCHAR *name,
                                       u32 mode,
                                       u32 uid,
                                       u32 gid,
-                                      yaffs_obj_t *equiv_obj,
+                                      struct yaffs_obj *equiv_obj,
                                       const YCHAR *alias_str, u32 rdev)
 {
-       yaffs_obj_t *in;
+       struct yaffs_obj *in;
        YCHAR *str = NULL;
 
-       yaffs_dev_t *dev = parent->my_dev;
+       struct yaffs_dev *dev = parent->my_dev;
 
        /* Check if the entry exists. If it does then fail the call since we don't want a dup.*/
        if (yaffs_find_by_name(parent, name))
@@ -1544,28 +1544,28 @@ static yaffs_obj_t *yaffs_create_obj(yaffs_obj_type type,
        return in;
 }
 
-yaffs_obj_t *yaffs_create_file(yaffs_obj_t *parent, const YCHAR *name,
+struct yaffs_obj *yaffs_create_file(struct yaffs_obj *parent, const YCHAR *name,
                        u32 mode, u32 uid, u32 gid)
 {
        return yaffs_create_obj(YAFFS_OBJECT_TYPE_FILE, parent, name, mode,
                                uid, gid, NULL, NULL, 0);
 }
 
-yaffs_obj_t *yaffs_create_dir(yaffs_obj_t *parent, const YCHAR *name,
+struct yaffs_obj *yaffs_create_dir(struct yaffs_obj *parent, const YCHAR *name,
                                u32 mode, u32 uid, u32 gid)
 {
        return yaffs_create_obj(YAFFS_OBJECT_TYPE_DIRECTORY, parent, name,
                                 mode, uid, gid, NULL, NULL, 0);
 }
 
-yaffs_obj_t *yaffs_create_special(yaffs_obj_t *parent, const YCHAR *name,
+struct yaffs_obj *yaffs_create_special(struct yaffs_obj *parent, const YCHAR *name,
                                u32 mode, u32 uid, u32 gid, u32 rdev)
 {
        return yaffs_create_obj(YAFFS_OBJECT_TYPE_SPECIAL, parent, name, mode,
                                 uid, gid, NULL, NULL, rdev);
 }
 
-yaffs_obj_t *yaffs_create_symlink(yaffs_obj_t *parent, const YCHAR *name,
+struct yaffs_obj *yaffs_create_symlink(struct yaffs_obj *parent, const YCHAR *name,
                                u32 mode, u32 uid, u32 gid,
                                const YCHAR *alias)
 {
@@ -1574,8 +1574,8 @@ yaffs_obj_t *yaffs_create_symlink(yaffs_obj_t *parent, const YCHAR *name,
 }
 
 /* yaffs_link_obj returns the object id of the equivalent object.*/
-yaffs_obj_t *yaffs_link_obj(yaffs_obj_t *parent, const YCHAR *name,
-                       yaffs_obj_t *equiv_obj)
+struct yaffs_obj *yaffs_link_obj(struct yaffs_obj *parent, const YCHAR *name,
+                       struct yaffs_obj *equiv_obj)
 {
        /* Get the real object in case we were fed a hard link as an equivalent object */
        equiv_obj = yaffs_get_equivalent_obj(equiv_obj);
@@ -1590,13 +1590,13 @@ yaffs_obj_t *yaffs_link_obj(yaffs_obj_t *parent, const YCHAR *name,
 
 }
 
-static int yaffs_change_obj_name(yaffs_obj_t *obj, yaffs_obj_t *new_dir,
+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;
 
-       yaffs_obj_t *existing_target;
+       struct yaffs_obj *existing_target;
 
        if (new_dir == NULL)
                new_dir = obj->parent;  /* use the old directory */
@@ -1647,14 +1647,14 @@ static int yaffs_change_obj_name(yaffs_obj_t *obj, yaffs_obj_t *new_dir,
        return YAFFS_FAIL;
 }
 
-int yaffs_rename_obj(yaffs_obj_t *old_dir, const YCHAR *old_name,
-               yaffs_obj_t *new_dir, const YCHAR *new_name)
+int yaffs_rename_obj(struct yaffs_obj *old_dir, const YCHAR *old_name,
+               struct yaffs_obj *new_dir, const YCHAR *new_name)
 {
-       yaffs_obj_t *obj = NULL;
-       yaffs_obj_t *existing_target = NULL;
+       struct yaffs_obj *obj = NULL;
+       struct yaffs_obj *existing_target = NULL;
        int force = 0;
        int result;
-       yaffs_dev_t *dev;
+       struct yaffs_dev *dev;
 
 
        if (!old_dir || old_dir->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY)
@@ -1717,7 +1717,7 @@ int yaffs_rename_obj(yaffs_obj_t *old_dir, const YCHAR *old_name,
 
 /*------------------------- Block Management and Page Allocation ----------------*/
 
-static int yaffs_init_blocks(yaffs_dev_t *dev)
+static int yaffs_init_blocks(struct yaffs_dev *dev)
 {
        int n_blocks = dev->internal_end_block - dev->internal_start_block + 1;
 
@@ -1754,7 +1754,7 @@ static int yaffs_init_blocks(yaffs_dev_t *dev)
        return YAFFS_FAIL;
 }
 
-static void yaffs_deinit_blocks(yaffs_dev_t *dev)
+static void yaffs_deinit_blocks(struct yaffs_dev *dev)
 {
        if (dev->block_info_alt && dev->block_info)
                YFREE_ALT(dev->block_info);
@@ -1773,7 +1773,7 @@ static void yaffs_deinit_blocks(yaffs_dev_t *dev)
        dev->chunk_bits = NULL;
 }
 
-void yaffs_block_became_dirty(yaffs_dev_t *dev, int block_no)
+void yaffs_block_became_dirty(struct yaffs_dev *dev, int block_no)
 {
        yaffs_block_info_t *bi = yaffs_get_block_info(dev, block_no);
 
@@ -1848,7 +1848,7 @@ void yaffs_block_became_dirty(yaffs_dev_t *dev, int block_no)
        }
 }
 
-static int yaffs_find_alloc_block(yaffs_dev_t *dev)
+static int yaffs_find_alloc_block(struct yaffs_dev *dev)
 {
        int i;
 
@@ -1901,7 +1901,7 @@ static int yaffs_find_alloc_block(yaffs_dev_t *dev)
  * Check if there's space to allocate...
  * Thinks.... do we need top make this ths same as yaffs_get_free_chunks()?
  */
-int yaffs_check_alloc_available(yaffs_dev_t *dev, int n_chunks)
+int yaffs_check_alloc_available(struct yaffs_dev *dev, int n_chunks)
 {
        int reserved_chunks;
        int reserved_blocks = dev->param.n_reserved_blocks;
@@ -1914,7 +1914,7 @@ int yaffs_check_alloc_available(yaffs_dev_t *dev, int n_chunks)
        return (dev->n_free_chunks > (reserved_chunks + n_chunks));
 }
 
-static int yaffs_alloc_chunk(yaffs_dev_t *dev, int use_reserver,
+static int yaffs_alloc_chunk(struct yaffs_dev *dev, int use_reserver,
                yaffs_block_info_t **block_ptr)
 {
        int ret_val;
@@ -1968,7 +1968,7 @@ static int yaffs_alloc_chunk(yaffs_dev_t *dev, int use_reserver,
        return -1;
 }
 
-static int yaffs_get_erased_chunks(yaffs_dev_t *dev)
+static int yaffs_get_erased_chunks(struct yaffs_dev *dev)
 {
        int n;
 
@@ -1985,7 +1985,7 @@ static int yaffs_get_erased_chunks(yaffs_dev_t *dev)
  * yaffs_skip_rest_of_block() skips over the rest of the allocation block
  * if we don't want to write to it.
  */
-void yaffs_skip_rest_of_block(yaffs_dev_t *dev)
+void yaffs_skip_rest_of_block(struct yaffs_dev *dev)
 {
        if(dev->alloc_block > 0){
                yaffs_block_info_t *bi = yaffs_get_block_info(dev, dev->alloc_block);
@@ -1997,7 +1997,7 @@ void yaffs_skip_rest_of_block(yaffs_dev_t *dev)
 }
 
 
-static int yaffs_gc_block(yaffs_dev_t *dev, int block,
+static int yaffs_gc_block(struct yaffs_dev *dev, int block,
                int whole_block)
 {
        int old_chunk;
@@ -2012,11 +2012,11 @@ static int yaffs_gc_block(yaffs_dev_t *dev, int block,
        int chunks_before = yaffs_get_erased_chunks(dev);
        int chunks_after;
 
-       yaffs_ext_tags tags;
+       struct yaffs_ext_tags tags;
 
        yaffs_block_info_t *bi = yaffs_get_block_info(dev, block);
 
-       yaffs_obj_t *object;
+       struct yaffs_obj *object;
 
        is_checkpt_block = (bi->block_state == YAFFS_BLOCK_STATE_CHECKPOINT);
 
@@ -2162,8 +2162,8 @@ static int yaffs_gc_block(yaffs_dev_t *dev, int block,
                                                 * and if it is left in place it will mess up scanning.
                                                 */
 
-                                               yaffs_obj_header *oh;
-                                               oh = (yaffs_obj_header *)buffer;
+                                               struct yaffs_obj_hdr *oh;
+                                               oh = (struct yaffs_obj_hdr *)buffer;
 
                                                oh->is_shrink = 0;
                                                tags.extra_is_shrink = 0;
@@ -2274,7 +2274,7 @@ static int yaffs_gc_block(yaffs_dev_t *dev, int block,
  * for garbage collection.
  */
 
-static unsigned yaffs_find_gc_block(yaffs_dev_t *dev,
+static unsigned yaffs_find_gc_block(struct yaffs_dev *dev,
                                        int aggressive,
                                        int background)
 {
@@ -2439,7 +2439,7 @@ static unsigned yaffs_find_gc_block(yaffs_dev_t *dev,
  * The idea is to help clear out space in a more spread-out manner.
  * Dunno if it really does anything useful.
  */
-static int yaffs_check_gc(yaffs_dev_t *dev, int background)
+static int yaffs_check_gc(struct yaffs_dev *dev, int background)
 {
        int aggressive = 0;
        int gc_ok = YAFFS_OK;
@@ -2534,7 +2534,7 @@ static int yaffs_check_gc(yaffs_dev_t *dev, int background)
  * 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(yaffs_dev_t *dev, unsigned urgency)
+int yaffs_bg_gc(struct yaffs_dev *dev, unsigned urgency)
 {
        int erased_chunks = dev->n_erased_blocks * dev->param.chunks_per_block;
 
@@ -2546,7 +2546,7 @@ int yaffs_bg_gc(yaffs_dev_t *dev, unsigned urgency)
 
 /*-------------------------  TAGS --------------------------------*/
 
-static int yaffs_tags_match(const yaffs_ext_tags *tags, int obj_id,
+static int yaffs_tags_match(const struct yaffs_ext_tags *tags, int obj_id,
                           int chunk_obj)
 {
        return (tags->chunk_id == chunk_obj &&
@@ -2557,16 +2557,16 @@ static int yaffs_tags_match(const yaffs_ext_tags *tags, int obj_id,
 
 /*-------------------- Data file manipulation -----------------*/
 
-static int yaffs_find_chunk_in_file(yaffs_obj_t *in, int inode_chunk,
-                                yaffs_ext_tags *tags)
+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 */
        yaffs_tnode_t *tn;
        int the_chunk = -1;
-       yaffs_ext_tags local_tags;
+       struct yaffs_ext_tags local_tags;
        int ret_val = -1;
 
-       yaffs_dev_t *dev = in->my_dev;
+       struct yaffs_dev *dev = in->my_dev;
 
        if (!tags) {
                /* Passed a NULL, so use our own tags space */
@@ -2585,15 +2585,15 @@ static int yaffs_find_chunk_in_file(yaffs_obj_t *in, int inode_chunk,
        return ret_val;
 }
 
-static int yaffs_find_del_file_chunk(yaffs_obj_t *in, int inode_chunk,
-                                         yaffs_ext_tags *tags)
+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 */
        yaffs_tnode_t *tn;
        int the_chunk = -1;
-       yaffs_ext_tags local_tags;
+       struct yaffs_ext_tags local_tags;
 
-       yaffs_dev_t *dev = in->my_dev;
+       struct yaffs_dev *dev = in->my_dev;
        int ret_val = -1;
 
        if (!tags) {
@@ -2620,7 +2620,7 @@ static int yaffs_find_del_file_chunk(yaffs_obj_t *in, int inode_chunk,
 }
 
 
-int yaffs_put_chunk_in_file(yaffs_obj_t *in, int inode_chunk,
+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.
@@ -2631,10 +2631,10 @@ int yaffs_put_chunk_in_file(yaffs_obj_t *in, int inode_chunk,
         */
 
        yaffs_tnode_t *tn;
-       yaffs_dev_t *dev = in->my_dev;
+       struct yaffs_dev *dev = in->my_dev;
        int existing_cunk;
-       yaffs_ext_tags existing_tags;
-       yaffs_ext_tags new_tags;
+       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) {
@@ -2748,7 +2748,7 @@ int yaffs_put_chunk_in_file(yaffs_obj_t *in, int inode_chunk,
        return YAFFS_OK;
 }
 
-static int yaffs_rd_data_obj(yaffs_obj_t *in, int inode_chunk,
+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);
@@ -2767,11 +2767,11 @@ static int yaffs_rd_data_obj(yaffs_obj_t *in, int inode_chunk,
 
 }
 
-void yaffs_chunk_del(yaffs_dev_t *dev, int chunk_id, int mark_flash, int lyn)
+void yaffs_chunk_del(struct yaffs_dev *dev, int chunk_id, int mark_flash, int lyn)
 {
        int block;
        int page;
-       yaffs_ext_tags tags;
+       struct yaffs_ext_tags tags;
        yaffs_block_info_t *bi;
 
        if (chunk_id <= 0)
@@ -2831,7 +2831,7 @@ void yaffs_chunk_del(yaffs_dev_t *dev, int chunk_id, int mark_flash, int lyn)
 
 }
 
-static int yaffs_wr_data_obj(yaffs_obj_t *in, int inode_chunk,
+static int yaffs_wr_data_obj(struct yaffs_obj *in, int inode_chunk,
                                        const u8 *buffer, int n_bytes,
                                        int use_reserve)
 {
@@ -2841,12 +2841,12 @@ static int yaffs_wr_data_obj(yaffs_obj_t *in, int inode_chunk,
         */
 
        int prev_chunk_id;
-       yaffs_ext_tags prev_tags;
+       struct yaffs_ext_tags prev_tags;
 
        int new_chunk_id;
-       yaffs_ext_tags new_tags;
+       struct yaffs_ext_tags new_tags;
 
-       yaffs_dev_t *dev = in->my_dev;
+       struct yaffs_dev *dev = in->my_dev;
 
        yaffs_check_gc(dev,0);
 
@@ -2894,27 +2894,27 @@ static int yaffs_wr_data_obj(yaffs_obj_t *in, int inode_chunk,
 /* UpdateObjectHeader updates the header on NAND for an object.
  * If name is not NULL, then that new name is used.
  */
-int yaffs_update_oh(yaffs_obj_t *in, const YCHAR *name, int force,
+int yaffs_update_oh(struct yaffs_obj *in, const YCHAR *name, int force,
                             int is_shrink, int shadows, yaffs_xattr_mod *xmod)
 {
 
        yaffs_block_info_t *bi;
 
-       yaffs_dev_t *dev = in->my_dev;
+       struct yaffs_dev *dev = in->my_dev;
 
        int prev_chunk_id;
        int ret_val = 0;
        int result = 0;
 
        int new_chunk_id;
-       yaffs_ext_tags new_tags;
-       yaffs_ext_tags old_tags;
+       struct yaffs_ext_tags new_tags;
+       struct yaffs_ext_tags old_tags;
        const YCHAR *alias = NULL;
 
        u8 *buffer = NULL;
        YCHAR old_name[YAFFS_MAX_NAME_LENGTH + 1];
 
-       yaffs_obj_header *oh = NULL;
+       struct yaffs_obj_hdr *oh = NULL;
 
        yaffs_strcpy(old_name, _Y("silly old name"));
 
@@ -2927,7 +2927,7 @@ int yaffs_update_oh(yaffs_obj_t *in, const YCHAR *name, int force,
                yaffs_check_obj_details_loaded(in);
 
                buffer = yaffs_get_temp_buffer(in->my_dev, __LINE__);
-               oh = (yaffs_obj_header *) buffer;
+               oh = (struct yaffs_obj_hdr *) buffer;
 
                prev_chunk_id = in->hdr_chunk;
 
@@ -2938,7 +2938,7 @@ int yaffs_update_oh(yaffs_obj_t *in, const YCHAR *name, int force,
                        yaffs_verify_oh(in, oh, &old_tags, 0);
 
                        memcpy(old_name, oh->name, sizeof(oh->name));
-                       memset(buffer, 0xFF, sizeof(yaffs_obj_header));
+                       memset(buffer, 0xFF, sizeof(struct yaffs_obj_hdr));
                } else
                        memset(buffer, 0xFF, dev->data_bytes_per_chunk);
 
@@ -3081,9 +3081,9 @@ int yaffs_update_oh(yaffs_obj_t *in, const YCHAR *name, int force,
  *   need a very intelligent search.
  */
 
-static int yaffs_obj_cache_dirty(yaffs_obj_t *obj)
+static int yaffs_obj_cache_dirty(struct yaffs_obj *obj)
 {
-       yaffs_dev_t *dev = obj->my_dev;
+       struct yaffs_dev *dev = obj->my_dev;
        int i;
        yaffs_cache_t *cache;
        int n_caches = obj->my_dev->param.n_caches;
@@ -3099,9 +3099,9 @@ static int yaffs_obj_cache_dirty(yaffs_obj_t *obj)
 }
 
 
-static void yaffs_flush_file_cache(yaffs_obj_t *obj)
+static void yaffs_flush_file_cache(struct yaffs_obj *obj)
 {
-       yaffs_dev_t *dev = obj->my_dev;
+       struct yaffs_dev *dev = obj->my_dev;
        int lowest = -99;       /* Stop compiler whining. */
        int i;
        yaffs_cache_t *cache;
@@ -3155,9 +3155,9 @@ static void yaffs_flush_file_cache(yaffs_obj_t *obj)
  *
  */
 
-void yaffs_flush_whole_cache(yaffs_dev_t *dev)
+void yaffs_flush_whole_cache(struct yaffs_dev *dev)
 {
-       yaffs_obj_t *obj;
+       struct yaffs_obj *obj;
        int n_caches = dev->param.n_caches;
        int i;
 
@@ -3185,7 +3185,7 @@ void yaffs_flush_whole_cache(yaffs_dev_t *dev)
  * Then look for the least recently used non-dirty one.
  * Then look for the least recently used dirty one...., flush and look again.
  */
-static yaffs_cache_t *yaffs_grab_chunk_worker(yaffs_dev_t *dev)
+static yaffs_cache_t *yaffs_grab_chunk_worker(struct yaffs_dev *dev)
 {
        int i;
 
@@ -3199,10 +3199,10 @@ static yaffs_cache_t *yaffs_grab_chunk_worker(yaffs_dev_t *dev)
        return NULL;
 }
 
-static yaffs_cache_t *yaffs_grab_chunk_cache(yaffs_dev_t *dev)
+static yaffs_cache_t *yaffs_grab_chunk_cache(struct yaffs_dev *dev)
 {
        yaffs_cache_t *cache;
-       yaffs_obj_t *the_obj;
+       struct yaffs_obj *the_obj;
        int usage;
        int i;
        int pushout;
@@ -3251,10 +3251,10 @@ static yaffs_cache_t *yaffs_grab_chunk_cache(yaffs_dev_t *dev)
 }
 
 /* Find a cached chunk */
-static yaffs_cache_t *yaffs_find_chunk_cache(const yaffs_obj_t *obj,
+static yaffs_cache_t *yaffs_find_chunk_cache(const struct yaffs_obj *obj,
                                              int chunk_id)
 {
-       yaffs_dev_t *dev = obj->my_dev;
+       struct yaffs_dev *dev = obj->my_dev;
        int i;
        if (dev->param.n_caches > 0) {
                for (i = 0; i < dev->param.n_caches; i++) {
@@ -3270,7 +3270,7 @@ static yaffs_cache_t *yaffs_find_chunk_cache(const yaffs_obj_t *obj,
 }
 
 /* Mark the chunk for the least recently used algorithym */
-static void yaffs_use_cache(yaffs_dev_t *dev, yaffs_cache_t *cache,
+static void yaffs_use_cache(struct yaffs_dev *dev, yaffs_cache_t *cache,
                                int is_write)
 {
 
@@ -3297,7 +3297,7 @@ static void yaffs_use_cache(yaffs_dev_t *dev, yaffs_cache_t *cache,
  * 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(yaffs_obj_t *object, int chunk_id)
+static void yaffs_invalidate_chunk_cache(struct yaffs_obj *object, int chunk_id)
 {
        if (object->my_dev->param.n_caches > 0) {
                yaffs_cache_t *cache = yaffs_find_chunk_cache(object, chunk_id);
@@ -3310,10 +3310,10 @@ static void yaffs_invalidate_chunk_cache(yaffs_obj_t *object, int chunk_id)
 /* Invalidate all the cache pages associated with this object
  * Do this whenever ther file is deleted or resized.
  */
-static void yaffs_invalidate_whole_cache(yaffs_obj_t *in)
+static void yaffs_invalidate_whole_cache(struct yaffs_obj *in)
 {
        int i;
-       yaffs_dev_t *dev = in->my_dev;
+       struct yaffs_dev *dev = in->my_dev;
 
        if (dev->param.n_caches > 0) {
                /* Invalidate it. */
@@ -3335,7 +3335,7 @@ static void yaffs_invalidate_whole_cache(yaffs_obj_t *in)
  * Curve-balls: the first chunk might also be the last chunk.
  */
 
-int yaffs_file_rd(yaffs_obj_t *in, u8 *buffer, loff_t offset,
+int yaffs_file_rd(struct yaffs_obj *in, u8 *buffer, loff_t offset,
                        int n_bytes)
 {
 
@@ -3346,7 +3346,7 @@ int yaffs_file_rd(yaffs_obj_t *in, u8 *buffer, loff_t offset,
        int n_done = 0;
        yaffs_cache_t *cache;
 
-       yaffs_dev_t *dev;
+       struct yaffs_dev *dev;
 
        dev = in->my_dev;
 
@@ -3427,7 +3427,7 @@ int yaffs_file_rd(yaffs_obj_t *in, u8 *buffer, loff_t offset,
        return n_done;
 }
 
-int yaffs_do_file_wr(yaffs_obj_t *in, const u8 *buffer, loff_t offset,
+int yaffs_do_file_wr(struct yaffs_obj *in, const u8 *buffer, loff_t offset,
                        int n_bytes, int write_trhrough)
 {
 
@@ -3442,7 +3442,7 @@ int yaffs_do_file_wr(yaffs_obj_t *in, const u8 *buffer, loff_t offset,
        u32 n_bytes_read;
        u32 chunk_start;
 
-       yaffs_dev_t *dev;
+       struct yaffs_dev *dev;
 
        dev = in->my_dev;
 
@@ -3603,7 +3603,7 @@ int yaffs_do_file_wr(yaffs_obj_t *in, const u8 *buffer, loff_t offset,
        return n_done;
 }
 
-int yaffs_wr_file(yaffs_obj_t *in, const u8 *buffer, loff_t offset,
+int yaffs_wr_file(struct yaffs_obj *in, const u8 *buffer, loff_t offset,
                        int n_bytes, int write_trhrough)
 {
        yaffs2_handle_hole(in,offset);
@@ -3614,10 +3614,10 @@ int yaffs_wr_file(yaffs_obj_t *in, const u8 *buffer, loff_t offset,
 
 /* ---------------------- File resizing stuff ------------------ */
 
-static void yaffs_prune_chunks(yaffs_obj_t *in, int new_size)
+static void yaffs_prune_chunks(struct yaffs_obj *in, int new_size)
 {
 
-       yaffs_dev_t *dev = in->my_dev;
+       struct yaffs_dev *dev = in->my_dev;
        int old_size = in->variant.file_variant.file_size;
 
        int last_del = 1 + (old_size - 1) / dev->data_bytes_per_chunk;
@@ -3656,11 +3656,11 @@ static void yaffs_prune_chunks(yaffs_obj_t *in, int new_size)
 }
 
 
-void yaffs_resize_file_down( yaffs_obj_t *obj, loff_t new_size)
+void yaffs_resize_file_down( struct yaffs_obj *obj, loff_t new_size)
 {
        int new_full;
        u32 new_partial;
-       yaffs_dev_t *dev = obj->my_dev;
+       struct yaffs_dev *dev = obj->my_dev;
 
        yaffs_addr_to_chunk(dev, new_size, &new_full, &new_partial);
 
@@ -3687,9 +3687,9 @@ void yaffs_resize_file_down( yaffs_obj_t *obj, loff_t new_size)
 }
 
 
-int yaffs_resize_file(yaffs_obj_t *in, loff_t new_size)
+int yaffs_resize_file(struct yaffs_obj *in, loff_t new_size)
 {
-       yaffs_dev_t *dev = in->my_dev;
+       struct yaffs_dev *dev = in->my_dev;
        int old_size = in->variant.file_variant.file_size;
 
        yaffs_flush_file_cache(in);
@@ -3726,7 +3726,7 @@ int yaffs_resize_file(yaffs_obj_t *in, loff_t new_size)
        return YAFFS_OK;
 }
 
-loff_t yaffs_get_file_size(yaffs_obj_t *obj)
+loff_t yaffs_get_file_size(struct yaffs_obj *obj)
 {
        YCHAR *alias = NULL;
        obj = yaffs_get_equivalent_obj(obj);
@@ -3746,7 +3746,7 @@ loff_t yaffs_get_file_size(yaffs_obj_t *obj)
 
 
 
-int yaffs_flush_file(yaffs_obj_t *in, int update_time, int data_sync)
+int yaffs_flush_file(struct yaffs_obj *in, int update_time, int data_sync)
 {
        int ret_val;
        if (in->dirty) {
@@ -3775,7 +3775,7 @@ int yaffs_flush_file(yaffs_obj_t *in, int update_time, int data_sync)
 
 }
 
-static int yaffs_generic_obj_del(yaffs_obj_t *in)
+static int yaffs_generic_obj_del(struct yaffs_obj *in)
 {
 
        /* First off, invalidate the file's data in the cache, without flushing. */
@@ -3800,12 +3800,12 @@ static int yaffs_generic_obj_del(yaffs_obj_t *in)
  * and the inode associated with the file.
  * It does not delete the links associated with the file.
  */
-static int yaffs_unlink_file_if_needed(yaffs_obj_t *in)
+static int yaffs_unlink_file_if_needed(struct yaffs_obj *in)
 {
 
        int ret_val;
        int del_now = 0;
-       yaffs_dev_t *dev = in->my_dev;
+       struct yaffs_dev *dev = in->my_dev;
 
        if (!in->my_inode)
                del_now = 1;
@@ -3832,11 +3832,11 @@ static int yaffs_unlink_file_if_needed(yaffs_obj_t *in)
        return ret_val;
 }
 
-int yaffs_del_file(yaffs_obj_t *in)
+int yaffs_del_file(struct yaffs_obj *in)
 {
        int ret_val = YAFFS_OK;
        int deleted; /* Need to cache value on stack if in is freed */
-       yaffs_dev_t *dev = in->my_dev;
+       struct yaffs_dev *dev = in->my_dev;
 
        if (dev->param.disable_soft_del || dev->param.is_yaffs2)
                yaffs_resize_file(in, 0);
@@ -3867,13 +3867,13 @@ int yaffs_del_file(yaffs_obj_t *in)
        }
 }
 
-static int yaffs_is_non_empty_dir(yaffs_obj_t *obj)
+static int yaffs_is_non_empty_dir(struct yaffs_obj *obj)
 {
        return (obj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY) &&
                !(ylist_empty(&obj->variant.dir_variant.children));
 }
 
-static int yaffs_del_dir(yaffs_obj_t *obj)
+static int yaffs_del_dir(struct yaffs_obj *obj)
 {
        /* First check that the directory is empty. */
        if (yaffs_is_non_empty_dir(obj))
@@ -3882,7 +3882,7 @@ static int yaffs_del_dir(yaffs_obj_t *obj)
        return yaffs_generic_obj_del(obj);
 }
 
-static int yaffs_del_symlink(yaffs_obj_t *in)
+static int yaffs_del_symlink(struct yaffs_obj *in)
 {
        if(in->variant.symlink_variant.alias)
                YFREE(in->variant.symlink_variant.alias);
@@ -3891,7 +3891,7 @@ static int yaffs_del_symlink(yaffs_obj_t *in)
        return yaffs_generic_obj_del(in);
 }
 
-static int yaffs_del_link(yaffs_obj_t *in)
+static int yaffs_del_link(struct yaffs_obj *in)
 {
        /* remove this hardlink from the list assocaited with the equivalent
         * object
@@ -3900,7 +3900,7 @@ static int yaffs_del_link(yaffs_obj_t *in)
        return yaffs_generic_obj_del(in);
 }
 
-int yaffs_del_obj(yaffs_obj_t *obj)
+int yaffs_del_obj(struct yaffs_obj *obj)
 {
 int ret_val = -1;
        switch (obj->variant_type) {
@@ -3931,7 +3931,7 @@ int ret_val = -1;
        return ret_val;
 }
 
-static int yaffs_unlink_worker(yaffs_obj_t *obj)
+static int yaffs_unlink_worker(struct yaffs_obj *obj)
 {
 
        int del_now = 0;
@@ -3959,12 +3959,12 @@ static int yaffs_unlink_worker(yaffs_obj_t *obj)
                 * - Delete the hardlink
                 */
 
-               yaffs_obj_t *hl;
-               yaffs_obj_t *parent;
+               struct yaffs_obj *hl;
+               struct yaffs_obj *parent;
                int ret_val;
                YCHAR name[YAFFS_MAX_NAME_LENGTH + 1];
 
-               hl = ylist_entry(obj->hard_links.next, yaffs_obj_t, hard_links);
+               hl = ylist_entry(obj->hard_links.next, struct yaffs_obj, hard_links);
 
                yaffs_get_obj_name(hl, name, YAFFS_MAX_NAME_LENGTH + 1);
                parent = hl->parent;
@@ -4008,7 +4008,7 @@ static int yaffs_unlink_worker(yaffs_obj_t *obj)
 }
 
 
-static int yaffs_unlink_obj(yaffs_obj_t *obj)
+static int yaffs_unlink_obj(struct yaffs_obj *obj)
 {
 
        if (obj && obj->unlink_allowed)
@@ -4017,9 +4017,9 @@ static int yaffs_unlink_obj(yaffs_obj_t *obj)
        return YAFFS_FAIL;
 
 }
-int yaffs_unlinker(yaffs_obj_t *dir, const YCHAR *name)
+int yaffs_unlinker(struct yaffs_obj *dir, const YCHAR *name)
 {
-       yaffs_obj_t *obj;
+       struct yaffs_obj *obj;
 
        obj = yaffs_find_by_name(dir, name);
        return yaffs_unlink_obj(obj);
@@ -4027,10 +4027,10 @@ int yaffs_unlinker(yaffs_obj_t *dir, const YCHAR *name)
 
 /*----------------------- Initialisation Scanning ---------------------- */
 
-void yaffs_handle_shadowed_obj(yaffs_dev_t *dev, int obj_id,
+void yaffs_handle_shadowed_obj(struct yaffs_dev *dev, int obj_id,
                                int backward_scanning)
 {
-       yaffs_obj_t *obj;
+       struct yaffs_obj *obj;
 
        if (!backward_scanning) {
                /* Handle YAFFS1 forward scanning case
@@ -4062,14 +4062,14 @@ void yaffs_handle_shadowed_obj(yaffs_dev_t *dev, int obj_id,
 }
 
 
-void yaffs_link_fixup(yaffs_dev_t *dev, yaffs_obj_t *hard_list)
+void yaffs_link_fixup(struct yaffs_dev *dev, struct yaffs_obj *hard_list)
 {
-       yaffs_obj_t *hl;
-       yaffs_obj_t *in;
+       struct yaffs_obj *hl;
+       struct yaffs_obj *in;
 
        while (hard_list) {
                hl = hard_list;
-               hard_list = (yaffs_obj_t *) (hard_list->hard_links.next);
+               hard_list = (struct yaffs_obj *) (hard_list->hard_links.next);
 
                in = yaffs_find_by_number(dev,
                                              hl->variant.hardlink_variant.
@@ -4091,14 +4091,14 @@ void yaffs_link_fixup(yaffs_dev_t *dev, yaffs_obj_t *hard_list)
 }
 
 
-static void yaffs_strip_deleted_objs(yaffs_dev_t *dev)
+static void yaffs_strip_deleted_objs(struct yaffs_dev *dev)
 {
        /*
        *  Sort out state of unlinked and deleted objects after scanning.
        */
        struct ylist_head *i;
        struct ylist_head *n;
-       yaffs_obj_t *l;
+       struct yaffs_obj *l;
 
        if (dev->read_only)
                return;
@@ -4107,7 +4107,7 @@ static void yaffs_strip_deleted_objs(yaffs_dev_t *dev)
        ylist_for_each_safe(i, n,
                &dev->unlinked_dir->variant.dir_variant.children) {
                if (i) {
-                       l = ylist_entry(i, yaffs_obj_t, siblings);
+                       l = ylist_entry(i, struct yaffs_obj, siblings);
                        yaffs_del_obj(l);
                }
        }
@@ -4115,7 +4115,7 @@ static void yaffs_strip_deleted_objs(yaffs_dev_t *dev)
        ylist_for_each_safe(i, n,
                &dev->del_dir->variant.dir_variant.children) {
                if (i) {
-                       l = ylist_entry(i, yaffs_obj_t, siblings);
+                       l = ylist_entry(i, struct yaffs_obj, siblings);
                        yaffs_del_obj(l);
                }
        }
@@ -4139,17 +4139,17 @@ static void yaffs_strip_deleted_objs(yaffs_dev_t *dev)
  * leaving the object "hanging" without being rooted in the directory tree.
  */
  
-static int yaffs_has_null_parent(yaffs_dev_t *dev, yaffs_obj_t *obj)
+static int yaffs_has_null_parent(struct yaffs_dev *dev, struct yaffs_obj *obj)
 {
        return (obj == dev->del_dir ||
                obj == dev->unlinked_dir||
                obj == dev->root_dir);
 }
 
-static void yaffs_fix_hanging_objs(yaffs_dev_t *dev)
+static void yaffs_fix_hanging_objs(struct yaffs_dev *dev)
 {
-       yaffs_obj_t *obj;
-       yaffs_obj_t *parent;
+       struct yaffs_obj *obj;
+       struct yaffs_obj *parent;
        int i;
        struct ylist_head *lh;
        struct ylist_head *n;
@@ -4167,7 +4167,7 @@ static void yaffs_fix_hanging_objs(yaffs_dev_t *dev)
        for (i = 0; i <  YAFFS_NOBJECT_BUCKETS; i++) {
                ylist_for_each_safe(lh, n, &dev->obj_bucket[i].list) {
                        if (lh) {
-                               obj = ylist_entry(lh, yaffs_obj_t, hash_link);
+                               obj = ylist_entry(lh, struct yaffs_obj, hash_link);
                                parent= obj->parent;
                                
                                if(yaffs_has_null_parent(dev,obj)){
@@ -4210,9 +4210,9 @@ static void yaffs_fix_hanging_objs(yaffs_dev_t *dev)
 /*
  * Delete directory contents for cleaning up lost and found.
  */
-static void yaffs_del_dir_contents(yaffs_obj_t *dir)
+static void yaffs_del_dir_contents(struct yaffs_obj *dir)
 {
-       yaffs_obj_t *obj;
+       struct yaffs_obj *obj;
        struct ylist_head *lh;
        struct ylist_head *n;
 
@@ -4221,7 +4221,7 @@ static void yaffs_del_dir_contents(yaffs_obj_t *dir)
        
        ylist_for_each_safe(lh, n, &dir->variant.dir_variant.children) {
                if (lh) {
-                       obj = ylist_entry(lh, yaffs_obj_t, siblings);
+                       obj = ylist_entry(lh, struct yaffs_obj, siblings);
                        if(obj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY)
                                yaffs_del_dir_contents(obj);
 
@@ -4238,17 +4238,17 @@ static void yaffs_del_dir_contents(yaffs_obj_t *dir)
                        
 }
 
-static void yaffs_empty_l_n_f(yaffs_dev_t *dev)
+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(yaffs_obj_t *in)
+static void yaffs_check_obj_details_loaded(struct yaffs_obj *in)
 {
        u8 *chunk_data;
-       yaffs_obj_header *oh;
-       yaffs_dev_t *dev;
-       yaffs_ext_tags tags;
+       struct yaffs_obj_hdr *oh;
+       struct yaffs_dev *dev;
+       struct yaffs_ext_tags tags;
        int result;
        int alloc_failed = 0;
 
@@ -4262,7 +4262,7 @@ static void yaffs_check_obj_details_loaded(yaffs_obj_t *in)
                chunk_data = yaffs_get_temp_buffer(dev, __LINE__);
 
                result = yaffs_rd_chunk_tags_nand(dev, in->hdr_chunk, chunk_data, &tags);
-               oh = (yaffs_obj_header *) chunk_data;
+               oh = (struct yaffs_obj_hdr *) chunk_data;
 
                in->yst_mode = oh->yst_mode;
 #ifdef CONFIG_YAFFS_WINCE
@@ -4312,9 +4312,9 @@ static void yaffs_check_obj_details_loaded(yaffs_obj_t *in)
  * called periodically.
  */
  
-static void yaffs_update_parent(yaffs_obj_t *obj)
+static void yaffs_update_parent(struct yaffs_obj *obj)
 {
-       yaffs_dev_t *dev;
+       struct yaffs_dev *dev;
        if(!obj)
                return;
 #ifndef CONFIG_YAFFS_WINCE
@@ -4335,10 +4335,10 @@ static void yaffs_update_parent(yaffs_obj_t *obj)
 #endif
 }
 
-void yaffs_update_dirty_dirs(yaffs_dev_t *dev)
+void yaffs_update_dirty_dirs(struct yaffs_dev *dev)
 {
        struct ylist_head *link;
-       yaffs_obj_t *obj;
+       struct yaffs_obj *obj;
        yaffs_dir_s *d_s;
        yaffs_obj_variant *o_v;
 
@@ -4350,7 +4350,7 @@ void yaffs_update_dirty_dirs(yaffs_dev_t *dev)
                
                d_s=ylist_entry(link,yaffs_dir_s,dirty);
                o_v = ylist_entry(d_s,yaffs_obj_variant,dir_variant);
-               obj = ylist_entry(o_v,yaffs_obj_t,variant);
+               obj = ylist_entry(o_v,struct yaffs_obj,variant);
 
                T(YAFFS_TRACE_BACKGROUND, (TSTR("Update directory %d" TENDSTR), obj->obj_id));
 
@@ -4359,10 +4359,10 @@ void yaffs_update_dirty_dirs(yaffs_dev_t *dev)
        }
 }
 
-static void yaffs_remove_obj_from_dir(yaffs_obj_t *obj)
+static void yaffs_remove_obj_from_dir(struct yaffs_obj *obj)
 {
-       yaffs_dev_t *dev = obj->my_dev;
-       yaffs_obj_t *parent;
+       struct yaffs_dev *dev = obj->my_dev;
+       struct yaffs_obj *parent;
 
        yaffs_verify_obj_in_dir(obj);
        parent = obj->parent;
@@ -4379,8 +4379,8 @@ static void yaffs_remove_obj_from_dir(yaffs_obj_t *obj)
        yaffs_verify_dir(parent);
 }
 
-void yaffs_add_obj_to_dir(yaffs_obj_t *directory,
-                                       yaffs_obj_t *obj)
+void yaffs_add_obj_to_dir(struct yaffs_obj *directory,
+                                       struct yaffs_obj *obj)
 {
        if (!directory) {
                T(YAFFS_TRACE_ALWAYS,
@@ -4424,7 +4424,7 @@ void yaffs_add_obj_to_dir(yaffs_obj_t *directory,
        yaffs_verify_obj_in_dir(obj);
 }
 
-yaffs_obj_t *yaffs_find_by_name(yaffs_obj_t *directory,
+struct yaffs_obj *yaffs_find_by_name(struct yaffs_obj *directory,
                                     const YCHAR *name)
 {
        int sum;
@@ -4432,7 +4432,7 @@ yaffs_obj_t *yaffs_find_by_name(yaffs_obj_t *directory,
        struct ylist_head *i;
        YCHAR buffer[YAFFS_MAX_NAME_LENGTH + 1];
 
-       yaffs_obj_t *l;
+       struct yaffs_obj *l;
 
        if (!name)
                return NULL;
@@ -4456,7 +4456,7 @@ yaffs_obj_t *yaffs_find_by_name(yaffs_obj_t *directory,
 
        ylist_for_each(i, &directory->variant.dir_variant.children) {
                if (i) {
-                       l = ylist_entry(i, yaffs_obj_t, siblings);
+                       l = ylist_entry(i, struct yaffs_obj, siblings);
 
                        if (l->parent != directory)
                                YBUG();
@@ -4487,7 +4487,7 @@ yaffs_obj_t *yaffs_find_by_name(yaffs_obj_t *directory,
  * actual object.
  */
 
-yaffs_obj_t *yaffs_get_equivalent_obj(yaffs_obj_t *obj)
+struct yaffs_obj *yaffs_get_equivalent_obj(struct yaffs_obj *obj)
 {
        if (obj && obj->variant_type == YAFFS_OBJECT_TYPE_HARDLINK) {
                /* We want the object id of the equivalent object, not this one */
@@ -4516,7 +4516,7 @@ yaffs_obj_t *yaffs_get_equivalent_obj(yaffs_obj_t *obj)
  *    starting at oh->name[1].
 
  */
-static void yaffs_fix_null_name(yaffs_obj_t * obj,YCHAR * name, int buffer_size)
+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){
@@ -4537,7 +4537,7 @@ static void yaffs_fix_null_name(yaffs_obj_t * obj,YCHAR * name, int buffer_size)
        }
 }
 
-static void yaffs_load_name_from_oh(yaffs_dev_t *dev,YCHAR *name, const YCHAR *oh_name, int buff_size)
+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){
@@ -4559,7 +4559,7 @@ static void yaffs_load_name_from_oh(yaffs_dev_t *dev,YCHAR *name, const YCHAR *o
 }
 
 
-static void yaffs_load_oh_from_name(yaffs_dev_t *dev, YCHAR *oh_name, const YCHAR *name)
+static void yaffs_load_oh_from_name(struct yaffs_dev *dev, YCHAR *oh_name, const YCHAR *name)
 {
 #ifdef CONFIG_YAFFS_AUTO_UNICODE
 
@@ -4600,7 +4600,7 @@ static void yaffs_load_oh_from_name(yaffs_dev_t *dev, YCHAR *oh_name, const YCHA
 
 }
 
-int yaffs_get_obj_name(yaffs_obj_t * obj, YCHAR * name, int buffer_size)
+int yaffs_get_obj_name(struct yaffs_obj * obj, YCHAR * name, int buffer_size)
 {
        memset(name, 0, buffer_size * sizeof(YCHAR));
        
@@ -4618,7 +4618,7 @@ int yaffs_get_obj_name(yaffs_obj_t * obj, YCHAR * name, int buffer_size)
                int result;
                u8 *buffer = yaffs_get_temp_buffer(obj->my_dev, __LINE__);
 
-               yaffs_obj_header *oh = (yaffs_obj_header *) buffer;
+               struct yaffs_obj_hdr *oh = (struct yaffs_obj_hdr *) buffer;
 
                memset(buffer, 0, obj->my_dev->data_bytes_per_chunk);
 
@@ -4638,7 +4638,7 @@ int yaffs_get_obj_name(yaffs_obj_t * obj, YCHAR * name, int buffer_size)
 }
 
 
-int yaffs_get_obj_length(yaffs_obj_t *obj)
+int yaffs_get_obj_length(struct yaffs_obj *obj)
 {
        /* Dereference any hard linking */
        obj = yaffs_get_equivalent_obj(obj);
@@ -4655,7 +4655,7 @@ int yaffs_get_obj_length(yaffs_obj_t *obj)
        }
 }
 
-int yaffs_get_obj_link_count(yaffs_obj_t *obj)
+int yaffs_get_obj_link_count(struct yaffs_obj *obj)
 {
        int count = 0;
        struct ylist_head *i;
@@ -4669,14 +4669,14 @@ int yaffs_get_obj_link_count(yaffs_obj_t *obj)
        return count;
 }
 
-int yaffs_get_obj_inode(yaffs_obj_t *obj)
+int yaffs_get_obj_inode(struct yaffs_obj *obj)
 {
        obj = yaffs_get_equivalent_obj(obj);
 
        return obj->obj_id;
 }
 
-unsigned yaffs_get_obj_type(yaffs_obj_t *obj)
+unsigned yaffs_get_obj_type(struct yaffs_obj *obj)
 {
        obj = yaffs_get_equivalent_obj(obj);
 
@@ -4708,7 +4708,7 @@ unsigned yaffs_get_obj_type(yaffs_obj_t *obj)
        }
 }
 
-YCHAR *yaffs_get_symlink_alias(yaffs_obj_t *obj)
+YCHAR *yaffs_get_symlink_alias(struct yaffs_obj *obj)
 {
        obj = yaffs_get_equivalent_obj(obj);
        if (obj->variant_type == YAFFS_OBJECT_TYPE_SYMLINK)
@@ -4719,7 +4719,7 @@ YCHAR *yaffs_get_symlink_alias(yaffs_obj_t *obj)
 
 #ifndef CONFIG_YAFFS_WINCE
 
-int yaffs_set_attribs(yaffs_obj_t *obj, struct iattr *attr)
+int yaffs_set_attribs(struct yaffs_obj *obj, struct iattr *attr)
 {
        unsigned int valid = attr->ia_valid;
 
@@ -4745,7 +4745,7 @@ int yaffs_set_attribs(yaffs_obj_t *obj, struct iattr *attr)
        return YAFFS_OK;
 
 }
-int yaffs_get_attribs(yaffs_obj_t *obj, struct iattr *attr)
+int yaffs_get_attribs(struct yaffs_obj *obj, struct iattr *attr)
 {
        unsigned int valid = 0;
 
@@ -4774,7 +4774,7 @@ int yaffs_get_attribs(yaffs_obj_t *obj, struct iattr *attr)
 #endif
 
 
-static int yaffs_do_xattrib_mod(yaffs_obj_t *obj, int set, const YCHAR *name, const void *value, int size, int flags)
+static int yaffs_do_xattrib_mod(struct yaffs_obj *obj, int set, const YCHAR *name, const void *value, int size, int flags)
 {
        yaffs_xattr_mod xmod;
 
@@ -4795,12 +4795,12 @@ static int yaffs_do_xattrib_mod(yaffs_obj_t *obj, int set, const YCHAR *name, co
                return -ENOSPC;
 }
 
-static int yaffs_apply_xattrib_mod(yaffs_obj_t *obj, char *buffer, yaffs_xattr_mod *xmod)
+static int yaffs_apply_xattrib_mod(struct yaffs_obj *obj, char *buffer, yaffs_xattr_mod *xmod)
 {
        int retval = 0;
-       int x_offs = sizeof(yaffs_obj_header);
-       yaffs_dev_t *dev = obj->my_dev;
-       int x_size = dev->data_bytes_per_chunk - sizeof(yaffs_obj_header);
+       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;
 
@@ -4817,14 +4817,14 @@ static int yaffs_apply_xattrib_mod(yaffs_obj_t *obj, char *buffer, yaffs_xattr_m
        return retval;
 }
 
-static int yaffs_do_xattrib_fetch(yaffs_obj_t *obj, const YCHAR *name, void *value, int size)
+static int yaffs_do_xattrib_fetch(struct yaffs_obj *obj, const YCHAR *name, void *value, int size)
 {
        char *buffer = NULL;
        int result;
-       yaffs_ext_tags tags;
-       yaffs_dev_t *dev = obj->my_dev;
-       int x_offs = sizeof(yaffs_obj_header);
-       int x_size = dev->data_bytes_per_chunk - sizeof(yaffs_obj_header);
+       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;
 
@@ -4868,29 +4868,29 @@ static int yaffs_do_xattrib_fetch(yaffs_obj_t *obj, const YCHAR *name, void *val
        return retval;
 }
 
-int yaffs_set_xattrib(yaffs_obj_t *obj, const YCHAR *name, const void * value, int size, int flags)
+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(yaffs_obj_t *obj, const YCHAR *name)
+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(yaffs_obj_t *obj, const YCHAR *name, void *value, int size)
+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(yaffs_obj_t *obj, char *buffer, int size)
+int yaffs_list_xattrib(struct yaffs_obj *obj, char *buffer, int size)
 {
        return yaffs_do_xattrib_fetch(obj, NULL, buffer,size);
 }
 
 /*---------------------------- Initialisation code -------------------------------------- */
 
-static int yaffs_check_dev_fns(const yaffs_dev_t *dev)
+static int yaffs_check_dev_fns(const struct yaffs_dev *dev)
 {
 
        /* Common functions, gotta have */
@@ -4923,7 +4923,7 @@ static int yaffs_check_dev_fns(const yaffs_dev_t *dev)
 }
 
 
-static int yaffs_create_initial_dir(yaffs_dev_t *dev)
+static int yaffs_create_initial_dir(struct yaffs_dev *dev)
 {
        /* Initialise the unlinked, deleted, root and lost and found directories */
 
@@ -4951,7 +4951,7 @@ static int yaffs_create_initial_dir(yaffs_dev_t *dev)
        return YAFFS_FAIL;
 }
 
-int yaffs_guts_initialise(yaffs_dev_t *dev)
+int yaffs_guts_initialise(struct yaffs_dev *dev)
 {
        int init_failed = 0;
        unsigned x;
@@ -5257,7 +5257,7 @@ int yaffs_guts_initialise(yaffs_dev_t *dev)
 
 }
 
-void yaffs_deinitialise(yaffs_dev_t *dev)
+void yaffs_deinitialise(struct yaffs_dev *dev)
 {
        if (dev->is_mounted) {
                int i;
@@ -5289,7 +5289,7 @@ void yaffs_deinitialise(yaffs_dev_t *dev)
        }
 }
 
-int yaffs_count_free_chunks(yaffs_dev_t *dev)
+int yaffs_count_free_chunks(struct yaffs_dev *dev)
 {
        int n_free=0;
        int b;
@@ -5316,7 +5316,7 @@ int yaffs_count_free_chunks(yaffs_dev_t *dev)
        return n_free;
 }
 
-int yaffs_get_n_free_chunks(yaffs_dev_t *dev)
+int yaffs_get_n_free_chunks(struct yaffs_dev *dev)
 {
        /* This is what we report to the outside world */
 
@@ -5365,13 +5365,13 @@ int yaffs_get_n_free_chunks(yaffs_dev_t *dev)
 
 static int yaffs_check_structures(void)
 {
-/*      yaffs_check_struct(yaffs_tags_t,8,"yaffs_tags_t"); */
+/*      yaffs_check_struct(struct yaffs_tags,8,"struct yaffs_tags"); */
 /*      yaffs_check_struct(yaffs_tags_union_t,8,"yaffs_tags_union_t"); */
 /*      yaffs_check_struct(yaffs_spare,16,"yaffs_spare"); */
 /*     yaffs_check_struct(yaffs_tnode_t, 2 * YAFFS_NTNODES_LEVEL0, "yaffs_tnode_t"); */
 
 #ifndef CONFIG_YAFFS_WINCE
-       yaffs_check_struct(yaffs_obj_header, 512, "yaffs_obj_header");
+       yaffs_check_struct(struct yaffs_obj_hdr, 512, "struct yaffs_obj_hdr");
 #endif
        return YAFFS_OK;
 }
index 1c9515c..4e4e6b1 100644 (file)
 
 /* ChunkCache is used for short read/write operations.*/
 typedef struct {
-       struct yaffs_obj_s *object;
+       struct yaffs_obj *object;
        int chunk_id;
        int last_use;
        int dirty;
@@ -130,17 +130,17 @@ typedef struct {
  */
 
 #ifndef CONFIG_YAFFS_NO_YAFFS1
-typedef struct {
+struct yaffs_tags {
        unsigned chunk_id:20;
        unsigned serial_number:2;
        unsigned n_bytes_lsb:10;
        unsigned obj_id:18;
        unsigned ecc:12;
        unsigned n_bytes_msb:2;
-} yaffs_tags_t;
+};
 
 typedef union {
-       yaffs_tags_t as_tags;
+       struct yaffs_tags as_tags;
        u8 as_bytes[8];
 } yaffs_tags_union_t;
 
@@ -155,18 +155,18 @@ typedef enum {
        YAFFS_ECC_RESULT_UNFIXED
 } yaffs_ecc_result;
 
-typedef enum {
+enum yaffs_obj_type {
        YAFFS_OBJECT_TYPE_UNKNOWN,
        YAFFS_OBJECT_TYPE_FILE,
        YAFFS_OBJECT_TYPE_SYMLINK,
        YAFFS_OBJECT_TYPE_DIRECTORY,
        YAFFS_OBJECT_TYPE_HARDLINK,
        YAFFS_OBJECT_TYPE_SPECIAL
-} yaffs_obj_type;
+} ;
 
 #define YAFFS_OBJECT_TYPE_MAX YAFFS_OBJECT_TYPE_SPECIAL
 
-typedef struct {
+struct yaffs_ext_tags{
 
        unsigned validity1;
        unsigned chunk_used;    /*  Status of the chunk: used or unused */
@@ -192,14 +192,14 @@ typedef struct {
        unsigned extra_is_shrink;       /* Is it a shrink header? */
        unsigned extra_shadows;         /* Does this shadow another object? */
 
-       yaffs_obj_type extra_obj_type;  /* What object type? */
+       enum yaffs_obj_type extra_obj_type;     /* What object type? */
 
        unsigned extra_length;          /* Length if it is a file */
        unsigned extra_equiv_id;        /* Equivalent object Id if it is a hard link */
 
        unsigned validty1;
 
-} yaffs_ext_tags;
+};
 
 /* Spare structure for YAFFS1 */
 typedef struct {
@@ -297,8 +297,8 @@ typedef struct {
 /* -------------------------- Object structure -------------------------------*/
 /* This is the object structure as stored on NAND */
 
-typedef struct {
-       yaffs_obj_type type;
+struct yaffs_obj_hdr {
+       enum yaffs_obj_type type;
 
        /* Apply to everything  */
        int parent_obj_id;
@@ -346,7 +346,7 @@ typedef struct {
        /* is_shrink applies to object headers written when we shrink the file (ie resize) */
        u32 is_shrink;
 
-} yaffs_obj_header;
+};
 
 /*--------------------------- Tnode -------------------------- */
 
@@ -384,7 +384,7 @@ typedef struct {
 } yaffs_symlink_t;
 
 typedef struct {
-       struct yaffs_obj_s *equiv_obj;
+       struct yaffs_obj *equiv_obj;
        u32 equiv_id;
 } yaffs_hard_link_s;
 
@@ -397,7 +397,7 @@ typedef union {
 
 
 
-struct yaffs_obj_s {
+struct yaffs_obj {
        u8 deleted:1;           /* This should only apply to unlinked files. */
        u8 soft_del:1;  /* it has also been soft deleted */
        u8 unlinked:1;  /* An unlinked file. The file should be in the unlinked directory.*/
@@ -424,7 +424,7 @@ struct yaffs_obj_s {
        u8 serial;              /* serial number of chunk in NAND. Cached here */
        u16 sum;                /* sum of the name to speed searching */
 
-       struct yaffs_dev_s *my_dev;       /* The device I'm on */
+       struct yaffs_dev *my_dev;       /* The device I'm on */
 
        struct ylist_head hash_link;     /* list of objects in this hash bucket */
 
@@ -432,7 +432,7 @@ struct yaffs_obj_s {
 
        /* directory structure stuff */
        /* also used for linking up the free list */
-       struct yaffs_obj_s *parent;
+       struct yaffs_obj *parent;
        struct ylist_head siblings;
 
        /* Where's my object header in NAND? */
@@ -464,18 +464,16 @@ struct yaffs_obj_s {
 
        void *my_inode;
 
-       yaffs_obj_type variant_type;
+       enum yaffs_obj_type variant_type;
 
        yaffs_obj_variant variant;
 
 };
 
-typedef struct yaffs_obj_s yaffs_obj_t;
-
-typedef struct {
+struct yaffs_obj_bucket {
        struct ylist_head list;
        int count;
-} yaffs_obj_bucket;
+} ;
 
 
 /* yaffs_checkpt_obj_t holds the definition of an object as dumped
@@ -487,7 +485,7 @@ typedef struct {
        u32 obj_id;
        u32 parent_id;
        int hdr_chunk;
-       yaffs_obj_type variant_type:3;
+       enum yaffs_obj_type variant_type:3;
        u8 deleted:1;
        u8 soft_del:1;
        u8 unlinked:1;
@@ -495,7 +493,6 @@ typedef struct {
        u8 rename_allowed:1;
        u8 unlink_allowed:1;
        u8 serial;
-
        int n_data_chunks;
        u32 size_or_equiv_obj;
 } yaffs_checkpt_obj_t;
@@ -514,7 +511,7 @@ typedef struct {
 /*----------------- Device ---------------------------------*/
 
 
-struct yaffs_param_s {
+struct yaffs_param {
        const YCHAR *name;
 
        /*
@@ -554,26 +551,26 @@ struct yaffs_param_s {
 
        /* NAND access functions (Must be set before calling YAFFS)*/
 
-       int (*write_chunk_fn) (struct yaffs_dev_s *dev,
+       int (*write_chunk_fn) (struct yaffs_dev *dev,
                                        int nand_chunk, const u8 *data,
                                        const yaffs_spare *spare);
-       int (*read_chunk_fn) (struct yaffs_dev_s *dev,
+       int (*read_chunk_fn) (struct yaffs_dev *dev,
                                        int nand_chunk, u8 *data,
                                        yaffs_spare *spare);
-       int (*erase_fn) (struct yaffs_dev_s *dev,
+       int (*erase_fn) (struct yaffs_dev *dev,
                                        int flash_block);
-       int (*initialise_flash_fn) (struct yaffs_dev_s *dev);
-       int (*deinitialise_flash_fn) (struct yaffs_dev_s *dev);
+       int (*initialise_flash_fn) (struct yaffs_dev *dev);
+       int (*deinitialise_flash_fn) (struct yaffs_dev *dev);
 
 #ifdef CONFIG_YAFFS_YAFFS2
-       int (*write_chunk_tags_fn) (struct yaffs_dev_s *dev,
+       int (*write_chunk_tags_fn) (struct yaffs_dev *dev,
                                         int nand_chunk, const u8 *data,
-                                        const yaffs_ext_tags *tags);
-       int (*read_chunk_tags_fn) (struct yaffs_dev_s *dev,
+                                        const struct yaffs_ext_tags *tags);
+       int (*read_chunk_tags_fn) (struct yaffs_dev *dev,
                                          int nand_chunk, u8 *data,
-                                         yaffs_ext_tags *tags);
-       int (*bad_block_fn) (struct yaffs_dev_s *dev, int block_no);
-       int (*query_block_fn) (struct yaffs_dev_s *dev, int block_no,
+                                         struct yaffs_ext_tags *tags);
+       int (*bad_block_fn) (struct yaffs_dev *dev, int block_no);
+       int (*query_block_fn) (struct yaffs_dev *dev, int block_no,
                               yaffs_block_state_t *state, u32 *seq_number);
 #endif
 
@@ -582,13 +579,13 @@ struct yaffs_param_s {
          * yaffs direct uses it to implement the faster readdir.
          * Linux uses it to protect the directory during unlocking.
         */
-       void (*remove_obj_fn)(struct yaffs_obj_s *obj);
+       void (*remove_obj_fn)(struct yaffs_obj *obj);
 
        /* Callback to mark the superblock dirty */
-       void (*sb_dirty_fn)(struct yaffs_dev_s *dev);
+       void (*sb_dirty_fn)(struct yaffs_dev *dev);
        
        /*  Callback to control garbage collection. */
-       unsigned (*gc_control)(struct yaffs_dev_s *dev);
+       unsigned (*gc_control)(struct yaffs_dev *dev);
 
         /* Debug control flags. Don't use unless you know what you're doing */
        int use_header_file_size;       /* Flag to determine if we should use file sizes from the header */
@@ -604,10 +601,9 @@ struct yaffs_param_s {
        int always_check_erased; /* Force chunk erased check always on */
 };
 
-typedef struct yaffs_param_s yaffs_param_t;
 
-struct yaffs_dev_s {
-       struct yaffs_param_s param;
+struct yaffs_dev {
+       struct yaffs_param param;
 
         /* Context storage. Holds extra OS specific data for this device */
 
@@ -687,7 +683,7 @@ struct yaffs_dev_s {
 
        int n_hardlinks;
 
-       yaffs_obj_bucket obj_bucket[YAFFS_NOBJECT_BUCKETS];
+       struct yaffs_obj_bucket obj_bucket[YAFFS_NOBJECT_BUCKETS];
        u32 bucket_finder;
 
        int n_free_chunks;
@@ -707,8 +703,8 @@ struct yaffs_dev_s {
        unsigned gc_skip;
 
        /* Special directories */
-       yaffs_obj_t *root_dir;
-       yaffs_obj_t *lost_n_found;
+       struct yaffs_obj *root_dir;
+       struct yaffs_obj *lost_n_found;
 
        /* Buffer areas for storing data to recover from write failures TODO
         *      u8            buffered_data[YAFFS_CHUNKS_PER_BLOCK][YAFFS_BYTES_PER_CHUNK];
@@ -722,9 +718,9 @@ struct yaffs_dev_s {
        int cache_last_use;
 
        /* Stuff for background deletion and unlinked files.*/
-       yaffs_obj_t *unlinked_dir;      /* Directory where unlinked and deleted files live. */
-       yaffs_obj_t *del_dir;   /* Directory where deleted objects are sent to disappear. */
-       yaffs_obj_t *unlinked_deletion; /* Current file being background deleted.*/
+       struct yaffs_obj *unlinked_dir; /* Directory where unlinked and deleted files live. */
+       struct yaffs_obj *del_dir;      /* Directory where deleted objects are sent to disappear. */
+       struct yaffs_obj *unlinked_deletion;    /* Current file being background deleted.*/
        int n_deleted_files;            /* Count of files awaiting deletion;*/
        int n_unlinked_files;           /* Count of unlinked files. */
        int n_bg_deletions;     /* Count of background deletions. */
@@ -772,7 +768,6 @@ struct yaffs_dev_s {
 
 };
 
-typedef struct yaffs_dev_s yaffs_dev_t;
 
 /* The static layout of block usage etc is stored in the super block header */
 typedef struct {
@@ -832,135 +827,136 @@ typedef struct {
 
 /*----------------------- YAFFS Functions -----------------------*/
 
-int yaffs_guts_initialise(yaffs_dev_t *dev);
-void yaffs_deinitialise(yaffs_dev_t *dev);
+int yaffs_guts_initialise(struct yaffs_dev *dev);
+void yaffs_deinitialise(struct yaffs_dev *dev);
 
-int yaffs_get_n_free_chunks(yaffs_dev_t *dev);
+int yaffs_get_n_free_chunks(struct yaffs_dev *dev);
 
-int yaffs_rename_obj(yaffs_obj_t *old_dir, const YCHAR *old_name,
-                      yaffs_obj_t *new_dir, const YCHAR *new_name);
+int yaffs_rename_obj(struct yaffs_obj *old_dir, const YCHAR *old_name,
+                      struct yaffs_obj *new_dir, const YCHAR *new_name);
 
-int yaffs_unlinker(yaffs_obj_t *dir, const YCHAR *name);
-int yaffs_del_obj(yaffs_obj_t *obj);
+int yaffs_unlinker(struct yaffs_obj *dir, const YCHAR *name);
+int yaffs_del_obj(struct yaffs_obj *obj);
 
-int yaffs_get_obj_name(yaffs_obj_t *obj, YCHAR *name, int buffer_size);
-int yaffs_get_obj_length(yaffs_obj_t *obj);
-int yaffs_get_obj_inode(yaffs_obj_t *obj);
-unsigned yaffs_get_obj_type(yaffs_obj_t *obj);
-int yaffs_get_obj_link_count(yaffs_obj_t *obj);
+int yaffs_get_obj_name(struct yaffs_obj *obj, YCHAR *name, int buffer_size);
+int yaffs_get_obj_length(struct yaffs_obj *obj);
+int yaffs_get_obj_inode(struct yaffs_obj *obj);
+unsigned yaffs_get_obj_type(struct yaffs_obj *obj);
+int yaffs_get_obj_link_count(struct yaffs_obj *obj);
 
-int yaffs_set_attribs(yaffs_obj_t *obj, struct iattr *attr);
-int yaffs_get_attribs(yaffs_obj_t *obj, struct iattr *attr);
+int yaffs_set_attribs(struct yaffs_obj *obj, struct iattr *attr);
+int yaffs_get_attribs(struct yaffs_obj *obj, struct iattr *attr);
 
 /* File operations */
-int yaffs_file_rd(yaffs_obj_t *obj, u8 *buffer, loff_t offset,
+int yaffs_file_rd(struct yaffs_obj *obj, u8 *buffer, loff_t offset,
                                int n_bytes);
-int yaffs_wr_file(yaffs_obj_t *obj, const u8 *buffer, loff_t offset,
+int yaffs_wr_file(struct yaffs_obj *obj, const u8 *buffer, loff_t offset,
                                int n_bytes, int write_trhrough);
-int yaffs_resize_file(yaffs_obj_t *obj, loff_t new_size);
+int yaffs_resize_file(struct yaffs_obj *obj, loff_t new_size);
 
-yaffs_obj_t *yaffs_create_file(yaffs_obj_t *parent, const YCHAR *name,
+struct yaffs_obj *yaffs_create_file(struct yaffs_obj *parent, const YCHAR *name,
                                u32 mode, u32 uid, u32 gid);
 
-int yaffs_flush_file(yaffs_obj_t *obj, int update_time, int data_sync);
+int yaffs_flush_file(struct yaffs_obj *obj, int update_time, int data_sync);
 
 /* Flushing and checkpointing */
-void yaffs_flush_whole_cache(yaffs_dev_t *dev);
+void yaffs_flush_whole_cache(struct yaffs_dev *dev);
 
-int yaffs_checkpoint_save(yaffs_dev_t *dev);
-int yaffs_checkpoint_restore(yaffs_dev_t *dev);
+int yaffs_checkpoint_save(struct yaffs_dev *dev);
+int yaffs_checkpoint_restore(struct yaffs_dev *dev);
 
 /* Directory operations */
-yaffs_obj_t *yaffs_create_dir(yaffs_obj_t *parent, const YCHAR *name,
+struct yaffs_obj *yaffs_create_dir(struct yaffs_obj *parent, const YCHAR *name,
                                u32 mode, u32 uid, u32 gid);
-yaffs_obj_t *yaffs_find_by_name(yaffs_obj_t *the_dir, const YCHAR *name);
-yaffs_obj_t *yaffs_find_by_number(yaffs_dev_t *dev, u32 number);
+struct yaffs_obj *yaffs_find_by_name(struct yaffs_obj *the_dir, const YCHAR *name);
+struct yaffs_obj *yaffs_find_by_number(struct yaffs_dev *dev, u32 number);
 
 /* Link operations */
-yaffs_obj_t *yaffs_link_obj(yaffs_obj_t *parent, const YCHAR *name,
-                        yaffs_obj_t *equiv_obj);
+struct yaffs_obj *yaffs_link_obj(struct yaffs_obj *parent, const YCHAR *name,
+                        struct yaffs_obj *equiv_obj);
 
-yaffs_obj_t *yaffs_get_equivalent_obj(yaffs_obj_t *obj);
+struct yaffs_obj *yaffs_get_equivalent_obj(struct yaffs_obj *obj);
 
 /* Symlink operations */
-yaffs_obj_t *yaffs_create_symlink(yaffs_obj_t *parent, const YCHAR *name,
+struct yaffs_obj *yaffs_create_symlink(struct yaffs_obj *parent, const YCHAR *name,
                                 u32 mode, u32 uid, u32 gid,
                                 const YCHAR *alias);
-YCHAR *yaffs_get_symlink_alias(yaffs_obj_t *obj);
+YCHAR *yaffs_get_symlink_alias(struct yaffs_obj *obj);
 
 /* Special inodes (fifos, sockets and devices) */
-yaffs_obj_t *yaffs_create_special(yaffs_obj_t *parent, const YCHAR *name,
+struct yaffs_obj *yaffs_create_special(struct yaffs_obj *parent, const YCHAR *name,
                                 u32 mode, u32 uid, u32 gid, u32 rdev);
 
 
-int yaffs_set_xattrib(yaffs_obj_t *obj, const YCHAR *name, const void * value, int size, int flags);
-int yaffs_get_xattrib(yaffs_obj_t *obj, const YCHAR *name, void *value, int size);
-int yaffs_list_xattrib(yaffs_obj_t *obj, char *buffer, int size);
-int yaffs_remove_xattrib(yaffs_obj_t *obj, const YCHAR *name);
+int yaffs_set_xattrib(struct yaffs_obj *obj, const YCHAR *name, const void * value, int size, int flags);
+int yaffs_get_xattrib(struct yaffs_obj *obj, const YCHAR *name, void *value, int size);
+int yaffs_list_xattrib(struct yaffs_obj *obj, char *buffer, int size);
+int yaffs_remove_xattrib(struct yaffs_obj *obj, const YCHAR *name);
 
 /* Special directories */
-yaffs_obj_t *yaffs_root(yaffs_dev_t *dev);
-yaffs_obj_t *yaffs_lost_n_found(yaffs_dev_t *dev);
+struct yaffs_obj *yaffs_root(struct yaffs_dev *dev);
+struct yaffs_obj *yaffs_lost_n_found(struct yaffs_dev *dev);
 
 #ifdef CONFIG_YAFFS_WINCE
 /* CONFIG_YAFFS_WINCE special stuff */
 void yfsd_win_file_time_now(u32 target[2]);
 #endif
 
-void yaffs_handle_defered_free(yaffs_obj_t *obj);
+void yaffs_handle_defered_free(struct yaffs_obj *obj);
 
-void yaffs_update_dirty_dirs(yaffs_dev_t *dev);
+void yaffs_update_dirty_dirs(struct yaffs_dev *dev);
 
-int yaffs_bg_gc(yaffs_dev_t *dev, unsigned urgency);
+int yaffs_bg_gc(struct yaffs_dev *dev, unsigned urgency);
 
 /* Debug dump  */
-int yaffs_dump_obj(yaffs_obj_t *obj);
+int yaffs_dump_obj(struct yaffs_obj *obj);
 
-void yaffs_guts_test(yaffs_dev_t *dev);
+void yaffs_guts_test(struct yaffs_dev *dev);
 
 /* A few useful functions to be used within the core files*/
-void yaffs_chunk_del(yaffs_dev_t *dev, int chunk_id, int mark_flash, int lyn);
+void yaffs_chunk_del(struct yaffs_dev *dev, int chunk_id, int mark_flash, int lyn);
 int yaffs_check_ff(u8 *buffer, int n_bytes);
-void yaffs_handle_chunk_error(yaffs_dev_t *dev, yaffs_block_info_t *bi);
+void yaffs_handle_chunk_error(struct yaffs_dev *dev, yaffs_block_info_t *bi);
 
-u8 *yaffs_get_temp_buffer(yaffs_dev_t *dev, int line_no);
-void yaffs_release_temp_buffer(yaffs_dev_t *dev, u8 *buffer, int line_no);
+u8 *yaffs_get_temp_buffer(struct yaffs_dev *dev, int line_no);
+void yaffs_release_temp_buffer(struct yaffs_dev *dev, u8 *buffer, int line_no);
 
-yaffs_obj_t *yaffs_find_or_create_by_number(yaffs_dev_t *dev,
+struct yaffs_obj *yaffs_find_or_create_by_number(struct yaffs_dev *dev,
                                                int number,
-                                               yaffs_obj_type type);
-int yaffs_put_chunk_in_file(yaffs_obj_t *in, int inode_chunk,
+                                               enum yaffs_obj_type type);
+int yaffs_put_chunk_in_file(struct yaffs_obj *in, int inode_chunk,
                                int nand_chunk, int in_scan);
-void yaffs_set_obj_name(yaffs_obj_t *obj, const YCHAR *name);
-void yaffs_set_obj_name_from_oh(yaffs_obj_t *obj, const yaffs_obj_header *oh);
-void yaffs_add_obj_to_dir(yaffs_obj_t *directory,
-                                       yaffs_obj_t *obj);
+void yaffs_set_obj_name(struct yaffs_obj *obj, const YCHAR *name);
+void yaffs_set_obj_name_from_oh(struct yaffs_obj *obj,
+                                const struct yaffs_obj_hdr *oh);
+void yaffs_add_obj_to_dir(struct yaffs_obj *directory,
+                                       struct yaffs_obj *obj);
 YCHAR *yaffs_clone_str(const YCHAR *str);
-void yaffs_link_fixup(yaffs_dev_t *dev, yaffs_obj_t *hard_list);
-void yaffs_block_became_dirty(yaffs_dev_t *dev, int block_no);
-int yaffs_update_oh(yaffs_obj_t *in, const YCHAR *name,
+void yaffs_link_fixup(struct yaffs_dev *dev, struct yaffs_obj *hard_list);
+void yaffs_block_became_dirty(struct yaffs_dev *dev, int block_no);
+int yaffs_update_oh(struct yaffs_obj *in, const YCHAR *name,
                                int force, int is_shrink, int shadows,
                                 yaffs_xattr_mod *xop);
-void yaffs_handle_shadowed_obj(yaffs_dev_t *dev, int obj_id,
+void yaffs_handle_shadowed_obj(struct yaffs_dev *dev, int obj_id,
                                int backward_scanning);
-int yaffs_check_alloc_available(yaffs_dev_t *dev, int n_chunks);
-yaffs_tnode_t *yaffs_get_tnode(yaffs_dev_t *dev);
-yaffs_tnode_t *yaffs_add_find_tnode_0(yaffs_dev_t *dev,
+int yaffs_check_alloc_available(struct yaffs_dev *dev, int n_chunks);
+yaffs_tnode_t *yaffs_get_tnode(struct yaffs_dev *dev);
+yaffs_tnode_t *yaffs_add_find_tnode_0(struct yaffs_dev *dev,
                                        yaffs_file_s *file_struct,
                                        u32 chunk_id,
                                        yaffs_tnode_t *passed_tn);
 
-int yaffs_do_file_wr(yaffs_obj_t *in, const u8 *buffer, loff_t offset,
+int yaffs_do_file_wr(struct yaffs_obj *in, const u8 *buffer, loff_t offset,
                        int n_bytes, int write_trhrough);
-void yaffs_resize_file_down( yaffs_obj_t *obj, loff_t new_size);
-void yaffs_skip_rest_of_block(yaffs_dev_t *dev);
+void yaffs_resize_file_down( struct yaffs_obj *obj, loff_t new_size);
+void yaffs_skip_rest_of_block(struct yaffs_dev *dev);
 
-int yaffs_count_free_chunks(yaffs_dev_t *dev);
+int yaffs_count_free_chunks(struct yaffs_dev *dev);
 
-yaffs_tnode_t *yaffs_find_tnode_0(yaffs_dev_t *dev,
+yaffs_tnode_t *yaffs_find_tnode_0(struct yaffs_dev *dev,
                                yaffs_file_s *file_struct,
                                u32 chunk_id);
 
-u32 yaffs_get_group_base(yaffs_dev_t *dev, yaffs_tnode_t *tn, unsigned pos);
+u32 yaffs_get_group_base(struct yaffs_dev *dev, yaffs_tnode_t *tn, unsigned pos);
 
 #endif
index 254a76e..2d808d7 100644 (file)
@@ -21,7 +21,7 @@
 
 struct yaffs_linux_context {
        struct ylist_head       context_list; /* List of these we have mounted */
-       struct yaffs_dev_s *dev;
+       struct yaffs_dev *dev;
        struct super_block * super;
        struct task_struct *bg_thread; /* Background thread for this device */
        int bg_running;
index 8d0eb19..dcf504f 100644 (file)
  * Any underlying MTD error results in YAFFS_FAIL.
  * Returns YAFFS_OK or YAFFS_FAIL.
  */
-int nandmtd1_write_chunk_tags(yaffs_dev_t *dev,
-       int nand_chunk, const u8 *data, const yaffs_ext_tags *etags)
+int nandmtd1_write_chunk_tags(struct yaffs_dev *dev,
+       int nand_chunk, const u8 *data, const struct yaffs_ext_tags *etags)
 {
-       struct mtd_info *mtd = yaffs_dev_to_mtd(dev);
+       struct mtd_info *mtd = struct yaffs_devo_mtd(dev);
        int chunk_bytes = dev->data_bytes_per_chunk;
        loff_t addr = ((loff_t)nand_chunk) * chunk_bytes;
        struct mtd_oob_ops ops;
        yaffs_packed_tags1 pt1;
        int retval;
 
-       /* we assume that packed_tags1 and yaffs_tags_t are compatible */
+       /* we assume that packed_tags1 and struct yaffs_tags are compatible */
        compile_time_assertion(sizeof(yaffs_packed_tags1) == 12);
-       compile_time_assertion(sizeof(yaffs_tags_t) == 8);
+       compile_time_assertion(sizeof(struct yaffs_tags) == 8);
 
        yaffs_pack_tags1(&pt1, etags);
-       yaffs_calc_tags_ecc((yaffs_tags_t *)&pt1);
+       yaffs_calc_tags_ecc((struct yaffs_tags *)&pt1);
 
        /* When deleting a chunk, the upper layer provides only skeletal
         * etags, one with is_deleted set.  However, we need to update the
@@ -120,7 +120,7 @@ int nandmtd1_write_chunk_tags(yaffs_dev_t *dev,
 
 /* Return with empty ExtendedTags but add ecc_result.
  */
-static int rettags(yaffs_ext_tags *etags, int ecc_result, int retval)
+static int rettags(struct yaffs_ext_tags *etags, int ecc_result, int retval)
 {
        if (etags) {
                memset(etags, 0, sizeof(*etags));
@@ -142,10 +142,10 @@ static int rettags(yaffs_ext_tags *etags, int ecc_result, int retval)
  *
  * Returns YAFFS_OK or YAFFS_FAIL.
  */
-int nandmtd1_read_chunk_tags(yaffs_dev_t *dev,
-       int nand_chunk, u8 *data, yaffs_ext_tags *etags)
+int nandmtd1_read_chunk_tags(struct yaffs_dev *dev,
+       int nand_chunk, u8 *data, struct yaffs_ext_tags *etags)
 {
-       struct mtd_info *mtd = yaffs_dev_to_mtd(dev);
+       struct mtd_info *mtd = struct yaffs_devo_mtd(dev);
        int chunk_bytes = dev->data_bytes_per_chunk;
        loff_t addr = ((loff_t)nand_chunk) * chunk_bytes;
        int eccres = YAFFS_ECC_RESULT_NO_ERROR;
@@ -212,7 +212,7 @@ int nandmtd1_read_chunk_tags(yaffs_dev_t *dev,
 
        /* Check the packed tags mini-ECC and correct if necessary/possible.
         */
-       retval = yaffs_check_tags_ecc((yaffs_tags_t *)&pt1);
+       retval = yaffs_check_tags_ecc((struct yaffs_tags *)&pt1);
        switch (retval) {
        case 0:
                /* no tags error, use MTD result */
@@ -248,9 +248,9 @@ int nandmtd1_read_chunk_tags(yaffs_dev_t *dev,
  *
  * Returns YAFFS_OK or YAFFS_FAIL.
  */
-int nandmtd1_mark_block_bad(struct yaffs_dev_s *dev, int block_no)
+int nandmtd1_mark_block_bad(struct yaffs_dev *dev, int block_no)
 {
-       struct mtd_info *mtd = yaffs_dev_to_mtd(dev);
+       struct mtd_info *mtd = struct yaffs_devo_mtd(dev);
        int blocksize = dev->param.chunks_per_block * dev->data_bytes_per_chunk;
        int retval;
 
@@ -288,13 +288,13 @@ static int nandmtd1_test_prerequists(struct mtd_info *mtd)
  *
  * Always returns YAFFS_OK.
  */
-int nandmtd1_query_block(struct yaffs_dev_s *dev, int block_no,
+int nandmtd1_query_block(struct yaffs_dev *dev, int block_no,
        yaffs_block_state_t *state_ptr, u32 *seq_ptr)
 {
-       struct mtd_info *mtd = yaffs_dev_to_mtd(dev);
+       struct mtd_info *mtd = struct yaffs_devo_mtd(dev);
        int chunk_num = block_no * dev->param.chunks_per_block;
        loff_t addr = (loff_t)chunk_num * dev->data_bytes_per_chunk;
-       yaffs_ext_tags etags;
+       struct yaffs_ext_tags etags;
        int state = YAFFS_BLOCK_STATE_DEAD;
        int seqnum = 0;
        int retval;
index 53ba308..d798a1f 100644 (file)
  * We assume that the data buffer is of size total_bytes_per_chunk so that we can also
  * use it to load the tags.
  */
-int nandmtd2_write_chunk_tags(yaffs_dev_t *dev, int nand_chunk,
+int nandmtd2_write_chunk_tags(struct yaffs_dev *dev, int nand_chunk,
                                      const u8 *data,
-                                     const yaffs_ext_tags *tags)
+                                     const struct yaffs_ext_tags *tags)
 {
-       struct mtd_info *mtd = yaffs_dev_to_mtd(dev);
+       struct mtd_info *mtd = struct yaffs_devo_mtd(dev);
        struct mtd_oob_ops ops;
        int retval = 0;
 
@@ -81,10 +81,10 @@ int nandmtd2_write_chunk_tags(yaffs_dev_t *dev, int nand_chunk,
                return YAFFS_FAIL;
 }
 
-int nandmtd2_read_chunk_tags(yaffs_dev_t *dev, int nand_chunk,
-                                      u8 *data, yaffs_ext_tags *tags)
+int nandmtd2_read_chunk_tags(struct yaffs_dev *dev, int nand_chunk,
+                                      u8 *data, struct yaffs_ext_tags *tags)
 {
-       struct mtd_info *mtd = yaffs_dev_to_mtd(dev);
+       struct mtd_info *mtd = struct yaffs_devo_mtd(dev);
        struct mtd_oob_ops ops;
 
        size_t dummy;
@@ -123,7 +123,7 @@ int nandmtd2_read_chunk_tags(yaffs_dev_t *dev, int nand_chunk,
                ops.len = data ? dev->data_bytes_per_chunk : packed_tags_size;
                ops.ooboffs = 0;
                ops.datbuf = data;
-               ops.oobbuf = yaffs_dev_to_lc(dev)->spare_buffer;
+               ops.oobbuf = struct yaffs_devo_lc(dev)->spare_buffer;
                retval = mtd->read_oob(mtd, addr, &ops);
        }
 
@@ -135,7 +135,7 @@ int nandmtd2_read_chunk_tags(yaffs_dev_t *dev, int nand_chunk,
                }
        } else {
                if (tags) {
-                       memcpy(packed_tags_ptr, yaffs_dev_to_lc(dev)->spare_buffer, packed_tags_size);
+                       memcpy(packed_tags_ptr, struct yaffs_devo_lc(dev)->spare_buffer, packed_tags_size);
                        yaffs_unpack_tags2(tags, &pt, !dev->param.no_tags_ecc);
                }
        }
@@ -157,9 +157,9 @@ int nandmtd2_read_chunk_tags(yaffs_dev_t *dev, int nand_chunk,
                return YAFFS_FAIL;
 }
 
-int nandmtd2_mark_block_bad(struct yaffs_dev_s *dev, int block_no)
+int nandmtd2_mark_block_bad(struct yaffs_dev *dev, int block_no)
 {
-       struct mtd_info *mtd = yaffs_dev_to_mtd(dev);
+       struct mtd_info *mtd = struct yaffs_devo_mtd(dev);
        int retval;
        T(YAFFS_TRACE_MTD,
          (TSTR("nandmtd2_mark_block_bad %d" TENDSTR), block_no));
@@ -176,10 +176,10 @@ int nandmtd2_mark_block_bad(struct yaffs_dev_s *dev, int block_no)
 
 }
 
-int nandmtd2_query_block(struct yaffs_dev_s *dev, int block_no,
+int nandmtd2_query_block(struct yaffs_dev *dev, int block_no,
                            yaffs_block_state_t *state, u32 *seq_number)
 {
-       struct mtd_info *mtd = yaffs_dev_to_mtd(dev);
+       struct mtd_info *mtd = struct yaffs_devo_mtd(dev);
        int retval;
 
        T(YAFFS_TRACE_MTD,
@@ -195,7 +195,7 @@ int nandmtd2_query_block(struct yaffs_dev_s *dev, int block_no,
                *state = YAFFS_BLOCK_STATE_DEAD;
                *seq_number = 0;
        } else {
-               yaffs_ext_tags t;
+               struct yaffs_ext_tags t;
                nandmtd2_read_chunk_tags(dev, block_no *
                                                   dev->param.chunks_per_block, NULL,
                                                   &t);
index 968109a..cdbe428 100644 (file)
@@ -23,7 +23,7 @@
 
 #include "yaffs_linux.h"
 
-int nandmtd_erase_block(yaffs_dev_t *dev, int block_no)
+int nandmtd_erase_block(struct yaffs_dev *dev, int block_no)
 {
        struct mtd_info *mtd = yaffs_dev_to_mtd(dev);
        u32 addr =
@@ -49,7 +49,7 @@ int nandmtd_erase_block(yaffs_dev_t *dev, int block_no)
                return YAFFS_FAIL;
 }
 
-int nandmtd_initialise(yaffs_dev_t *dev)
+int nandmtd_initialise(struct yaffs_dev *dev)
 {
        return YAFFS_OK;
 }
index 919d354..198bca3 100644 (file)
@@ -22,6 +22,6 @@
 extern struct nand_oobinfo yaffs_oobinfo;
 extern struct nand_oobinfo yaffs_noeccinfo;
 #endif
-int nandmtd_erase_block(yaffs_dev_t *dev, int block_no);
-int nandmtd_initialise(yaffs_dev_t *dev);
+int nandmtd_erase_block(struct yaffs_dev *dev, int block_no);
+int nandmtd_initialise(struct yaffs_dev *dev);
 #endif
index 83e93e2..a71b2bb 100644 (file)
 #ifndef __YAFFS_MTDIF1_H__
 #define __YAFFS_MTDIF1_H__
 
-int nandmtd1_write_chunk_tags(yaffs_dev_t *dev, int nand_chunk,
-       const u8 *data, const yaffs_ext_tags *tags);
+int nandmtd1_write_chunk_tags(struct yaffs_dev *dev, int nand_chunk,
+       const u8 *data, const struct yaffs_ext_tags *tags);
 
-int nandmtd1_read_chunk_tags(yaffs_dev_t *dev, int nand_chunk,
-       u8 *data, yaffs_ext_tags *tags);
+int nandmtd1_read_chunk_tags(struct yaffs_dev *dev, int nand_chunk,
+       u8 *data, struct yaffs_ext_tags *tags);
 
-int nandmtd1_mark_block_bad(struct yaffs_dev_s *dev, int block_no);
+int nandmtd1_mark_block_bad(struct yaffs_dev *dev, int block_no);
 
-int nandmtd1_query_block(struct yaffs_dev_s *dev, int block_no,
+int nandmtd1_query_block(struct yaffs_dev *dev, int block_no,
        yaffs_block_state_t *state, u32 *seq_number);
 
 #endif
index 4cce67b..751dabb 100644 (file)
 #define __YAFFS_MTDIF2_H__
 
 #include "yaffs_guts.h"
-int nandmtd2_write_chunk_tags(yaffs_dev_t *dev, int nand_chunk,
+int nandmtd2_write_chunk_tags(struct yaffs_dev *dev, int nand_chunk,
                                const u8 *data,
-                               const yaffs_ext_tags *tags);
-int nandmtd2_read_chunk_tags(yaffs_dev_t *dev, int nand_chunk,
-                               u8 *data, yaffs_ext_tags *tags);
-int nandmtd2_mark_block_bad(struct yaffs_dev_s *dev, int block_no);
-int nandmtd2_query_block(struct yaffs_dev_s *dev, int block_no,
+                               const struct yaffs_ext_tags *tags);
+int nandmtd2_read_chunk_tags(struct yaffs_dev *dev, int nand_chunk,
+                               u8 *data, struct yaffs_ext_tags *tags);
+int nandmtd2_mark_block_bad(struct yaffs_dev *dev, int block_no);
+int nandmtd2_query_block(struct yaffs_dev *dev, int block_no,
                        yaffs_block_state_t *state, u32 *seq_number);
 
 #endif
index 5fee1a3..11eec44 100644 (file)
 
 #include "yaffs_getblockinfo.h"
 
-int yaffs_rd_chunk_tags_nand(yaffs_dev_t *dev, int nand_chunk,
+int yaffs_rd_chunk_tags_nand(struct yaffs_dev *dev, int nand_chunk,
                                           u8 *buffer,
-                                          yaffs_ext_tags *tags)
+                                          struct yaffs_ext_tags *tags)
 {
        int result;
-       yaffs_ext_tags local_tags;
+       struct yaffs_ext_tags local_tags;
 
        int realigned_chunk = nand_chunk - dev->chunk_offset;
 
@@ -51,10 +51,10 @@ int yaffs_rd_chunk_tags_nand(yaffs_dev_t *dev, int nand_chunk,
        return result;
 }
 
-int yaffs_wr_chunk_tags_nand(yaffs_dev_t *dev,
+int yaffs_wr_chunk_tags_nand(struct yaffs_dev *dev,
                                                   int nand_chunk,
                                                   const u8 *buffer,
-                                                  yaffs_ext_tags *tags)
+                                                  struct yaffs_ext_tags *tags)
 {
 
        dev->n_page_writes++;
@@ -88,7 +88,7 @@ int yaffs_wr_chunk_tags_nand(yaffs_dev_t *dev,
                                                                       tags);
 }
 
-int yaffs_mark_bad(yaffs_dev_t *dev, int block_no)
+int yaffs_mark_bad(struct yaffs_dev *dev, int block_no)
 {
        block_no -= dev->block_offset;
 
@@ -99,7 +99,7 @@ int yaffs_mark_bad(yaffs_dev_t *dev, int block_no)
                return yaffs_tags_compat_mark_bad(dev, block_no);
 }
 
-int yaffs_query_init_block_state(yaffs_dev_t *dev,
+int yaffs_query_init_block_state(struct yaffs_dev *dev,
                                                 int block_no,
                                                 yaffs_block_state_t *state,
                                                 u32 *seq_number)
@@ -115,7 +115,7 @@ int yaffs_query_init_block_state(yaffs_dev_t *dev,
 }
 
 
-int yaffs_erase_block(struct yaffs_dev_s *dev,
+int yaffs_erase_block(struct yaffs_dev *dev,
                                  int flash_block)
 {
        int result;
@@ -129,7 +129,7 @@ int yaffs_erase_block(struct yaffs_dev_s *dev,
        return result;
 }
 
-int yaffs_init_nand(struct yaffs_dev_s *dev)
+int yaffs_init_nand(struct yaffs_dev *dev)
 {
        if(dev->param.initialise_flash_fn)
                return dev->param.initialise_flash_fn(dev);
index 127b129..51a334b 100644 (file)
 
 
 
-int yaffs_rd_chunk_tags_nand(yaffs_dev_t *dev, int nand_chunk,
+int yaffs_rd_chunk_tags_nand(struct yaffs_dev *dev, int nand_chunk,
                                        u8 *buffer,
-                                       yaffs_ext_tags *tags);
+                                       struct yaffs_ext_tags *tags);
 
-int yaffs_wr_chunk_tags_nand(yaffs_dev_t *dev,
+int yaffs_wr_chunk_tags_nand(struct yaffs_dev *dev,
                                                int nand_chunk,
                                                const u8 *buffer,
-                                               yaffs_ext_tags *tags);
+                                               struct yaffs_ext_tags *tags);
 
-int yaffs_mark_bad(yaffs_dev_t *dev, int block_no);
+int yaffs_mark_bad(struct yaffs_dev *dev, int block_no);
 
-int yaffs_query_init_block_state(yaffs_dev_t *dev,
+int yaffs_query_init_block_state(struct yaffs_dev *dev,
                                                int block_no,
                                                yaffs_block_state_t *state,
                                                unsigned *seq_number);
 
-int yaffs_erase_block(struct yaffs_dev_s *dev,
+int yaffs_erase_block(struct yaffs_dev *dev,
                                  int flash_block);
 
-int yaffs_init_nand(struct yaffs_dev_s *dev);
+int yaffs_init_nand(struct yaffs_dev *dev);
 
 #endif
 
index 77df13f..45dd54d 100644 (file)
@@ -14,7 +14,7 @@
 #include "yaffs_packedtags1.h"
 #include "yportenv.h"
 
-void yaffs_pack_tags1(yaffs_packed_tags1 *pt, const yaffs_ext_tags *t)
+void yaffs_pack_tags1(yaffs_packed_tags1 *pt, const struct yaffs_ext_tags *t)
 {
        pt->chunk_id = t->chunk_id;
        pt->serial_number = t->serial_number;
@@ -27,7 +27,7 @@ void yaffs_pack_tags1(yaffs_packed_tags1 *pt, const yaffs_ext_tags *t)
 
 }
 
-void yaffs_unpack_tags1(yaffs_ext_tags *t, const yaffs_packed_tags1 *pt)
+void yaffs_unpack_tags1(struct yaffs_ext_tags *t, const yaffs_packed_tags1 *pt)
 {
        static const u8 all_ff[] =
            { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
@@ -45,6 +45,6 @@ void yaffs_unpack_tags1(yaffs_ext_tags *t, const yaffs_packed_tags1 *pt)
                t->is_deleted = (pt->deleted) ? 0 : 1;
                t->serial_number = pt->serial_number;
        } else {
-               memset(t, 0, sizeof(yaffs_ext_tags));
+               memset(t, 0, sizeof(struct yaffs_ext_tags));
        }
 }
index 50f32e8..01f952a 100644 (file)
@@ -32,6 +32,6 @@ typedef struct {
 
 } yaffs_packed_tags1;
 
-void yaffs_pack_tags1(yaffs_packed_tags1 *pt, const yaffs_ext_tags *t);
-void yaffs_unpack_tags1(yaffs_ext_tags *t, const yaffs_packed_tags1 *pt);
+void yaffs_pack_tags1(yaffs_packed_tags1 *pt, const struct yaffs_ext_tags *t);
+void yaffs_unpack_tags1(struct yaffs_ext_tags *t, const yaffs_packed_tags1 *pt);
 #endif
index 4873f78..20f0d78 100644 (file)
@@ -51,7 +51,7 @@ static void yaffs_dump_packed_tags2(const yaffs_packed_tags2 *pt)
        yaffs_dump_packed_tags2_tags_only(&pt->t);
 }
 
-static void yaffs_dump_tags2(const yaffs_ext_tags *t)
+static void yaffs_dump_tags2(const struct yaffs_ext_tags *t)
 {
        T(YAFFS_TRACE_MTD,
          (TSTR
@@ -63,7 +63,7 @@ static void yaffs_dump_tags2(const yaffs_ext_tags *t)
 }
 
 void yaffs_pack_tags2_tags_only(yaffs_packed_tags2_tags_only *ptt,
-               const yaffs_ext_tags *t)
+               const struct yaffs_ext_tags *t)
 {
        ptt->chunk_id = t->chunk_id;
        ptt->seq_number = t->seq_number;
@@ -97,7 +97,7 @@ void yaffs_pack_tags2_tags_only(yaffs_packed_tags2_tags_only *ptt,
 }
 
 
-void yaffs_pack_tags2(yaffs_packed_tags2 *pt, const yaffs_ext_tags *t, int tags_ecc)
+void yaffs_pack_tags2(yaffs_packed_tags2 *pt, const struct yaffs_ext_tags *t, int tags_ecc)
 {
        yaffs_pack_tags2_tags_only(&pt->t, t);
 
@@ -108,11 +108,11 @@ void yaffs_pack_tags2(yaffs_packed_tags2 *pt, const yaffs_ext_tags *t, int tags_
 }
 
 
-void yaffs_unpack_tags2_tags_only(yaffs_ext_tags *t,
+void yaffs_unpack_tags2_tags_only(struct yaffs_ext_tags *t,
                yaffs_packed_tags2_tags_only *ptt)
 {
 
-       memset(t, 0, sizeof(yaffs_ext_tags));
+       memset(t, 0, sizeof(struct yaffs_ext_tags));
 
        yaffs_init_tags(t);
 
@@ -156,7 +156,7 @@ void yaffs_unpack_tags2_tags_only(yaffs_ext_tags *t,
 }
 
 
-void yaffs_unpack_tags2(yaffs_ext_tags *t, yaffs_packed_tags2 *pt, int tags_ecc)
+void yaffs_unpack_tags2(struct yaffs_ext_tags *t, yaffs_packed_tags2 *pt, int tags_ecc)
 {
 
        yaffs_ecc_result ecc_result = YAFFS_ECC_RESULT_NO_ERROR;
index fd7a239..e869a8a 100644 (file)
@@ -34,10 +34,10 @@ typedef struct {
 } yaffs_packed_tags2;
 
 /* Full packed tags with ECC, used for oob tags */
-void yaffs_pack_tags2(yaffs_packed_tags2 *pt, const yaffs_ext_tags *t, int tags_ecc);
-void yaffs_unpack_tags2(yaffs_ext_tags *t, yaffs_packed_tags2 *pt, int tags_ecc);
+void yaffs_pack_tags2(yaffs_packed_tags2 *pt, const struct yaffs_ext_tags *t, int tags_ecc);
+void yaffs_unpack_tags2(struct yaffs_ext_tags *t, yaffs_packed_tags2 *pt, int tags_ecc);
 
 /* Only the tags part (no ECC for use with inband tags */
-void yaffs_pack_tags2_tags_only(yaffs_packed_tags2_tags_only *pt, const yaffs_ext_tags *t);
-void yaffs_unpack_tags2_tags_only(yaffs_ext_tags *t, yaffs_packed_tags2_tags_only *pt);
+void yaffs_pack_tags2_tags_only(yaffs_packed_tags2_tags_only *pt, const struct yaffs_ext_tags *t);
+void yaffs_unpack_tags2_tags_only(struct yaffs_ext_tags *t, yaffs_packed_tags2_tags_only *pt);
 #endif
index 5af3a33..f3fe9e8 100644 (file)
@@ -17,7 +17,7 @@
 #include "yaffs_getblockinfo.h"
 #include "yaffs_trace.h"
 
-static void yaffs_handle_rd_data_error(yaffs_dev_t *dev, int nand_chunk);
+static void yaffs_handle_rd_data_error(struct yaffs_dev *dev, int nand_chunk);
 
 
 static const char yaffs_count_bits_table[256] = {
@@ -54,7 +54,7 @@ void yaffs_calc_ecc(const u8 *data, yaffs_spare *spare)
        yaffs_ecc_cacl(&data[256], spare->ecc2);
 }
 
-void yaffs_calc_tags_ecc(yaffs_tags_t *tags)
+void yaffs_calc_tags_ecc(struct yaffs_tags *tags)
 {
        /* Calculate an ecc */
 
@@ -77,7 +77,7 @@ void yaffs_calc_tags_ecc(yaffs_tags_t *tags)
 
 }
 
-int yaffs_check_tags_ecc(yaffs_tags_t *tags)
+int yaffs_check_tags_ecc(struct yaffs_tags *tags)
 {
        unsigned ecc = tags->ecc;
 
@@ -109,7 +109,7 @@ int yaffs_check_tags_ecc(yaffs_tags_t *tags)
 /********** Tags **********/
 
 static void yaffs_load_tags_to_spare(yaffs_spare *spare_ptr,
-                               yaffs_tags_t *tags_ptr)
+                               struct yaffs_tags *tags_ptr)
 {
        yaffs_tags_union_t *tu = (yaffs_tags_union_t *) tags_ptr;
 
@@ -125,8 +125,8 @@ static void yaffs_load_tags_to_spare(yaffs_spare *spare_ptr,
        spare_ptr->tb7 = tu->as_bytes[7];
 }
 
-static void yaffs_get_tags_from_spare(yaffs_dev_t *dev, yaffs_spare *spare_ptr,
-                               yaffs_tags_t *tags_ptr)
+static void yaffs_get_tags_from_spare(struct yaffs_dev *dev, yaffs_spare *spare_ptr,
+                               struct yaffs_tags *tags_ptr)
 {
        yaffs_tags_union_t *tu = (yaffs_tags_union_t *) tags_ptr;
        int result;
@@ -152,7 +152,7 @@ static void yaffs_spare_init(yaffs_spare *spare)
        memset(spare, 0xFF, sizeof(yaffs_spare));
 }
 
-static int yaffs_wr_nand(struct yaffs_dev_s *dev,
+static int yaffs_wr_nand(struct yaffs_dev *dev,
                                int nand_chunk, const u8 *data,
                                yaffs_spare *spare)
 {
@@ -166,7 +166,7 @@ static int yaffs_wr_nand(struct yaffs_dev_s *dev,
        return dev->param.write_chunk_fn(dev, nand_chunk, data, spare);
 }
 
-static int yaffs_rd_chunk_nand(struct yaffs_dev_s *dev,
+static int yaffs_rd_chunk_nand(struct yaffs_dev *dev,
                                   int nand_chunk,
                                   u8 *data,
                                   yaffs_spare *spare,
@@ -294,7 +294,7 @@ static int yaffs_rd_chunk_nand(struct yaffs_dev_s *dev,
  * Functions for robustisizing
  */
 
-static void yaffs_handle_rd_data_error(yaffs_dev_t *dev, int nand_chunk)
+static void yaffs_handle_rd_data_error(struct yaffs_dev *dev, int nand_chunk)
 {
        int flash_block = nand_chunk / dev->param.chunks_per_block;
 
@@ -311,13 +311,13 @@ static void yaffs_handle_rd_data_error(yaffs_dev_t *dev, int nand_chunk)
 }
 
 
-int yaffs_tags_compat_wr(yaffs_dev_t *dev,
+int yaffs_tags_compat_wr(struct yaffs_dev *dev,
                                                int nand_chunk,
                                                const u8 *data,
-                                               const yaffs_ext_tags *ext_tags)
+                                               const struct yaffs_ext_tags *ext_tags)
 {
        yaffs_spare spare;
-       yaffs_tags_t tags;
+       struct yaffs_tags tags;
 
        yaffs_spare_init(&spare);
 
@@ -347,14 +347,14 @@ int yaffs_tags_compat_wr(yaffs_dev_t *dev,
        return yaffs_wr_nand(dev, nand_chunk, data, &spare);
 }
 
-int yaffs_tags_compat_rd(yaffs_dev_t *dev,
+int yaffs_tags_compat_rd(struct yaffs_dev *dev,
                                                     int nand_chunk,
                                                     u8 *data,
-                                                    yaffs_ext_tags *ext_tags)
+                                                    struct yaffs_ext_tags *ext_tags)
 {
 
        yaffs_spare spare;
-       yaffs_tags_t tags;
+       struct yaffs_tags tags;
        yaffs_ecc_result ecc_result = YAFFS_ECC_RESULT_UNKNOWN;
 
        static yaffs_spare spare_ff;
@@ -401,7 +401,7 @@ int yaffs_tags_compat_rd(yaffs_dev_t *dev,
        }
 }
 
-int yaffs_tags_compat_mark_bad(struct yaffs_dev_s *dev,
+int yaffs_tags_compat_mark_bad(struct yaffs_dev *dev,
                                            int flash_block)
 {
 
@@ -420,7 +420,7 @@ int yaffs_tags_compat_mark_bad(struct yaffs_dev_s *dev,
 
 }
 
-int yaffs_tags_compat_query_block(struct yaffs_dev_s *dev,
+int yaffs_tags_compat_query_block(struct yaffs_dev *dev,
                                          int block_no,
                                          yaffs_block_state_t *state,
                                          u32 *seq_number)
index 9f0fc5d..c906883 100644 (file)
 #define __YAFFS_TAGSCOMPAT_H__
 
 #include "yaffs_guts.h"
-int yaffs_tags_compat_wr(yaffs_dev_t *dev,
+int yaffs_tags_compat_wr(struct yaffs_dev *dev,
                                                int nand_chunk,
                                                const u8 *data,
-                                               const yaffs_ext_tags *tags);
-int yaffs_tags_compat_rd(yaffs_dev_t *dev,
+                                               const struct yaffs_ext_tags *tags);
+int yaffs_tags_compat_rd(struct yaffs_dev *dev,
                                                int nand_chunk,
                                                u8 *data,
-                                               yaffs_ext_tags *tags);
-int yaffs_tags_compat_mark_bad(struct yaffs_dev_s *dev,
+                                               struct yaffs_ext_tags *tags);
+int yaffs_tags_compat_mark_bad(struct yaffs_dev *dev,
                                            int block_no);
-int yaffs_tags_compat_query_block(struct yaffs_dev_s *dev,
+int yaffs_tags_compat_query_block(struct yaffs_dev *dev,
                                          int block_no,
                                          yaffs_block_state_t *state,
                                          u32 *seq_number);
 
-void yaffs_calc_tags_ecc(yaffs_tags_t *tags);
-int yaffs_check_tags_ecc(yaffs_tags_t *tags);
+void yaffs_calc_tags_ecc(struct yaffs_tags *tags);
+int yaffs_check_tags_ecc(struct yaffs_tags *tags);
 int yaffs_count_bits(u8 byte);
 
 #endif
index 787cdba..67a5eaf 100644 (file)
 
 #include "yaffs_tagsvalidity.h"
 
-void yaffs_init_tags(yaffs_ext_tags *tags)
+void yaffs_init_tags(struct yaffs_ext_tags *tags)
 {
-       memset(tags, 0, sizeof(yaffs_ext_tags));
+       memset(tags, 0, sizeof(struct yaffs_ext_tags));
        tags->validity1 = 0xAAAAAAAA;
        tags->validty1 = 0x55555555;
 }
 
-int yaffs_validate_tags(yaffs_ext_tags *tags)
+int yaffs_validate_tags(struct yaffs_ext_tags *tags)
 {
        return (tags->validity1 == 0xAAAAAAAA &&
                tags->validty1 == 0x55555555);
index 085056c..ae3116f 100644 (file)
@@ -19,6 +19,6 @@
 
 #include "yaffs_guts.h"
 
-void yaffs_init_tags(yaffs_ext_tags *tags);
-int yaffs_validate_tags(yaffs_ext_tags *tags);
+void yaffs_init_tags(struct yaffs_ext_tags *tags);
+int yaffs_validate_tags(struct yaffs_ext_tags *tags);
 #endif
index 5bdddc0..0e27228 100644 (file)
 #include "yaffs_getblockinfo.h"
 #include "yaffs_nand.h"
 
-int yaffs_skip_verification(yaffs_dev_t *dev)
+int yaffs_skip_verification(struct yaffs_dev *dev)
 {
        dev=dev;
        return !(yaffs_trace_mask & (YAFFS_TRACE_VERIFY | YAFFS_TRACE_VERIFY_FULL));
 }
 
-static int yaffs_skip_full_verification(yaffs_dev_t *dev)
+static int yaffs_skip_full_verification(struct yaffs_dev *dev)
 {
        dev=dev;
        return !(yaffs_trace_mask & (YAFFS_TRACE_VERIFY_FULL));
 }
 
-static int yaffs_skip_nand_verification(yaffs_dev_t *dev)
+static int yaffs_skip_nand_verification(struct yaffs_dev *dev)
 {
        dev=dev;
        return !(yaffs_trace_mask & (YAFFS_TRACE_VERIFY_NAND));
@@ -51,7 +51,7 @@ static const char *block_state_name[] = {
 };
 
 
-void yaffs_verify_blk(yaffs_dev_t *dev, yaffs_block_info_t *bi, int n)
+void yaffs_verify_blk(struct yaffs_dev *dev, yaffs_block_info_t *bi, int n)
 {
        int actually_used;
        int in_use;
@@ -92,7 +92,7 @@ void yaffs_verify_blk(yaffs_dev_t *dev, yaffs_block_info_t *bi, int n)
 
 
 
-void yaffs_verify_collected_blk(yaffs_dev_t *dev, yaffs_block_info_t *bi, int n)
+void yaffs_verify_collected_blk(struct yaffs_dev *dev, yaffs_block_info_t *bi, int n)
 {
        yaffs_verify_blk(dev, bi, n);
 
@@ -105,7 +105,7 @@ void yaffs_verify_collected_blk(yaffs_dev_t *dev, yaffs_block_info_t *bi, int n)
        }
 }
 
-void yaffs_verify_blocks(yaffs_dev_t *dev)
+void yaffs_verify_blocks(struct yaffs_dev *dev)
 {
        int i;
        int state_count[YAFFS_NUMBER_OF_BLOCK_STATES];
@@ -161,7 +161,7 @@ void yaffs_verify_blocks(yaffs_dev_t *dev)
  * Verify the object header. oh must be valid, but obj and tags may be NULL in which
  * case those tests will not be performed.
  */
-void yaffs_verify_oh(yaffs_obj_t *obj, yaffs_obj_header *oh, yaffs_ext_tags *tags, int parent_check)
+void yaffs_verify_oh(struct yaffs_obj *obj, struct yaffs_obj_hdr *oh, struct yaffs_ext_tags *tags, int parent_check)
 {
        if (obj && yaffs_skip_verification(obj->my_dev))
                return;
@@ -217,15 +217,15 @@ void yaffs_verify_oh(yaffs_obj_t *obj, yaffs_obj_header *oh, yaffs_ext_tags *tag
 
 
 
-void yaffs_verify_file(yaffs_obj_t *obj)
+void yaffs_verify_file(struct yaffs_obj *obj)
 {
        int required_depth;
        int actual_depth;
        u32 last_chunk;
        u32 x;
        u32 i;
-       yaffs_dev_t *dev;
-       yaffs_ext_tags tags;
+       struct yaffs_dev *dev;
+       struct yaffs_ext_tags tags;
        yaffs_tnode_t *tn;
        u32 obj_id;
 
@@ -276,7 +276,7 @@ void yaffs_verify_file(yaffs_obj_t *obj)
 }
 
 
-void yaffs_verify_link(yaffs_obj_t *obj)
+void yaffs_verify_link(struct yaffs_obj *obj)
 {
        if (obj && yaffs_skip_verification(obj->my_dev))
                return;
@@ -284,7 +284,7 @@ void yaffs_verify_link(yaffs_obj_t *obj)
        /* Verify sane equivalent object */
 }
 
-void yaffs_verify_symlink(yaffs_obj_t *obj)
+void yaffs_verify_symlink(struct yaffs_obj *obj)
 {
        if (obj && yaffs_skip_verification(obj->my_dev))
                return;
@@ -292,15 +292,15 @@ void yaffs_verify_symlink(yaffs_obj_t *obj)
        /* Verify symlink string */
 }
 
-void yaffs_verify_special(yaffs_obj_t *obj)
+void yaffs_verify_special(struct yaffs_obj *obj)
 {
        if (obj && yaffs_skip_verification(obj->my_dev))
                return;
 }
 
-void yaffs_verify_obj(yaffs_obj_t *obj)
+void yaffs_verify_obj(struct yaffs_obj *obj)
 {
-       yaffs_dev_t *dev;
+       struct yaffs_dev *dev;
 
        u32 chunk_min;
        u32 chunk_max;
@@ -345,11 +345,11 @@ void yaffs_verify_obj(yaffs_obj_t *obj)
        }
 
        if (chunk_valid && !yaffs_skip_nand_verification(dev)) {
-               yaffs_ext_tags tags;
-               yaffs_obj_header *oh;
+               struct yaffs_ext_tags tags;
+               struct yaffs_obj_hdr *oh;
                u8 *buffer = yaffs_get_temp_buffer(dev, __LINE__);
 
-               oh = (yaffs_obj_header *)buffer;
+               oh = (struct yaffs_obj_hdr *)buffer;
 
                yaffs_rd_chunk_tags_nand(dev, obj->hdr_chunk, buffer,
                                &tags);
@@ -399,9 +399,9 @@ void yaffs_verify_obj(yaffs_obj_t *obj)
        }
 }
 
-void yaffs_verify_objects(yaffs_dev_t *dev)
+void yaffs_verify_objects(struct yaffs_dev *dev)
 {
-       yaffs_obj_t *obj;
+       struct yaffs_obj *obj;
        int i;
        struct ylist_head *lh;
 
@@ -413,7 +413,7 @@ void yaffs_verify_objects(yaffs_dev_t *dev)
        for (i = 0; i <  YAFFS_NOBJECT_BUCKETS; i++) {
                ylist_for_each(lh, &dev->obj_bucket[i].list) {
                        if (lh) {
-                               obj = ylist_entry(lh, yaffs_obj_t, hash_link);
+                               obj = ylist_entry(lh, struct yaffs_obj, hash_link);
                                yaffs_verify_obj(obj);
                        }
                }
@@ -421,10 +421,10 @@ void yaffs_verify_objects(yaffs_dev_t *dev)
 }
 
 
-void yaffs_verify_obj_in_dir(yaffs_obj_t *obj)
+void yaffs_verify_obj_in_dir(struct yaffs_obj *obj)
 {
        struct ylist_head *lh;
-       yaffs_obj_t *list_obj;
+       struct yaffs_obj *list_obj;
 
        int count = 0;
 
@@ -452,7 +452,7 @@ void yaffs_verify_obj_in_dir(yaffs_obj_t *obj)
 
        ylist_for_each(lh, &obj->parent->variant.dir_variant.children) {
                if (lh) {
-                       list_obj = ylist_entry(lh, yaffs_obj_t, siblings);
+                       list_obj = ylist_entry(lh, struct yaffs_obj, siblings);
                        yaffs_verify_obj(list_obj);
                        if (obj == list_obj)
                                count++;
@@ -465,10 +465,10 @@ void yaffs_verify_obj_in_dir(yaffs_obj_t *obj)
        }
 }
 
-void yaffs_verify_dir(yaffs_obj_t *directory)
+void yaffs_verify_dir(struct yaffs_obj *directory)
 {
        struct ylist_head *lh;
-       yaffs_obj_t *list_obj;
+       struct yaffs_obj *list_obj;
 
        if (!directory) {
                YBUG();
@@ -489,7 +489,7 @@ void yaffs_verify_dir(yaffs_obj_t *directory)
 
        ylist_for_each(lh, &directory->variant.dir_variant.children) {
                if (lh) {
-                       list_obj = ylist_entry(lh, yaffs_obj_t, siblings);
+                       list_obj = ylist_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),
@@ -503,7 +503,7 @@ void yaffs_verify_dir(yaffs_obj_t *directory)
 
 static int yaffs_free_verification_failures;
 
-void yaffs_verify_free_chunks(yaffs_dev_t *dev)
+void yaffs_verify_free_chunks(struct yaffs_dev *dev)
 {
        int counted;
        int difference;
@@ -523,7 +523,7 @@ void yaffs_verify_free_chunks(yaffs_dev_t *dev)
        }
 }
 
-int yaffs_verify_file_sane(yaffs_obj_t *in)
+int yaffs_verify_file_sane(struct yaffs_obj *in)
 {
        in=in;
        return YAFFS_OK;
index 6118afd..fdff0ba 100644 (file)
 
 #include "yaffs_guts.h"
 
-void yaffs_verify_blk(yaffs_dev_t *dev, yaffs_block_info_t *bi, int n);
-void yaffs_verify_collected_blk(yaffs_dev_t *dev, yaffs_block_info_t *bi, int n);
-void yaffs_verify_blocks(yaffs_dev_t *dev);
-
-void yaffs_verify_oh(yaffs_obj_t *obj, yaffs_obj_header *oh, yaffs_ext_tags *tags, int parent_check);
-void yaffs_verify_file(yaffs_obj_t *obj);
-void yaffs_verify_link(yaffs_obj_t *obj);
-void yaffs_verify_symlink(yaffs_obj_t *obj);
-void yaffs_verify_special(yaffs_obj_t *obj);
-void yaffs_verify_obj(yaffs_obj_t *obj);
-void yaffs_verify_objects(yaffs_dev_t *dev);
-void yaffs_verify_obj_in_dir(yaffs_obj_t *obj);
-void yaffs_verify_dir(yaffs_obj_t *directory);
-void yaffs_verify_free_chunks(yaffs_dev_t *dev);
-
-int yaffs_verify_file_sane(yaffs_obj_t *obj);
-
-int yaffs_skip_verification(yaffs_dev_t *dev);
+void yaffs_verify_blk(struct yaffs_dev *dev, yaffs_block_info_t *bi, int n);
+void yaffs_verify_collected_blk(struct yaffs_dev *dev, yaffs_block_info_t *bi, int n);
+void yaffs_verify_blocks(struct yaffs_dev *dev);
+
+void yaffs_verify_oh(struct yaffs_obj *obj, struct yaffs_obj_hdr *oh, struct yaffs_ext_tags *tags, int parent_check);
+void yaffs_verify_file(struct yaffs_obj *obj);
+void yaffs_verify_link(struct yaffs_obj *obj);
+void yaffs_verify_symlink(struct yaffs_obj *obj);
+void yaffs_verify_special(struct yaffs_obj *obj);
+void yaffs_verify_obj(struct yaffs_obj *obj);
+void yaffs_verify_objects(struct yaffs_dev *dev);
+void yaffs_verify_obj_in_dir(struct yaffs_obj *obj);
+void yaffs_verify_dir(struct yaffs_obj *directory);
+void yaffs_verify_free_chunks(struct yaffs_dev *dev);
+
+int yaffs_verify_file_sane(struct yaffs_obj *obj);
+
+int yaffs_skip_verification(struct yaffs_dev *dev);
 
 #endif
 
index 8230537..e1438da 100644 (file)
  * the VFS.
  *
  * Special notes:
- * >> 2.4: sb->u.generic_sbp points to the yaffs_dev_t associated with
+ * >> 2.4: sb->u.generic_sbp points to the struct yaffs_dev associated with
  *         this superblock
- * >> 2.6: sb->s_fs_info  points to the yaffs_dev_t associated with this
+ * >> 2.6: sb->s_fs_info  points to the struct yaffs_dev associated with this
  *         superblock
- * >> inode->u.generic_ip points to the associated yaffs_obj_t.
+ * >> inode->u.generic_ip points to the associated struct yaffs_obj.
  */
 
 /*
@@ -209,13 +209,13 @@ static struct inode *yaffs_iget(struct super_block *sb, unsigned long ino);
 #define yaffs_inode_to_obj_lv(iptr) ((iptr)->u.generic_ip)
 #endif
 
-#define yaffs_inode_to_obj(iptr) ((yaffs_obj_t *)(yaffs_inode_to_obj_lv(iptr)))
+#define yaffs_inode_to_obj(iptr) ((struct yaffs_obj *)(yaffs_inode_to_obj_lv(iptr)))
 #define yaffs_dentry_to_obj(dptr) yaffs_inode_to_obj((dptr)->d_inode)
 
 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0))
-#define yaffs_super_to_dev(sb) ((yaffs_dev_t *)sb->s_fs_info)
+#define yaffs_super_to_dev(sb) ((struct yaffs_dev *)sb->s_fs_info)
 #else
-#define yaffs_super_to_dev(sb) ((yaffs_dev_t *)sb->u.generic_sbp)
+#define yaffs_super_to_dev(sb) ((struct yaffs_dev *)sb->u.generic_sbp)
 #endif
 
 
@@ -340,7 +340,7 @@ static void *yaffs_follow_link(struct dentry *dentry, struct nameidata *nd);
 static int yaffs_follow_link(struct dentry *dentry, struct nameidata *nd);
 #endif
 
-static void yaffs_touch_super(yaffs_dev_t *dev);
+static void yaffs_touch_super(struct yaffs_dev *dev);
 
 static loff_t yaffs_dir_llseek(struct file *file, loff_t offset, int origin);
 
@@ -507,19 +507,19 @@ static  int yaffs_vfs_setsize(struct inode *inode, loff_t newsize)
 
 }
 
-static unsigned yaffs_gc_control_callback(yaffs_dev_t *dev)
+static unsigned yaffs_gc_control_callback(struct yaffs_dev *dev)
 {
        return yaffs_gc_control;
 }
                                                                                                                        
-static void yaffs_gross_lock(yaffs_dev_t *dev)
+static void yaffs_gross_lock(struct yaffs_dev *dev)
 {
        T(YAFFS_TRACE_LOCK, (TSTR("yaffs locking %p\n"), current));
        down(&(yaffs_dev_to_lc(dev)->gross_lock));
        T(YAFFS_TRACE_LOCK, (TSTR("yaffs locked %p\n"), current));
 }
 
-static void yaffs_gross_unlock(yaffs_dev_t *dev)
+static void yaffs_gross_unlock(struct yaffs_dev *dev)
 {
        T(YAFFS_TRACE_LOCK, (TSTR("yaffs unlocking %p\n"), current));
        up(&(yaffs_dev_to_lc(dev)->gross_lock));
@@ -552,8 +552,8 @@ struct dentry *yaffs2_get_parent(struct dentry *dentry)
        struct dentry *parent = ERR_PTR(-ENOENT);
        struct inode *inode;
        unsigned long parent_ino;
-       yaffs_obj_t *d_obj;
-       yaffs_obj_t *parent_obj;
+       struct yaffs_obj *d_obj;
+       struct yaffs_obj *parent_obj;
 
        d_obj = yaffs_inode_to_obj(dentry->d_inode);
 
@@ -603,7 +603,7 @@ static struct export_operations yaffs_export_ops =
  * next object before the object is deleted.
  *
  * Many readdirs (and thus seach conexts) may be alive simulateously so
- * each yaffs_dev_t has a list of these.
+ * each struct yaffs_dev has a list of these.
  *
  * A seach context lives for the duration of a readdir.
  *
@@ -611,9 +611,9 @@ static struct export_operations yaffs_export_ops =
  */
 
 struct yaffs_search_context {
-       yaffs_dev_t *dev;
-       yaffs_obj_t *dir_obj;
-       yaffs_obj_t *next_return;
+       struct yaffs_dev *dev;
+       struct yaffs_obj *dir_obj;
+       struct yaffs_obj *next_return;
        struct ylist_head others;
 };
 
@@ -623,9 +623,9 @@ struct yaffs_search_context {
  *
  * Called at start of readdir.
  */
-static struct yaffs_search_context * yaffs_new_search(yaffs_obj_t *dir)
+static struct yaffs_search_context * yaffs_new_search(struct yaffs_obj *dir)
 {
-       yaffs_dev_t *dev = dir->my_dev;
+       struct yaffs_dev *dev = dir->my_dev;
        struct yaffs_search_context *sc = YMALLOC(sizeof(struct yaffs_search_context));
        if(sc){
                sc->dir_obj = dir;
@@ -635,7 +635,7 @@ static struct yaffs_search_context * yaffs_new_search(yaffs_obj_t *dir)
                else
                        sc->next_return = ylist_entry(
                                 dir->variant.dir_variant.children.next,
-                               yaffs_obj_t,siblings);
+                               struct yaffs_obj,siblings);
                YINIT_LIST_HEAD(&sc->others);
                ylist_add(&sc->others,&(yaffs_dev_to_lc(dev)->search_contexts));
        }
@@ -672,7 +672,7 @@ static void yaffs_search_advance(struct yaffs_search_context *sc)
                 if( next == &sc->dir_obj->variant.dir_variant.children)
                         sc->next_return = NULL; /* end of list */
                 else
-                        sc->next_return = ylist_entry(next,yaffs_obj_t,siblings);
+                        sc->next_return = ylist_entry(next,struct yaffs_obj,siblings);
         }
 }
 
@@ -681,7 +681,7 @@ static void yaffs_search_advance(struct yaffs_search_context *sc)
  * We check open search contexts and advance any which are currently
  * on the object being iterated.
  */
-static void yaffs_remove_obj_callback(yaffs_obj_t *obj)
+static void yaffs_remove_obj_callback(struct yaffs_obj *obj)
 {
 
         struct ylist_head *i;
@@ -712,7 +712,7 @@ static int yaffs_readlink(struct dentry *dentry, char __user *buffer,
        unsigned char *alias;
        int ret;
 
-       yaffs_dev_t *dev = yaffs_dentry_to_obj(dentry)->my_dev;
+       struct yaffs_dev *dev = yaffs_dentry_to_obj(dentry)->my_dev;
 
        yaffs_gross_lock(dev);
 
@@ -739,7 +739,7 @@ static int yaffs_follow_link(struct dentry *dentry, struct nameidata *nd)
 #endif
        unsigned char *alias;
        int ret_int = 0;
-       yaffs_dev_t *dev = yaffs_dentry_to_obj(dentry)->my_dev;
+       struct yaffs_dev *dev = yaffs_dentry_to_obj(dentry)->my_dev;
 
        yaffs_gross_lock(dev);
 
@@ -775,7 +775,7 @@ void yaffs_put_link(struct dentry *dentry, struct nameidata *nd, void *alias) {
 #endif
 
 struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev,
-                               yaffs_obj_t *obj);
+                               struct yaffs_obj *obj);
 
 /*
  * Lookup is used to find objects in the fs
@@ -788,10 +788,10 @@ static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry,
 static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry)
 #endif
 {
-       yaffs_obj_t *obj;
+       struct yaffs_obj *obj;
        struct inode *inode = NULL;     /* NCB 2.5/2.6 needs NULL here */
 
-       yaffs_dev_t *dev = yaffs_inode_to_obj(dir)->my_dev;
+       struct yaffs_dev *dev = yaffs_inode_to_obj(dir)->my_dev;
 
        if(current != yaffs_dev_to_lc(dev)->readdir_process)
                yaffs_gross_lock(dev);
@@ -857,10 +857,10 @@ static void yaffs_put_inode(struct inode *inode)
 #endif
 
 
-static void yaffs_unstitch_obj(struct inode *inode, yaffs_obj_t *obj)
+static void yaffs_unstitch_obj(struct inode *inode, struct yaffs_obj *obj)
 {
        /* Clear the association between the inode and
-        * the yaffs_obj_t.
+        * the struct yaffs_obj.
         */
        obj->my_inode = NULL;
        yaffs_inode_to_obj_lv(inode) = NULL;
@@ -879,8 +879,8 @@ static void yaffs_unstitch_obj(struct inode *inode, yaffs_obj_t *obj)
  */
 static void yaffs_evict_inode( struct inode *inode)
 {
-       yaffs_obj_t *obj;
-       yaffs_dev_t *dev;
+       struct yaffs_obj *obj;
+       struct yaffs_dev *dev;
        int deleteme = 0;
 
        obj = yaffs_inode_to_obj(inode);
@@ -921,8 +921,8 @@ static void yaffs_evict_inode( struct inode *inode)
 
 static void yaffs_clear_inode(struct inode *inode)
 {
-       yaffs_obj_t *obj;
-       yaffs_dev_t *dev;
+       struct yaffs_obj *obj;
+       struct yaffs_dev *dev;
 
        obj = yaffs_inode_to_obj(inode);
 
@@ -947,8 +947,8 @@ static void yaffs_clear_inode(struct inode *inode)
  */
 static void yaffs_delete_inode(struct inode *inode)
 {
-       yaffs_obj_t *obj = yaffs_inode_to_obj(inode);
-       yaffs_dev_t *dev;
+       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,
@@ -975,9 +975,9 @@ static int yaffs_file_flush(struct file *file, fl_owner_t id)
 static int yaffs_file_flush(struct file *file)
 #endif
 {
-       yaffs_obj_t *obj = yaffs_dentry_to_obj(file->f_dentry);
+       struct yaffs_obj *obj = yaffs_dentry_to_obj(file->f_dentry);
 
-       yaffs_dev_t *dev = obj->my_dev;
+       struct yaffs_dev *dev = obj->my_dev;
 
        T(YAFFS_TRACE_OS,
                (TSTR("yaffs_file_flush object %d (%s)\n"), obj->obj_id,
@@ -996,11 +996,11 @@ static int yaffs_readpage_nolock(struct file *f, struct page *pg)
 {
        /* Lifted from jffs2 */
 
-       yaffs_obj_t *obj;
+       struct yaffs_obj *obj;
        unsigned char *pg_buf;
        int ret;
 
-       yaffs_dev_t *dev;
+       struct yaffs_dev *dev;
 
        T(YAFFS_TRACE_OS,
                (TSTR("yaffs_readpage_nolock at %08x, size %08x\n"),
@@ -1072,12 +1072,12 @@ static int yaffs_writepage(struct page *page, struct writeback_control *wbc)
 static int yaffs_writepage(struct page *page)
 #endif
 {
-       yaffs_dev_t *dev;
+       struct yaffs_dev *dev;
        struct address_space *mapping = page->mapping;
        struct inode *inode;
        unsigned long end_index;
        char *buffer;
-       yaffs_obj_t *obj;
+       struct yaffs_obj *obj;
        int n_written = 0;
        unsigned n_bytes;
        loff_t i_size;
@@ -1303,7 +1303,7 @@ static int yaffs_commit_write(struct file *f, struct page *pg, unsigned offset,
 #endif
 
 
-static void yaffs_fill_inode_from_obj(struct inode *inode, yaffs_obj_t *obj)
+static void yaffs_fill_inode_from_obj(struct inode *inode, struct yaffs_obj *obj)
 {
        if (inode && obj) {
 
@@ -1411,7 +1411,7 @@ static void yaffs_fill_inode_from_obj(struct inode *inode, yaffs_obj_t *obj)
 }
 
 struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev,
-                               yaffs_obj_t *obj)
+                               struct yaffs_obj *obj)
 {
        struct inode *inode;
 
@@ -1446,10 +1446,10 @@ struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev,
 static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n,
                                loff_t *pos)
 {
-       yaffs_obj_t *obj;
+       struct yaffs_obj *obj;
        int n_written, ipos;
        struct inode *inode;
-       yaffs_dev_t *dev;
+       struct yaffs_dev *dev;
 
        obj = yaffs_dentry_to_obj(f->f_dentry);
 
@@ -1505,8 +1505,8 @@ static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n,
 
 static ssize_t yaffs_hold_space(struct file *f)
 {
-       yaffs_obj_t *obj;
-       yaffs_dev_t *dev;
+       struct yaffs_obj *obj;
+       struct yaffs_dev *dev;
 
        int n_free_chunks;
 
@@ -1526,8 +1526,8 @@ static ssize_t yaffs_hold_space(struct file *f)
 
 static void yaffs_release_space(struct file *f)
 {
-       yaffs_obj_t *obj;
-       yaffs_dev_t *dev;
+       struct yaffs_obj *obj;
+       struct yaffs_dev *dev;
 
 
        obj = yaffs_dentry_to_obj(f->f_dentry);
@@ -1569,12 +1569,12 @@ static loff_t yaffs_dir_llseek(struct file *file, loff_t offset, int origin)
 
 static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir)
 {
-       yaffs_obj_t *obj;
-       yaffs_dev_t *dev;
+       struct yaffs_obj *obj;
+       struct yaffs_dev *dev;
         struct yaffs_search_context *sc;
        struct inode *inode = f->f_dentry->d_inode;
        unsigned long offset, curoffs;
-       yaffs_obj_t *l;
+       struct yaffs_obj *l;
         int ret_val = 0;
 
        char name[YAFFS_MAX_NAME_LENGTH + 1];
@@ -1697,10 +1697,10 @@ static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode,
 {
        struct inode *inode;
 
-       yaffs_obj_t *obj = NULL;
-       yaffs_dev_t *dev;
+       struct yaffs_obj *obj = NULL;
+       struct yaffs_dev *dev;
 
-       yaffs_obj_t *parent = yaffs_inode_to_obj(dir);
+       struct yaffs_obj *parent = yaffs_inode_to_obj(dir);
 
        int error = -ENOSPC;
        uid_t uid = YCRED(current)->fsuid;
@@ -1800,8 +1800,8 @@ static int yaffs_unlink(struct inode *dir, struct dentry *dentry)
 {
        int ret_val;
 
-       yaffs_dev_t *dev;
-       yaffs_obj_t *obj;
+       struct yaffs_dev *dev;
+       struct yaffs_obj *obj;
 
        T(YAFFS_TRACE_OS,
                (TSTR("yaffs_unlink %d:%s\n"),
@@ -1833,9 +1833,9 @@ static int yaffs_link(struct dentry *old_dentry, struct inode *dir,
                        struct dentry *dentry)
 {
        struct inode *inode = old_dentry->d_inode;
-       yaffs_obj_t *obj = NULL;
-       yaffs_obj_t *link = NULL;
-       yaffs_dev_t *dev;
+       struct yaffs_obj *obj = NULL;
+       struct yaffs_obj *link = NULL;
+       struct yaffs_dev *dev;
 
        T(YAFFS_TRACE_OS, (TSTR("yaffs_link\n")));
 
@@ -1871,8 +1871,8 @@ static int yaffs_link(struct dentry *old_dentry, struct inode *dir,
 static int yaffs_symlink(struct inode *dir, struct dentry *dentry,
                                const char *symname)
 {
-       yaffs_obj_t *obj;
-       yaffs_dev_t *dev;
+       struct yaffs_obj *obj;
+       struct yaffs_dev *dev;
        uid_t uid = YCRED(current)->fsuid;
        gid_t gid = (dir->i_mode & S_ISGID) ? dir->i_gid : YCRED(current)->fsgid;
 
@@ -1907,8 +1907,8 @@ static int yaffs_sync_object(struct file *file, struct dentry *dentry,
 #endif
 {
 
-       yaffs_obj_t *obj;
-       yaffs_dev_t *dev;
+       struct yaffs_obj *obj;
+       struct yaffs_dev *dev;
 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 34))
        struct dentry *dentry = file->f_path.dentry;
 #endif
@@ -1933,9 +1933,9 @@ static int yaffs_sync_object(struct file *file, struct dentry *dentry,
 static int yaffs_rename(struct inode *old_dir, struct dentry *old_dentry,
                        struct inode *new_dir, struct dentry *new_dentry)
 {
-       yaffs_dev_t *dev;
+       struct yaffs_dev *dev;
        int ret_val = YAFFS_FAIL;
-       yaffs_obj_t *target;
+       struct yaffs_obj *target;
 
        T(YAFFS_TRACE_OS, (TSTR("yaffs_rename\n")));
        dev = yaffs_inode_to_obj(old_dir)->my_dev;
@@ -1984,7 +1984,7 @@ static int yaffs_setattr(struct dentry *dentry, struct iattr *attr)
 {
        struct inode *inode = dentry->d_inode;
        int error = 0;
-       yaffs_dev_t *dev;
+       struct yaffs_dev *dev;
 
        T(YAFFS_TRACE_OS,
                (TSTR("yaffs_setattr of object %d\n"),
@@ -2035,8 +2035,8 @@ int yaffs_setxattr(struct dentry *dentry, const char *name,
 {
        struct inode *inode = dentry->d_inode;
        int error = 0;
-       yaffs_dev_t *dev;
-       yaffs_obj_t *obj = yaffs_inode_to_obj(inode);
+       struct yaffs_dev *dev;
+       struct yaffs_obj *obj = yaffs_inode_to_obj(inode);
 
        T(YAFFS_TRACE_OS,
                (TSTR("yaffs_setxattr of object %d\n"),
@@ -2067,8 +2067,8 @@ ssize_t yaffs_getxattr(struct dentry *dentry, const char *name, void *buff,
 {
        struct inode *inode = dentry->d_inode;
        int error = 0;
-       yaffs_dev_t *dev;
-       yaffs_obj_t *obj = yaffs_inode_to_obj(inode);
+       struct yaffs_dev *dev;
+       struct yaffs_obj *obj = yaffs_inode_to_obj(inode);
 
        T(YAFFS_TRACE_OS,
                (TSTR("yaffs_getxattr \"%s\" from object %d\n"),
@@ -2091,8 +2091,8 @@ int yaffs_removexattr(struct dentry *dentry, const char *name)
 {
        struct inode *inode = dentry->d_inode;
        int error = 0;
-       yaffs_dev_t *dev;
-       yaffs_obj_t *obj = yaffs_inode_to_obj(inode);
+       struct yaffs_dev *dev;
+       struct yaffs_obj *obj = yaffs_inode_to_obj(inode);
 
        T(YAFFS_TRACE_OS,
                (TSTR("yaffs_removexattr of object %d\n"),
@@ -2121,8 +2121,8 @@ ssize_t yaffs_listxattr(struct dentry *dentry, char *buff, size_t size)
 {
        struct inode *inode = dentry->d_inode;
        int error = 0;
-       yaffs_dev_t *dev;
-       yaffs_obj_t *obj = yaffs_inode_to_obj(inode);
+       struct yaffs_dev *dev;
+       struct yaffs_obj *obj = yaffs_inode_to_obj(inode);
 
        T(YAFFS_TRACE_OS,
                (TSTR("yaffs_listxattr of object %d\n"),
@@ -2148,16 +2148,16 @@ ssize_t yaffs_listxattr(struct dentry *dentry, char *buff, size_t size)
 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17))
 static int yaffs_statfs(struct dentry *dentry, struct kstatfs *buf)
 {
-       yaffs_dev_t *dev = yaffs_dentry_to_obj(dentry)->my_dev;
+       struct yaffs_dev *dev = yaffs_dentry_to_obj(dentry)->my_dev;
        struct super_block *sb = dentry->d_sb;
 #elif (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0))
 static int yaffs_statfs(struct super_block *sb, struct kstatfs *buf)
 {
-       yaffs_dev_t *dev = yaffs_super_to_dev(sb);
+       struct yaffs_dev *dev = yaffs_super_to_dev(sb);
 #else
 static int yaffs_statfs(struct super_block *sb, struct statfs *buf)
 {
-       yaffs_dev_t *dev = yaffs_super_to_dev(sb);
+       struct yaffs_dev *dev = yaffs_super_to_dev(sb);
 #endif
 
        T(YAFFS_TRACE_OS, (TSTR("yaffs_statfs\n")));
@@ -2220,7 +2220,7 @@ static int yaffs_statfs(struct super_block *sb, struct statfs *buf)
 static void yaffs_flush_inodes(struct super_block *sb)
 {
        struct inode *iptr;
-       yaffs_obj_t *obj;
+       struct yaffs_obj *obj;
        
        list_for_each_entry(iptr,&sb->s_inodes, i_sb_list){
                obj = yaffs_inode_to_obj(iptr);
@@ -2235,7 +2235,7 @@ static void yaffs_flush_inodes(struct super_block *sb)
 
 static void yaffs_flush_super(struct super_block *sb, int do_checkpoint)
 {
-       yaffs_dev_t *dev = yaffs_super_to_dev(sb);      
+       struct yaffs_dev *dev = yaffs_super_to_dev(sb); 
        if(!dev)
                return;
        
@@ -2247,7 +2247,7 @@ static void yaffs_flush_super(struct super_block *sb, int do_checkpoint)
 }
 
 
-static unsigned yaffs_bg_gc_urgency(yaffs_dev_t *dev)
+static unsigned yaffs_bg_gc_urgency(struct yaffs_dev *dev)
 {
        unsigned erased_chunks = dev->n_erased_blocks * dev->param.chunks_per_block;
        struct yaffs_linux_context *context = yaffs_dev_to_lc(dev);
@@ -2272,7 +2272,7 @@ static int yaffs_do_sync_fs(struct super_block *sb,
                                int request_checkpoint)
 {
 
-       yaffs_dev_t *dev = yaffs_super_to_dev(sb);
+       struct yaffs_dev *dev = yaffs_super_to_dev(sb);
        unsigned int oneshot_checkpoint = (yaffs_auto_checkpoint & 4);
        unsigned gc_urgent = yaffs_bg_gc_urgency(dev);
        int do_checkpoint;
@@ -2321,7 +2321,7 @@ void yaffs_background_waker(unsigned long data)
 
 static int yaffs_bg_thread_fn(void *data)
 {
-       yaffs_dev_t *dev = (yaffs_dev_t *)data;
+       struct yaffs_dev *dev = (struct yaffs_dev *)data;
        struct yaffs_linux_context *context = yaffs_dev_to_lc(dev);
        unsigned long now = jiffies;
        unsigned long next_dir_update = now;
@@ -2400,7 +2400,7 @@ static int yaffs_bg_thread_fn(void *data)
        return 0;
 }
 
-static int yaffs_bg_start(yaffs_dev_t *dev)
+static int yaffs_bg_start(struct yaffs_dev *dev)
 {
        int retval = 0;
        struct yaffs_linux_context *context = yaffs_dev_to_lc(dev);
@@ -2421,7 +2421,7 @@ static int yaffs_bg_start(yaffs_dev_t *dev)
        return retval;
 }
 
-static void yaffs_bg_stop(yaffs_dev_t *dev)
+static void yaffs_bg_stop(struct yaffs_dev *dev)
 {
        struct yaffs_linux_context *ctxt = yaffs_dev_to_lc(dev);
 
@@ -2438,12 +2438,12 @@ static int yaffs_bg_thread_fn(void *data)
        return 0;
 }
 
-static int yaffs_bg_start(yaffs_dev_t *dev)
+static int yaffs_bg_start(struct yaffs_dev *dev)
 {
        return 0;
 }
 
-static void yaffs_bg_stop(yaffs_dev_t *dev)
+static void yaffs_bg_stop(struct yaffs_dev *dev)
 {
 }
 #endif
@@ -2491,8 +2491,8 @@ static int yaffs_sync_fs(struct super_block *sb)
 static struct inode *yaffs_iget(struct super_block *sb, unsigned long ino)
 {
        struct inode *inode;
-       yaffs_obj_t *obj;
-       yaffs_dev_t *dev = yaffs_super_to_dev(sb);
+       struct yaffs_obj *obj;
+       struct yaffs_dev *dev = yaffs_super_to_dev(sb);
 
        T(YAFFS_TRACE_OS,
                (TSTR("yaffs_iget for %lu\n"), ino));
@@ -2529,8 +2529,8 @@ static void yaffs_read_inode(struct inode *inode)
         * need to lock again.
         */
 
-       yaffs_obj_t *obj;
-       yaffs_dev_t *dev = yaffs_super_to_dev(inode->i_sb);
+       struct yaffs_obj *obj;
+       struct yaffs_dev *dev = yaffs_super_to_dev(inode->i_sb);
 
        T(YAFFS_TRACE_OS,
                (TSTR("yaffs_read_inode for %d\n"), (int)inode->i_ino));
@@ -2553,7 +2553,7 @@ struct semaphore yaffs_context_lock;
 
 static void yaffs_put_super(struct super_block *sb)
 {
-       yaffs_dev_t *dev = yaffs_super_to_dev(sb);
+       struct yaffs_dev *dev = yaffs_super_to_dev(sb);
 
        T(YAFFS_TRACE_OS, (TSTR("yaffs_put_super\n")));
 
@@ -2599,7 +2599,7 @@ static void yaffs_mtd_put_super(struct super_block *sb)
 }
 
 
-static void yaffs_touch_super(yaffs_dev_t *dev)
+static void yaffs_touch_super(struct yaffs_dev *dev)
 {
        struct super_block *sb = yaffs_dev_to_lc(dev)->super;
 
@@ -2691,13 +2691,13 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version,
        int n_blocks;
        struct inode *inode = NULL;
        struct dentry *root;
-       yaffs_dev_t *dev = 0;
+       struct yaffs_dev *dev = 0;
        char devname_buf[BDEVNAME_SIZE + 1];
        struct mtd_info *mtd;
        int err;
        char *data_str = (char *)data;
        struct yaffs_linux_context *context = NULL;
-       yaffs_param_t *param;
+       struct yaffs_param *param;
 
        int read_only = 0;
 
@@ -2866,7 +2866,7 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version,
 
        /* OK, so if we got here, we have an MTD that's NAND and looks
         * like it has the right capabilities
-        * Set the yaffs_dev_t up for mtd
+        * Set the struct yaffs_dev up for mtd
         */
 
        if (!read_only && !(mtd->flags & MTD_WRITEABLE)){
@@ -2875,7 +2875,7 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version,
                sb->s_flags |= MS_RDONLY;
        }
 
-       dev = kmalloc(sizeof(yaffs_dev_t), GFP_KERNEL);
+       dev = kmalloc(sizeof(struct yaffs_dev), GFP_KERNEL);
        context = kmalloc(sizeof(struct yaffs_linux_context),GFP_KERNEL);
        
        if(!dev || !context ){
@@ -2891,10 +2891,10 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version,
                /* Deep shit could not allocate device structure */
                T(YAFFS_TRACE_ALWAYS,
                  (TSTR("yaffs_read_super: Failed trying to allocate "
-                  "yaffs_dev_t. \n")));
+                  "struct yaffs_dev. \n")));
                return NULL;
        }
-       memset(dev, 0, sizeof(yaffs_dev_t));
+       memset(dev, 0, sizeof(struct yaffs_dev));
        param = &(dev->param);
 
        memset(context,0,sizeof(struct yaffs_linux_context));
@@ -3192,7 +3192,7 @@ static DECLARE_FSTYPE(yaffs2_fs_type, "yaffs2", yaffs2_read_super,
 static struct proc_dir_entry *my_proc_entry;
 static struct proc_dir_entry *debug_proc_entry;
 
-static char *yaffs_dump_dev_part0(char *buf, yaffs_dev_t * dev)
+static char *yaffs_dump_dev_part0(char *buf, struct yaffs_dev * dev)
 {
        buf += sprintf(buf, "start_block.......... %d\n", dev->param.start_block);
        buf += sprintf(buf, "end_block............ %d\n", dev->param.end_block);
@@ -3214,7 +3214,7 @@ static char *yaffs_dump_dev_part0(char *buf, yaffs_dev_t * dev)
 }
 
 
-static char *yaffs_dump_dev_part1(char *buf, yaffs_dev_t * dev)
+static char *yaffs_dump_dev_part1(char *buf, struct yaffs_dev * dev)
 {
        buf += sprintf(buf, "data_bytes_per_chunk. %d\n", dev->data_bytes_per_chunk);
        buf += sprintf(buf, "chunk_grp_bits....... %d\n", dev->chunk_grp_bits);
@@ -3280,7 +3280,7 @@ static int yaffs_proc_read(char *page,
                /* Locate and print the Nth entry.  Order N-squared but N is small. */
                ylist_for_each(item, &yaffs_context_list) {
                        struct yaffs_linux_context *dc = ylist_entry(item, struct yaffs_linux_context, context_list);
-                       yaffs_dev_t *dev = dc->dev;
+                       struct yaffs_dev *dev = dc->dev;
 
                        if (n < (step & ~1)) {
                                n+=2;
@@ -3313,7 +3313,7 @@ static int yaffs_stats_proc_read(char *page,
        /* Locate and print the Nth entry.  Order N-squared but N is small. */
        ylist_for_each(item, &yaffs_context_list) {
                struct yaffs_linux_context *dc = ylist_entry(item, struct yaffs_linux_context, context_list);
-               yaffs_dev_t *dev = dc->dev;
+               struct yaffs_dev *dev = dc->dev;
 
                int erased_chunks;
 
index 9bceaa3..0a7c85c 100644 (file)
  * the VFS.
  *
  * Special notes:
- * >> 2.4: sb->u.generic_sbp points to the yaffs_dev_t associated with
+ * >> 2.4: sb->u.generic_sbp points to the struct yaffs_dev associated with
  *         this superblock
- * >> 2.6: sb->s_fs_info  points to the yaffs_dev_t associated with this
+ * >> 2.6: sb->s_fs_info  points to the struct yaffs_dev associated with this
  *         superblock
- * >> inode->u.generic_ip points to the associated yaffs_obj_t.
+ * >> inode->u.generic_ip points to the associated struct yaffs_obj.
  */
 
 /*
@@ -111,9 +111,9 @@ module_param(yaffs_bg_enable, uint, 0644);
 static struct inode *yaffs_iget(struct super_block *sb, unsigned long ino);
 
 #define yaffs_inode_to_obj_lv(iptr) ((iptr)->i_private)
-#define yaffs_inode_to_obj(iptr) ((yaffs_obj_t *)(yaffs_inode_to_obj_lv(iptr)))
+#define yaffs_inode_to_obj(iptr) ((struct yaffs_obj *)(yaffs_inode_to_obj_lv(iptr)))
 #define yaffs_dentry_to_obj(dptr) yaffs_inode_to_obj((dptr)->d_inode)
-#define yaffs_super_to_dev(sb) ((yaffs_dev_t *)sb->s_fs_info)
+#define yaffs_super_to_dev(sb) ((struct yaffs_dev *)sb->s_fs_info)
 
 
 #define update_dir_time(dir) do {\
@@ -186,7 +186,7 @@ static int yaffs_readlink(struct dentry *dentry, char __user *buffer,
 void yaffs_put_link(struct dentry *dentry, struct nameidata *nd, void *alias);
 static void *yaffs_follow_link(struct dentry *dentry, struct nameidata *nd);
 
-static void yaffs_touch_super(yaffs_dev_t *dev);
+static void yaffs_touch_super(struct yaffs_dev *dev);
 
 static loff_t yaffs_dir_llseek(struct file *file, loff_t offset, int origin);
 
@@ -289,22 +289,22 @@ static  int yaffs_vfs_setsize(struct inode *inode, loff_t newsize)
        return 0;
 }
 
-static unsigned yaffs_gc_control_callback(yaffs_dev_t *dev)
+static unsigned yaffs_gc_control_callback(struct yaffs_dev *dev)
 {
        return yaffs_gc_control;
 }
                                                                                                                        
-static void yaffs_gross_lock(yaffs_dev_t *dev)
+static void yaffs_gross_lock(struct yaffs_dev *dev)
 {
        T(YAFFS_TRACE_LOCK, (TSTR("yaffs locking %p\n"), current));
-       down(&(yaffs_dev_to_lc(dev)->gross_lock));
+       down(&(struct yaffs_devo_lc(dev)->gross_lock));
        T(YAFFS_TRACE_LOCK, (TSTR("yaffs locked %p\n"), current));
 }
 
-static void yaffs_gross_unlock(yaffs_dev_t *dev)
+static void yaffs_gross_unlock(struct yaffs_dev *dev)
 {
        T(YAFFS_TRACE_LOCK, (TSTR("yaffs unlocking %p\n"), current));
-       up(&(yaffs_dev_to_lc(dev)->gross_lock));
+       up(&(struct yaffs_devo_lc(dev)->gross_lock));
 }
 
 
@@ -335,8 +335,8 @@ struct dentry *yaffs2_get_parent(struct dentry *dentry)
        struct dentry *parent = ERR_PTR(-ENOENT);
        struct inode *inode;
        unsigned long parent_ino;
-       yaffs_obj_t *d_obj;
-       yaffs_obj_t *parent_obj;
+       struct yaffs_obj *d_obj;
+       struct yaffs_obj *parent_obj;
 
        d_obj = yaffs_inode_to_obj(dentry->d_inode);
 
@@ -384,7 +384,7 @@ static struct export_operations yaffs_export_ops =
  * next object before the object is deleted.
  *
  * Many readdirs (and thus seach conexts) may be alive simulateously so
- * each yaffs_dev_t has a list of these.
+ * each struct yaffs_dev has a list of these.
  *
  * A seach context lives for the duration of a readdir.
  *
@@ -392,9 +392,9 @@ static struct export_operations yaffs_export_ops =
  */
 
 struct yaffs_search_context {
-       yaffs_dev_t *dev;
-       yaffs_obj_t *dir_obj;
-       yaffs_obj_t *next_return;
+       struct yaffs_dev *dev;
+       struct yaffs_obj *dir_obj;
+       struct yaffs_obj *next_return;
        struct ylist_head others;
 };
 
@@ -404,9 +404,9 @@ struct yaffs_search_context {
  *
  * Called at start of readdir.
  */
-static struct yaffs_search_context * yaffs_new_search(yaffs_obj_t *dir)
+static struct yaffs_search_context * yaffs_new_search(struct yaffs_obj *dir)
 {
-       yaffs_dev_t *dev = dir->my_dev;
+       struct yaffs_dev *dev = dir->my_dev;
        struct yaffs_search_context *sc = YMALLOC(sizeof(struct yaffs_search_context));
        if(sc){
                sc->dir_obj = dir;
@@ -416,9 +416,9 @@ static struct yaffs_search_context * yaffs_new_search(yaffs_obj_t *dir)
                else
                        sc->next_return = ylist_entry(
                                 dir->variant.dir_variant.children.next,
-                               yaffs_obj_t,siblings);
+                               struct yaffs_obj,siblings);
                YINIT_LIST_HEAD(&sc->others);
-               ylist_add(&sc->others,&(yaffs_dev_to_lc(dev)->search_contexts));
+               ylist_add(&sc->others,&(struct yaffs_devo_lc(dev)->search_contexts));
        }
        return sc;
 }
@@ -453,7 +453,7 @@ static void yaffs_search_advance(struct yaffs_search_context *sc)
                 if( next == &sc->dir_obj->variant.dir_variant.children)
                         sc->next_return = NULL; /* end of list */
                 else
-                        sc->next_return = ylist_entry(next,yaffs_obj_t,siblings);
+                        sc->next_return = ylist_entry(next,struct yaffs_obj,siblings);
         }
 }
 
@@ -462,12 +462,12 @@ static void yaffs_search_advance(struct yaffs_search_context *sc)
  * We check open search contexts and advance any which are currently
  * on the object being iterated.
  */
-static void yaffs_remove_obj_callback(yaffs_obj_t *obj)
+static void yaffs_remove_obj_callback(struct yaffs_obj *obj)
 {
 
         struct ylist_head *i;
         struct yaffs_search_context *sc;
-        struct ylist_head *search_contexts = &(yaffs_dev_to_lc(obj->my_dev)->search_contexts);
+        struct ylist_head *search_contexts = &(struct yaffs_devo_lc(obj->my_dev)->search_contexts);
 
 
         /* Iterate through the directory search contexts.
@@ -493,7 +493,7 @@ static int yaffs_readlink(struct dentry *dentry, char __user *buffer,
        unsigned char *alias;
        int ret;
 
-       yaffs_dev_t *dev = yaffs_dentry_to_obj(dentry)->my_dev;
+       struct yaffs_dev *dev = yaffs_dentry_to_obj(dentry)->my_dev;
 
        yaffs_gross_lock(dev);
 
@@ -513,7 +513,7 @@ static void *yaffs_follow_link(struct dentry *dentry, struct nameidata *nd)
 {
        unsigned char *alias;
        void *ret;
-       yaffs_dev_t *dev = yaffs_dentry_to_obj(dentry)->my_dev;
+       struct yaffs_dev *dev = yaffs_dentry_to_obj(dentry)->my_dev;
 
        yaffs_gross_lock(dev);
 
@@ -536,7 +536,7 @@ void yaffs_put_link(struct dentry *dentry, struct nameidata *nd, void *alias) {
 }
 
 struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev,
-                               yaffs_obj_t *obj);
+                               struct yaffs_obj *obj);
 
 /*
  * Lookup is used to find objects in the fs
@@ -545,12 +545,12 @@ struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev,
 static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry,
                                struct nameidata *n)
 {
-       yaffs_obj_t *obj;
+       struct yaffs_obj *obj;
        struct inode *inode = NULL;     /* NCB 2.5/2.6 needs NULL here */
 
-       yaffs_dev_t *dev = yaffs_inode_to_obj(dir)->my_dev;
+       struct yaffs_dev *dev = yaffs_inode_to_obj(dir)->my_dev;
 
-       if(current != yaffs_dev_to_lc(dev)->readdir_process)
+       if(current != struct yaffs_devo_lc(dev)->readdir_process)
                yaffs_gross_lock(dev);
 
        T(YAFFS_TRACE_OS,
@@ -563,7 +563,7 @@ static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry,
        obj = yaffs_get_equivalent_obj(obj);    /* in case it was a hardlink */
 
        /* Can't hold gross lock when calling yaffs_get_inode() */
-       if(current != yaffs_dev_to_lc(dev)->readdir_process)
+       if(current != struct yaffs_devo_lc(dev)->readdir_process)
                yaffs_gross_unlock(dev);
 
        if (obj) {
@@ -606,10 +606,10 @@ static void yaffs_put_inode(struct inode *inode)
 #endif
 
 
-static void yaffs_unstitch_obj(struct inode *inode, yaffs_obj_t *obj)
+static void yaffs_unstitch_obj(struct inode *inode, struct yaffs_obj *obj)
 {
        /* Clear the association between the inode and
-        * the yaffs_obj_t.
+        * the struct yaffs_obj.
         */
        obj->my_inode = NULL;
        yaffs_inode_to_obj_lv(inode) = NULL;
@@ -627,8 +627,8 @@ static void yaffs_unstitch_obj(struct inode *inode, yaffs_obj_t *obj)
  */
 static void yaffs_evict_inode( struct inode *inode)
 {
-       yaffs_obj_t *obj;
-       yaffs_dev_t *dev;
+       struct yaffs_obj *obj;
+       struct yaffs_dev *dev;
        int deleteme = 0;
 
        obj = yaffs_inode_to_obj(inode);
@@ -662,9 +662,9 @@ static void yaffs_evict_inode( struct inode *inode)
 
 static int yaffs_file_flush(struct file *file, fl_owner_t id)
 {
-       yaffs_obj_t *obj = yaffs_dentry_to_obj(file->f_dentry);
+       struct yaffs_obj *obj = yaffs_dentry_to_obj(file->f_dentry);
 
-       yaffs_dev_t *dev = obj->my_dev;
+       struct yaffs_dev *dev = obj->my_dev;
 
        T(YAFFS_TRACE_OS,
                (TSTR("yaffs_file_flush object %d (%s)\n"), obj->obj_id,
@@ -683,11 +683,11 @@ static int yaffs_readpage_nolock(struct file *f, struct page *pg)
 {
        /* Lifted from jffs2 */
 
-       yaffs_obj_t *obj;
+       struct yaffs_obj *obj;
        unsigned char *pg_buf;
        int ret;
 
-       yaffs_dev_t *dev;
+       struct yaffs_dev *dev;
 
        T(YAFFS_TRACE_OS,
                (TSTR("yaffs_readpage_nolock at %08x, size %08x\n"),
@@ -750,12 +750,12 @@ static int yaffs_readpage(struct file *f, struct page *pg)
 
 static int yaffs_writepage(struct page *page, struct writeback_control *wbc)
 {
-       yaffs_dev_t *dev;
+       struct yaffs_dev *dev;
        struct address_space *mapping = page->mapping;
        struct inode *inode;
        unsigned long end_index;
        char *buffer;
-       yaffs_obj_t *obj;
+       struct yaffs_obj *obj;
        int n_written = 0;
        unsigned n_bytes;
        loff_t i_size;
@@ -920,7 +920,7 @@ static int yaffs_write_end(struct file *filp, struct address_space *mapping,
 }
 
 
-static void yaffs_fill_inode_from_obj(struct inode *inode, yaffs_obj_t *obj)
+static void yaffs_fill_inode_from_obj(struct inode *inode, struct yaffs_obj *obj)
 {
        if (inode && obj) {
 
@@ -1014,7 +1014,7 @@ static void yaffs_fill_inode_from_obj(struct inode *inode, yaffs_obj_t *obj)
 }
 
 struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev,
-                               yaffs_obj_t *obj)
+                               struct yaffs_obj *obj)
 {
        struct inode *inode;
 
@@ -1049,10 +1049,10 @@ struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev,
 static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n,
                                loff_t *pos)
 {
-       yaffs_obj_t *obj;
+       struct yaffs_obj *obj;
        int n_written, ipos;
        struct inode *inode;
-       yaffs_dev_t *dev;
+       struct yaffs_dev *dev;
 
        obj = yaffs_dentry_to_obj(f->f_dentry);
 
@@ -1108,8 +1108,8 @@ static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n,
 
 static ssize_t yaffs_hold_space(struct file *f)
 {
-       yaffs_obj_t *obj;
-       yaffs_dev_t *dev;
+       struct yaffs_obj *obj;
+       struct yaffs_dev *dev;
 
        int n_free_chunks;
 
@@ -1129,8 +1129,8 @@ static ssize_t yaffs_hold_space(struct file *f)
 
 static void yaffs_release_space(struct file *f)
 {
-       yaffs_obj_t *obj;
-       yaffs_dev_t *dev;
+       struct yaffs_obj *obj;
+       struct yaffs_dev *dev;
 
 
        obj = yaffs_dentry_to_obj(f->f_dentry);
@@ -1172,12 +1172,12 @@ static loff_t yaffs_dir_llseek(struct file *file, loff_t offset, int origin)
 
 static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir)
 {
-       yaffs_obj_t *obj;
-       yaffs_dev_t *dev;
+       struct yaffs_obj *obj;
+       struct yaffs_dev *dev;
         struct yaffs_search_context *sc;
        struct inode *inode = f->f_dentry->d_inode;
        unsigned long offset, curoffs;
-       yaffs_obj_t *l;
+       struct yaffs_obj *l;
         int ret_val = 0;
 
        char name[YAFFS_MAX_NAME_LENGTH + 1];
@@ -1187,7 +1187,7 @@ static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir)
 
        yaffs_gross_lock(dev);
 
-       yaffs_dev_to_lc(dev)->readdir_process = current;
+       struct yaffs_devo_lc(dev)->readdir_process = current;
 
        offset = f->f_pos;
 
@@ -1272,7 +1272,7 @@ static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir)
 
 out:
        yaffs_search_end(sc);
-       yaffs_dev_to_lc(dev)->readdir_process = NULL;
+       struct yaffs_devo_lc(dev)->readdir_process = NULL;
        yaffs_gross_unlock(dev);
 
        return ret_val;
@@ -1291,10 +1291,10 @@ static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode,
 {
        struct inode *inode;
 
-       yaffs_obj_t *obj = NULL;
-       yaffs_dev_t *dev;
+       struct yaffs_obj *obj = NULL;
+       struct yaffs_dev *dev;
 
-       yaffs_obj_t *parent = yaffs_inode_to_obj(dir);
+       struct yaffs_obj *parent = yaffs_inode_to_obj(dir);
 
        int error = -ENOSPC;
        uid_t uid = YCRED(current)->fsuid;
@@ -1385,8 +1385,8 @@ static int yaffs_unlink(struct inode *dir, struct dentry *dentry)
 {
        int ret_val;
 
-       yaffs_dev_t *dev;
-       yaffs_obj_t *obj;
+       struct yaffs_dev *dev;
+       struct yaffs_obj *obj;
 
        T(YAFFS_TRACE_OS,
                (TSTR("yaffs_unlink %d:%s\n"),
@@ -1418,9 +1418,9 @@ static int yaffs_link(struct dentry *old_dentry, struct inode *dir,
                        struct dentry *dentry)
 {
        struct inode *inode = old_dentry->d_inode;
-       yaffs_obj_t *obj = NULL;
-       yaffs_obj_t *link = NULL;
-       yaffs_dev_t *dev;
+       struct yaffs_obj *obj = NULL;
+       struct yaffs_obj *link = NULL;
+       struct yaffs_dev *dev;
 
        T(YAFFS_TRACE_OS, (TSTR("yaffs_link\n")));
 
@@ -1456,8 +1456,8 @@ static int yaffs_link(struct dentry *old_dentry, struct inode *dir,
 static int yaffs_symlink(struct inode *dir, struct dentry *dentry,
                                const char *symname)
 {
-       yaffs_obj_t *obj;
-       yaffs_dev_t *dev;
+       struct yaffs_obj *obj;
+       struct yaffs_dev *dev;
        uid_t uid = YCRED(current)->fsuid;
        gid_t gid = (dir->i_mode & S_ISGID) ? dir->i_gid : YCRED(current)->fsgid;
 
@@ -1487,8 +1487,8 @@ static int yaffs_symlink(struct inode *dir, struct dentry *dentry,
 static int yaffs_sync_object(struct file *file, int datasync)
 {
 
-       yaffs_obj_t *obj;
-       yaffs_dev_t *dev;
+       struct yaffs_obj *obj;
+       struct yaffs_dev *dev;
        struct dentry *dentry = file->f_path.dentry;
 
        obj = yaffs_dentry_to_obj(dentry);
@@ -1511,9 +1511,9 @@ static int yaffs_sync_object(struct file *file, int datasync)
 static int yaffs_rename(struct inode *old_dir, struct dentry *old_dentry,
                        struct inode *new_dir, struct dentry *new_dentry)
 {
-       yaffs_dev_t *dev;
+       struct yaffs_dev *dev;
        int ret_val = YAFFS_FAIL;
-       yaffs_obj_t *target;
+       struct yaffs_obj *target;
 
        T(YAFFS_TRACE_OS, (TSTR("yaffs_rename\n")));
        dev = yaffs_inode_to_obj(old_dir)->my_dev;
@@ -1562,7 +1562,7 @@ static int yaffs_setattr(struct dentry *dentry, struct iattr *attr)
 {
        struct inode *inode = dentry->d_inode;
        int error = 0;
-       yaffs_dev_t *dev;
+       struct yaffs_dev *dev;
 
        T(YAFFS_TRACE_OS,
                (TSTR("yaffs_setattr of object %d\n"),
@@ -1613,8 +1613,8 @@ int yaffs_setxattr(struct dentry *dentry, const char *name,
 {
        struct inode *inode = dentry->d_inode;
        int error = 0;
-       yaffs_dev_t *dev;
-       yaffs_obj_t *obj = yaffs_inode_to_obj(inode);
+       struct yaffs_dev *dev;
+       struct yaffs_obj *obj = yaffs_inode_to_obj(inode);
 
        T(YAFFS_TRACE_OS,
                (TSTR("yaffs_setxattr of object %d\n"),
@@ -1645,8 +1645,8 @@ ssize_t yaffs_getxattr(struct dentry *dentry, const char *name, void *buff,
 {
        struct inode *inode = dentry->d_inode;
        int error = 0;
-       yaffs_dev_t *dev;
-       yaffs_obj_t *obj = yaffs_inode_to_obj(inode);
+       struct yaffs_dev *dev;
+       struct yaffs_obj *obj = yaffs_inode_to_obj(inode);
 
        T(YAFFS_TRACE_OS,
                (TSTR("yaffs_getxattr \"%s\" from object %d\n"),
@@ -1669,8 +1669,8 @@ int yaffs_removexattr(struct dentry *dentry, const char *name)
 {
        struct inode *inode = dentry->d_inode;
        int error = 0;
-       yaffs_dev_t *dev;
-       yaffs_obj_t *obj = yaffs_inode_to_obj(inode);
+       struct yaffs_dev *dev;
+       struct yaffs_obj *obj = yaffs_inode_to_obj(inode);
 
        T(YAFFS_TRACE_OS,
                (TSTR("yaffs_removexattr of object %d\n"),
@@ -1699,8 +1699,8 @@ ssize_t yaffs_listxattr(struct dentry *dentry, char *buff, size_t size)
 {
        struct inode *inode = dentry->d_inode;
        int error = 0;
-       yaffs_dev_t *dev;
-       yaffs_obj_t *obj = yaffs_inode_to_obj(inode);
+       struct yaffs_dev *dev;
+       struct yaffs_obj *obj = yaffs_inode_to_obj(inode);
 
        T(YAFFS_TRACE_OS,
                (TSTR("yaffs_listxattr of object %d\n"),
@@ -1725,7 +1725,7 @@ ssize_t yaffs_listxattr(struct dentry *dentry, char *buff, size_t size)
 
 static int yaffs_statfs(struct dentry *dentry, struct kstatfs *buf)
 {
-       yaffs_dev_t *dev = yaffs_dentry_to_obj(dentry)->my_dev;
+       struct yaffs_dev *dev = yaffs_dentry_to_obj(dentry)->my_dev;
        struct super_block *sb = dentry->d_sb;
 
        T(YAFFS_TRACE_OS, (TSTR("yaffs_statfs\n")));
@@ -1788,7 +1788,7 @@ static int yaffs_statfs(struct dentry *dentry, struct kstatfs *buf)
 static void yaffs_flush_inodes(struct super_block *sb)
 {
        struct inode *iptr;
-       yaffs_obj_t *obj;
+       struct yaffs_obj *obj;
        
        list_for_each_entry(iptr,&sb->s_inodes, i_sb_list){
                obj = yaffs_inode_to_obj(iptr);
@@ -1803,7 +1803,7 @@ static void yaffs_flush_inodes(struct super_block *sb)
 
 static void yaffs_flush_super(struct super_block *sb, int do_checkpoint)
 {
-       yaffs_dev_t *dev = yaffs_super_to_dev(sb);      
+       struct yaffs_dev *dev = yaffs_super_to_dev(sb); 
        if(!dev)
                return;
        
@@ -1815,10 +1815,10 @@ static void yaffs_flush_super(struct super_block *sb, int do_checkpoint)
 }
 
 
-static unsigned yaffs_bg_gc_urgency(yaffs_dev_t *dev)
+static unsigned yaffs_bg_gc_urgency(struct yaffs_dev *dev)
 {
        unsigned erased_chunks = dev->n_erased_blocks * dev->param.chunks_per_block;
-       struct yaffs_linux_context *context = yaffs_dev_to_lc(dev);
+       struct yaffs_linux_context *context = struct yaffs_devo_lc(dev);
        unsigned scattered = 0; /* Free chunks not in an erased block */
 
        if(erased_chunks < dev->n_free_chunks)
@@ -1840,7 +1840,7 @@ static int yaffs_do_sync_fs(struct super_block *sb,
                                int request_checkpoint)
 {
 
-       yaffs_dev_t *dev = yaffs_super_to_dev(sb);
+       struct yaffs_dev *dev = yaffs_super_to_dev(sb);
        unsigned int oneshot_checkpoint = (yaffs_auto_checkpoint & 4);
        unsigned gc_urgent = yaffs_bg_gc_urgency(dev);
        int do_checkpoint;
@@ -1888,8 +1888,8 @@ void yaffs_background_waker(unsigned long data)
 
 static int yaffs_bg_thread_fn(void *data)
 {
-       yaffs_dev_t *dev = (yaffs_dev_t *)data;
-       struct yaffs_linux_context *context = yaffs_dev_to_lc(dev);
+       struct yaffs_dev *dev = (struct yaffs_dev *)data;
+       struct yaffs_linux_context *context = struct yaffs_devo_lc(dev);
        unsigned long now = jiffies;
        unsigned long next_dir_update = now;
        unsigned long next_gc = now;
@@ -1960,10 +1960,10 @@ static int yaffs_bg_thread_fn(void *data)
        return 0;
 }
 
-static int yaffs_bg_start(yaffs_dev_t *dev)
+static int yaffs_bg_start(struct yaffs_dev *dev)
 {
        int retval = 0;
-       struct yaffs_linux_context *context = yaffs_dev_to_lc(dev);
+       struct yaffs_linux_context *context = struct yaffs_devo_lc(dev);
 
        if(dev->read_only)
                return -1;
@@ -1981,9 +1981,9 @@ static int yaffs_bg_start(yaffs_dev_t *dev)
  &nb