return 1;
}
-int yflash_WriteChunkToNAND(struct yaffs_dev *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 struct yaffs_spare *spare)
{
int written;
}
-int yflash_ReadChunkFromNAND(struct yaffs_dev *dev,int nand_chunk, u8 *data, yaffs_spare *spare)
+int yflash_ReadChunkFromNAND(struct yaffs_dev *dev,int nand_chunk, u8 *data, struct yaffs_spare *spare)
{
int nread;
-int yflash2_QueryNANDBlock(struct yaffs_dev *dev, int block_no, yaffs_block_state_t *state, u32 *seq_number)
+int yflash2_QueryNANDBlock(struct yaffs_dev *dev, int block_no, enum yaffs_block_state *state, u32 *seq_number)
{
struct yaffs_ext_tags tags;
int chunkNo;
}
}
-int ynorif1_WriteChunkToNAND(struct yaffs_dev *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 struct yaffs_spare *spare)
{
u32 *dataAddr = Chunk2DataAddr(dev,nand_chunk);
u32 *spareAddr = Chunk2SpareAddr(dev,nand_chunk);
- yaffs_spare tmpSpare;
+ struct yaffs_spare tmpSpare;
/* We should only be getting called for one of 3 reasons:
* Writing a chunk: data and spare will not be NULL
* Writing a bad block marker: data will be NULL, spare not NULL
*/
- if(sizeof(yaffs_spare) != 16)
+ if(sizeof(struct yaffs_spare) != 16)
YBUG();
if(data && spare)
/* Write a pre-marker */
memset(&tmpSpare,0xff,sizeof(tmpSpare));
tmpSpare.page_status = YNOR_PREMARKER;
- ynorif1_FlashWrite32(spareAddr,(u32 *)&tmpSpare,sizeof(yaffs_spare)/4);
+ ynorif1_FlashWrite32(spareAddr,(u32 *)&tmpSpare,sizeof(struct yaffs_spare)/4);
/* Write the data */
ynorif1_FlashWrite32(dataAddr,(u32 *)data,dev->param.total_bytes_per_chunk / 4);
- memcpy(&tmpSpare,spare,sizeof(yaffs_spare));
+ memcpy(&tmpSpare,spare,sizeof(struct yaffs_spare));
/* Write the real tags, but override the premarker*/
tmpSpare.page_status = YNOR_PREMARKER;
- ynorif1_FlashWrite32(spareAddr,(u32 *)&tmpSpare,sizeof(yaffs_spare)/4);
+ ynorif1_FlashWrite32(spareAddr,(u32 *)&tmpSpare,sizeof(struct yaffs_spare)/4);
/* Write a post-marker */
tmpSpare.page_status = YNOR_POSTMARKER;
ynorif1_FlashRead32(spareAddr,(u32 *)&tmpSpare,16/ 4);
- ynorif1_AndBytes((u8 *)&tmpSpare,(u8 *)spare,sizeof(yaffs_spare));
+ ynorif1_AndBytes((u8 *)&tmpSpare,(u8 *)spare,sizeof(struct yaffs_spare));
ynorif1_FlashWrite32(spareAddr,(u32 *)&tmpSpare,16/ 4);
}
}
-int ynorif1_ReadChunkFromNAND(struct yaffs_dev *dev,int nand_chunk, u8 *data, yaffs_spare *spare)
+int ynorif1_ReadChunkFromNAND(struct yaffs_dev *dev,int nand_chunk, u8 *data, struct yaffs_spare *spare)
{
u32 *dataAddr = Chunk2DataAddr(dev,nand_chunk);
#include "yaffs_guts.h"
-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_WriteChunkToNAND(struct yaffs_dev *dev,int nand_chunk,const u8 *data, const struct yaffs_spare *spare);
+int ynorif1_ReadChunkFromNAND(struct yaffs_dev *dev,int nand_chunk, u8 *data, struct 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);
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);
+int yramdisk_query_block(struct yaffs_dev *dev, int block_no, enum yaffs_block_state *state, int *seq_number);
#endif
}
-int nandemul2k_QueryNANDBlock(struct yaffs_dev *dev, int block_no, yaffs_block_state_t *state, u32 *seq_number)
+int nandemul2k_QueryNANDBlock(struct yaffs_dev *dev, int block_no, enum yaffs_block_state *state, u32 *seq_number)
{
struct yaffs_ext_tags tags;
int chunkNo;
return YAFFS_OK;
}
-int yflash_QueryNANDBlock(struct yaffs_dev *dev, int block_no, yaffs_block_state_t *state, int *seq_number)
+int yflash_QueryNANDBlock(struct yaffs_dev *dev, int block_no, enum yaffs_block_state *state, int *seq_number)
{
*state = YAFFS_BLOCK_STATE_EMPTY;
*seq_number = 0;
#include "yaffs_guts.h"
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_WriteChunkToNAND(struct yaffs_dev *dev,int nand_chunk,const u8 *data, const struct 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_ReadChunkFromNAND(struct yaffs_dev *dev,int nand_chunk, u8 *data, struct 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);
+int yflash_QueryNANDBlock(struct yaffs_dev *dev, int block_no, enum yaffs_block_state *state, u32 *seq_number);
#endif
#include "yaffs_guts.h"
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_WriteChunkToNAND(struct yaffs_dev *dev,int nand_chunk,const u8 *data, const struct 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_ReadChunkFromNAND(struct yaffs_dev *dev,int nand_chunk, u8 *data, struct 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);
+int yflash2_QueryNANDBlock(struct yaffs_dev *dev, int block_no, enum yaffs_block_state *state, u32 *seq_number);
#endif
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);
+ enum yaffs_block_state *state, u32 *seq_number);
int nandemul2k_EraseBlockInNAND(struct yaffs_dev *dev,
int flash_block);
int nandemul2k_InitialiseNAND(struct yaffs_dev *dev);
return geometry->checkBlockOk(dev,blockId);
}
-int ynandif_QueryNANDBlock(struct yaffs_dev *dev, int blockId, yaffs_block_state_t *state, u32 *seq_number)
+int ynandif_QueryNANDBlock(struct yaffs_dev *dev, int blockId, enum yaffs_block_state *state, u32 *seq_number)
{
unsigned chunkNo;
struct yaffs_ext_tags tags;
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_QueryNANDBlock(struct yaffs_dev *dev, int block_no, enum yaffs_block_state *state, u32 *seq_number);
int ynandif_GetGeometry(struct yaffs_dev *dev, ynandif_Geometry *geometry);
#endif
MTD1_CODE="yaffs_mtdif1_multi.c"
MTD2_CODE="yaffs_mtdif2_multi.c"
elif [ $MULTIORSINGLE = s ]; then
- VFSGLUE="yaffs_vfs_single.c"
+ VFS_CODE="yaffs_vfs_single.c"
MTD1_CODE="yaffs_mtdif1_single.c"
MTD2_CODE="yaffs_mtdif2_single.c"
}
-yaffs_tnode_t *yaffs_alloc_raw_tnode(struct yaffs_dev *dev)
+struct yaffs_tnode *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(struct yaffs_dev *dev, yaffs_tnode_t *tn)
+void yaffs_free_raw_tnode(struct yaffs_dev *dev, struct yaffs_tnode *tn)
{
yaffs_Allocator *allocator = dev->allocator;
kmem_cache_free(allocator->tnode_cache,tn);
}
int nandmtd2_QueryNANDBlock(struct yaffs_dev *dev, int block_no,
- yaffs_block_state_t * state, int *seq_number)
+ enum yaffs_block_state * state, int *seq_number)
{
struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice);
int retval;
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.
- yaffs_tags_union_t temp;
+ union yaffs_tags_union * tags = (union yaffs_tags_union* )tagsPtr; // Work in bytes.
+ union yaffs_tags_union temp;
memset(&temp, 0, sizeof(temp));
// Ick, I hate magic numbers.
}
-static void yaffs_calc_ecc(const u8 *data, yaffs_spare *spare)
+static void yaffs_calc_ecc(const u8 *data, struct yaffs_spare *spare)
{
yaffs_ecc_cacl(data , spare->ecc1);
yaffs_ecc_cacl(&data[256] , spare->ecc2);
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;
+ unsigned char *b = ((union yaffs_tags_union *)tags)->as_bytes;
unsigned i,j;
unsigned ecc = 0;
unsigned bit = 0;
b[7] |= ((ecc & 0x3F) << 2);
}
}
-static void yaffs_load_tags_to_spare(yaffs_spare *sparePtr, struct yaffs_tags *tagsPtr)
+static void yaffs_load_tags_to_spare(struct yaffs_spare *sparePtr, struct yaffs_tags *tagsPtr)
{
- yaffs_tags_union_t *tu = (yaffs_tags_union_t *)tagsPtr;
+ union yaffs_tags_union *tu = (union yaffs_tags_union *)tagsPtr;
//yaffs_calc_tags_ecc(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;
+ union yaffs_tags_union * tags = (union yaffs_tags_union* )tagsPtr; // Work in bytes.
+ union yaffs_tags_union temp;
memset(&temp, 0, sizeof(temp));
// Ick, I hate magic numbers.
static int write_chunk(u8 *data, u32 obj_id, u32 chunk_id, u32 n_bytes)
{
struct yaffs_tags t;
- yaffs_spare s;
+ struct yaffs_spare s;
error = write(outFile,data,512);
if(error < 0) return error;
memset(&t,0xff,sizeof (struct yaffs_tags));
- memset(&s,0xff,sizeof (yaffs_spare));
+ memset(&s,0xff,sizeof (struct yaffs_spare));
t.chunk_id = chunk_id;
t.serial_number = 0;
nPages++;
- return write(outFile,&s,sizeof(yaffs_spare));
+ return write(outFile,&s,sizeof(struct yaffs_spare));
}
dev = dev;
}
-yaffs_tnode_t *yaffs_alloc_raw_tnode(struct yaffs_dev *dev)
+struct yaffs_tnode *yaffs_alloc_raw_tnode(struct yaffs_dev *dev)
{
- return (yaffs_tnode_t *)YMALLOC(dev->tnode_size);
+ return (struct yaffs_tnode *)YMALLOC(dev->tnode_size);
}
-void yaffs_free_raw_tnode(struct yaffs_dev *dev, yaffs_tnode_t *tn)
+void yaffs_free_raw_tnode(struct yaffs_dev *dev, struct yaffs_tnode *tn)
{
dev = dev;
YFREE(tn);
struct yaffs_tnode_list {
struct yaffs_tnode_list *next;
- yaffs_tnode_t *tnodes;
+ struct yaffs_tnode *tnodes;
};
-typedef struct yaffs_tnode_list yaffs_tnodelist_t;
-struct yaffs_obj_list_struct {
+struct yaffs_obj_list {
+ struct yaffs_obj_list *next;
struct yaffs_obj *objects;
- struct yaffs_obj_list_struct *next;
};
-typedef struct yaffs_obj_list_struct yaffs_obj_list;
-
struct yaffs_allocator {
int n_tnodes_created;
- yaffs_tnode_t *free_tnodes;
+ struct yaffs_tnode *free_tnodes;
int n_free_tnodes;
- yaffs_tnodelist_t *alloc_tnode_list;
+ struct yaffs_tnode_list *alloc_tnode_list;
int n_obj_created;
struct yaffs_obj *free_objs;
int n_free_objects;
- yaffs_obj_list *allocated_obj_list;
+ struct yaffs_obj_list *allocated_obj_list;
};
struct yaffs_allocator *allocator = (struct yaffs_allocator *)dev->allocator;
- yaffs_tnodelist_t *tmp;
+ struct yaffs_tnode_list *tmp;
if(!allocator){
YBUG();
{
struct yaffs_allocator *allocator = (struct yaffs_allocator *)dev->allocator;
int i;
- yaffs_tnode_t *new_tnodes;
+ struct yaffs_tnode *new_tnodes;
u8 *mem;
- yaffs_tnode_t *curr;
- yaffs_tnode_t *next;
- yaffs_tnodelist_t *tnl;
+ struct yaffs_tnode *curr;
+ struct yaffs_tnode *next;
+ struct yaffs_tnode_list *tnl;
if(!allocator){
YBUG();
/* New hookup for wide tnodes */
for (i = 0; i < n_tnodes - 1; i++) {
- curr = (yaffs_tnode_t *) &mem[i * dev->tnode_size];
- next = (yaffs_tnode_t *) &mem[(i+1) * dev->tnode_size];
+ curr = (struct yaffs_tnode *) &mem[i * dev->tnode_size];
+ next = (struct yaffs_tnode *) &mem[(i+1) * dev->tnode_size];
curr->internal[0] = next;
}
- curr = (yaffs_tnode_t *) &mem[(n_tnodes - 1) * dev->tnode_size];
+ curr = (struct yaffs_tnode *) &mem[(n_tnodes - 1) * dev->tnode_size];
curr->internal[0] = allocator->free_tnodes;
- allocator->free_tnodes = (yaffs_tnode_t *)mem;
+ allocator->free_tnodes = (struct yaffs_tnode *)mem;
allocator->n_free_tnodes += n_tnodes;
allocator->n_tnodes_created += n_tnodes;
* but it just means we can't free this bunch of tnodes later.
*/
- tnl = YMALLOC(sizeof(yaffs_tnodelist_t));
+ tnl = YMALLOC(sizeof(struct yaffs_tnode_list));
if (!tnl) {
T(YAFFS_TRACE_ERROR,
(TSTR
}
-yaffs_tnode_t *yaffs_alloc_raw_tnode(struct yaffs_dev *dev)
+struct yaffs_tnode *yaffs_alloc_raw_tnode(struct yaffs_dev *dev)
{
struct yaffs_allocator *allocator = (struct yaffs_allocator *)dev->allocator;
- yaffs_tnode_t *tn = NULL;
+ struct yaffs_tnode *tn = NULL;
if(!allocator){
YBUG();
}
/* FreeTnode frees up a tnode and puts it back on the free list */
-void yaffs_free_raw_tnode(struct yaffs_dev *dev, yaffs_tnode_t *tn)
+void yaffs_free_raw_tnode(struct yaffs_dev *dev, struct yaffs_tnode *tn)
{
struct yaffs_allocator *allocator = dev->allocator;
static void yaffs_deinit_raw_objs(struct yaffs_dev *dev)
{
struct yaffs_allocator *allocator = dev->allocator;
- yaffs_obj_list *tmp;
+ struct yaffs_obj_list *tmp;
if(!allocator){
YBUG();
int i;
struct yaffs_obj *new_objs;
- yaffs_obj_list *list;
+ struct yaffs_obj_list *list;
if(!allocator){
YBUG();
/* make these things */
new_objs = YMALLOC(n_obj * sizeof(struct yaffs_obj));
- list = YMALLOC(sizeof(yaffs_obj_list));
+ list = YMALLOC(sizeof(struct yaffs_obj_list));
if (!new_objs || !list) {
if (new_objs){
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(struct yaffs_dev *dev);
-void yaffs_free_raw_tnode(struct yaffs_dev *dev, yaffs_tnode_t *tn);
+struct yaffs_tnode *yaffs_alloc_raw_tnode(struct yaffs_dev *dev);
+void yaffs_free_raw_tnode(struct yaffs_dev *dev, struct yaffs_tnode *tn);
struct yaffs_obj *yaffs_alloc_raw_obj(struct yaffs_dev *dev);
void yaffs_free_raw_obj(struct yaffs_dev *dev, struct yaffs_obj *obj);
dev->internal_start_block, dev->internal_end_block));
for (i = dev->internal_start_block; i <= dev->internal_end_block; i++) {
- yaffs_block_info_t *bi = yaffs_get_block_info(dev, i);
+ struct yaffs_block_info *bi = yaffs_get_block_info(dev, i);
if (bi->block_state == YAFFS_BLOCK_STATE_CHECKPOINT) {
T(YAFFS_TRACE_CHECKPOINT, (TSTR("erasing checkpt block %d"TENDSTR), i));
blocks_avail > 0) {
for (i = dev->checkpt_next_block; i <= dev->internal_end_block; i++) {
- yaffs_block_info_t *bi = yaffs_get_block_info(dev, i);
+ struct yaffs_block_info *bi = yaffs_get_block_info(dev, i);
if (bi->block_state == YAFFS_BLOCK_STATE_EMPTY) {
dev->checkpt_next_block = i + 1;
dev->checkpt_cur_block = i;
if (dev->checkpt_cur_chunk == 0) {
/* First chunk we write for the block? Set block state to
checkpoint */
- yaffs_block_info_t *bi = yaffs_get_block_info(dev, dev->checkpt_cur_block);
+ struct yaffs_block_info *bi = yaffs_get_block_info(dev, dev->checkpt_cur_block);
bi->block_state = YAFFS_BLOCK_STATE_CHECKPOINT;
dev->blocks_in_checkpt++;
}
int i;
for (i = 0; i < dev->blocks_in_checkpt && dev->checkpt_block_list[i] >= 0; i++) {
int blk = dev->checkpt_block_list[i];
- yaffs_block_info_t *bi = NULL;
+ struct yaffs_block_info *bi = NULL;
if( dev->internal_start_block <= blk && blk <= dev->internal_end_block)
bi = yaffs_get_block_info(dev, blk);
if (bi && bi->block_state == YAFFS_BLOCK_STATE_EMPTY)
#include "yaffs_trace.h"
/* Function to manipulate block info */
-static Y_INLINE yaffs_block_info_t *yaffs_get_block_info(struct yaffs_dev * dev, int blk)
+static Y_INLINE struct yaffs_block_info *yaffs_get_block_info(struct yaffs_dev * dev, int blk)
{
if (blk < dev->internal_start_block || blk > dev->internal_end_block) {
T(YAFFS_TRACE_ERROR,
enum yaffs_obj_type type);
-static int yaffs_apply_xattrib_mod(struct yaffs_obj *obj, char *buffer, yaffs_xattr_mod *xmod);
+static int yaffs_apply_xattrib_mod(struct yaffs_obj *obj, char *buffer, struct yaffs_xattr_mod *xmod);
static void yaffs_remove_obj_from_dir(struct yaffs_obj *obj);
static int yaffs_check_structures(void);
int chunk_obj);
static int yaffs_alloc_chunk(struct yaffs_dev *dev, int use_reserver,
- yaffs_block_info_t **block_ptr);
+ struct yaffs_block_info **block_ptr);
static void yaffs_check_obj_details_loaded(struct yaffs_obj *in);
yaffs2_checkpt_invalidate(dev);
do {
- yaffs_block_info_t *bi = 0;
+ struct yaffs_block_info *bi = 0;
int erased_ok = 0;
chunk = yaffs_alloc_chunk(dev, use_reserver, &bi);
static void yaffs_retire_block(struct yaffs_dev *dev, int flash_block)
{
- yaffs_block_info_t *bi = yaffs_get_block_info(dev, flash_block);
+ struct yaffs_block_info *bi = yaffs_get_block_info(dev, flash_block);
yaffs2_checkpt_invalidate(dev);
tags=tags;
}
-void yaffs_handle_chunk_error(struct yaffs_dev *dev, yaffs_block_info_t *bi)
+void yaffs_handle_chunk_error(struct yaffs_dev *dev, struct yaffs_block_info *bi)
{
if (!bi->gc_prioritise) {
bi->gc_prioritise = 1;
int erased_ok)
{
int flash_block = nand_chunk / dev->param.chunks_per_block;
- yaffs_block_info_t *bi = yaffs_get_block_info(dev, flash_block);
+ struct yaffs_block_info *bi = yaffs_get_block_info(dev, flash_block);
yaffs_handle_chunk_error(dev, bi);
*/
-yaffs_tnode_t *yaffs_get_tnode(struct yaffs_dev *dev)
+struct yaffs_tnode *yaffs_get_tnode(struct yaffs_dev *dev)
{
- yaffs_tnode_t *tn = yaffs_alloc_raw_tnode(dev);
+ struct yaffs_tnode *tn = yaffs_alloc_raw_tnode(dev);
if (tn){
memset(tn, 0, dev->tnode_size);
dev->n_tnodes++;
}
/* FreeTnode frees up a tnode and puts it back on the free list */
-static void yaffs_free_tnode(struct yaffs_dev *dev, yaffs_tnode_t *tn)
+static void yaffs_free_tnode(struct yaffs_dev *dev, struct yaffs_tnode *tn)
{
yaffs_free_raw_tnode(dev,tn);
dev->n_tnodes--;
}
-void yaffs_load_tnode_0(struct yaffs_dev *dev, yaffs_tnode_t *tn, unsigned pos,
+void yaffs_load_tnode_0(struct yaffs_dev *dev, struct yaffs_tnode *tn, unsigned pos,
unsigned val)
{
u32 *map = (u32 *)tn;
}
}
-u32 yaffs_get_group_base(struct yaffs_dev *dev, yaffs_tnode_t *tn,
+u32 yaffs_get_group_base(struct yaffs_dev *dev, struct yaffs_tnode *tn,
unsigned pos)
{
u32 *map = (u32 *)tn;
*/
/* FindLevel0Tnode finds the level 0 tnode, if one exists. */
-yaffs_tnode_t *yaffs_find_tnode_0(struct yaffs_dev *dev,
- yaffs_file_s *file_struct,
+struct yaffs_tnode *yaffs_find_tnode_0(struct yaffs_dev *dev,
+ struct yaffs_file_var *file_struct,
u32 chunk_id)
{
- yaffs_tnode_t *tn = file_struct->top;
+ struct yaffs_tnode *tn = file_struct->top;
u32 i;
int required_depth;
int level = file_struct->top_level;
* be plugged into the ttree.
*/
-yaffs_tnode_t *yaffs_add_find_tnode_0(struct yaffs_dev *dev,
- yaffs_file_s *file_struct,
+struct yaffs_tnode *yaffs_add_find_tnode_0(struct yaffs_dev *dev,
+ struct yaffs_file_var *file_struct,
u32 chunk_id,
- yaffs_tnode_t *passed_tn)
+ struct yaffs_tnode *passed_tn)
{
int required_depth;
int i;
int l;
- yaffs_tnode_t *tn;
+ struct yaffs_tnode *tn;
u32 x;
static void yaffs_soft_del_chunk(struct yaffs_dev *dev, int chunk)
{
- yaffs_block_info_t *the_block;
+ struct yaffs_block_info *the_block;
unsigned block_no;
T(YAFFS_TRACE_DELETION, (TSTR("soft delete chunk %d" TENDSTR), chunk));
* Thus, essentially this is the same as DeleteWorker except that the chunks are soft deleted.
*/
-static int yaffs_soft_del_worker(struct yaffs_obj *in, yaffs_tnode_t *tn,
+static int yaffs_soft_del_worker(struct yaffs_obj *in, struct yaffs_tnode *tn,
u32 level, int chunk_offset)
{
int i;
* If there is no data in a subtree then it is pruned.
*/
-static yaffs_tnode_t *yaffs_prune_worker(struct yaffs_dev *dev, yaffs_tnode_t *tn,
+static struct yaffs_tnode *yaffs_prune_worker(struct yaffs_dev *dev, struct yaffs_tnode *tn,
u32 level, int del0)
{
int i;
}
static int yaffs_prune_tree(struct yaffs_dev *dev,
- yaffs_file_s *file_struct)
+ struct yaffs_file_var *file_struct)
{
int i;
int has_data;
int done = 0;
- yaffs_tnode_t *tn;
+ struct yaffs_tnode *tn;
if (file_struct->top_level > 0) {
file_struct->top =
enum yaffs_obj_type type)
{
struct yaffs_obj *the_obj=NULL;
- yaffs_tnode_t *tn = NULL;
+ struct yaffs_tnode *tn = NULL;
if (number < 0)
number = yaffs_new_obj_id(dev);
dev->alloc_block = -1; /* force it to get a new one */
/* If the first allocation strategy fails, thry the alternate one */
- dev->block_info = YMALLOC(n_blocks * sizeof(yaffs_block_info_t));
+ dev->block_info = YMALLOC(n_blocks * sizeof(struct yaffs_block_info));
if (!dev->block_info) {
- dev->block_info = YMALLOC_ALT(n_blocks * sizeof(yaffs_block_info_t));
+ dev->block_info = YMALLOC_ALT(n_blocks * sizeof(struct yaffs_block_info));
dev->block_info_alt = 1;
} else
dev->block_info_alt = 0;
}
if (dev->block_info && dev->chunk_bits) {
- memset(dev->block_info, 0, n_blocks * sizeof(yaffs_block_info_t));
+ memset(dev->block_info, 0, n_blocks * sizeof(struct yaffs_block_info));
memset(dev->chunk_bits, 0, dev->chunk_bit_stride * n_blocks);
return YAFFS_OK;
}
void yaffs_block_became_dirty(struct yaffs_dev *dev, int block_no)
{
- yaffs_block_info_t *bi = yaffs_get_block_info(dev, block_no);
+ struct yaffs_block_info *bi = yaffs_get_block_info(dev, block_no);
int erased_ok = 0;
{
int i;
- yaffs_block_info_t *bi;
+ struct yaffs_block_info *bi;
if (dev->n_erased_blocks < 1) {
/* Hoosterman we've got a problem.
}
static int yaffs_alloc_chunk(struct yaffs_dev *dev, int use_reserver,
- yaffs_block_info_t **block_ptr)
+ struct yaffs_block_info **block_ptr)
{
int ret_val;
- yaffs_block_info_t *bi;
+ struct yaffs_block_info *bi;
if (dev->alloc_block < 0) {
/* Get next block to allocate off */
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);
+ struct yaffs_block_info *bi = yaffs_get_block_info(dev, dev->alloc_block);
if(bi->block_state == YAFFS_BLOCK_STATE_ALLOCATING){
bi->block_state = YAFFS_BLOCK_STATE_FULL;
dev->alloc_block = -1;
struct yaffs_ext_tags tags;
- yaffs_block_info_t *bi = yaffs_get_block_info(dev, block);
+ struct yaffs_block_info *bi = yaffs_get_block_info(dev, block);
struct yaffs_obj *object;
unsigned selected = 0;
int prioritised = 0;
int prioritised_exist = 0;
- yaffs_block_info_t *bi;
+ struct yaffs_block_info *bi;
int threshold;
/* First let's see if we need to grab a prioritised block */
struct yaffs_ext_tags *tags)
{
/*Get the Tnode, then get the level 0 offset chunk offset */
- yaffs_tnode_t *tn;
+ struct yaffs_tnode *tn;
int the_chunk = -1;
struct yaffs_ext_tags local_tags;
int ret_val = -1;
struct yaffs_ext_tags *tags)
{
/* Get the Tnode, then get the level 0 offset chunk offset */
- yaffs_tnode_t *tn;
+ struct yaffs_tnode *tn;
int the_chunk = -1;
struct yaffs_ext_tags local_tags;
* nand_chunk = 0 is a dummy insert to make sure the tnodes are there.
*/
- yaffs_tnode_t *tn;
+ struct yaffs_tnode *tn;
struct yaffs_dev *dev = in->my_dev;
int existing_cunk;
struct yaffs_ext_tags existing_tags;
int block;
int page;
struct yaffs_ext_tags tags;
- yaffs_block_info_t *bi;
+ struct yaffs_block_info *bi;
if (chunk_id <= 0)
return;
* If name is not NULL, then that new name is used.
*/
int yaffs_update_oh(struct yaffs_obj *in, const YCHAR *name, int force,
- int is_shrink, int shadows, yaffs_xattr_mod *xmod)
+ int is_shrink, int shadows, struct yaffs_xattr_mod *xmod)
{
- yaffs_block_info_t *bi;
+ struct yaffs_block_info *bi;
struct yaffs_dev *dev = in->my_dev;
{
struct yaffs_dev *dev = obj->my_dev;
int i;
- yaffs_cache_t *cache;
+ struct yaffs_cache *cache;
int n_caches = obj->my_dev->param.n_caches;
for (i = 0; i < n_caches; i++) {
struct yaffs_dev *dev = obj->my_dev;
int lowest = -99; /* Stop compiler whining. */
int i;
- yaffs_cache_t *cache;
+ struct yaffs_cache *cache;
int chunk_written = 0;
int n_caches = obj->my_dev->param.n_caches;
* 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(struct yaffs_dev *dev)
+static struct yaffs_cache *yaffs_grab_chunk_worker(struct yaffs_dev *dev)
{
int i;
return NULL;
}
-static yaffs_cache_t *yaffs_grab_chunk_cache(struct yaffs_dev *dev)
+static struct yaffs_cache *yaffs_grab_chunk_cache(struct yaffs_dev *dev)
{
- yaffs_cache_t *cache;
+ struct yaffs_cache *cache;
struct yaffs_obj *the_obj;
int usage;
int i;
}
/* Find a cached chunk */
-static yaffs_cache_t *yaffs_find_chunk_cache(const struct yaffs_obj *obj,
+static struct yaffs_cache *yaffs_find_chunk_cache(const struct yaffs_obj *obj,
int chunk_id)
{
struct yaffs_dev *dev = obj->my_dev;
}
/* Mark the chunk for the least recently used algorithym */
-static void yaffs_use_cache(struct yaffs_dev *dev, yaffs_cache_t *cache,
+static void yaffs_use_cache(struct yaffs_dev *dev, struct yaffs_cache *cache,
int is_write)
{
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);
+ struct yaffs_cache *cache = yaffs_find_chunk_cache(object, chunk_id);
if (cache)
cache->object = NULL;
int n_copy;
int n = n_bytes;
int n_done = 0;
- yaffs_cache_t *cache;
+ struct yaffs_cache *cache;
struct yaffs_dev *dev;
* or we're using inband tags, so we want to use the cache buffers.
*/
if (dev->param.n_caches > 0) {
- yaffs_cache_t *cache;
+ struct yaffs_cache *cache;
/* If we can't find the data in the cache, then load the cache */
cache = yaffs_find_chunk_cache(in, chunk);
{
struct ylist_head *link;
struct yaffs_obj *obj;
- yaffs_dir_s *d_s;
- yaffs_obj_variant *o_v;
+ struct yaffs_dir_var *d_s;
+ union yaffs_obj_var *o_v;
T(YAFFS_TRACE_BACKGROUND, (TSTR("Update dirty directories" TENDSTR)));
link = dev->dirty_dirs.next;
ylist_del_init(link);
- d_s=ylist_entry(link,yaffs_dir_s,dirty);
- o_v = ylist_entry(d_s,yaffs_obj_variant,dir_variant);
+ d_s=ylist_entry(link,struct yaffs_dir_var,dirty);
+ o_v = ylist_entry(d_s,union yaffs_obj_var,dir_variant);
obj = ylist_entry(o_v,struct yaffs_obj,variant);
T(YAFFS_TRACE_BACKGROUND, (TSTR("Update directory %d" TENDSTR), obj->obj_id));
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;
+ struct yaffs_xattr_mod xmod;
int result;
return -ENOSPC;
}
-static int yaffs_apply_xattrib_mod(struct yaffs_obj *obj, char *buffer, yaffs_xattr_mod *xmod)
+static int yaffs_apply_xattrib_mod(struct yaffs_obj *obj, char *buffer, struct yaffs_xattr_mod *xmod)
{
int retval = 0;
int x_offs = sizeof(struct yaffs_obj_hdr);
dev->chunk_grp_bits = bits - dev->tnode_width;
dev->tnode_size = (dev->tnode_width * YAFFS_NTNODES_LEVEL0)/8;
- if(dev->tnode_size < sizeof(yaffs_tnode_t))
- dev->tnode_size = sizeof(yaffs_tnode_t);
+ if(dev->tnode_size < sizeof(struct yaffs_tnode))
+ dev->tnode_size = sizeof(struct yaffs_tnode);
dev->chunk_grp_size = 1 << dev->chunk_grp_bits;
dev->param.n_caches > 0) {
int i;
void *buf;
- int cache_bytes = dev->param.n_caches * sizeof(yaffs_cache_t);
+ int cache_bytes = dev->param.n_caches * sizeof(struct yaffs_cache);
if (dev->param.n_caches > YAFFS_MAX_SHORT_OP_CACHES)
dev->param.n_caches = YAFFS_MAX_SHORT_OP_CACHES;
int n_free=0;
int b;
- yaffs_block_info_t *blk;
+ struct yaffs_block_info *blk;
blk = dev->block_info;
for (b = dev->internal_start_block; b <= dev->internal_end_block; b++) {
static int yaffs_check_structures(void)
{
/* 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"); */
+/* yaffs_check_struct(union yaffs_tags_union,8,"union yaffs_tags_union"); */
+/* yaffs_check_struct(struct yaffs_spare,16,"struct yaffs_spare"); */
+/* yaffs_check_struct(struct yaffs_tnode, 2 * YAFFS_NTNODES_LEVEL0, "struct yaffs_tnode"); */
#ifndef CONFIG_YAFFS_WINCE
yaffs_check_struct(struct yaffs_obj_hdr, 512, "struct yaffs_obj_hdr");
#define YAFFS_SEQUENCE_BAD_BLOCK 0xFFFF0000
/* ChunkCache is used for short read/write operations.*/
-typedef struct {
+struct yaffs_cache {
struct yaffs_obj *object;
int chunk_id;
int last_use;
int n_bytes; /* Only valid if the cache is dirty */
int locked; /* Can't push out or flush while locked. */
u8 *data;
-} yaffs_cache_t;
+} ;
unsigned n_bytes_msb:2;
};
-typedef union {
+union yaffs_tags_union{
struct yaffs_tags as_tags;
u8 as_bytes[8];
-} yaffs_tags_union_t;
+} ;
#endif
/* Stuff used for extended tags in YAFFS2 */
-typedef enum {
+enum yaffs_ecc_result {
YAFFS_ECC_RESULT_UNKNOWN,
YAFFS_ECC_RESULT_NO_ERROR,
YAFFS_ECC_RESULT_FIXED,
YAFFS_ECC_RESULT_UNFIXED
-} yaffs_ecc_result;
+} ;
enum yaffs_obj_type {
YAFFS_OBJECT_TYPE_UNKNOWN,
struct yaffs_ext_tags{
- unsigned validity1;
+ unsigned validity0;
unsigned chunk_used; /* Status of the chunk: used or unused */
unsigned obj_id; /* If 0 then this is not part of an object (unused) */
unsigned chunk_id; /* If 0 then this is a header, else a data chunk */
unsigned n_bytes; /* Only valid for data chunks */
/* The following stuff only has meaning when we read */
- yaffs_ecc_result ecc_result;
+ enum yaffs_ecc_result ecc_result;
unsigned block_bad;
/* YAFFS 1 stuff */
unsigned extra_length; /* Length if it is a file */
unsigned extra_equiv_id; /* Equivalent object Id if it is a hard link */
- unsigned validty1;
+ unsigned validity1;
};
/* Spare structure for YAFFS1 */
-typedef struct {
+struct yaffs_spare{
u8 tb0;
u8 tb1;
u8 tb2;
u8 tb6;
u8 tb7;
u8 ecc2[3];
-} yaffs_spare;
+} ;
/*Special structure for passing through to mtd */
struct yaffs_nand_spare {
- yaffs_spare spare;
+ struct yaffs_spare spare;
int eccres1;
int eccres2;
};
/* Block data in RAM */
-typedef enum {
+enum yaffs_block_state{
YAFFS_BLOCK_STATE_UNKNOWN = 0,
YAFFS_BLOCK_STATE_SCANNING,
YAFFS_BLOCK_STATE_DEAD
/* This block has failed and is not in use */
-} yaffs_block_state_t;
+};
#define YAFFS_NUMBER_OF_BLOCK_STATES (YAFFS_BLOCK_STATE_DEAD + 1)
-typedef struct {
+struct yaffs_block_info{
int soft_del_pages:10; /* number of soft deleted pages */
int pages_in_use:10; /* number of pages in use */
u32 seq_number; /* block sequence number for yaffs2 */
#endif
-} yaffs_block_info_t;
+} ;
/* -------------------------- Object structure -------------------------------*/
/* This is the object structure as stored on NAND */
/*--------------------------- Tnode -------------------------- */
-union yaffs_tnode_union {
- union yaffs_tnode_union *internal[YAFFS_NTNODES_INTERNAL];
-
+struct yaffs_tnode {
+ struct yaffs_tnode *internal[YAFFS_NTNODES_INTERNAL];
};
-typedef union yaffs_tnode_union yaffs_tnode_t;
/*------------------------ Object -----------------------------*/
* - a hard link
*/
-typedef struct {
+struct yaffs_file_var {
u32 file_size;
u32 scanned_size;
u32 shrink_size;
int top_level;
- yaffs_tnode_t *top;
-} yaffs_file_s;
+ struct yaffs_tnode *top;
+} ;
-typedef struct {
+struct yaffs_dir_var{
struct ylist_head children; /* list of child links */
struct ylist_head dirty; /* Entry for list of dirty directories */
-} yaffs_dir_s;
+};
-typedef struct {
+struct yaffs_symlink_var{
YCHAR *alias;
-} yaffs_symlink_t;
+};
-typedef struct {
+struct yaffs_hardlink_var{
struct yaffs_obj *equiv_obj;
u32 equiv_id;
-} yaffs_hard_link_s;
+};
-typedef union {
- yaffs_file_s file_variant;
- yaffs_dir_s dir_variant;
- yaffs_symlink_t symlink_variant;
- yaffs_hard_link_s hardlink_variant;
-} yaffs_obj_variant;
+union yaffs_obj_var{
+ struct yaffs_file_var file_variant;
+ struct yaffs_dir_var dir_variant;
+ struct yaffs_symlink_var symlink_variant;
+ struct yaffs_hardlink_var hardlink_variant;
+};
enum yaffs_obj_type variant_type;
- yaffs_obj_variant variant;
+ union yaffs_obj_var variant;
};
} ;
-/* yaffs_checkpt_obj_t holds the definition of an object as dumped
+/* yaffs_checkpt_obj holds the definition of an object as dumped
* by checkpointing.
*/
-typedef struct {
+struct yaffs_checkpt_obj{
int struct_type;
u32 obj_id;
u32 parent_id;
u8 serial;
int n_data_chunks;
u32 size_or_equiv_obj;
-} yaffs_checkpt_obj_t;
+};
/*--------------------- Temporary buffers ----------------
*
* These are chunk-sized working buffers. Each device has a few
*/
-typedef struct {
+struct yaffs_buffer {
u8 *buffer;
int line; /* track from whence this buffer was allocated */
int max_line;
-} yaffs_buffer_t;
+} ;
/*----------------- Device ---------------------------------*/
int (*write_chunk_fn) (struct yaffs_dev *dev,
int nand_chunk, const u8 *data,
- const yaffs_spare *spare);
+ const struct yaffs_spare *spare);
int (*read_chunk_fn) (struct yaffs_dev *dev,
int nand_chunk, u8 *data,
- yaffs_spare *spare);
+ struct yaffs_spare *spare);
int (*erase_fn) (struct yaffs_dev *dev,
int flash_block);
int (*initialise_flash_fn) (struct yaffs_dev *dev);
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);
+ enum yaffs_block_state *state, u32 *seq_number);
#endif
/* The remove_obj_fn function must be supplied by OS flavours that
int checkpoint_blocks_required; /* Number of blocks needed to store current checkpoint set */
/* Block Info */
- yaffs_block_info_t *block_info;
+ struct yaffs_block_info *block_info;
u8 *chunk_bits; /* bitmap of chunks in use */
unsigned block_info_alt:1; /* was allocated using alternative strategy */
unsigned chunk_bits_alt:1; /* was allocated using alternative strategy */
/* Buffer areas for storing data to recover from write failures TODO
* u8 buffered_data[YAFFS_CHUNKS_PER_BLOCK][YAFFS_BYTES_PER_CHUNK];
- * yaffs_spare buffered_spare[YAFFS_CHUNKS_PER_BLOCK];
+ * struct yaffs_spare buffered_spare[YAFFS_CHUNKS_PER_BLOCK];
*/
int buffered_block; /* Which block is buffered here? */
int doing_buffered_block_rewrite;
- yaffs_cache_t *cache;
+ struct yaffs_cache *cache;
int cache_last_use;
/* Stuff for background deletion and unlinked files.*/
int n_bg_deletions; /* Count of background deletions. */
/* Temporary buffer management */
- yaffs_buffer_t temp_buffer[YAFFS_N_TEMP_BUFFERS];
+ struct yaffs_buffer temp_buffer[YAFFS_N_TEMP_BUFFERS];
int max_temp;
int temp_in_use;
int unmanaged_buffer_allocs;
};
-/* The static layout of block usage etc is stored in the super block header */
-typedef struct {
- int StructType;
- int version;
- int checkpt_start_block;
- int checkpt_end_block;
- int start_block;
- int end_block;
- int rfu[100];
-} yaffs_sb_header;
-
/* The CheckpointDevice structure holds the device information that changes at runtime and
* must be preserved over unmount/mount cycles.
*/
-typedef struct {
+struct yaffs_checkpt_dev{
int struct_type;
int n_erased_blocks;
int alloc_block; /* Current block being allocated off */
/* yaffs2 runtime stuff */
unsigned seq_number; /* Sequence number of currently allocating block */
-} yaffs_checkpt_dev_t;
+};
-typedef struct {
+struct yaffs_checkpt_validity{
int struct_type;
u32 magic;
u32 version;
u32 head;
-} yaffs_checkpt_validty_t;
+};
-struct yaffs_shadow_fixer_s {
+struct yaffs_shadow_fixer {
int obj_id;
int shadowed_id;
- struct yaffs_shadow_fixer_s *next;
+ struct yaffs_shadow_fixer *next;
};
/* Structure for doing xattr modifications */
-typedef struct {
+struct yaffs_xattr_mod{
int set; /* If 0 then this is a deletion */
const YCHAR *name;
const void *data;
int size;
int flags;
int result;
-}yaffs_xattr_mod;
+};
/*----------------------- YAFFS Functions -----------------------*/
/* A few useful functions to be used within the core files*/
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(struct yaffs_dev *dev, yaffs_block_info_t *bi);
+void yaffs_handle_chunk_error(struct yaffs_dev *dev, struct yaffs_block_info *bi);
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);
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);
+ struct yaffs_xattr_mod *xop);
void yaffs_handle_shadowed_obj(struct yaffs_dev *dev, int obj_id,
int backward_scanning);
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,
+struct yaffs_tnode *yaffs_get_tnode(struct yaffs_dev *dev);
+struct yaffs_tnode *yaffs_add_find_tnode_0(struct yaffs_dev *dev,
+ struct yaffs_file_var *file_struct,
u32 chunk_id,
- yaffs_tnode_t *passed_tn);
+ struct yaffs_tnode *passed_tn);
int yaffs_do_file_wr(struct yaffs_obj *in, const u8 *buffer, loff_t offset,
int n_bytes, int write_trhrough);
int yaffs_count_free_chunks(struct yaffs_dev *dev);
-yaffs_tnode_t *yaffs_find_tnode_0(struct yaffs_dev *dev,
- yaffs_file_s *file_struct,
+struct yaffs_tnode *yaffs_find_tnode_0(struct yaffs_dev *dev,
+ struct yaffs_file_var *file_struct,
u32 chunk_id);
-u32 yaffs_get_group_base(struct yaffs_dev *dev, yaffs_tnode_t *tn, unsigned pos);
+u32 yaffs_get_group_base(struct yaffs_dev *dev, struct yaffs_tnode *tn, unsigned pos);
#endif
int nandmtd1_mark_block_bad(struct yaffs_dev *dev, int block_no);
int nandmtd1_query_block(struct yaffs_dev *dev, int block_no,
- yaffs_block_state_t *state, u32 *seq_number);
+ enum yaffs_block_state *state, u32 *seq_number);
#endif
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 = struct yaffs_devo_mtd(dev);
+ struct mtd_info *mtd = yaffs_dev_to_mtd(dev);
int chunk_bytes = dev->data_bytes_per_chunk;
loff_t addr = ((loff_t)nand_chunk) * chunk_bytes;
struct mtd_oob_ops ops;
int nandmtd1_read_chunk_tags(struct yaffs_dev *dev,
int nand_chunk, u8 *data, struct yaffs_ext_tags *etags)
{
- struct mtd_info *mtd = struct yaffs_devo_mtd(dev);
+ struct mtd_info *mtd = yaffs_dev_to_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;
*/
int nandmtd1_mark_block_bad(struct yaffs_dev *dev, int block_no)
{
- struct mtd_info *mtd = struct yaffs_devo_mtd(dev);
+ struct mtd_info *mtd = yaffs_dev_to_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 *dev, int block_no,
- yaffs_block_state_t *state_ptr, u32 *seq_ptr)
+ enum yaffs_block_state *state_ptr, u32 *seq_ptr)
{
- struct mtd_info *mtd = struct yaffs_devo_mtd(dev);
+ struct mtd_info *mtd = yaffs_dev_to_mtd(dev);
int chunk_num = block_no * dev->param.chunks_per_block;
loff_t addr = (loff_t)chunk_num * dev->data_bytes_per_chunk;
struct yaffs_ext_tags etags;
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);
+ enum yaffs_block_state *state, u32 *seq_number);
#endif
const u8 *data,
const struct yaffs_ext_tags *tags)
{
- struct mtd_info *mtd = struct yaffs_devo_mtd(dev);
+ struct mtd_info *mtd = yaffs_dev_to_mtd(dev);
struct mtd_oob_ops ops;
int retval = 0;
int nandmtd2_read_chunk_tags(struct yaffs_dev *dev, int nand_chunk,
u8 *data, struct yaffs_ext_tags *tags)
{
- struct mtd_info *mtd = struct yaffs_devo_mtd(dev);
+ struct mtd_info *mtd = yaffs_dev_to_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 = struct yaffs_devo_lc(dev)->spare_buffer;
+ ops.oobbuf = yaffs_dev_to_lc(dev)->spare_buffer;
retval = mtd->read_oob(mtd, addr, &ops);
}
}
} else {
if (tags) {
- memcpy(packed_tags_ptr, struct yaffs_devo_lc(dev)->spare_buffer, packed_tags_size);
+ memcpy(packed_tags_ptr, yaffs_dev_to_lc(dev)->spare_buffer, packed_tags_size);
yaffs_unpack_tags2(tags, &pt, !dev->param.no_tags_ecc);
}
}
int nandmtd2_mark_block_bad(struct yaffs_dev *dev, int block_no)
{
- struct mtd_info *mtd = struct yaffs_devo_mtd(dev);
+ struct mtd_info *mtd = yaffs_dev_to_mtd(dev);
int retval;
T(YAFFS_TRACE_MTD,
(TSTR("nandmtd2_mark_block_bad %d" TENDSTR), block_no));
}
int nandmtd2_query_block(struct yaffs_dev *dev, int block_no,
- yaffs_block_state_t *state, u32 *seq_number)
+ enum yaffs_block_state *state, u32 *seq_number)
{
- struct mtd_info *mtd = struct yaffs_devo_mtd(dev);
+ struct mtd_info *mtd = yaffs_dev_to_mtd(dev);
int retval;
T(YAFFS_TRACE_MTD,
if (tags &&
tags->ecc_result > YAFFS_ECC_RESULT_NO_ERROR) {
- yaffs_block_info_t *bi;
+ struct yaffs_block_info *bi;
bi = yaffs_get_block_info(dev, nand_chunk/dev->param.chunks_per_block);
yaffs_handle_chunk_error(dev, bi);
}
int yaffs_query_init_block_state(struct yaffs_dev *dev,
int block_no,
- yaffs_block_state_t *state,
+ enum yaffs_block_state *state,
u32 *seq_number)
{
block_no -= dev->block_offset;
int yaffs_query_init_block_state(struct yaffs_dev *dev,
int block_no,
- yaffs_block_state_t *state,
+ enum yaffs_block_state *state,
unsigned *seq_number);
int yaffs_erase_block(struct yaffs_dev *dev,
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;
+ enum yaffs_ecc_result ecc_result = YAFFS_ECC_RESULT_NO_ERROR;
if (pt->t.seq_number != 0xFFFFFFFF &&
tags_ecc){
/********** Tags ECC calculations *********/
-void yaffs_calc_ecc(const u8 *data, yaffs_spare *spare)
+void yaffs_calc_ecc(const u8 *data, struct yaffs_spare *spare)
{
yaffs_ecc_cacl(data, spare->ecc1);
yaffs_ecc_cacl(&data[256], spare->ecc2);
{
/* Calculate an ecc */
- unsigned char *b = ((yaffs_tags_union_t *) tags)->as_bytes;
+ unsigned char *b = ((union yaffs_tags_union *) tags)->as_bytes;
unsigned i, j;
unsigned ecc = 0;
unsigned bit = 0;
if (ecc && ecc <= 64) {
/* TODO: Handle the failure better. Retire? */
- unsigned char *b = ((yaffs_tags_union_t *) tags)->as_bytes;
+ unsigned char *b = ((union yaffs_tags_union *) tags)->as_bytes;
ecc--;
/********** Tags **********/
-static void yaffs_load_tags_to_spare(yaffs_spare *spare_ptr,
+static void yaffs_load_tags_to_spare(struct yaffs_spare *spare_ptr,
struct yaffs_tags *tags_ptr)
{
- yaffs_tags_union_t *tu = (yaffs_tags_union_t *) tags_ptr;
+ union yaffs_tags_union *tu = (union yaffs_tags_union *) tags_ptr;
yaffs_calc_tags_ecc(tags_ptr);
spare_ptr->tb7 = tu->as_bytes[7];
}
-static void yaffs_get_tags_from_spare(struct yaffs_dev *dev, yaffs_spare *spare_ptr,
+static void yaffs_get_tags_from_spare(struct yaffs_dev *dev, struct yaffs_spare *spare_ptr,
struct yaffs_tags *tags_ptr)
{
- yaffs_tags_union_t *tu = (yaffs_tags_union_t *) tags_ptr;
+ union yaffs_tags_union *tu = (union yaffs_tags_union *) tags_ptr;
int result;
tu->as_bytes[0] = spare_ptr->tb0;
dev->n_tags_ecc_unfixed++;
}
-static void yaffs_spare_init(yaffs_spare *spare)
+static void yaffs_spare_init(struct yaffs_spare *spare)
{
- memset(spare, 0xFF, sizeof(yaffs_spare));
+ memset(spare, 0xFF, sizeof(struct yaffs_spare));
}
static int yaffs_wr_nand(struct yaffs_dev *dev,
int nand_chunk, const u8 *data,
- yaffs_spare *spare)
+ struct yaffs_spare *spare)
{
if (nand_chunk < dev->param.start_block * dev->param.chunks_per_block) {
T(YAFFS_TRACE_ERROR,
static int yaffs_rd_chunk_nand(struct yaffs_dev *dev,
int nand_chunk,
u8 *data,
- yaffs_spare *spare,
- yaffs_ecc_result *ecc_result,
+ struct yaffs_spare *spare,
+ enum yaffs_ecc_result *ecc_result,
int correct_errors)
{
int ret_val;
- yaffs_spare local_spare;
+ struct yaffs_spare local_spare;
if (!spare && data) {
/* If we don't have a real spare, then we use a local one. */
memset(&nspare, 0, sizeof(nspare));
ret_val = dev->param.read_chunk_fn(dev, nand_chunk, data,
- (yaffs_spare *) &nspare);
- memcpy(spare, &nspare, sizeof(yaffs_spare));
+ (struct yaffs_spare *) &nspare);
+ memcpy(spare, &nspare, sizeof(struct yaffs_spare));
if (data && correct_errors) {
if (nspare.eccres1 > 0) {
T(YAFFS_TRACE_ERROR,
const u8 *data,
const struct yaffs_ext_tags *ext_tags)
{
- yaffs_spare spare;
+ struct yaffs_spare spare;
struct yaffs_tags tags;
yaffs_spare_init(&spare);
struct yaffs_ext_tags *ext_tags)
{
- yaffs_spare spare;
+ struct yaffs_spare spare;
struct yaffs_tags tags;
- yaffs_ecc_result ecc_result = YAFFS_ECC_RESULT_UNKNOWN;
+ enum yaffs_ecc_result ecc_result = YAFFS_ECC_RESULT_UNKNOWN;
- static yaffs_spare spare_ff;
+ static struct yaffs_spare spare_ff;
static int init;
if (!init) {
int flash_block)
{
- yaffs_spare spare;
+ struct yaffs_spare spare;
- memset(&spare, 0xff, sizeof(yaffs_spare));
+ memset(&spare, 0xff, sizeof(struct yaffs_spare));
spare.block_status = 'Y';
int yaffs_tags_compat_query_block(struct yaffs_dev *dev,
int block_no,
- yaffs_block_state_t *state,
+ enum yaffs_block_state *state,
u32 *seq_number)
{
- yaffs_spare spare0, spare1;
- static yaffs_spare spare_ff;
+ struct yaffs_spare spare0, spare1;
+ static struct yaffs_spare spare_ff;
static int init;
- yaffs_ecc_result dummy;
+ enum yaffs_ecc_result dummy;
if (!init) {
memset(&spare_ff, 0xFF, sizeof(spare_ff));
int block_no);
int yaffs_tags_compat_query_block(struct yaffs_dev *dev,
int block_no,
- yaffs_block_state_t *state,
+ enum yaffs_block_state *state,
u32 *seq_number);
void yaffs_calc_tags_ecc(struct yaffs_tags *tags);
void yaffs_init_tags(struct yaffs_ext_tags *tags)
{
memset(tags, 0, sizeof(struct yaffs_ext_tags));
- tags->validity1 = 0xAAAAAAAA;
- tags->validty1 = 0x55555555;
+ tags->validity0 = 0xAAAAAAAA;
+ tags->validity1 = 0x55555555;
}
int yaffs_validate_tags(struct yaffs_ext_tags *tags)
{
- return (tags->validity1 == 0xAAAAAAAA &&
- tags->validty1 == 0x55555555);
+ return (tags->validity0 == 0xAAAAAAAA &&
+ tags->validity1 == 0x55555555);
}
};
-void yaffs_verify_blk(struct yaffs_dev *dev, yaffs_block_info_t *bi, int n)
+void yaffs_verify_blk(struct yaffs_dev *dev, struct yaffs_block_info *bi, int n)
{
int actually_used;
int in_use;
-void yaffs_verify_collected_blk(struct yaffs_dev *dev, yaffs_block_info_t *bi, int n)
+void yaffs_verify_collected_blk(struct yaffs_dev *dev, struct yaffs_block_info *bi, int n)
{
yaffs_verify_blk(dev, bi, n);
memset(state_count, 0, sizeof(state_count));
for (i = dev->internal_start_block; i <= dev->internal_end_block; i++) {
- yaffs_block_info_t *bi = yaffs_get_block_info(dev, i);
+ struct yaffs_block_info *bi = yaffs_get_block_info(dev, i);
yaffs_verify_blk(dev, bi, i);
if (bi->block_state < YAFFS_NUMBER_OF_BLOCK_STATES)
u32 i;
struct yaffs_dev *dev;
struct yaffs_ext_tags tags;
- yaffs_tnode_t *tn;
+ struct yaffs_tnode *tn;
u32 obj_id;
if (!obj)
#include "yaffs_guts.h"
-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_blk(struct yaffs_dev *dev, struct yaffs_block_info *bi, int n);
+void yaffs_verify_collected_blk(struct yaffs_dev *dev, struct yaffs_block_info *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);
static void yaffs_gross_lock(struct yaffs_dev *dev)
{
T(YAFFS_TRACE_LOCK, (TSTR("yaffs locking %p\n"), current));
- down(&(struct yaffs_devo_lc(dev)->gross_lock));
+ down(&(yaffs_dev_to_lc(dev)->gross_lock));
T(YAFFS_TRACE_LOCK, (TSTR("yaffs locked %p\n"), current));
}
static void yaffs_gross_unlock(struct yaffs_dev *dev)
{
T(YAFFS_TRACE_LOCK, (TSTR("yaffs unlocking %p\n"), current));
- up(&(struct yaffs_devo_lc(dev)->gross_lock));
+ up(&(yaffs_dev_to_lc(dev)->gross_lock));
}
dir->variant.dir_variant.children.next,
struct yaffs_obj,siblings);
YINIT_LIST_HEAD(&sc->others);
- ylist_add(&sc->others,&(struct yaffs_devo_lc(dev)->search_contexts));
+ ylist_add(&sc->others,&(yaffs_dev_to_lc(dev)->search_contexts));
}
return sc;
}
struct ylist_head *i;
struct yaffs_search_context *sc;
- struct ylist_head *search_contexts = &(struct yaffs_devo_lc(obj->my_dev)->search_contexts);
+ struct ylist_head *search_contexts = &(yaffs_dev_to_lc(obj->my_dev)->search_contexts);
/* Iterate through the directory search contexts.
struct yaffs_dev *dev = yaffs_inode_to_obj(dir)->my_dev;
- if(current != struct yaffs_devo_lc(dev)->readdir_process)
+ if(current != yaffs_dev_to_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 != struct yaffs_devo_lc(dev)->readdir_process)
+ if(current != yaffs_dev_to_lc(dev)->readdir_process)
yaffs_gross_unlock(dev);
if (obj) {
yaffs_gross_lock(dev);
- struct yaffs_devo_lc(dev)->readdir_process = current;
+ yaffs_dev_to_lc(dev)->readdir_process = current;
offset = f->f_pos;
out:
yaffs_search_end(sc);
- struct yaffs_devo_lc(dev)->readdir_process = NULL;
+ yaffs_dev_to_lc(dev)->readdir_process = NULL;
yaffs_gross_unlock(dev);
return ret_val;
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 = struct yaffs_devo_lc(dev);
+ struct yaffs_linux_context *context = yaffs_dev_to_lc(dev);
unsigned scattered = 0; /* Free chunks not in an erased block */
if(erased_chunks < dev->n_free_chunks)
static int yaffs_bg_thread_fn(void *data)
{
struct yaffs_dev *dev = (struct yaffs_dev *)data;
- struct yaffs_linux_context *context = struct yaffs_devo_lc(dev);
+ struct yaffs_linux_context *context = yaffs_dev_to_lc(dev);
unsigned long now = jiffies;
unsigned long next_dir_update = now;
unsigned long next_gc = now;
static int yaffs_bg_start(struct yaffs_dev *dev)
{
int retval = 0;
- struct yaffs_linux_context *context = struct yaffs_devo_lc(dev);
+ struct yaffs_linux_context *context = yaffs_dev_to_lc(dev);
if(dev->read_only)
return -1;
static void yaffs_bg_stop(struct yaffs_dev *dev)
{
- struct yaffs_linux_context *ctxt = struct yaffs_devo_lc(dev);
+ struct yaffs_linux_context *ctxt = yaffs_dev_to_lc(dev);
ctxt->bg_running = 0;
yaffs_flush_super(sb,1);
- if (struct yaffs_devo_lc(dev)->put_super_fn)
- struct yaffs_devo_lc(dev)->put_super_fn(sb);
+ if (yaffs_dev_to_lc(dev)->put_super_fn)
+ yaffs_dev_to_lc(dev)->put_super_fn(sb);
yaffs_deinitialise(dev);
yaffs_gross_unlock(dev);
down(&yaffs_context_lock);
- ylist_del_init(&(struct yaffs_devo_lc(dev)->context_list));
+ ylist_del_init(&(yaffs_dev_to_lc(dev)->context_list));
up(&yaffs_context_lock);
- if (struct yaffs_devo_lc(dev)->spare_buffer) {
- YFREE(struct yaffs_devo_lc(dev)->spare_buffer);
- struct yaffs_devo_lc(dev)->spare_buffer = NULL;
+ if (yaffs_dev_to_lc(dev)->spare_buffer) {
+ YFREE(yaffs_dev_to_lc(dev)->spare_buffer);
+ yaffs_dev_to_lc(dev)->spare_buffer = NULL;
}
kfree(dev);
static void yaffs_mtd_put_super(struct super_block *sb)
{
- struct mtd_info *mtd = struct yaffs_devo_mtd(yaffs_super_to_dev(sb));
+ struct mtd_info *mtd = yaffs_dev_to_mtd(yaffs_super_to_dev(sb));
if (mtd->sync)
mtd->sync(mtd);
static void yaffs_touch_super(struct yaffs_dev *dev)
{
- struct super_block *sb = struct yaffs_devo_lc(dev)->super;
+ struct super_block *sb = yaffs_dev_to_lc(dev)->super;
T(YAFFS_TRACE_OS, (TSTR("yaffs_touch_super() sb = %p\n"), sb));
if (sb)
nandmtd2_read_chunk_tags;
param->bad_block_fn = nandmtd2_mark_block_bad;
param->query_block_fn = nandmtd2_query_block;
- struct yaffs_devo_lc(dev)->spare_buffer = YMALLOC(mtd->oobsize);
+ yaffs_dev_to_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;
- struct yaffs_devo_lc(dev)->put_super_fn = yaffs_mtd_put_super;
+ yaffs_dev_to_lc(dev)->put_super_fn = yaffs_mtd_put_super;
param->sb_dirty_fn = yaffs_touch_super;
param->gc_control = yaffs_gc_control_callback;
- struct yaffs_devo_lc(dev)->super= sb;
+ yaffs_dev_to_lc(dev)->super= sb;
#ifndef CONFIG_YAFFS_DOES_ECC
}
context->mount_id = mount_id;
- ylist_add_tail(&(struct yaffs_devo_lc(dev)->context_list), &yaffs_context_list);
+ ylist_add_tail(&(yaffs_dev_to_lc(dev)->context_list), &yaffs_context_list);
up(&yaffs_context_lock);
/* Directory search handling...*/
- YINIT_LIST_HEAD(&(struct yaffs_devo_lc(dev)->search_contexts));
+ YINIT_LIST_HEAD(&(yaffs_dev_to_lc(dev)->search_contexts));
param->remove_obj_fn = yaffs_remove_obj_callback;
- init_MUTEX(&(struct yaffs_devo_lc(dev)->gross_lock));
+ init_MUTEX(&(yaffs_dev_to_lc(dev)->gross_lock));
yaffs_gross_lock(dev);
int chunk;
int c;
int deleted;
- yaffs_block_state_t state;
+ enum yaffs_block_state state;
struct yaffs_obj *hard_list = NULL;
- yaffs_block_info_t *bi;
+ struct yaffs_block_info *bi;
u32 seq_number;
struct yaffs_obj_hdr *oh;
struct yaffs_obj *in;
int alloc_failed = 0;
- struct yaffs_shadow_fixer_s *shadow_fixers = NULL;
+ struct yaffs_shadow_fixer *shadow_fixers = NULL;
u8 *chunk_data;
if (in && oh->shadows_obj > 0) {
- struct yaffs_shadow_fixer_s *fixer;
- fixer = YMALLOC(sizeof(struct yaffs_shadow_fixer_s));
+ struct yaffs_shadow_fixer *fixer;
+ fixer = YMALLOC(sizeof(struct yaffs_shadow_fixer));
if (fixer) {
fixer->next = shadow_fixers;
shadow_fixers = fixer;
/* Fix up any shadowed objects */
{
- struct yaffs_shadow_fixer_s *fixer;
+ struct yaffs_shadow_fixer *fixer;
struct yaffs_obj *obj;
while (shadow_fixers) {
int i;
unsigned seq;
unsigned block_no = 0;
- yaffs_block_info_t *b;
+ struct yaffs_block_info *b;
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(struct yaffs_dev *dev, yaffs_block_info_t *bi)
+void yaffs2_clear_oldest_dirty_seq(struct yaffs_dev *dev, struct yaffs_block_info *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(struct yaffs_dev *dev, unsigned block_no, yaffs_block_info_t *bi)
+void yaffs2_update_oldest_dirty_seq(struct yaffs_dev *dev, unsigned block_no, struct yaffs_block_info *bi)
{
if(!dev->param.is_yaffs2)
return;
}
int yaffs_block_ok_for_gc(struct yaffs_dev *dev,
- yaffs_block_info_t *bi)
+ struct yaffs_block_info *bi)
{
if (!dev->param.is_yaffs2)
u32 oldest = 0;
u32 oldest_seq = 0;
- yaffs_block_info_t *bi;
+ struct yaffs_block_info *bi;
if(!dev->param.is_yaffs2)
return oldest;
int n_blocks;
int dev_blocks = (dev->param.end_block - dev->param.start_block + 1);
- n_bytes += sizeof(yaffs_checkpt_validty_t);
- n_bytes += sizeof(yaffs_checkpt_dev_t);
- n_bytes += dev_blocks * sizeof(yaffs_block_info_t);
+ n_bytes += sizeof(struct yaffs_checkpt_validity);
+ n_bytes += sizeof(struct yaffs_checkpt_dev);
+ n_bytes += dev_blocks * sizeof(struct yaffs_block_info);
n_bytes += dev_blocks * dev->chunk_bit_stride;
- n_bytes += (sizeof(yaffs_checkpt_obj_t) + sizeof(u32)) * (dev->n_obj);
+ n_bytes += (sizeof(struct yaffs_checkpt_obj) + sizeof(u32)) * (dev->n_obj);
n_bytes += (dev->tnode_size + sizeof(u32)) * (dev->n_tnodes);
- n_bytes += sizeof(yaffs_checkpt_validty_t);
+ n_bytes += sizeof(struct yaffs_checkpt_validity);
n_bytes += sizeof(u32); /* checksum*/
/* Round up and add 2 blocks to allow for some bad blocks, so add 3 */
static int yaffs2_wr_checkpt_validity_marker(struct yaffs_dev *dev, int head)
{
- yaffs_checkpt_validty_t cp;
+ struct yaffs_checkpt_validity cp;
memset(&cp, 0, sizeof(cp));
1 : 0;
}
-static int yaffs2_rd_checkpt_validty_marker(struct yaffs_dev *dev, int head)
+static int yaffs2_rd_checkpt_validity_marker(struct yaffs_dev *dev, int head)
{
- yaffs_checkpt_validty_t cp;
+ struct yaffs_checkpt_validity cp;
int ok;
ok = (yaffs2_checkpt_rd(dev, &cp, sizeof(cp)) == sizeof(cp));
return ok ? 1 : 0;
}
-static void yaffs2_dev_to_checkpt_dev(yaffs_checkpt_dev_t *cp,
+static void yaffs2_dev_to_checkpt_dev(struct yaffs_checkpt_dev *cp,
struct yaffs_dev *dev)
{
cp->n_erased_blocks = dev->n_erased_blocks;
}
static void yaffs_checkpt_dev_to_dev(struct yaffs_dev *dev,
- yaffs_checkpt_dev_t *cp)
+ struct yaffs_checkpt_dev *cp)
{
dev->n_erased_blocks = cp->n_erased_blocks;
dev->alloc_block = cp->alloc_block;
static int yaffs2_wr_checkpt_dev(struct yaffs_dev *dev)
{
- yaffs_checkpt_dev_t cp;
+ struct yaffs_checkpt_dev cp;
u32 n_bytes;
u32 n_blocks = (dev->internal_end_block - dev->internal_start_block + 1);
/* Write block info */
if (ok) {
- n_bytes = n_blocks * sizeof(yaffs_block_info_t);
+ n_bytes = n_blocks * sizeof(struct yaffs_block_info);
ok = (yaffs2_checkpt_wr(dev, dev->block_info, n_bytes) == n_bytes);
}
static int yaffs2_rd_checkpt_dev(struct yaffs_dev *dev)
{
- yaffs_checkpt_dev_t cp;
+ struct yaffs_checkpt_dev cp;
u32 n_bytes;
u32 n_blocks = (dev->internal_end_block - dev->internal_start_block + 1);
yaffs_checkpt_dev_to_dev(dev, &cp);
- n_bytes = n_blocks * sizeof(yaffs_block_info_t);
+ n_bytes = n_blocks * sizeof(struct yaffs_block_info);
ok = (yaffs2_checkpt_rd(dev, dev->block_info, n_bytes) == n_bytes);
return ok ? 1 : 0;
}
-static void yaffs2_obj_checkpt_obj(yaffs_checkpt_obj_t *cp,
+static void yaffs2_obj_checkpt_obj(struct yaffs_checkpt_obj *cp,
struct yaffs_obj *obj)
{
cp->size_or_equiv_obj = obj->variant.hardlink_variant.equiv_id;
}
-static int taffs2_checkpt_obj_to_obj(struct yaffs_obj *obj, yaffs_checkpt_obj_t *cp)
+static int taffs2_checkpt_obj_to_obj(struct yaffs_obj *obj, struct yaffs_checkpt_obj *cp)
{
struct yaffs_obj *parent;
-static int yaffs2_checkpt_tnode_worker(struct yaffs_obj *in, yaffs_tnode_t *tn,
+static int yaffs2_checkpt_tnode_worker(struct yaffs_obj *in, struct yaffs_tnode *tn,
u32 level, int chunk_offset)
{
int i;
u32 base_chunk;
int ok = 1;
struct yaffs_dev *dev = obj->my_dev;
- yaffs_file_s *file_stuct_ptr = &obj->variant.file_variant;
- yaffs_tnode_t *tn;
+ struct yaffs_file_var *file_stuct_ptr = &obj->variant.file_variant;
+ struct yaffs_tnode *tn;
int nread = 0;
ok = (yaffs2_checkpt_rd(dev, &base_chunk, sizeof(base_chunk)) == sizeof(base_chunk));
static int yaffs2_wr_checkpt_objs(struct yaffs_dev *dev)
{
struct yaffs_obj *obj;
- yaffs_checkpt_obj_t cp;
+ struct yaffs_checkpt_obj cp;
int i;
int ok = 1;
struct ylist_head *lh;
}
/* Dump end of list */
- memset(&cp, 0xFF, sizeof(yaffs_checkpt_obj_t));
+ memset(&cp, 0xFF, sizeof(struct yaffs_checkpt_obj));
cp.struct_type = sizeof(cp);
if (ok)
static int yaffs2_rd_checkpt_objs(struct yaffs_dev *dev)
{
struct yaffs_obj *obj;
- yaffs_checkpt_obj_t cp;
+ struct yaffs_checkpt_obj cp;
int ok = 1;
int done = 0;
struct yaffs_obj *hard_list = NULL;
if (ok) {
T(YAFFS_TRACE_CHECKPOINT, (TSTR("read checkpoint validity" TENDSTR)));
- ok = yaffs2_rd_checkpt_validty_marker(dev, 1);
+ ok = yaffs2_rd_checkpt_validity_marker(dev, 1);
}
if (ok) {
T(YAFFS_TRACE_CHECKPOINT, (TSTR("read checkpoint device" TENDSTR)));
}
if (ok) {
T(YAFFS_TRACE_CHECKPOINT, (TSTR("read checkpoint validity" TENDSTR)));
- ok = yaffs2_rd_checkpt_validty_marker(dev, 0);
+ ok = yaffs2_rd_checkpt_validity_marker(dev, 0);
}
if (ok) {
int result;
int c;
int deleted;
- yaffs_block_state_t state;
+ enum yaffs_block_state state;
struct yaffs_obj *hard_list = NULL;
- yaffs_block_info_t *bi;
+ struct yaffs_block_info *bi;
u32 seq_number;
struct yaffs_obj_hdr *oh;
struct yaffs_obj *in;
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);
+void yaffs2_clear_oldest_dirty_seq(struct yaffs_dev *dev, struct yaffs_block_info *bi);
+void yaffs2_update_oldest_dirty_seq(struct yaffs_dev *dev, unsigned block_no, struct yaffs_block_info *bi);
+int yaffs_block_ok_for_gc(struct yaffs_dev *dev, struct yaffs_block_info *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);
projects / yaffs2.git / commitdiff