}
-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 "
char name0[100];
char name1[100];
int i;
- yaffs_dev_t *dev;
+ struct yaffs_dev *dev;
yaffs_trace_mask = 0;
static yflash_Device filedisk;
-static int CheckInit(yaffs_dev_t *dev)
+static int CheckInit(struct yaffs_dev *dev)
{
static int initialised = 0;
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;
}
-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;
}
-int yflash_EraseBlockInNAND(yaffs_dev_t *dev, int blockNumber)
+int yflash_EraseBlockInNAND(struct yaffs_dev *dev, int blockNumber)
{
int i;
}
-int yflash_InitialiseNAND(yaffs_dev_t *dev)
+int yflash_InitialiseNAND(struct yaffs_dev *dev)
{
return YAFFS_OK;
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;
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
{
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
{
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;
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);
}
}
-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;
}
-int yflash2_EraseBlockInNAND(yaffs_dev_t *dev, int blockNumber)
+int yflash2_EraseBlockInNAND(struct yaffs_dev *dev, int blockNumber)
{
int i;
}
-int yflash2_InitialiseNAND(yaffs_dev_t *dev)
+int yflash2_InitialiseNAND(struct yaffs_dev *dev)
{
CheckInit();
-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;
#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;
return (u32 *) addr;
}
-u32 *Block2FormatAddr(yaffs_dev_t *dev,int blockNumber)
+u32 *Block2FormatAddr(struct yaffs_dev *dev,int blockNumber)
{
u32 addr;
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;
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;
}
}
-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);
}
-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);
}
-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);
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;
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;
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)
}
-int ynorif1_InitialiseNAND(yaffs_dev_t *dev)
+int ynorif1_InitialiseNAND(struct yaffs_dev *dev)
{
int i;
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();
#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
static yramdisk_device ramdisk;
-static int CheckInit(yaffs_dev_t *dev)
+static int CheckInit(struct yaffs_dev *dev)
{
static int initialised = 0;
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;
}
-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;
}
-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;
}
-int yramdisk_erase(yaffs_dev_t *dev, int blockNumber)
+int yramdisk_erase(struct yaffs_dev *dev, int blockNumber)
{
CheckInit(dev);
}
-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.
#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
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;
}
-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;
}
-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;
}
-int nandemul2k_EraseBlockInNAND(yaffs_dev_t *dev, int blockNumber)
+int nandemul2k_EraseBlockInNAND(struct yaffs_dev *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;
}
-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;
// /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[] = {
#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)
{
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);
-static int yramsim_initialise(yaffs_dev_t *dev)
+static int yramsim_initialise(struct yaffs_dev *dev)
{
SimData *sim = DevToSim(dev);
Block **blockList = sim->blockList;
}
-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)
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)
{
}
-static int yramsim_erase(yaffs_dev_t *dev,unsigned blockId)
+static int yramsim_erase(struct yaffs_dev *dev,unsigned blockId)
{
SimData *sim = DevToSim(dev);
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;
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;
}
-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)
{
#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);
static yflash_Device ramdisk;
-static int CheckInit(yaffs_dev_t *dev)
+static int CheckInit(struct yaffs_dev *dev)
{
static int initialised = 0;
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;
}
-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;
}
-int yflash_CheckChunkErased(yaffs_dev_t *dev,int nand_chunk)
+int yflash_CheckChunkErased(struct yaffs_dev *dev,int nand_chunk)
{
int blk;
int pg;
}
-int yflash_EraseBlockInNAND(yaffs_dev_t *dev, int blockNumber)
+int yflash_EraseBlockInNAND(struct yaffs_dev *dev, int blockNumber)
{
CheckInit(dev);
}
-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;
}
#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
#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
#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);
* 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;
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;
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);
}
-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;
}
-int ynandif_InitialiseNAND(yaffs_dev_t *dev)
+int ynandif_InitialiseNAND(struct yaffs_dev *dev)
{
ynandif_Geometry *geometry = (ynandif_Geometry *)(dev->driver_context);
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);
}
-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;
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
typedef struct yaffsfs_DeviceConfigurationStruct {
const YCHAR *prefix;
- struct yaffs_dev_s *dev;
+ struct yaffs_dev *dev;
} yaffsfs_DeviceConfiguration;
#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;
typedef struct {
int count; /* Number of handles accessing this inode */
- yaffs_obj_t *iObj;
+ struct yaffs_obj *iObj;
} yaffsfs_Inode;
typedef struct{
return NULL;
}
-yaffs_obj_t *yaffsfs_GetHandleObject(int handle)
+struct yaffs_obj *yaffsfs_GetHandleObject(int handle)
{
yaffsfs_Inode *in = yaffsfs_GetInodePointer(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;
* 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;
}
-static int yaffsfs_CountHandles(yaffs_obj_t *obj)
+static int yaffsfs_CountHandles(struct yaffs_obj *obj)
{
int i = yaffsfs_FindInodeIdForObject(obj);
static void yaffsfs_ReleaseInode(yaffsfs_Inode *in)
{
- yaffs_obj_t *obj;
+ struct yaffs_obj *obj;
obj = in->iObj;
* 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;
* 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;
}
#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;
}
#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){
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)
*
* 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;
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);
/*
* 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);
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;
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;
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;
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();
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();
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;
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;
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;
* 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)
}
-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;
static int yaffsfs_DoStatOrLStat(const YCHAR *path, struct yaffs_stat *buf,int doLStat)
{
- yaffs_obj_t *obj;
+ struct yaffs_obj *obj;
int retVal = -1;
int yaffs_fstat(int fd, struct yaffs_stat *buf)
{
- yaffs_obj_t *obj;
+ struct yaffs_obj *obj;
int retVal = -1;
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;
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;
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;
int yaffs_fgetxattr(int fd, const char *name, void *data, int size)
{
- yaffs_obj_t *obj;
+ struct yaffs_obj *obj;
int retVal = -1;
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;
int yaffs_flistxattr(int fd, char *data, int size)
{
- yaffs_obj_t *obj;
+ struct yaffs_obj *obj;
int retVal = -1;
static int yaffs_do_removexattr(const YCHAR *path, const char *name, int follow)
{
- yaffs_obj_t *obj;
+ struct yaffs_obj *obj;
int retVal = -1;
int yaffs_fremovexattr(int fd, const char *name)
{
- yaffs_obj_t *obj;
+ struct yaffs_obj *obj;
int retVal = -1;
#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;
const unsigned *watime,
const unsigned *wmtime)
{
- yaffs_obj_t *obj;
+ struct yaffs_obj *obj;
int result;
int retVal = -1;
#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;
int yaffs_access(const YCHAR *path, int amode)
{
- yaffs_obj_t *obj;
+ struct yaffs_obj *obj;
int retval = 0;
int yaffs_chmod(const YCHAR *path, mode_t mode)
{
- yaffs_obj_t *obj;
+ struct yaffs_obj *obj;
int retVal = -1;
int yaffs_fchmod(int fd, mode_t mode)
{
- yaffs_obj_t *obj;
+ struct yaffs_obj *obj;
int retVal = -1;
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;
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;
{
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));
int yaffs_sync(const YCHAR *path)
{
int retVal=-1;
- yaffs_dev_t *dev=NULL;
+ struct yaffs_dev *dev=NULL;
YCHAR *dummy;
yaffsfs_Lock();
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();
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();
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();
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();
int yaffs_inodecount(const YCHAR *path)
{
loff_t retVal= -1;
- yaffs_dev_t *dev=NULL;
+ struct yaffs_dev *dev=NULL;
YCHAR *dummy;
yaffsfs_Lock();
}
-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;
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);
}
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;
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! */
}
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;
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();
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 */
int yaffs_readlink(const YCHAR *path, YCHAR *buf, int bufsiz)
{
- yaffs_obj_t *obj = NULL;
+ struct yaffs_obj *obj = NULL;
int retVal;
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;
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;
*/
int yaffs_n_handles(const YCHAR *path)
{
- yaffs_obj_t *obj;
+ struct yaffs_obj *obj;
obj = yaffsfs_FindObject(NULL,path,0,1);
#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"
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);
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;
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")));
allocator->object_cache =
kmem_cache_create(allocator->object_name,
- sizeof(yaffs_obj_t),
+ sizeof(struct yaffs_obj),
0, 0,
fake_ctor_list[mount_id]);
}
-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){
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){
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);
#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 */
}
-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;
}
-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;
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;
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;
}
-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);
*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,
* 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.
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];
(((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.
#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));
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;
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;
* 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;
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;
(((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
#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);
#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;
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;
};
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;
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;
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;
}
-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;
}
/* 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;
-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;
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;
}
-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){
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) {
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) {
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--;
}
}
-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;
}
}
-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);
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;
#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
* 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,
(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) {
}
}
-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);
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);
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);
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;
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;
#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
#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;
}
-static int yaffs_checkpt_erase(yaffs_dev_t *dev)
+static int yaffs_checkpt_erase(struct yaffs_dev *dev)
{
int i;
}
-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;
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));
}
-int yaffs2_checkpt_open(yaffs_dev_t *dev, int writing)
+int yaffs2_checkpt_open(struct yaffs_dev *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);
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);
}
-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;
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;
return i;
}
-int yaffs_checkpt_close(yaffs_dev_t *dev)
+int yaffs_checkpt_close(struct yaffs_dev *dev)
{
if (dev->checkpt_open_write) {
return 0;
}
-int yaffs2_checkpt_invalidate_stream(yaffs_dev_t *dev)
+int yaffs2_checkpt_invalidate_stream(struct yaffs_dev *dev)
{
/* Erase the checkpoint data */
#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
#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,
/* 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;
* 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;
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;
}
-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;
/*
* 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;
* 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;
}
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);
}
-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;
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;
* 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);
"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__);
*
*/
-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;
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;
}
}
-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;
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));
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];
*/
-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){
}
/* 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;
}
-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;
}
}
-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;
*/
/* 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)
{
* 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)
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;
}
-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;
* 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) {
}
-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) {
* 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;
}
-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;
/* 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;
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... */
}
-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)) {
}
/* 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));
}
-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;
}
}
-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;
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);
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;
}
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 */
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)
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);
* 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))
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)
{
}
/* 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);
}
-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 */
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)
/*------------------------- 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;
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);
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);
}
}
-static int yaffs_find_alloc_block(yaffs_dev_t *dev)
+static int yaffs_find_alloc_block(struct yaffs_dev *dev)
{
int i;
* 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;
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;
return -1;
}
-static int yaffs_get_erased_chunks(yaffs_dev_t *dev)
+static int yaffs_get_erased_chunks(struct yaffs_dev *dev)
{
int n;
* yaffs_skip_rest_of_block() skips over the rest of the allocation block
* if we don't want to write to it.
*/
-void yaffs_skip_rest_of_block(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);
}
-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;
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);
* 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;
* 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)
{
* 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;
* 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;
/*------------------------- 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 &&
/*-------------------- 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 */
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) {
}
-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.
*/
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) {
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);
}
-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)
}
-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)
{
*/
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);
/* 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"));
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;
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);
* 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;
}
-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;
*
*/
-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;
* 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;
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;
}
/* 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++) {
}
/* 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)
{
* 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);
/* 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. */
* 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)
{
int n_done = 0;
yaffs_cache_t *cache;
- yaffs_dev_t *dev;
+ struct yaffs_dev *dev;
dev = in->my_dev;
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)
{
u32 n_bytes_read;
u32 chunk_start;
- yaffs_dev_t *dev;
+ struct yaffs_dev *dev;
dev = in->my_dev;
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);
/* ---------------------- 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;
}
-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);
}
-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);
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);
-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) {
}
-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. */
* 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;
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);
}
}
-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))
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);
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
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) {
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;
* - 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;
}
-static int yaffs_unlink_obj(yaffs_obj_t *obj)
+static int yaffs_unlink_obj(struct yaffs_obj *obj)
{
if (obj && obj->unlink_allowed)
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);
/*----------------------- 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
}
-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.
}
-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;
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);
}
}
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);
}
}
* 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;
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)){
/*
* 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;
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);
}
-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;
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
* 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
#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;
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));
}
}
-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;
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,
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;
struct ylist_head *i;
YCHAR buffer[YAFFS_MAX_NAME_LENGTH + 1];
- yaffs_obj_t *l;
+ struct yaffs_obj *l;
if (!name)
return NULL;
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();
* 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 */
* 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){
}
}
-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){
}
-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
}
-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));
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);
}
-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);
}
}
-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;
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);
}
}
-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)
#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;
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;
#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;
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;
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;
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 */
}
-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 */
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;
}
-void yaffs_deinitialise(yaffs_dev_t *dev)
+void yaffs_deinitialise(struct yaffs_dev *dev)
{
if (dev->is_mounted) {
int i;
}
}
-int yaffs_count_free_chunks(yaffs_dev_t *dev)
+int yaffs_count_free_chunks(struct yaffs_dev *dev)
{
int n_free=0;
int b;
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 */
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;
}
/* 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;
*/
#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;
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 */
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 {
/* -------------------------- 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;
/* is_shrink applies to object headers written when we shrink the file (ie resize) */
u32 is_shrink;
-} yaffs_obj_header;
+};
/*--------------------------- Tnode -------------------------- */
} yaffs_symlink_t;
typedef struct {
- struct yaffs_obj_s *equiv_obj;
+ struct yaffs_obj *equiv_obj;
u32 equiv_id;
} yaffs_hard_link_s;
-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.*/
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 */
/* 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? */
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
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;
u8 rename_allowed:1;
u8 unlink_allowed:1;
u8 serial;
-
int n_data_chunks;
u32 size_or_equiv_obj;
} yaffs_checkpt_obj_t;
/*----------------- Device ---------------------------------*/
-struct yaffs_param_s {
+struct yaffs_param {
const YCHAR *name;
/*
/* 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
* 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 */
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 */
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;
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];
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. */
};
-typedef struct yaffs_dev_s yaffs_dev_t;
/* The static layout of block usage etc is stored in the super block header */
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
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;
* 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
/* 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));
*
* 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;
/* 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 */
*
* 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;
*
* 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;
* 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;
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;
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);
}
}
} 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);
}
}
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));
}
-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,
*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);
#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 =
return YAFFS_FAIL;
}
-int nandmtd_initialise(yaffs_dev_t *dev)
+int nandmtd_initialise(struct yaffs_dev *dev)
{
return YAFFS_OK;
}
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
#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
#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
#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;
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++;
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;
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)
}
-int yaffs_erase_block(struct yaffs_dev_s *dev,
+int yaffs_erase_block(struct yaffs_dev *dev,
int flash_block)
{
int result;
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);
-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
#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;
}
-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,
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));
}
}
} 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
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
}
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;
}
-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);
}
-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);
}
-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;
} 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
#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] = {
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 */
}
-int yaffs_check_tags_ecc(yaffs_tags_t *tags)
+int yaffs_check_tags_ecc(struct yaffs_tags *tags)
{
unsigned ecc = tags->ecc;
/********** 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;
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;
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)
{
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,
* 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;
}
-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);
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;
}
}
-int yaffs_tags_compat_mark_bad(struct yaffs_dev_s *dev,
+int yaffs_tags_compat_mark_bad(struct yaffs_dev *dev,
int flash_block)
{
}
-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)
#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
#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);
#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
#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));
};
-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;
-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);
}
}
-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];
* 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;
-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;
}
-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;
/* 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;
/* 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;
}
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);
}
}
-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;
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);
}
}
}
-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;
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++;
}
}
-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();
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),
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;
}
}
-int yaffs_verify_file_sane(yaffs_obj_t *in)
+int yaffs_verify_file_sane(struct yaffs_obj *in)
{
in=in;
return YAFFS_OK;
#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
* 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.
*/
/*
#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
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);
}
-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));
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);
* 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.
*
*/
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;
};
*
* 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;
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));
}
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);
}
}
* 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;
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);
#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);
#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
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);
#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;
*/
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);
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);
*/
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,
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,
{
/* 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"),
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;
#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) {
}
struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev,
- yaffs_obj_t *obj)
+ struct yaffs_obj *obj)
{
struct inode *inode;
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);
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;
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);
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];
{
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;
{
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"),
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")));
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;
#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
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;
{
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"),
{
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"),
{
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"),
{
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"),
{
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"),
#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")));
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);
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;
}
-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);
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;
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;
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);
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);
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
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));
* 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));
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")));
}
-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;
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;
/* 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)){
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 ){
/* 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));
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);
}
-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);
/* 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;
/* 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;
* 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.
*/
/*
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 {\
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);
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));
}
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);
* 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.
*
*/
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;
};
*
* 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;
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;
}
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);
}
}
* 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.
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);
{
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);
}
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
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,
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) {
#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;
*/
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);
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,
{
/* 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"),
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;
}
-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) {
}
struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev,
- yaffs_obj_t *obj)
+ struct yaffs_obj *obj)
{
struct inode *inode;
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);
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;
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);
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];
yaffs_gross_lock(dev);
- yaffs_dev_to_lc(dev)->readdir_process = current;
+ struct yaffs_devo_lc(dev)->readdir_process = current;
offset = f->f_pos;
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;
{
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;
{
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"),
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")));
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;
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);
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;
{
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"),
{
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"),
{
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"),
{
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"),
{
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"),
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")));
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);
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;
}
-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)
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;
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;
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;
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);
+ struct yaffs_linux_context *ctxt = struct yaffs_devo_lc(dev);
ctxt->bg_running = 0;
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));
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")));
yaffs_flush_super(sb,1);
- if (yaffs_dev_to_lc(dev)->put_super_fn)
- yaffs_dev_to_lc(dev)->put_super_fn(sb);
+ if (struct yaffs_devo_lc(dev)->put_super_fn)
+ struct yaffs_devo_lc(dev)->put_super_fn(sb);
yaffs_deinitialise(dev);
yaffs_gross_unlock(dev);
down(&yaffs_context_lock);
- ylist_del_init(&(yaffs_dev_to_lc(dev)->context_list));
+ ylist_del_init(&(struct yaffs_devo_lc(dev)->context_list));
up(&yaffs_context_lock);
- if (yaffs_dev_to_lc(dev)->spare_buffer) {
- YFREE(yaffs_dev_to_lc(dev)->spare_buffer);
- yaffs_dev_to_lc(dev)->spare_buffer = NULL;
+ if (struct yaffs_devo_lc(dev)->spare_buffer) {
+ YFREE(struct yaffs_devo_lc(dev)->spare_buffer);
+ struct yaffs_devo_lc(dev)->spare_buffer = NULL;
}
kfree(dev);
static void yaffs_mtd_put_super(struct super_block *sb)
{
- struct mtd_info *mtd = yaffs_dev_to_mtd(yaffs_super_to_dev(sb));
+ struct mtd_info *mtd = struct yaffs_devo_mtd(yaffs_super_to_dev(sb));
if (mtd->sync)
mtd->sync(mtd);
}
-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;
+ struct super_block *sb = struct yaffs_devo_lc(dev)->super;
T(YAFFS_TRACE_OS, (TSTR("yaffs_touch_super() sb = %p\n"), sb));
if (sb)
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;
/* 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)){
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 ){
/* 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));
nandmtd2_read_chunk_tags;
param->bad_block_fn = nandmtd2_mark_block_bad;
param->query_block_fn = nandmtd2_query_block;
- yaffs_dev_to_lc(dev)->spare_buffer = YMALLOC(mtd->oobsize);
+ struct yaffs_devo_lc(dev)->spare_buffer = YMALLOC(mtd->oobsize);
param->is_yaffs2 = 1;
param->total_bytes_per_chunk = mtd->writesize;
param->chunks_per_block = mtd->erasesize / mtd->writesize;
param->erase_fn = nandmtd_erase_block;
param->initialise_flash_fn = nandmtd_initialise;
- yaffs_dev_to_lc(dev)->put_super_fn = yaffs_mtd_put_super;
+ struct yaffs_devo_lc(dev)->put_super_fn = yaffs_mtd_put_super;
param->sb_dirty_fn = yaffs_touch_super;
param->gc_control = yaffs_gc_control_callback;
- yaffs_dev_to_lc(dev)->super= sb;
+ struct yaffs_devo_lc(dev)->super= sb;
#ifndef CONFIG_YAFFS_DOES_ECC
}
context->mount_id = mount_id;
- ylist_add_tail(&(yaffs_dev_to_lc(dev)->context_list), &yaffs_context_list);
+ ylist_add_tail(&(struct yaffs_devo_lc(dev)->context_list), &yaffs_context_list);
up(&yaffs_context_lock);
/* Directory search handling...*/
- YINIT_LIST_HEAD(&(yaffs_dev_to_lc(dev)->search_contexts));
+ YINIT_LIST_HEAD(&(struct yaffs_devo_lc(dev)->search_contexts));
param->remove_obj_fn = yaffs_remove_obj_callback;
- init_MUTEX(&(yaffs_dev_to_lc(dev)->gross_lock));
+ init_MUTEX(&(struct yaffs_devo_lc(dev)->gross_lock));
yaffs_gross_lock(dev);
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);
}
-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);
/* 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;
/* 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;
#include "yaffs_nand.h"
-int yaffs1_scan(yaffs_dev_t *dev)
+int yaffs1_scan(struct yaffs_dev *dev)
{
- yaffs_ext_tags tags;
+ struct yaffs_ext_tags tags;
int blk;
int result;
int c;
int deleted;
yaffs_block_state_t state;
- yaffs_obj_t *hard_list = NULL;
+ struct yaffs_obj *hard_list = NULL;
yaffs_block_info_t *bi;
u32 seq_number;
- yaffs_obj_header *oh;
- yaffs_obj_t *in;
- yaffs_obj_t *parent;
+ struct yaffs_obj_hdr *oh;
+ struct yaffs_obj *in;
+ struct yaffs_obj *parent;
int alloc_failed = 0;
chunk_data,
NULL);
- oh = (yaffs_obj_header *) chunk_data;
+ oh = (struct yaffs_obj_hdr *) chunk_data;
in = yaffs_find_by_number(dev,
tags.obj_id);
/* Fix up any shadowed objects */
{
struct yaffs_shadow_fixer_s *fixer;
- yaffs_obj_t *obj;
+ struct yaffs_obj *obj;
while (shadow_fixers) {
fixer = shadow_fixers;
#define __YAFFS_YAFFS1_H__
#include "yaffs_guts.h"
-int yaffs1_scan(yaffs_dev_t *dev);
+int yaffs1_scan(struct yaffs_dev *dev);
#endif
* yaffs2_find_oldest_dirty_seq()
* Calculate the oldest dirty sequence number if we don't know it.
*/
-void yaffs_calc_oldest_dirty_seq(yaffs_dev_t *dev)
+void yaffs_calc_oldest_dirty_seq(struct yaffs_dev *dev)
{
int i;
unsigned seq;
}
-void yaffs2_find_oldest_dirty_seq(yaffs_dev_t *dev)
+void yaffs2_find_oldest_dirty_seq(struct yaffs_dev *dev)
{
if(!dev->param.is_yaffs2)
return;
* becomes invalid). If the value matches the oldest then we clear
* dev->oldest_dirty_seq to force its recomputation.
*/
-void yaffs2_clear_oldest_dirty_seq(yaffs_dev_t *dev, yaffs_block_info_t *bi)
+void yaffs2_clear_oldest_dirty_seq(struct yaffs_dev *dev, yaffs_block_info_t *bi)
{
if(!dev->param.is_yaffs2)
* Update the oldest dirty sequence number whenever we dirty a block.
* Only do this if the oldest_dirty_seq is actually being tracked.
*/
-void yaffs2_update_oldest_dirty_seq(yaffs_dev_t *dev, unsigned block_no, yaffs_block_info_t *bi)
+void yaffs2_update_oldest_dirty_seq(struct yaffs_dev *dev, unsigned block_no, yaffs_block_info_t *bi)
{
if(!dev->param.is_yaffs2)
return;
}
}
-int yaffs_block_ok_for_gc(yaffs_dev_t *dev,
+int yaffs_block_ok_for_gc(struct yaffs_dev *dev,
yaffs_block_info_t *bi)
{
* periodically finds the oldest full block by sequence number for refreshing.
* Only for yaffs2.
*/
-u32 yaffs2_find_refresh_block(yaffs_dev_t *dev)
+u32 yaffs2_find_refresh_block(struct yaffs_dev *dev)
{
u32 b ;
return oldest;
}
-int yaffs2_checkpt_required(yaffs_dev_t *dev)
+int yaffs2_checkpt_required(struct yaffs_dev *dev)
{
int nblocks;
(nblocks >= YAFFS_CHECKPOINT_MIN_BLOCKS);
}
-int yaffs_calc_checkpt_blocks_required(yaffs_dev_t *dev)
+int yaffs_calc_checkpt_blocks_required(struct yaffs_dev *dev)
{
int retval;
/*--------------------- Checkpointing --------------------*/
-static int yaffs2_wr_checkpt_validity_marker(yaffs_dev_t *dev, int head)
+static int yaffs2_wr_checkpt_validity_marker(struct yaffs_dev *dev, int head)
{
yaffs_checkpt_validty_t cp;
1 : 0;
}
-static int yaffs2_rd_checkpt_validty_marker(yaffs_dev_t *dev, int head)
+static int yaffs2_rd_checkpt_validty_marker(struct yaffs_dev *dev, int head)
{
yaffs_checkpt_validty_t cp;
int ok;
}
static void yaffs2_dev_to_checkpt_dev(yaffs_checkpt_dev_t *cp,
- yaffs_dev_t *dev)
+ struct yaffs_dev *dev)
{
cp->n_erased_blocks = dev->n_erased_blocks;
cp->alloc_block = dev->alloc_block;
}
-static void yaffs_checkpt_dev_to_dev(yaffs_dev_t *dev,
+static void yaffs_checkpt_dev_to_dev(struct yaffs_dev *dev,
yaffs_checkpt_dev_t *cp)
{
dev->n_erased_blocks = cp->n_erased_blocks;
}
-static int yaffs2_wr_checkpt_dev(yaffs_dev_t *dev)
+static int yaffs2_wr_checkpt_dev(struct yaffs_dev *dev)
{
yaffs_checkpt_dev_t cp;
u32 n_bytes;
}
-static int yaffs2_rd_checkpt_dev(yaffs_dev_t *dev)
+static int yaffs2_rd_checkpt_dev(struct yaffs_dev *dev)
{
yaffs_checkpt_dev_t cp;
u32 n_bytes;
}
static void yaffs2_obj_checkpt_obj(yaffs_checkpt_obj_t *cp,
- yaffs_obj_t *obj)
+ struct yaffs_obj *obj)
{
cp->obj_id = obj->obj_id;
cp->size_or_equiv_obj = obj->variant.hardlink_variant.equiv_id;
}
-static int taffs2_checkpt_obj_to_obj(yaffs_obj_t *obj, yaffs_checkpt_obj_t *cp)
+static int taffs2_checkpt_obj_to_obj(struct yaffs_obj *obj, yaffs_checkpt_obj_t *cp)
{
- yaffs_obj_t *parent;
+ struct yaffs_obj *parent;
if (obj->variant_type != cp->variant_type) {
T(YAFFS_TRACE_ERROR, (TSTR("Checkpoint read object %d type %d "
-static int yaffs2_checkpt_tnode_worker(yaffs_obj_t *in, yaffs_tnode_t *tn,
+static int yaffs2_checkpt_tnode_worker(struct yaffs_obj *in, yaffs_tnode_t *tn,
u32 level, int chunk_offset)
{
int i;
- yaffs_dev_t *dev = in->my_dev;
+ struct yaffs_dev *dev = in->my_dev;
int ok = 1;
if (tn) {
}
-static int yaffs2_wr_checkpt_tnodes(yaffs_obj_t *obj)
+static int yaffs2_wr_checkpt_tnodes(struct yaffs_obj *obj)
{
u32 end_marker = ~0;
int ok = 1;
return ok ? 1 : 0;
}
-static int yaffs2_rd_checkpt_tnodes(yaffs_obj_t *obj)
+static int yaffs2_rd_checkpt_tnodes(struct yaffs_obj *obj)
{
u32 base_chunk;
int ok = 1;
- yaffs_dev_t *dev = obj->my_dev;
+ struct yaffs_dev *dev = obj->my_dev;
yaffs_file_s *file_stuct_ptr = &obj->variant.file_variant;
yaffs_tnode_t *tn;
int nread = 0;
}
-static int yaffs2_wr_checkpt_objs(yaffs_dev_t *dev)
+static int yaffs2_wr_checkpt_objs(struct yaffs_dev *dev)
{
- yaffs_obj_t *obj;
+ struct yaffs_obj *obj;
yaffs_checkpt_obj_t cp;
int i;
int ok = 1;
for (i = 0; ok && 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);
if (!obj->defered_free) {
yaffs2_obj_checkpt_obj(&cp, obj);
cp.struct_type = sizeof(cp);
return ok ? 1 : 0;
}
-static int yaffs2_rd_checkpt_objs(yaffs_dev_t *dev)
+static int yaffs2_rd_checkpt_objs(struct yaffs_dev *dev)
{
- yaffs_obj_t *obj;
+ struct yaffs_obj *obj;
yaffs_checkpt_obj_t cp;
int ok = 1;
int done = 0;
- yaffs_obj_t *hard_list = NULL;
+ struct yaffs_obj *hard_list = NULL;
while (ok && !done) {
ok = (yaffs2_checkpt_rd(dev, &cp, sizeof(cp)) == sizeof(cp));
return ok ? 1 : 0;
}
-static int yaffs2_wr_checkpt_sum(yaffs_dev_t *dev)
+static int yaffs2_wr_checkpt_sum(struct yaffs_dev *dev)
{
u32 checkpt_sum;
int ok;
return 1;
}
-static int yaffs2_rd_checkpt_sum(yaffs_dev_t *dev)
+static int yaffs2_rd_checkpt_sum(struct yaffs_dev *dev)
{
u32 checkpt_sum0;
u32 checkpt_sum1;
}
-static int yaffs2_wr_checkpt_data(yaffs_dev_t *dev)
+static int yaffs2_wr_checkpt_data(struct yaffs_dev *dev)
{
int ok = 1;
return dev->is_checkpointed;
}
-static int yaffs2_rd_checkpt_data(yaffs_dev_t *dev)
+static int yaffs2_rd_checkpt_data(struct yaffs_dev *dev)
{
int ok = 1;
}
-void yaffs2_checkpt_invalidate(yaffs_dev_t *dev)
+void yaffs2_checkpt_invalidate(struct yaffs_dev *dev)
{
if (dev->is_checkpointed ||
dev->blocks_in_checkpt > 0) {
}
-int yaffs_checkpoint_save(yaffs_dev_t *dev)
+int yaffs_checkpoint_save(struct yaffs_dev *dev)
{
T(YAFFS_TRACE_CHECKPOINT, (TSTR("save entry: is_checkpointed %d"TENDSTR), dev->is_checkpointed));
return dev->is_checkpointed;
}
-int yaffs2_checkpt_restore(yaffs_dev_t *dev)
+int yaffs2_checkpt_restore(struct yaffs_dev *dev)
{
int retval;
T(YAFFS_TRACE_CHECKPOINT, (TSTR("restore entry: is_checkpointed %d"TENDSTR), dev->is_checkpointed));
return retval;
}
-int yaffs2_handle_hole(yaffs_obj_t *obj, loff_t new_size)
+int yaffs2_handle_hole(struct yaffs_obj *obj, loff_t new_size)
{
/* if new_size > old_file_size.
* We're going to be writing a hole.
int increase;
int small_hole ;
int result = YAFFS_OK;
- yaffs_dev_t *dev = NULL;
+ struct yaffs_dev *dev = NULL;
u8 *local_buffer = NULL;
return aseq - bseq;
}
-int yaffs2_scan_backwards(yaffs_dev_t *dev)
+int yaffs2_scan_backwards(struct yaffs_dev *dev)
{
- yaffs_ext_tags tags;
+ struct yaffs_ext_tags tags;
int blk;
int block_iter;
int start_iter;
int c;
int deleted;
yaffs_block_state_t state;
- yaffs_obj_t *hard_list = NULL;
+ struct yaffs_obj *hard_list = NULL;
yaffs_block_info_t *bi;
u32 seq_number;
- yaffs_obj_header *oh;
- yaffs_obj_t *in;
- yaffs_obj_t *parent;
+ struct yaffs_obj_hdr *oh;
+ struct yaffs_obj *in;
+ struct yaffs_obj *parent;
int n_blocks = dev->internal_end_block - dev->internal_start_block + 1;
int is_unlinked;
u8 *chunk_data;
chunk_data,
NULL);
- oh = (yaffs_obj_header *) chunk_data;
+ oh = (struct yaffs_obj_hdr *) chunk_data;
if (dev->param.inband_tags) {
/* Fix up the header if they got corrupted by inband tags */
#include "yaffs_guts.h"
-void yaffs_calc_oldest_dirty_seq(yaffs_dev_t *dev);
-void yaffs2_find_oldest_dirty_seq(yaffs_dev_t *dev);
-void yaffs2_clear_oldest_dirty_seq(yaffs_dev_t *dev, yaffs_block_info_t *bi);
-void yaffs2_update_oldest_dirty_seq(yaffs_dev_t *dev, unsigned block_no, yaffs_block_info_t *bi);
-int yaffs_block_ok_for_gc(yaffs_dev_t *dev, yaffs_block_info_t *bi);
-u32 yaffs2_find_refresh_block(yaffs_dev_t *dev);
-int yaffs2_checkpt_required(yaffs_dev_t *dev);
-int yaffs_calc_checkpt_blocks_required(yaffs_dev_t *dev);
+void yaffs_calc_oldest_dirty_seq(struct yaffs_dev *dev);
+void yaffs2_find_oldest_dirty_seq(struct yaffs_dev *dev);
+void yaffs2_clear_oldest_dirty_seq(struct yaffs_dev *dev, yaffs_block_info_t *bi);
+void yaffs2_update_oldest_dirty_seq(struct yaffs_dev *dev, unsigned block_no, yaffs_block_info_t *bi);
+int yaffs_block_ok_for_gc(struct yaffs_dev *dev, yaffs_block_info_t *bi);
+u32 yaffs2_find_refresh_block(struct yaffs_dev *dev);
+int yaffs2_checkpt_required(struct yaffs_dev *dev);
+int yaffs_calc_checkpt_blocks_required(struct yaffs_dev *dev);
-void yaffs2_checkpt_invalidate(yaffs_dev_t *dev);
-int yaffs2_checkpt_save(yaffs_dev_t *dev);
-int yaffs2_checkpt_restore(yaffs_dev_t *dev);
+void yaffs2_checkpt_invalidate(struct yaffs_dev *dev);
+int yaffs2_checkpt_save(struct yaffs_dev *dev);
+int yaffs2_checkpt_restore(struct yaffs_dev *dev);
-int yaffs2_handle_hole(yaffs_obj_t *obj, loff_t new_size);
-int yaffs2_scan_backwards(yaffs_dev_t *dev);
+int yaffs2_handle_hole(struct yaffs_obj *obj, loff_t new_size);
+int yaffs2_scan_backwards(struct yaffs_dev *dev);
#endif
projects / yaffs2.git / commitdiff