diff options
| author | Charles Manning <cdhmanning@gmail.com> | 2010-10-07 11:10:58 +1300 |
|---|---|---|
| committer | Charles Manning <cdhmanning@gmail.com> | 2010-10-07 11:14:38 +1300 |
| commit | f43976eda35065890e7cf0a008e9518158eb71d6 (patch) | |
| tree | e19e6579100cf68632cb0981f277269e086c039e | |
| parent | 70c6bf2ff57c8a2fb778accdd5b4227abf273674 (diff) | |
yaffs Make more symbol changes
Signed-off-by: Charles Manning <cdhmanning@gmail.com>
64 files changed, 4509 insertions, 4509 deletions
diff --git a/direct/basic-test/dtest.c b/direct/basic-test/dtest.c index f272f0c..779ac15 100644 --- a/direct/basic-test/dtest.c +++ b/direct/basic-test/dtest.c @@ -2642,15 +2642,15 @@ void big_xattr_test(const char *mountpt) } -void dump_dev_stats(yaffs_Device *dev, const char * str) +void dump_dev_stats(yaffs_dev_t *dev, const char * str) { printf("%s\n",str); printf( "space free %d erased %d " "nand reads %d writes %d erases %d " "gc all %d passive %d oldestdirty %d blocks %d copies %d \n", - dev->nFreeChunks, dev->nErasedBlocks * dev->param.nChunksPerBlock, - dev->nPageReads, dev->nPageWrites, dev->nBlockErasures, - dev->allGCs, dev->passiveGCs, dev->oldestDirtyGCs, dev->nGCBlocks, dev->nGCCopies); + dev->n_free_chunks, dev->n_erased_blocks * dev->param.chunks_per_block, + dev->n_page_reads, dev->n_page_writes, dev->n_erasures, + dev->all_gcs, dev->passive_gc_count, dev->oldest_dirty_gc_count, dev->n_gc_blocks, dev->n_gc_copies); } void test_flash_traffic(const char *mountpt) @@ -2658,7 +2658,7 @@ void test_flash_traffic(const char *mountpt) char name0[100]; char name1[100]; int i; - yaffs_Device *dev; + yaffs_dev_t *dev; yaffs_trace_mask = 0; diff --git a/direct/basic-test/yaffs_fileem.c b/direct/basic-test/yaffs_fileem.c index 90c8f9e..419b16f 100644 --- a/direct/basic-test/yaffs_fileem.c +++ b/direct/basic-test/yaffs_fileem.c @@ -62,7 +62,7 @@ typedef struct static yflash_Device filedisk; -static int CheckInit(yaffs_Device *dev) +static int CheckInit(yaffs_dev_t *dev) { static int initialised = 0; @@ -118,7 +118,7 @@ static int CheckInit(yaffs_Device *dev) return 1; } -int yflash_WriteChunkToNAND(yaffs_Device *dev,int chunkInNAND,const __u8 *data, const yaffs_Spare *spare) +int yflash_WriteChunkToNAND(yaffs_dev_t *dev,int nand_chunk,const __u8 *data, const yaffs_spare *spare) { int written; @@ -128,7 +128,7 @@ int yflash_WriteChunkToNAND(yaffs_Device *dev,int chunkInNAND,const __u8 *data, if(data) { - lseek(filedisk.handle,chunkInNAND * 528,SEEK_SET); + lseek(filedisk.handle,nand_chunk * 528,SEEK_SET); written = write(filedisk.handle,data,512); if(written != 512) return YAFFS_FAIL; @@ -136,7 +136,7 @@ int yflash_WriteChunkToNAND(yaffs_Device *dev,int chunkInNAND,const __u8 *data, if(spare) { - lseek(filedisk.handle,chunkInNAND * 528 + 512,SEEK_SET); + lseek(filedisk.handle,nand_chunk * 528 + 512,SEEK_SET); written = write(filedisk.handle,spare,16); if(written != 16) return YAFFS_FAIL; @@ -148,7 +148,7 @@ int yflash_WriteChunkToNAND(yaffs_Device *dev,int chunkInNAND,const __u8 *data, } -int yflash_ReadChunkFromNAND(yaffs_Device *dev,int chunkInNAND, __u8 *data, yaffs_Spare *spare) +int yflash_ReadChunkFromNAND(yaffs_dev_t *dev,int nand_chunk, __u8 *data, yaffs_spare *spare) { int nread; @@ -158,7 +158,7 @@ int yflash_ReadChunkFromNAND(yaffs_Device *dev,int chunkInNAND, __u8 *data, yaff if(data) { - lseek(filedisk.handle,chunkInNAND * 528,SEEK_SET); + lseek(filedisk.handle,nand_chunk * 528,SEEK_SET); nread = read(filedisk.handle,data,512); if(nread != 512) return YAFFS_FAIL; @@ -166,7 +166,7 @@ int yflash_ReadChunkFromNAND(yaffs_Device *dev,int chunkInNAND, __u8 *data, yaff if(spare) { - lseek(filedisk.handle,chunkInNAND * 528 + 512,SEEK_SET); + lseek(filedisk.handle,nand_chunk * 528 + 512,SEEK_SET); nread= read(filedisk.handle,spare,16); if(nread != 16) return YAFFS_FAIL; @@ -178,7 +178,7 @@ int yflash_ReadChunkFromNAND(yaffs_Device *dev,int chunkInNAND, __u8 *data, yaff } -int yflash_EraseBlockInNAND(yaffs_Device *dev, int blockNumber) +int yflash_EraseBlockInNAND(yaffs_dev_t *dev, int blockNumber) { int i; @@ -208,7 +208,7 @@ int yflash_EraseBlockInNAND(yaffs_Device *dev, int blockNumber) } -int yflash_InitialiseNAND(yaffs_Device *dev) +int yflash_InitialiseNAND(yaffs_dev_t *dev) { return YAFFS_OK; diff --git a/direct/basic-test/yaffs_fileem2k.c b/direct/basic-test/yaffs_fileem2k.c index a939e26..ad76c01 100644 --- a/direct/basic-test/yaffs_fileem2k.c +++ b/direct/basic-test/yaffs_fileem2k.c @@ -73,7 +73,7 @@ static int nops_so_far; int ops_multiplier; -static void yflash2_MaybePowerFail(unsigned int chunkInNAND, int failPoint) +static void yflash2_MaybePowerFail(unsigned int nand_chunk, int failPoint) { nops_so_far++; @@ -83,8 +83,8 @@ static void yflash2_MaybePowerFail(unsigned int chunkInNAND, int failPoint) if(simulate_power_failure && remaining_ops < 1){ printf("Simulated power failure after %d operations\n",nops_so_far); - printf(" power failed on chunkInNAND %d, at fail point %d\n", - chunkInNAND, failPoint); + printf(" power failed on nand_chunk %d, at fail point %d\n", + nand_chunk, failPoint); exit(0); } } @@ -171,7 +171,7 @@ int yflash2_GetNumberOfBlocks(void) return filedisk.nBlocks; } -int yflash2_WriteChunkWithTagsToNAND(yaffs_Device *dev,int chunkInNAND,const __u8 *data, const yaffs_ExtendedTags *tags) +int yflash2_WriteChunkWithTagsToNAND(yaffs_dev_t *dev,int nand_chunk,const __u8 *data, const yaffs_ext_tags *tags) { int written; int pos; @@ -180,22 +180,22 @@ int yflash2_WriteChunkWithTagsToNAND(yaffs_Device *dev,int chunkInNAND,const __u int nRead; int error; - T(YAFFS_TRACE_MTD,(TSTR("write chunk %d data %x tags %x" TENDSTR),chunkInNAND,(unsigned)data, (unsigned)tags)); + T(YAFFS_TRACE_MTD,(TSTR("write chunk %d data %x tags %x" TENDSTR),nand_chunk,(unsigned)data, (unsigned)tags)); CheckInit(); - if(dev->param.inbandTags){ + if(dev->param.inband_tags){ yaffs_PackedTags2TagsPart * pt2tp; - pt2tp = (yaffs_PackedTags2TagsPart *)&data[dev->nDataBytesPerChunk]; + pt2tp = (yaffs_PackedTags2TagsPart *)&data[dev->data_bytes_per_chunk]; yaffs_PackTags2TagsPart(pt2tp,tags); - pos = (chunkInNAND % (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE)) * PAGE_SIZE; - h = filedisk.handle[(chunkInNAND / (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE))]; + pos = (nand_chunk % (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE)) * PAGE_SIZE; + h = filedisk.handle[(nand_chunk / (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE))]; lseek(h,pos,SEEK_SET); - written = write(h,data,dev->param.totalBytesPerChunk); + written = write(h,data,dev->param.total_bytes_per_chunk); if(yaffs_test_partial_write){ @@ -203,7 +203,7 @@ int yflash2_WriteChunkWithTagsToNAND(yaffs_Device *dev,int chunkInNAND,const __u exit(1); } - if(written != dev->param.totalBytesPerChunk) return YAFFS_FAIL; + if(written != dev->param.total_bytes_per_chunk) return YAFFS_FAIL; } @@ -215,25 +215,25 @@ int yflash2_WriteChunkWithTagsToNAND(yaffs_Device *dev,int chunkInNAND,const __u if(data) { - pos = (chunkInNAND % (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE)) * PAGE_SIZE; - h = filedisk.handle[(chunkInNAND / (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE))]; + pos = (nand_chunk % (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE)) * PAGE_SIZE; + h = filedisk.handle[(nand_chunk / (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE))]; - memcpy(localBuffer,data, dev->nDataBytesPerChunk); + memcpy(localBuffer,data, dev->data_bytes_per_chunk); n_partials = rand()%20; for(i = 0; i < n_partials; i++){ - bpos = rand() % dev->nDataBytesPerChunk; + bpos = rand() % dev->data_bytes_per_chunk; localBuffer[bpos] |= (1 << (rand() & 7)); } - if(REPORT_ERROR && memcmp(localBuffer,data,dev->nDataBytesPerChunk)) + if(REPORT_ERROR && memcmp(localBuffer,data,dev->data_bytes_per_chunk)) printf("nand simulator: data does not match\n"); lseek(h,pos,SEEK_SET); - written = write(h,localBuffer,dev->nDataBytesPerChunk); + written = write(h,localBuffer,dev->data_bytes_per_chunk); if(yaffs_test_partial_write){ close(h); @@ -241,34 +241,34 @@ int yflash2_WriteChunkWithTagsToNAND(yaffs_Device *dev,int chunkInNAND,const __u } - if(written != dev->nDataBytesPerChunk) return YAFFS_FAIL; + if(written != dev->data_bytes_per_chunk) return YAFFS_FAIL; } - // yflash2_MaybePowerFail(chunkInNAND,1); + // yflash2_MaybePowerFail(nand_chunk,1); if(tags) { - pos = (chunkInNAND % (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE)) * PAGE_SIZE + PAGE_DATA_SIZE ; - h = filedisk.handle[(chunkInNAND / (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE))]; + pos = (nand_chunk % (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE)) * PAGE_SIZE + PAGE_DATA_SIZE ; + h = filedisk.handle[(nand_chunk / (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE))]; lseek(h,pos,SEEK_SET); - if( 0 && dev->param.isYaffs2) + if( 0 && dev->param.is_yaffs2) { - written = write(h,tags,sizeof(yaffs_ExtendedTags)); - if(written != sizeof(yaffs_ExtendedTags)) return YAFFS_FAIL; + written = write(h,tags,sizeof(yaffs_ext_tags)); + if(written != sizeof(yaffs_ext_tags)) return YAFFS_FAIL; } else { yaffs_PackedTags2 pt; - yaffs_PackTags2(&pt,tags, !dev->param.noTagsECC); + yaffs_PackTags2(&pt,tags, !dev->param.no_tags_ecc); __u8 * ptab = (__u8 *)&pt; nRead = read(h,localBuffer,sizeof(pt)); for(i = error = 0; REPORT_ERROR && i < sizeof(pt) && !error; i++){ if(localBuffer[i] != 0xFF){ printf("nand simulation: chunk %d oob byte %d was %0x2\n", - chunkInNAND,i,localBuffer[i]); + nand_chunk,i,localBuffer[i]); error = 1; } } @@ -294,25 +294,25 @@ int yflash2_WriteChunkWithTagsToNAND(yaffs_Device *dev,int chunkInNAND,const __u } } - //yflash2_MaybePowerFail(chunkInNAND,2); + //yflash2_MaybePowerFail(nand_chunk,2); /* Next do the whole write */ if(data) { - pos = (chunkInNAND % (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE)) * PAGE_SIZE; - h = filedisk.handle[(chunkInNAND / (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE))]; + pos = (nand_chunk % (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE)) * PAGE_SIZE; + h = filedisk.handle[(nand_chunk / (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE))]; memset(localBuffer,0xFF, PAGE_SIZE); - for(i = 0; i < dev->nDataBytesPerChunk; i++){ + for(i = 0; i < dev->data_bytes_per_chunk; i++){ localBuffer[i] &= data[i]; } - if(REPORT_ERROR && memcmp(localBuffer,data,dev->nDataBytesPerChunk)) + if(REPORT_ERROR && memcmp(localBuffer,data,dev->data_bytes_per_chunk)) printf("nand simulator: data does not match\n"); lseek(h,pos,SEEK_SET); - written = write(h,localBuffer,dev->nDataBytesPerChunk); + written = write(h,localBuffer,dev->data_bytes_per_chunk); if(yaffs_test_partial_write){ close(h); @@ -320,33 +320,33 @@ int yflash2_WriteChunkWithTagsToNAND(yaffs_Device *dev,int chunkInNAND,const __u } - if(written != dev->nDataBytesPerChunk) return YAFFS_FAIL; + if(written != dev->data_bytes_per_chunk) return YAFFS_FAIL; } if(tags) { - pos = (chunkInNAND % (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE)) * PAGE_SIZE + PAGE_DATA_SIZE ; - h = filedisk.handle[(chunkInNAND / (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE))]; + pos = (nand_chunk % (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE)) * PAGE_SIZE + PAGE_DATA_SIZE ; + h = filedisk.handle[(nand_chunk / (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE))]; lseek(h,pos,SEEK_SET); - if( 0 && dev->param.isYaffs2) + if( 0 && dev->param.is_yaffs2) { - written = write(h,tags,sizeof(yaffs_ExtendedTags)); - if(written != sizeof(yaffs_ExtendedTags)) return YAFFS_FAIL; + written = write(h,tags,sizeof(yaffs_ext_tags)); + if(written != sizeof(yaffs_ext_tags)) return YAFFS_FAIL; } else { yaffs_PackedTags2 pt; - yaffs_PackTags2(&pt,tags,!dev->param.noTagsECC); + yaffs_PackTags2(&pt,tags,!dev->param.no_tags_ecc); __u8 * ptab = (__u8 *)&pt; nRead = read(h,localBuffer,sizeof(pt)); for(i = error = 0; REPORT_ERROR && i < sizeof(pt) && !error; i++){ if(localBuffer[i] != 0xFF){ printf("nand simulation: chunk %d oob byte %d was %0x2\n", - chunkInNAND,i,localBuffer[i]); + nand_chunk,i,localBuffer[i]); error = 1; } } @@ -364,7 +364,7 @@ int yflash2_WriteChunkWithTagsToNAND(yaffs_Device *dev,int chunkInNAND,const __u } } - yflash2_MaybePowerFail(chunkInNAND,3); + yflash2_MaybePowerFail(nand_chunk,3); } return YAFFS_OK; @@ -388,7 +388,7 @@ static int fail320 = 1; static int failRead10 = 2; -int yflash2_ReadChunkWithTagsFromNAND(yaffs_Device *dev,int chunkInNAND, __u8 *data, yaffs_ExtendedTags *tags) +int yflash2_ReadChunkWithTagsFromNAND(yaffs_dev_t *dev,int nand_chunk, __u8 *data, yaffs_ext_tags *tags) { int nread; int pos; @@ -397,14 +397,14 @@ int yflash2_ReadChunkWithTagsFromNAND(yaffs_Device *dev,int chunkInNAND, __u8 *d int retval = YAFFS_OK; int nRead; - T(YAFFS_TRACE_MTD,(TSTR("read chunk %d data %x tags %x" TENDSTR),chunkInNAND,(unsigned)data, (unsigned)tags)); + T(YAFFS_TRACE_MTD,(TSTR("read chunk %d data %x tags %x" TENDSTR),nand_chunk,(unsigned)data, (unsigned)tags)); CheckInit(); - if(dev->param.inbandTags){ + if(dev->param.inband_tags){ /* Got to suck the tags out of the data area */ if(!data) { localData=1; @@ -413,19 +413,19 @@ int yflash2_ReadChunkWithTagsFromNAND(yaffs_Device *dev,int chunkInNAND, __u8 *d yaffs_PackedTags2TagsPart * pt2tp; - pt2tp = (yaffs_PackedTags2TagsPart *)&data[dev->nDataBytesPerChunk]; + pt2tp = (yaffs_PackedTags2TagsPart *)&data[dev->data_bytes_per_chunk]; - pos = (chunkInNAND % (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE)) * PAGE_SIZE; - h = filedisk.handle[(chunkInNAND / (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE))]; + pos = (nand_chunk % (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE)) * PAGE_SIZE; + h = filedisk.handle[(nand_chunk / (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE))]; lseek(h,pos,SEEK_SET); - nRead = read(h, data,dev->param.totalBytesPerChunk); + nRead = read(h, data,dev->param.total_bytes_per_chunk); yaffs_unpack_tags2tags_part(tags,pt2tp); - if(nread != dev->param.totalBytesPerChunk) + if(nread != dev->param.total_bytes_per_chunk) retval = YAFFS_FAIL; if(localData) @@ -440,57 +440,57 @@ int yflash2_ReadChunkWithTagsFromNAND(yaffs_Device *dev,int chunkInNAND, __u8 *d if(data) { - pos = (chunkInNAND % (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE)) * PAGE_SIZE; - h = filedisk.handle[(chunkInNAND / (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE))]; + pos = (nand_chunk % (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE)) * PAGE_SIZE; + h = filedisk.handle[(nand_chunk / (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE))]; lseek(h,pos,SEEK_SET); - nread = read(h,data,dev->nDataBytesPerChunk); + nread = read(h,data,dev->data_bytes_per_chunk); - if(nread != dev->nDataBytesPerChunk) + if(nread != dev->data_bytes_per_chunk) retval = YAFFS_FAIL; } if(tags) { - pos = (chunkInNAND % (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE)) * PAGE_SIZE + PAGE_DATA_SIZE; - h = filedisk.handle[(chunkInNAND / (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE))]; + pos = (nand_chunk % (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE)) * PAGE_SIZE + PAGE_DATA_SIZE; + h = filedisk.handle[(nand_chunk / (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE))]; lseek(h,pos,SEEK_SET); - if(0 && dev->param.isYaffs2) + if(0 && dev->param.is_yaffs2) { - nread= read(h,tags,sizeof(yaffs_ExtendedTags)); - if(nread != sizeof(yaffs_ExtendedTags)) + nread= read(h,tags,sizeof(yaffs_ext_tags)); + if(nread != sizeof(yaffs_ext_tags)) retval = YAFFS_FAIL; - if(yaffs_check_all_ff((__u8 *)tags,sizeof(yaffs_ExtendedTags))) + if(yaffs_check_all_ff((__u8 *)tags,sizeof(yaffs_ext_tags))) { yaffs_init_tags(tags); } else { - tags->chunkUsed = 1; + tags->chunk_used = 1; } } else { yaffs_PackedTags2 pt; nread= read(h,&pt,sizeof(pt)); - yaffs_unpack_tags2(tags,&pt, !dev->param.noTagsECC); + yaffs_unpack_tags2(tags,&pt, !dev->param.no_tags_ecc); #ifdef SIMULATE_FAILURES - if((chunkInNAND >> 6) == 100) { - if(fail300 && tags->eccResult == YAFFS_ECC_RESULT_NO_ERROR){ - tags->eccResult = YAFFS_ECC_RESULT_FIXED; + if((nand_chunk >> 6) == 100) { + if(fail300 && tags->ecc_result == YAFFS_ECC_RESULT_NO_ERROR){ + tags->ecc_result = YAFFS_ECC_RESULT_FIXED; fail300 = 0; } } - if((chunkInNAND >> 6) == 110) { - if(fail320 && tags->eccResult == YAFFS_ECC_RESULT_NO_ERROR){ - tags->eccResult = YAFFS_ECC_RESULT_FIXED; + if((nand_chunk >> 6) == 110) { + if(fail320 && tags->ecc_result == YAFFS_ECC_RESULT_NO_ERROR){ + tags->ecc_result = YAFFS_ECC_RESULT_FIXED; fail320 = 0; } } #endif - if(failRead10>0 && chunkInNAND == 10){ + if(failRead10>0 && nand_chunk == 10){ failRead10--; nread = 0; } @@ -508,7 +508,7 @@ int yflash2_ReadChunkWithTagsFromNAND(yaffs_Device *dev,int chunkInNAND, __u8 *d } -int yflash2_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo) +int yflash2_MarkNANDBlockBad(struct yaffs_dev_s *dev, int block_no) { int written; int h; @@ -518,8 +518,8 @@ int yflash2_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo) CheckInit(); memset(&pt,0,sizeof(pt)); - h = filedisk.handle[(blockNo / ( BLOCKS_PER_HANDLE))]; - lseek(h,((blockNo % BLOCKS_PER_HANDLE) * dev->param.nChunksPerBlock) * PAGE_SIZE + PAGE_DATA_SIZE,SEEK_SET); + h = filedisk.handle[(block_no / ( BLOCKS_PER_HANDLE))]; + lseek(h,((block_no % BLOCKS_PER_HANDLE) * dev->param.chunks_per_block) * PAGE_SIZE + PAGE_DATA_SIZE,SEEK_SET); written = write(h,&pt,sizeof(pt)); if(written != sizeof(pt)) return YAFFS_FAIL; @@ -529,7 +529,7 @@ int yflash2_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo) } -int yflash2_EraseBlockInNAND(yaffs_Device *dev, int blockNumber) +int yflash2_EraseBlockInNAND(yaffs_dev_t *dev, int blockNumber) { int i; @@ -558,8 +558,8 @@ int yflash2_EraseBlockInNAND(yaffs_Device *dev, int blockNumber) h = filedisk.handle[(blockNumber / ( BLOCKS_PER_HANDLE))]; - lseek(h,((blockNumber % BLOCKS_PER_HANDLE) * dev->param.nChunksPerBlock) * PAGE_SIZE,SEEK_SET); - for(i = 0; i < dev->param.nChunksPerBlock; i++) + lseek(h,((blockNumber % BLOCKS_PER_HANDLE) * dev->param.chunks_per_block) * PAGE_SIZE,SEEK_SET); + for(i = 0; i < dev->param.chunks_per_block; i++) { write(h,pg,PAGE_SIZE); } @@ -570,7 +570,7 @@ int yflash2_EraseBlockInNAND(yaffs_Device *dev, int blockNumber) } -int yflash2_InitialiseNAND(yaffs_Device *dev) +int yflash2_InitialiseNAND(yaffs_dev_t *dev) { CheckInit(); @@ -580,28 +580,28 @@ int yflash2_InitialiseNAND(yaffs_Device *dev) -int yflash2_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockNo, yaffs_BlockState *state, __u32 *sequenceNumber) +int yflash2_QueryNANDBlock(struct yaffs_dev_s *dev, int block_no, yaffs_block_state_t *state, __u32 *seq_number) { - yaffs_ExtendedTags tags; + yaffs_ext_tags tags; int chunkNo; - *sequenceNumber = 0; + *seq_number = 0; - chunkNo = blockNo * dev->param.nChunksPerBlock; + chunkNo = block_no * dev->param.chunks_per_block; yflash2_ReadChunkWithTagsFromNAND(dev,chunkNo,NULL,&tags); - if(tags.blockBad) + if(tags.block_bad) { *state = YAFFS_BLOCK_STATE_DEAD; } - else if(!tags.chunkUsed) + else if(!tags.chunk_used) { *state = YAFFS_BLOCK_STATE_EMPTY; } - else if(tags.chunkUsed) + else if(tags.chunk_used) { *state = YAFFS_BLOCK_STATE_NEEDS_SCANNING; - *sequenceNumber = tags.sequenceNumber; + *seq_number = tags.seq_number; } return YAFFS_OK; } diff --git a/direct/basic-test/yaffs_norif1.c b/direct/basic-test/yaffs_norif1.c index 4fcf971..5657c00 100644 --- a/direct/basic-test/yaffs_norif1.c +++ b/direct/basic-test/yaffs_norif1.c @@ -88,7 +88,7 @@ const char *yaffs_norif1_c_version = "$Id: yaffs_norif1.c,v 1.6 2010-02-18 01:18 #define DEVICE_BASE (32 * 1024 * 1024) #endif -__u32 *Block2Addr(yaffs_Device *dev, int blockNumber) +__u32 *Block2Addr(yaffs_dev_t *dev, int blockNumber) { __u32 addr; dev=dev; @@ -99,7 +99,7 @@ __u32 *Block2Addr(yaffs_Device *dev, int blockNumber) return (__u32 *) addr; } -__u32 *Block2FormatAddr(yaffs_Device *dev,int blockNumber) +__u32 *Block2FormatAddr(yaffs_dev_t *dev,int blockNumber) { __u32 addr; @@ -108,14 +108,14 @@ __u32 *Block2FormatAddr(yaffs_Device *dev,int blockNumber) return (__u32 *)addr; } -__u32 *Chunk2DataAddr(yaffs_Device *dev,int chunkId) +__u32 *Chunk2DataAddr(yaffs_dev_t *dev,int chunk_id) { unsigned block; unsigned chunkInBlock; __u32 addr; - block = chunkId/dev->param.nChunksPerBlock; - chunkInBlock = chunkId % dev->param.nChunksPerBlock; + block = chunk_id/dev->param.chunks_per_block; + chunkInBlock = chunk_id % dev->param.chunks_per_block; addr = (__u32) Block2Addr(dev,block); addr += chunkInBlock * DATA_BYTES_PER_CHUNK; @@ -123,14 +123,14 @@ __u32 *Chunk2DataAddr(yaffs_Device *dev,int chunkId) return (__u32 *)addr; } -__u32 *Chunk2SpareAddr(yaffs_Device *dev,int chunkId) +__u32 *Chunk2SpareAddr(yaffs_dev_t *dev,int chunk_id) { unsigned block; unsigned chunkInBlock; __u32 addr; - block = chunkId/dev->param.nChunksPerBlock; - chunkInBlock = chunkId % dev->param.nChunksPerBlock; + block = chunk_id/dev->param.chunks_per_block; + chunkInBlock = chunk_id % dev->param.chunks_per_block; addr = (__u32) Block2Addr(dev,block); addr += SPARE_AREA_OFFSET; @@ -149,12 +149,12 @@ void ynorif1_AndBytes(__u8*target, const __u8 *src, int nbytes) } } -int ynorif1_WriteChunkToNAND(yaffs_Device *dev,int chunkInNAND,const __u8 *data, const yaffs_Spare *spare) +int ynorif1_WriteChunkToNAND(yaffs_dev_t *dev,int nand_chunk,const __u8 *data, const yaffs_spare *spare) { - __u32 *dataAddr = Chunk2DataAddr(dev,chunkInNAND); - __u32 *spareAddr = Chunk2SpareAddr(dev,chunkInNAND); + __u32 *dataAddr = Chunk2DataAddr(dev,nand_chunk); + __u32 *spareAddr = Chunk2SpareAddr(dev,nand_chunk); - yaffs_Spare tmpSpare; + yaffs_spare tmpSpare; /* We should only be getting called for one of 3 reasons: * Writing a chunk: data and spare will not be NULL @@ -162,30 +162,30 @@ int ynorif1_WriteChunkToNAND(yaffs_Device *dev,int chunkInNAND,const __u8 *data, * Writing a bad block marker: data will be NULL, spare not NULL */ - if(sizeof(yaffs_Spare) != 16) + if(sizeof(yaffs_spare) != 16) YBUG(); if(data && spare) { - if(spare->pageStatus != 0xff) + if(spare->page_status != 0xff) YBUG(); /* Write a pre-marker */ memset(&tmpSpare,0xff,sizeof(tmpSpare)); - tmpSpare.pageStatus = YNOR_PREMARKER; - ynorif1_FlashWrite32(spareAddr,(__u32 *)&tmpSpare,sizeof(yaffs_Spare)/4); + tmpSpare.page_status = YNOR_PREMARKER; + ynorif1_FlashWrite32(spareAddr,(__u32 *)&tmpSpare,sizeof(yaffs_spare)/4); /* Write the data */ - ynorif1_FlashWrite32(dataAddr,(__u32 *)data,dev->param.totalBytesPerChunk / 4); + ynorif1_FlashWrite32(dataAddr,(__u32 *)data,dev->param.total_bytes_per_chunk / 4); - memcpy(&tmpSpare,spare,sizeof(yaffs_Spare)); + memcpy(&tmpSpare,spare,sizeof(yaffs_spare)); /* Write the real tags, but override the premarker*/ - tmpSpare.pageStatus = YNOR_PREMARKER; - ynorif1_FlashWrite32(spareAddr,(__u32 *)&tmpSpare,sizeof(yaffs_Spare)/4); + tmpSpare.page_status = YNOR_PREMARKER; + ynorif1_FlashWrite32(spareAddr,(__u32 *)&tmpSpare,sizeof(yaffs_spare)/4); /* Write a post-marker */ - tmpSpare.pageStatus = YNOR_POSTMARKER; + tmpSpare.page_status = YNOR_POSTMARKER; ynorif1_FlashWrite32(spareAddr,(__u32 *)&tmpSpare,sizeof(tmpSpare)/4); } else if(spare){ @@ -193,7 +193,7 @@ int ynorif1_WriteChunkToNAND(yaffs_Device *dev,int chunkInNAND,const __u8 *data, ynorif1_FlashRead32(spareAddr,(__u32 *)&tmpSpare,16/ 4); - ynorif1_AndBytes((__u8 *)&tmpSpare,(__u8 *)spare,sizeof(yaffs_Spare)); + ynorif1_AndBytes((__u8 *)&tmpSpare,(__u8 *)spare,sizeof(yaffs_spare)); ynorif1_FlashWrite32(spareAddr,(__u32 *)&tmpSpare,16/ 4); } @@ -206,15 +206,15 @@ int ynorif1_WriteChunkToNAND(yaffs_Device *dev,int chunkInNAND,const __u8 *data, } -int ynorif1_ReadChunkFromNAND(yaffs_Device *dev,int chunkInNAND, __u8 *data, yaffs_Spare *spare) +int ynorif1_ReadChunkFromNAND(yaffs_dev_t *dev,int nand_chunk, __u8 *data, yaffs_spare *spare) { - __u32 *dataAddr = Chunk2DataAddr(dev,chunkInNAND); - __u32 *spareAddr = Chunk2SpareAddr(dev,chunkInNAND); + __u32 *dataAddr = Chunk2DataAddr(dev,nand_chunk); + __u32 *spareAddr = Chunk2SpareAddr(dev,nand_chunk); if(data) { - ynorif1_FlashRead32(dataAddr,(__u32 *)data,dev->param.totalBytesPerChunk / 4); + ynorif1_FlashRead32(dataAddr,(__u32 *)data,dev->param.total_bytes_per_chunk / 4); } if(spare) @@ -224,11 +224,11 @@ int ynorif1_ReadChunkFromNAND(yaffs_Device *dev,int chunkInNAND, __u8 *data, yaf /* If the page status is YNOR_POSTMARKER then it was written properly * so change that to 0xFF so that the rest of yaffs is happy. */ - if(spare->pageStatus == YNOR_POSTMARKER) - spare->pageStatus = 0xFF; - else if(spare->pageStatus != 0xff && - (spare->pageStatus | YNOR_PREMARKER) != 0xff) - spare->pageStatus = YNOR_PREMARKER; + if(spare->page_status == YNOR_POSTMARKER) + spare->page_status = 0xFF; + else if(spare->page_status != 0xff && + (spare->page_status | YNOR_PREMARKER) != 0xff) + spare->page_status = YNOR_PREMARKER; } @@ -236,7 +236,7 @@ int ynorif1_ReadChunkFromNAND(yaffs_Device *dev,int chunkInNAND, __u8 *data, yaf } -static int ynorif1_FormatBlock(yaffs_Device *dev, int blockNumber) +static int ynorif1_FormatBlock(yaffs_dev_t *dev, int blockNumber) { __u32 *blockAddr = Block2Addr(dev,blockNumber); __u32 *formatAddr = Block2FormatAddr(dev,blockNumber); @@ -248,7 +248,7 @@ static int ynorif1_FormatBlock(yaffs_Device *dev, int blockNumber) return YAFFS_OK; } -static int ynorif1_UnformatBlock(yaffs_Device *dev, int blockNumber) +static int ynorif1_UnformatBlock(yaffs_dev_t *dev, int blockNumber) { __u32 *formatAddr = Block2FormatAddr(dev,blockNumber); __u32 formatValue = 0; @@ -258,7 +258,7 @@ static int ynorif1_UnformatBlock(yaffs_Device *dev, int blockNumber) return YAFFS_OK; } -static int ynorif1_IsBlockFormatted(yaffs_Device *dev, int blockNumber) +static int ynorif1_IsBlockFormatted(yaffs_dev_t *dev, int blockNumber) { __u32 *formatAddr = Block2FormatAddr(dev,blockNumber); __u32 formatValue; @@ -269,7 +269,7 @@ static int ynorif1_IsBlockFormatted(yaffs_Device *dev, int blockNumber) return (formatValue == FORMAT_VALUE); } -int ynorif1_EraseBlockInNAND(yaffs_Device *dev, int blockNumber) +int ynorif1_EraseBlockInNAND(yaffs_dev_t *dev, int blockNumber) { if(blockNumber < 0 || blockNumber >= BLOCKS_IN_DEVICE) @@ -286,13 +286,13 @@ int ynorif1_EraseBlockInNAND(yaffs_Device *dev, int blockNumber) } -int ynorif1_InitialiseNAND(yaffs_Device *dev) +int ynorif1_InitialiseNAND(yaffs_dev_t *dev) { int i; ynorif1_FlashInit(); /* Go through the blocks formatting them if they are not formatted */ - for(i = dev->param.startBlock; i <= dev->param.endBlock; i++){ + for(i = dev->param.start_block; i <= dev->param.end_block; i++){ if(!ynorif1_IsBlockFormatted(dev,i)){ ynorif1_FormatBlock(dev,i); } @@ -300,7 +300,7 @@ int ynorif1_InitialiseNAND(yaffs_Device *dev) return YAFFS_OK; } -int ynorif1_DeinitialiseNAND(yaffs_Device *dev) +int ynorif1_Deinitialise_flash_fn(yaffs_dev_t *dev) { dev=dev; ynorif1_FlashDeinit(); diff --git a/direct/basic-test/yaffs_norif1.h b/direct/basic-test/yaffs_norif1.h index 2ab11d2..ac78423 100644 --- a/direct/basic-test/yaffs_norif1.h +++ b/direct/basic-test/yaffs_norif1.h @@ -19,11 +19,11 @@ #include "yaffs_guts.h" -int ynorif1_WriteChunkToNAND(yaffs_Device *dev,int chunkInNAND,const __u8 *data, const yaffs_Spare *spare); -int ynorif1_ReadChunkFromNAND(yaffs_Device *dev,int chunkInNAND, __u8 *data, yaffs_Spare *spare); -int ynorif1_EraseBlockInNAND(yaffs_Device *dev, int blockNumber); -int ynorif1_InitialiseNAND(yaffs_Device *dev); -int ynorif1_DeinitialiseNAND(yaffs_Device *dev); +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); #endif diff --git a/direct/basic-test/yaffs_ramdisk.c b/direct/basic-test/yaffs_ramdisk.c index 9ca963b..f6e7773 100644 --- a/direct/basic-test/yaffs_ramdisk.c +++ b/direct/basic-test/yaffs_ramdisk.c @@ -15,7 +15,7 @@ * yaffs_ramdisk.c: yaffs ram disk component * This provides a ram disk under yaffs. * NB this is not intended for NAND emulation. - * Use this with dev->useNANDECC enabled, then ECC overheads are not required. + * Use this with dev->use_nand_ecc enabled, then ECC overheads are not required. */ const char *yaffs_ramdisk_c_version = "$Id: yaffs_ramdisk.c,v 1.6 2010-01-11 04:06:47 charles Exp $"; @@ -61,7 +61,7 @@ typedef struct static yramdisk_device ramdisk; -static int CheckInit(yaffs_Device *dev) +static int CheckInit(yaffs_dev_t *dev) { static int initialised = 0; @@ -119,7 +119,7 @@ static int CheckInit(yaffs_Device *dev) return 1; } -int yramdisk_wr_chunk(yaffs_Device *dev,int chunkInNAND,const __u8 *data, const yaffs_ExtendedTags *tags) +int yramdisk_wr_chunk(yaffs_dev_t *dev,int nand_chunk,const __u8 *data, const yaffs_ext_tags *tags) { int blk; int pg; @@ -127,8 +127,8 @@ int yramdisk_wr_chunk(yaffs_Device *dev,int chunkInNAND,const __u8 *data, const CheckInit(dev); - blk = chunkInNAND/32; - pg = chunkInNAND%32; + blk = nand_chunk/32; + pg = nand_chunk%32; if(data) @@ -150,7 +150,7 @@ int yramdisk_wr_chunk(yaffs_Device *dev,int chunkInNAND,const __u8 *data, const } -int yramdisk_rd_chunk(yaffs_Device *dev,int chunkInNAND, __u8 *data, yaffs_ExtendedTags *tags) +int yramdisk_rd_chunk(yaffs_dev_t *dev,int nand_chunk, __u8 *data, yaffs_ext_tags *tags) { int blk; int pg; @@ -158,8 +158,8 @@ int yramdisk_rd_chunk(yaffs_Device *dev,int chunkInNAND, __u8 *data, yaffs_Exten CheckInit(dev); - blk = chunkInNAND/32; - pg = chunkInNAND%32; + blk = nand_chunk/32; + pg = nand_chunk%32; if(data) @@ -181,7 +181,7 @@ int yramdisk_rd_chunk(yaffs_Device *dev,int chunkInNAND, __u8 *data, yaffs_Exten } -int yramdisk_check_chunk_erased(yaffs_Device *dev,int chunkInNAND) +int yramdisk_check_chunk_erased(yaffs_dev_t *dev,int nand_chunk) { int blk; int pg; @@ -190,8 +190,8 @@ int yramdisk_check_chunk_erased(yaffs_Device *dev,int chunkInNAND) CheckInit(dev); - blk = chunkInNAND/32; - pg = chunkInNAND%32; + blk = nand_chunk/32; + pg = nand_chunk%32; for(i = 0; i < 528; i++) @@ -206,7 +206,7 @@ int yramdisk_check_chunk_erased(yaffs_Device *dev,int chunkInNAND) } -int yramdisk_erase(yaffs_Device *dev, int blockNumber) +int yramdisk_erase(yaffs_dev_t *dev, int blockNumber) { CheckInit(dev); @@ -224,9 +224,9 @@ int yramdisk_erase(yaffs_Device *dev, int blockNumber) } -int yramdisk_initialise(yaffs_Device *dev) +int yramdisk_initialise(yaffs_dev_t *dev) { - //dev->useNANDECC = 1; // force on useNANDECC which gets faked. + //dev->use_nand_ecc = 1; // force on use_nand_ecc which gets faked. // This saves us doing ECC checks. return YAFFS_OK; diff --git a/direct/basic-test/yaffs_ramdisk.h b/direct/basic-test/yaffs_ramdisk.h index 772743e..c250bcc 100644 --- a/direct/basic-test/yaffs_ramdisk.h +++ b/direct/basic-test/yaffs_ramdisk.h @@ -22,10 +22,10 @@ #include "yaffs_guts.h" -int yramdisk_erase(yaffs_Device *dev, int blockNumber); -int yramdisk_wr_chunk(yaffs_Device *dev,int chunkInNAND,const __u8 *data, const yaffs_ExtendedTags *tags); -int yramdisk_rd_chunk(yaffs_Device *dev,int chunkInNAND, __u8 *data, yaffs_ExtendedTags *tags); -int yramdisk_initialise(yaffs_Device *dev); -int yramdisk_mark_block_bad(yaffs_Device *dev,int blockNumber); -int yramdisk_query_block(yaffs_Device *dev, int blockNo, yaffs_BlockState *state, int *sequenceNumber); +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); #endif diff --git a/direct/basic-test/yaffs_ramem2k.c b/direct/basic-test/yaffs_ramem2k.c index f0b7c71..9bf673a 100644 --- a/direct/basic-test/yaffs_ramem2k.c +++ b/direct/basic-test/yaffs_ramem2k.c @@ -191,7 +191,7 @@ static int CheckInit(void) return 1; } -int nandemul2k_WriteChunkWithTagsToNAND(yaffs_Device *dev,int chunkInNAND,const __u8 *data, const yaffs_ExtendedTags *tags) +int nandemul2k_WriteChunkWithTagsToNAND(yaffs_dev_t *dev,int nand_chunk,const __u8 *data, const yaffs_ext_tags *tags) { int blk; int pg; @@ -200,8 +200,8 @@ int nandemul2k_WriteChunkWithTagsToNAND(yaffs_Device *dev,int chunkInNAND,const __u8 *x; - blk = chunkInNAND/PAGES_PER_BLOCK; - pg = chunkInNAND%PAGES_PER_BLOCK; + blk = nand_chunk/PAGES_PER_BLOCK; + pg = nand_chunk%PAGES_PER_BLOCK; if(data) @@ -221,7 +221,7 @@ int nandemul2k_WriteChunkWithTagsToNAND(yaffs_Device *dev,int chunkInNAND,const { x = &ned.block[blk]->page[pg]->data[PAGE_DATA_SIZE]; - yaffs_PackTags2((yaffs_PackedTags2 *)x,tags, !dev->param.noTagsECC); + yaffs_PackTags2((yaffs_PackedTags2 *)x,tags, !dev->param.no_tags_ecc); } @@ -234,7 +234,7 @@ int nandemul2k_WriteChunkWithTagsToNAND(yaffs_Device *dev,int chunkInNAND,const } -int nandemul2k_ReadChunkWithTagsFromNAND(yaffs_Device *dev,int chunkInNAND, __u8 *data, yaffs_ExtendedTags *tags) +int nandemul2k_ReadChunkWithTagsFromNAND(yaffs_dev_t *dev,int nand_chunk, __u8 *data, yaffs_ext_tags *tags) { int blk; int pg; @@ -243,8 +243,8 @@ int nandemul2k_ReadChunkWithTagsFromNAND(yaffs_Device *dev,int chunkInNAND, __u8 - blk = chunkInNAND/PAGES_PER_BLOCK; - pg = chunkInNAND%PAGES_PER_BLOCK; + blk = nand_chunk/PAGES_PER_BLOCK; + pg = nand_chunk%PAGES_PER_BLOCK; if(data) @@ -257,14 +257,14 @@ int nandemul2k_ReadChunkWithTagsFromNAND(yaffs_Device *dev,int chunkInNAND, __u8 { x = &ned.block[blk]->page[pg]->data[PAGE_DATA_SIZE]; - yaffs_unpack_tags2(tags,(yaffs_PackedTags2 *)x, !dev->param.noTagsECC); + yaffs_unpack_tags2(tags,(yaffs_PackedTags2 *)x, !dev->param.no_tags_ecc); } return YAFFS_OK; } -static int nandemul2k_CheckChunkErased(yaffs_Device *dev,int chunkInNAND) +static int nandemul2k_CheckChunkErased(yaffs_dev_t *dev,int nand_chunk) { int blk; int pg; @@ -272,8 +272,8 @@ static int nandemul2k_CheckChunkErased(yaffs_Device *dev,int chunkInNAND) - blk = chunkInNAND/PAGES_PER_BLOCK; - pg = chunkInNAND%PAGES_PER_BLOCK; + blk = nand_chunk/PAGES_PER_BLOCK; + pg = nand_chunk%PAGES_PER_BLOCK; for(i = 0; i < PAGE_TOTAL_SIZE; i++) @@ -288,7 +288,7 @@ static int nandemul2k_CheckChunkErased(yaffs_Device *dev,int chunkInNAND) } -int nandemul2k_EraseBlockInNAND(yaffs_Device *dev, int blockNumber) +int nandemul2k_EraseBlockInNAND(yaffs_dev_t *dev, int blockNumber) { @@ -308,18 +308,18 @@ int nandemul2k_EraseBlockInNAND(yaffs_Device *dev, int blockNumber) return YAFFS_OK; } -int nandemul2k_InitialiseNAND(yaffs_Device *dev) +int nandemul2k_InitialiseNAND(yaffs_dev_t *dev) { CheckInit(); return YAFFS_OK; } -int nandemul2k_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo) +int nandemul2k_MarkNANDBlockBad(struct yaffs_dev_s *dev, int block_no) { __u8 *x; - x = &ned.block[blockNo]->page[0]->data[PAGE_DATA_SIZE]; + x = &ned.block[block_no]->page[0]->data[PAGE_DATA_SIZE]; memset(x,0,sizeof(yaffs_PackedTags2)); @@ -328,28 +328,28 @@ int nandemul2k_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo) } -int nandemul2k_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockNo, yaffs_BlockState *state, __u32 *sequenceNumber) +int nandemul2k_QueryNANDBlock(struct yaffs_dev_s *dev, int block_no, yaffs_block_state_t *state, __u32 *seq_number) { - yaffs_ExtendedTags tags; + yaffs_ext_tags tags; int chunkNo; - *sequenceNumber = 0; + *seq_number = 0; - chunkNo = blockNo * dev->param.nChunksPerBlock; + chunkNo = block_no * dev->param.chunks_per_block; nandemul2k_ReadChunkWithTagsFromNAND(dev,chunkNo,NULL,&tags); - if(tags.blockBad) + if(tags.block_bad) { *state = YAFFS_BLOCK_STATE_DEAD; } - else if(!tags.chunkUsed) + else if(!tags.chunk_used) { *state = YAFFS_BLOCK_STATE_EMPTY; } - else if(tags.chunkUsed) + else if(tags.chunk_used) { *state = YAFFS_BLOCK_STATE_NEEDS_SCANNING; - *sequenceNumber = tags.sequenceNumber; + *seq_number = tags.seq_number; } return YAFFS_OK; } diff --git a/direct/basic-test/yaffscfg.c b/direct/basic-test/yaffscfg.c index c2ac04f..590cb87 100644 --- a/direct/basic-test/yaffscfg.c +++ b/direct/basic-test/yaffscfg.c @@ -67,16 +67,16 @@ void yaffsfs_LocalInitialisation(void) // /boot 2MB boot disk (flash) // /flash 14MB flash disk (flash) // NB Though /boot and /flash occupy the same physical device they -// are still disticnt "yaffs_Devices. You may think of these as "partitions" +// are still disticnt "yaffs_dev_ts. 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_Device ramDev; -static yaffs_Device bootDev; -static yaffs_Device flashDev; +static yaffs_dev_t ramDev; +static yaffs_dev_t bootDev; +static yaffs_dev_t flashDev; static yaffsfs_DeviceConfiguration yaffsfs_config[] = { @@ -99,46 +99,46 @@ int yaffs_start_up(void) // Set up devices // /ram - ramDev.nDataBytesPerChunk = 512; - ramDev.nChunksPerBlock = 32; - ramDev.nReservedBlocks = 2; // Set this smaller for RAM - ramDev.startBlock = 1; // Can't use block 0 - ramDev.endBlock = 127; // Last block in 2MB. - ramDev.useNANDECC = 1; - ramDev.nShortOpCaches = 0; // Disable caching on this device. + ramDev.data_bytes_per_chunk = 512; + ramDev.chunks_per_block = 32; + ramDev.n_reserved_blocks = 2; // Set this smaller for RAM + ramDev.start_block = 1; // Can't use block 0 + ramDev.end_block = 127; // Last block in 2MB. + ramDev.use_nand_ecc = 1; + ramDev.n_caches = 0; // Disable caching on this device. ramDev.genericDevice = (void *) 0; // Used to identify the device in fstat. - ramDev.writeChunkWithTagsToNAND = yramdisk_wr_chunk; - ramDev.readChunkWithTagsFromNAND = yramdisk_rd_chunk; - ramDev.eraseBlockInNAND = yramdisk_erase; - ramDev.initialiseNAND = yramdisk_initialise; + ramDev.write_chunk_tags_fn = yramdisk_wr_chunk; + ramDev.read_chunk_tags_fn = yramdisk_rd_chunk; + ramDev.erase_fn = yramdisk_erase; + ramDev.initialise_flash_fn = yramdisk_initialise; // /boot - bootDev.nDataBytesPerChunk = 512; - bootDev.nChunksPerBlock = 32; - bootDev.nReservedBlocks = 5; - bootDev.startBlock = 1; // Can't use block 0 - bootDev.endBlock = 127; // Last block in 2MB. - bootDev.useNANDECC = 0; // use YAFFS's ECC - bootDev.nShortOpCaches = 10; // Use caches + bootDev.data_bytes_per_chunk = 512; + bootDev.chunks_per_block = 32; + bootDev.n_reserved_blocks = 5; + bootDev.start_block = 1; // Can't use block 0 + bootDev.end_block = 127; // Last block in 2MB. + bootDev.use_nand_ecc = 0; // use YAFFS's ECC + bootDev.n_caches = 10; // Use caches bootDev.genericDevice = (void *) 1; // Used to identify the device in fstat. - bootDev.writeChunkToNAND = yflash_WriteChunkToNAND; - bootDev.readChunkFromNAND = yflash_ReadChunkFromNAND; - bootDev.eraseBlockInNAND = yflash_EraseBlockInNAND; - bootDev.initialiseNAND = yflash_InitialiseNAND; + bootDev.write_chunk_fn = yflash_WriteChunkToNAND; + bootDev.read_chunk_fn = yflash_ReadChunkFromNAND; + bootDev.erase_fn = yflash_EraseBlockInNAND; + bootDev.initialise_flash_fn = yflash_InitialiseNAND; // /flash - flashDev.nDataBytesPerChunk = 512; - flashDev.nChunksPerBlock = 32; - flashDev.nReservedBlocks = 5; - flashDev.startBlock = 128; // First block after 2MB - flashDev.endBlock = 1023; // Last block in 16MB - flashDev.useNANDECC = 0; // use YAFFS's ECC - flashDev.nShortOpCaches = 10; // Use caches + flashDev.data_bytes_per_chunk = 512; + flashDev.chunks_per_block = 32; + flashDev.n_reserved_blocks = 5; + flashDev.start_block = 128; // First block after 2MB + flashDev.end_block = 1023; // Last block in 16MB + flashDev.use_nand_ecc = 0; // use YAFFS's ECC + flashDev.n_caches = 10; // Use caches flashDev.genericDevice = (void *) 2; // Used to identify the device in fstat. - flashDev.writeChunkToNAND = yflash_WriteChunkToNAND; - flashDev.readChunkFromNAND = yflash_ReadChunkFromNAND; - flashDev.eraseBlockInNAND = yflash_EraseBlockInNAND; - flashDev.initialiseNAND = yflash_InitialiseNAND; + flashDev.write_chunk_fn = yflash_WriteChunkToNAND; + flashDev.read_chunk_fn = yflash_ReadChunkFromNAND; + flashDev.erase_fn = yflash_EraseBlockInNAND; + flashDev.initialise_flash_fn = yflash_InitialiseNAND; yaffs_initialise(yaffsfs_config); #endif diff --git a/direct/basic-test/yaffscfg2k.c b/direct/basic-test/yaffscfg2k.c index 57ec4a9..de8953e 100644 --- a/direct/basic-test/yaffscfg2k.c +++ b/direct/basic-test/yaffscfg2k.c @@ -106,9 +106,9 @@ void yaffsfs_LocalInitialisation(void) #include "yaffs_flashif2.h" #include "yaffs_nandemul2k.h" -struct yaffs_DeviceStruct ram1Dev; -struct yaffs_DeviceStruct flashDev; -struct yaffs_DeviceStruct m18_1Dev; +struct yaffs_dev_s ram1Dev; +struct yaffs_dev_s flashDev; +struct yaffs_dev_s m18_1Dev; int yaffs_start_up(void) { @@ -120,39 +120,39 @@ int yaffs_start_up(void) // /ram1 ram, yaffs1 memset(&ram1Dev,0,sizeof(ram1Dev)); ram1Dev.param.name = "ram1"; - ram1Dev.param.totalBytesPerChunk = 512; - ram1Dev.param.nChunksPerBlock = 32; - ram1Dev.param.nReservedBlocks = 2; // Set this smaller for RAM - ram1Dev.param.startBlock = 0; // Can use block 0 - ram1Dev.param.endBlock = 127; // Last block in 2MB. - //ram1Dev.param.useNANDECC = 1; - ram1Dev.param.nShortOpCaches = 0; // Disable caching on this device. - ram1Dev.driverContext = (void *) 0; // Used to identify the device in fstat. - ram1Dev.param.writeChunkWithTagsToNAND = yramdisk_wr_chunk; - ram1Dev.param.readChunkWithTagsFromNAND = yramdisk_rd_chunk; - ram1Dev.param.eraseBlockInNAND = yramdisk_erase; - ram1Dev.param.initialiseNAND = yramdisk_initialise; + ram1Dev.param.total_bytes_per_chunk = 512; + ram1Dev.param.chunks_per_block = 32; + ram1Dev.param.n_reserved_blocks = 2; // Set this smaller for RAM + ram1Dev.param.start_block = 0; // Can use block 0 + ram1Dev.param.end_block = 127; // Last block in 2MB. + //ram1Dev.param.use_nand_ecc = 1; + ram1Dev.param.n_caches = 0; // Disable caching on this device. + ram1Dev.driver_context = (void *) 0; // Used to identify the device in fstat. + ram1Dev.param.write_chunk_tags_fn = yramdisk_wr_chunk; + ram1Dev.param.read_chunk_tags_fn = yramdisk_rd_chunk; + ram1Dev.param.erase_fn = yramdisk_erase; + ram1Dev.param.initialise_flash_fn = yramdisk_initialise; yaffs_add_device(&ram1Dev); // /M18-1 yaffs1 on M18 nor sim memset(&m18_1Dev,0,sizeof(m18_1Dev)); m18_1Dev.param.name = "M18-1"; - m18_1Dev.param.totalBytesPerChunk = 1024; - m18_1Dev.param.nChunksPerBlock =248; - m18_1Dev.param.nReservedBlocks = 2; - m18_1Dev.param.startBlock = 0; // Can use block 0 - m18_1Dev.param.endBlock = 31; // Last block - m18_1Dev.param.useNANDECC = 0; // use YAFFS's ECC - m18_1Dev.param.nShortOpCaches = 10; // Use caches - m18_1Dev.driverContext = (void *) 1; // Used to identify the device in fstat. - m18_1Dev.param.writeChunkToNAND = ynorif1_WriteChunkToNAND; - m18_1Dev.param.readChunkFromNAND = ynorif1_ReadChunkFromNAND; - m18_1Dev.param.eraseBlockInNAND = ynorif1_EraseBlockInNAND; - m18_1Dev.param.initialiseNAND = ynorif1_InitialiseNAND; - m18_1Dev.param.deinitialiseNAND = ynorif1_DeinitialiseNAND; - -// m18_1Dev.param.disableSoftDelete = 1; + m18_1Dev.param.total_bytes_per_chunk = 1024; + m18_1Dev.param.chunks_per_block =248; + m18_1Dev.param.n_reserved_blocks = 2; + m18_1Dev.param.start_block = 0; // Can use block 0 + m18_1Dev.param.end_block = 31; // Last block + m18_1Dev.param.use_nand_ecc = 0; // use YAFFS's ECC + m18_1Dev.param.n_caches = 10; // Use caches + m18_1Dev.driver_context = (void *) 1; // Used to identify the device in fstat. + m18_1Dev.param.write_chunk_fn = ynorif1_WriteChunkToNAND; + m18_1Dev.param.read_chunk_fn = ynorif1_ReadChunkFromNAND; + m18_1Dev.param.erase_fn = ynorif1_EraseBlockInNAND; + m18_1Dev.param.initialise_flash_fn = ynorif1_InitialiseNAND; + m18_1Dev.param.deinitialise_flash_fn = ynorif1_Deinitialise_flash_fn; + +// m18_1Dev.param.disable_soft_del = 1; yaffs_add_device(&m18_1Dev); @@ -161,25 +161,25 @@ int yaffs_start_up(void) // memset(&flashDev,0,sizeof(flashDev)); flashDev.param.name = "yaffs2"; - flashDev.param.totalBytesPerChunk = 2048; - flashDev.param.nChunksPerBlock = 64; - flashDev.param.nReservedBlocks = 5; - flashDev.param.inbandTags = 0; - flashDev.param.startBlock = 0; - flashDev.param.endBlock = yflash2_GetNumberOfBlocks()-1; - flashDev.param.isYaffs2 = 1; - flashDev.param.useNANDECC=1; - flashDev.param.wideTnodesDisabled=0; - flashDev.param.refreshPeriod = 1000; - flashDev.param.nShortOpCaches = 10; // Use caches - flashDev.driverContext = (void *) 2; // Used to identify the device in fstat. - flashDev.param.writeChunkWithTagsToNAND = yflash2_WriteChunkWithTagsToNAND; - flashDev.param.readChunkWithTagsFromNAND = yflash2_ReadChunkWithTagsFromNAND; - flashDev.param.eraseBlockInNAND = yflash2_EraseBlockInNAND; - flashDev.param.initialiseNAND = yflash2_InitialiseNAND; - flashDev.param.markNANDBlockBad = yflash2_MarkNANDBlockBad; - flashDev.param.queryNANDBlock = yflash2_QueryNANDBlock; - flashDev.param.enableXattr = 1; + flashDev.param.total_bytes_per_chunk = 2048; + flashDev.param.chunks_per_block = 64; + flashDev.param.n_reserved_blocks = 5; + flashDev.param.inband_tags = 0; + flashDev.param.start_block = 0; + flashDev.param.end_block = yflash2_GetNumberOfBlocks()-1; + flashDev.param.is_yaffs2 = 1; + flashDev.param.use_nand_ecc=1; + flashDev.param.wide_tnodes_disabled=0; + flashDev.param.refresh_period = 1000; + flashDev.param.n_caches = 10; // Use caches + flashDev.driver_context = (void *) 2; // Used to identify the device in fstat. + flashDev.param.write_chunk_tags_fn = yflash2_WriteChunkWithTagsToNAND; + flashDev.param.read_chunk_tags_fn = yflash2_ReadChunkWithTagsFromNAND; + flashDev.param.erase_fn = yflash2_EraseBlockInNAND; + flashDev.param.initialise_flash_fn = yflash2_InitialiseNAND; + flashDev.param.bad_block_fn = yflash2_MarkNANDBlockBad; + flashDev.param.query_block_fn = yflash2_QueryNANDBlock; + flashDev.param.enable_xattr = 1; yaffs_add_device(&flashDev); diff --git a/direct/basic-test/yramsim.c b/direct/basic-test/yramsim.c index 48509c7..0a50fcf 100644 --- a/direct/basic-test/yramsim.c +++ b/direct/basic-test/yramsim.c @@ -26,9 +26,9 @@ typedef struct { SimData *simDevs[N_RAM_SIM_DEVS]; -static SimData *DevToSim(yaffs_Device *dev) +static SimData *DevToSim(yaffs_dev_t *dev) { - ynandif_Geometry *geom = (ynandif_Geometry *)(dev->driverContext); + ynandif_Geometry *geom = (ynandif_Geometry *)(dev->driver_context); SimData * sim = (SimData*)(geom->privateData); return sim; } @@ -62,7 +62,7 @@ static int yramsim_erase_internal(SimData *sim, unsigned blockId,int force) -static int yramsim_initialise(yaffs_Device *dev) +static int yramsim_initialise(yaffs_dev_t *dev) { SimData *sim = DevToSim(dev); Block **blockList = sim->blockList; @@ -70,12 +70,12 @@ static int yramsim_initialise(yaffs_Device *dev) } -static int yramsim_deinitialise(yaffs_Device *dev) +static int yramsim_deinitialise(yaffs_dev_t *dev) { return 1; } -static int yramsim_rd_chunk (yaffs_Device *dev, unsigned pageId, +static int yramsim_rd_chunk (yaffs_dev_t *dev, unsigned pageId, unsigned char *data, unsigned dataLength, unsigned char *spare, unsigned spareLength, int *eccStatus) @@ -110,7 +110,7 @@ static int yramsim_rd_chunk (yaffs_Device *dev, unsigned pageId, return 1; } -static int yramsim_wr_chunk (yaffs_Device *dev,unsigned pageId, +static int yramsim_wr_chunk (yaffs_dev_t *dev,unsigned pageId, const unsigned char *data, unsigned dataLength, const unsigned char *spare, unsigned spareLength) { @@ -142,7 +142,7 @@ static int yramsim_wr_chunk (yaffs_Device *dev,unsigned pageId, } -static int yramsim_erase(yaffs_Device *dev,unsigned blockId) +static int yramsim_erase(yaffs_dev_t *dev,unsigned blockId) { SimData *sim = DevToSim(dev); @@ -150,7 +150,7 @@ static int yramsim_erase(yaffs_Device *dev,unsigned blockId) return yramsim_erase_internal(sim,blockId,0); } -static int yramsim_check_block_ok(yaffs_Device *dev,unsigned blockId) +static int yramsim_check_block_ok(yaffs_dev_t *dev,unsigned blockId) { SimData *sim = DevToSim(dev); Block **blockList = sim->blockList; @@ -161,7 +161,7 @@ static int yramsim_check_block_ok(yaffs_Device *dev,unsigned blockId) return blockList[blockId]->blockOk ? 1 : 0; } -static int yramsim_mark_block_bad(yaffs_Device *dev,unsigned blockId) +static int yramsim_mark_block_bad(yaffs_dev_t *dev,unsigned blockId) { SimData *sim = DevToSim(dev); Block **blockList = sim->blockList; @@ -236,9 +236,9 @@ static SimData *yramsim_alloc_sim_data(__u32 devId, __u32 nBlocks) } -struct yaffs_DeviceStruct *yramsim_CreateRamSim(const YCHAR *name, +struct yaffs_dev_s *yramsim_CreateRamSim(const YCHAR *name, __u32 devId, __u32 nBlocks, - __u32 startBlock, __u32 endBlock) + __u32 start_block, __u32 end_block) { SimData *sim; ynandif_Geometry *g; @@ -253,19 +253,19 @@ struct yaffs_DeviceStruct *yramsim_CreateRamSim(const YCHAR *name, return NULL; } - if(startBlock >= sim->nBlocks) - startBlock = 0; - if(endBlock == 0 || endBlock >= sim->nBlocks) - endBlock = sim->nBlocks - 1; + if(start_block >= sim->nBlocks) + start_block = 0; + if(end_block == 0 || end_block >= sim->nBlocks) + end_block = sim->nBlocks - 1; memset(g,0,sizeof(ynandif_Geometry)); - g->startBlock = startBlock; - g->endBlock = endBlock; + g->start_block = start_block; + g->end_block = end_block; g->dataSize = DATA_SIZE; g->spareSize= SPARE_SIZE; g->pagesPerBlock = PAGES_PER_BLOCK; g->hasECC = 1; - g->inbandTags = 0; + g->inband_tags = 0; g->useYaffs2 = 1; g->initialise = yramsim_initialise; g->deinitialise = yramsim_deinitialise; diff --git a/direct/basic-test/yramsim.h b/direct/basic-test/yramsim.h index 81a7d87..4f20364 100644 --- a/direct/basic-test/yramsim.h +++ b/direct/basic-test/yramsim.h @@ -23,9 +23,9 @@ #define N_RAM_SIM_DEVS 2 -struct yaffs_DeviceStruct *yramsim_CreateRamSim(const YCHAR *name, +struct yaffs_dev_s *yramsim_CreateRamSim(const YCHAR *name, __u32 devId, __u32 nBlocks, - __u32 startBlock, __u32 endBlock); + __u32 start_block, __u32 end_block); #endif diff --git a/direct/tests/nor_stress.c b/direct/tests/nor_stress.c index 20df837..730bd43 100644 --- a/direct/tests/nor_stress.c +++ b/direct/tests/nor_stress.c @@ -87,9 +87,9 @@ void MakeFullNames(const char *prefix) MakeName(fullTempMainName,prefix,"tmp-main"); } -static void FatalError(int lineNo) +static void FatalError(int line_no) { - printf("Integrity error %d\n",lineNo); + printf("Integrity error %d\n",line_no); if(fuzz_test) return; diff --git a/direct/yaffs_flashif.c b/direct/yaffs_flashif.c index b7ee482..79732a1 100644 --- a/direct/yaffs_flashif.c +++ b/direct/yaffs_flashif.c @@ -50,7 +50,7 @@ typedef struct static yflash_Device ramdisk; -static int CheckInit(yaffs_Device *dev) +static int CheckInit(yaffs_dev_t *dev) { static int initialised = 0; @@ -108,7 +108,7 @@ static int CheckInit(yaffs_Device *dev) return 1; } -int yflash_WriteChunkWithTagsToNAND(yaffs_Device *dev,int chunkInNAND,const __u8 *data, yaffs_ExtendedTags *tags) +int yflash_WriteChunkWithTagsToNAND(yaffs_dev_t *dev,int nand_chunk,const __u8 *data, yaffs_ext_tags *tags) { int blk; int pg; @@ -116,8 +116,8 @@ int yflash_WriteChunkWithTagsToNAND(yaffs_Device *dev,int chunkInNAND,const __u8 CheckInit(dev); - blk = chunkInNAND/32; - pg = chunkInNAND%32; + blk = nand_chunk/32; + pg = nand_chunk%32; if(data) @@ -138,7 +138,7 @@ int yflash_WriteChunkWithTagsToNAND(yaffs_Device *dev,int chunkInNAND,const __u8 } -int yflash_ReadChunkWithTagsFromNAND(yaffs_Device *dev,int chunkInNAND, __u8 *data, yaffs_Tags *tags) +int yflash_ReadChunkWithTagsFromNAND(yaffs_dev_t *dev,int nand_chunk, __u8 *data, yaffs_tags_t *tags) { int blk; int pg; @@ -146,8 +146,8 @@ int yflash_ReadChunkWithTagsFromNAND(yaffs_Device *dev,int chunkInNAND, __u8 *da CheckInit(dev); - blk = chunkInNAND/32; - pg = chunkInNAND%32; + blk = nand_chunk/32; + pg = nand_chunk%32; if(data) @@ -167,7 +167,7 @@ int yflash_ReadChunkWithTagsFromNAND(yaffs_Device *dev,int chunkInNAND, __u8 *da } -int yflash_CheckChunkErased(yaffs_Device *dev,int chunkInNAND) +int yflash_CheckChunkErased(yaffs_dev_t *dev,int nand_chunk) { int blk; int pg; @@ -176,8 +176,8 @@ int yflash_CheckChunkErased(yaffs_Device *dev,int chunkInNAND) CheckInit(dev); - blk = chunkInNAND/32; - pg = chunkInNAND%32; + blk = nand_chunk/32; + pg = nand_chunk%32; for(i = 0; i < 528; i++) @@ -192,7 +192,7 @@ int yflash_CheckChunkErased(yaffs_Device *dev,int chunkInNAND) } -int yflash_EraseBlockInNAND(yaffs_Device *dev, int blockNumber) +int yflash_EraseBlockInNAND(yaffs_dev_t *dev, int blockNumber) { CheckInit(dev); @@ -210,19 +210,19 @@ int yflash_EraseBlockInNAND(yaffs_Device *dev, int blockNumber) } -int yflash_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo) +int yflash_MarkNANDBlockBad(struct yaffs_dev_s *dev, int block_no) { return YAFFS_OK; } -int yflash_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockNo, yaffs_BlockState *state, int *sequenceNumber) +int yflash_QueryNANDBlock(struct yaffs_dev_s *dev, int block_no, yaffs_block_state_t *state, int *seq_number) { *state = YAFFS_BLOCK_STATE_EMPTY; - *sequenceNumber = 0; + *seq_number = 0; } -int yflash_InitialiseNAND(yaffs_Device *dev) +int yflash_InitialiseNAND(yaffs_dev_t *dev) { return YAFFS_OK; } diff --git a/direct/yaffs_flashif.h b/direct/yaffs_flashif.h index eec2842..bc3ed70 100644 --- a/direct/yaffs_flashif.h +++ b/direct/yaffs_flashif.h @@ -18,13 +18,13 @@ #include "yaffs_guts.h" -int yflash_EraseBlockInNAND(yaffs_Device *dev, int blockNumber); -int yflash_WriteChunkToNAND(yaffs_Device *dev,int chunkInNAND,const __u8 *data, const yaffs_Spare *spare); -int yflash_WriteChunkWithTagsToNAND(yaffs_Device *dev,int chunkInNAND,const __u8 *data, const yaffs_ExtendedTags *tags); -int yflash_ReadChunkFromNAND(yaffs_Device *dev,int chunkInNAND, __u8 *data, yaffs_Spare *spare); -int yflash_ReadChunkWithTagsFromNAND(yaffs_Device *dev,int chunkInNAND, __u8 *data, yaffs_ExtendedTags *tags); -int yflash_InitialiseNAND(yaffs_Device *dev); -int yflash_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo); -int yflash_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockNo, yaffs_BlockState *state, __u32 *sequenceNumber); +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); #endif diff --git a/direct/yaffs_flashif2.h b/direct/yaffs_flashif2.h index 3d4e1fd..de82085 100644 --- a/direct/yaffs_flashif2.h +++ b/direct/yaffs_flashif2.h @@ -18,14 +18,14 @@ #include "yaffs_guts.h" -int yflash2_EraseBlockInNAND(yaffs_Device *dev, int blockNumber); -int yflash2_WriteChunkToNAND(yaffs_Device *dev,int chunkInNAND,const __u8 *data, const yaffs_Spare *spare); -int yflash2_WriteChunkWithTagsToNAND(yaffs_Device *dev,int chunkInNAND,const __u8 *data, const yaffs_ExtendedTags *tags); -int yflash2_ReadChunkFromNAND(yaffs_Device *dev,int chunkInNAND, __u8 *data, yaffs_Spare *spare); -int yflash2_ReadChunkWithTagsFromNAND(yaffs_Device *dev,int chunkInNAND, __u8 *data, yaffs_ExtendedTags *tags); -int yflash2_EraseBlockInNAND(yaffs_Device *dev, int blockNumber); -int yflash2_InitialiseNAND(yaffs_Device *dev); -int yflash2_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo); -int yflash2_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockNo, yaffs_BlockState *state, __u32 *sequenceNumber); +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); #endif diff --git a/direct/yaffs_nandif.c b/direct/yaffs_nandif.c index b0c9bd8..8a8f3fb 100644 --- a/direct/yaffs_nandif.c +++ b/direct/yaffs_nandif.c @@ -29,21 +29,21 @@ * 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_Device * dev, int chunkInNAND, +int ynandif_WriteChunkWithTagsToNAND(yaffs_dev_t * dev, int nand_chunk, const __u8 * data, - const yaffs_ExtendedTags * tags) + const yaffs_ext_tags * tags) { int retval = 0; yaffs_PackedTags2 pt; void *spare; unsigned spareSize = 0; - ynandif_Geometry *geometry = (ynandif_Geometry *)(dev->driverContext); + ynandif_Geometry *geometry = (ynandif_Geometry *)(dev->driver_context); T(YAFFS_TRACE_MTD, (TSTR ("nandmtd2_WriteChunkWithTagsToNAND chunk %d data %p tags %p" - TENDSTR), chunkInNAND, data, tags)); + TENDSTR), nand_chunk, data, tags)); /* For yaffs2 writing there must be both data and tags. @@ -51,27 +51,27 @@ int ynandif_WriteChunkWithTagsToNAND(yaffs_Device * dev, int chunkInNAND, * the end of the data buffer. */ - if(dev->param.inbandTags){ + if(dev->param.inband_tags){ yaffs_PackedTags2TagsPart *pt2tp; - pt2tp = (yaffs_PackedTags2TagsPart *)(data + dev->nDataBytesPerChunk); + pt2tp = (yaffs_PackedTags2TagsPart *)(data + dev->data_bytes_per_chunk); yaffs_PackTags2TagsPart(pt2tp,tags); spare = NULL; spareSize = 0; } else{ - yaffs_PackTags2(&pt, tags,!dev->param.noTagsECC); + yaffs_PackTags2(&pt, tags,!dev->param.no_tags_ecc); spare = &pt; spareSize = sizeof(yaffs_PackedTags2); } - retval = geometry->writeChunk(dev,chunkInNAND, - data, dev->param.totalBytesPerChunk, spare, spareSize); + retval = geometry->writeChunk(dev,nand_chunk, + data, dev->param.total_bytes_per_chunk, spare, spareSize); return retval; } -int ynandif_ReadChunkWithTagsFromNAND(yaffs_Device * dev, int chunkInNAND, - __u8 * data, yaffs_ExtendedTags * tags) +int ynandif_ReadChunkWithTagsFromNAND(yaffs_dev_t * dev, int nand_chunk, + __u8 * data, yaffs_ext_tags * tags) { yaffs_PackedTags2 pt; int localData = 0; @@ -79,17 +79,17 @@ int ynandif_ReadChunkWithTagsFromNAND(yaffs_Device * dev, int chunkInNAND, unsigned spareSize; int retval = 0; int eccStatus; //0 = ok, 1 = fixed, -1 = unfixed - ynandif_Geometry *geometry = (ynandif_Geometry *)(dev->driverContext); + ynandif_Geometry *geometry = (ynandif_Geometry *)(dev->driver_context); T(YAFFS_TRACE_MTD, (TSTR ("nandmtd2_ReadChunkWithTagsFromNAND chunk %d data %p tags %p" - TENDSTR), chunkInNAND, data, tags)); + TENDSTR), nand_chunk, data, tags)); if(!tags){ spare = NULL; spareSize = 0; - }else if(dev->param.inbandTags){ + }else if(dev->param.inband_tags){ if(!data) { localData = 1; @@ -103,34 +103,34 @@ int ynandif_ReadChunkWithTagsFromNAND(yaffs_Device * dev, int chunkInNAND, spareSize = sizeof(yaffs_PackedTags2); } - retval = geometry->readChunk(dev,chunkInNAND, + retval = geometry->readChunk(dev,nand_chunk, data, - data ? dev->param.totalBytesPerChunk : 0, + data ? dev->param.total_bytes_per_chunk : 0, spare,spareSize, &eccStatus); - if(dev->param.inbandTags){ + if(dev->param.inband_tags){ if(tags){ yaffs_PackedTags2TagsPart * pt2tp; - pt2tp = (yaffs_PackedTags2TagsPart *)&data[dev->nDataBytesPerChunk]; + pt2tp = (yaffs_PackedTags2TagsPart *)&data[dev->data_bytes_per_chunk]; yaffs_unpack_tags2tags_part(tags,pt2tp); } } else { if (tags){ - yaffs_unpack_tags2(tags, &pt,!dev->param.noTagsECC); + yaffs_unpack_tags2(tags, &pt,!dev->param.no_tags_ecc); } } - if(tags && tags->chunkUsed){ + if(tags && tags->chunk_used){ if(eccStatus < 0 || - tags->eccResult == YAFFS_ECC_RESULT_UNFIXED) - tags->eccResult = YAFFS_ECC_RESULT_UNFIXED; + tags->ecc_result == YAFFS_ECC_RESULT_UNFIXED) + tags->ecc_result = YAFFS_ECC_RESULT_UNFIXED; else if(eccStatus > 0 || - tags->eccResult == YAFFS_ECC_RESULT_FIXED) - tags->eccResult = YAFFS_ECC_RESULT_FIXED; + tags->ecc_result == YAFFS_ECC_RESULT_FIXED) + tags->ecc_result = YAFFS_ECC_RESULT_FIXED; else - tags->eccResult = YAFFS_ECC_RESULT_NO_ERROR; + tags->ecc_result = YAFFS_ECC_RESULT_NO_ERROR; } if(localData) @@ -139,37 +139,37 @@ int ynandif_ReadChunkWithTagsFromNAND(yaffs_Device * dev, int chunkInNAND, return retval; } -int ynandif_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockId) +int ynandif_MarkNANDBlockBad(struct yaffs_dev_s *dev, int blockId) { - ynandif_Geometry *geometry = (ynandif_Geometry *)(dev->driverContext); + ynandif_Geometry *geometry = (ynandif_Geometry *)(dev->driver_context); return geometry->markBlockBad(dev,blockId); } -int ynandif_EraseBlockInNAND(struct yaffs_DeviceStruct *dev, int blockId) +int ynandif_EraseBlockInNAND(struct yaffs_dev_s *dev, int blockId) { - ynandif_Geometry *geometry = (ynandif_Geometry *)(dev->driverContext); + ynandif_Geometry *geometry = (ynandif_Geometry *)(dev->driver_context); return geometry->eraseBlock(dev,blockId); } -static int ynandif_IsBlockOk(struct yaffs_DeviceStruct *dev, int blockId) +static int ynandif_IsBlockOk(struct yaffs_dev_s *dev, int blockId) { - ynandif_Geometry *geometry = (ynandif_Geometry *)(dev->driverContext); + ynandif_Geometry *geometry = (ynandif_Geometry *)(dev->driver_context); return geometry->checkBlockOk(dev,blockId); } -int ynandif_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockId, yaffs_BlockState *state, __u32 *sequenceNumber) +int ynandif_QueryNANDBlock(struct yaffs_dev_s *dev, int blockId, yaffs_block_state_t *state, __u32 *seq_number) { unsigned chunkNo; - yaffs_ExtendedTags tags; + yaffs_ext_tags tags; - *sequenceNumber = 0; + *seq_number = 0; - chunkNo = blockId * dev->param.nChunksPerBlock; + chunkNo = blockId * dev->param.chunks_per_block; if(!ynandif_IsBlockOk(dev,blockId)){ *state = YAFFS_BLOCK_STATE_DEAD; @@ -178,14 +178,14 @@ int ynandif_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockId, yaffs_Bl { ynandif_ReadChunkWithTagsFromNAND(dev,chunkNo,NULL,&tags); - if(!tags.chunkUsed) + if(!tags.chunk_used) { *state = YAFFS_BLOCK_STATE_EMPTY; } else { *state = YAFFS_BLOCK_STATE_NEEDS_SCANNING; - *sequenceNumber = tags.sequenceNumber; + *seq_number = tags.seq_number; } } @@ -193,18 +193,18 @@ int ynandif_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockId, yaffs_Bl } -int ynandif_InitialiseNAND(yaffs_Device *dev) +int ynandif_InitialiseNAND(yaffs_dev_t *dev) { - ynandif_Geometry *geometry = (ynandif_Geometry *)(dev->driverContext); + ynandif_Geometry *geometry = (ynandif_Geometry *)(dev->driver_context); geometry->initialise(dev); return YAFFS_OK; } -int ynandif_DeinitialiseNAND(yaffs_Device *dev) +int ynandif_Deinitialise_flash_fn(yaffs_dev_t *dev) { - ynandif_Geometry *geometry = (ynandif_Geometry *)(dev->driverContext); + ynandif_Geometry *geometry = (ynandif_Geometry *)(dev->driver_context); geometry->deinitialise(dev); @@ -212,35 +212,35 @@ int ynandif_DeinitialiseNAND(yaffs_Device *dev) } -struct yaffs_DeviceStruct * +struct yaffs_dev_s * 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_DeviceStruct *dev = YMALLOC(sizeof(struct yaffs_DeviceStruct)); + struct yaffs_dev_s *dev = YMALLOC(sizeof(struct yaffs_dev_s)); if(dev && clonedName){ - memset(dev,0,sizeof(struct yaffs_DeviceStruct)); + memset(dev,0,sizeof(struct yaffs_dev_s)); yaffs_strcpy(clonedName,name); dev->param.name = clonedName; - dev->param.writeChunkWithTagsToNAND = ynandif_WriteChunkWithTagsToNAND; - dev->param.readChunkWithTagsFromNAND = ynandif_ReadChunkWithTagsFromNAND; - dev->param.eraseBlockInNAND = ynandif_EraseBlockInNAND; - dev->param.initialiseNAND = ynandif_InitialiseNAND; - dev->param.queryNANDBlock = ynandif_QueryNANDBlock; - dev->param.markNANDBlockBad = ynandif_MarkNANDBlockBad; - dev->param.nShortOpCaches = 20; - dev->param.startBlock = geometry->startBlock; - dev->param.endBlock = geometry->endBlock; - dev->param.totalBytesPerChunk = geometry->dataSize; - dev->param.spareBytesPerChunk = geometry->spareSize; - dev->param.inbandTags = geometry->inbandTags; - dev->param.nChunksPerBlock = geometry->pagesPerBlock; - dev->param.useNANDECC = geometry->hasECC; - dev->param.isYaffs2 = geometry->useYaffs2; - dev->param.nReservedBlocks = 5; - dev->driverContext = (void *)geometry; + dev->param.write_chunk_tags_fn = ynandif_WriteChunkWithTagsToNAND; + dev->param.read_chunk_tags_fn = ynandif_ReadChunkWithTagsFromNAND; + dev->param.erase_fn = ynandif_EraseBlockInNAND; + dev->param.initialise_flash_fn = ynandif_InitialiseNAND; + dev->param.query_block_fn = ynandif_QueryNANDBlock; + dev->param.bad_block_fn = ynandif_MarkNANDBlockBad; + dev->param.n_caches = 20; + dev->param.start_block = geometry->start_block; + dev->param.end_block = geometry->end_block; + dev->param.total_bytes_per_chunk = geometry->dataSize; + dev->param.spare_bytes_per_chunk = geometry->spareSize; + dev->param.inband_tags = geometry->inband_tags; + dev->param.chunks_per_block = geometry->pagesPerBlock; + dev->param.use_nand_ecc = geometry->hasECC; + dev->param.is_yaffs2 = geometry->useYaffs2; + dev->param.n_reserved_blocks = 5; + dev->driver_context = (void *)geometry; yaffs_add_device(dev); diff --git a/direct/yaffs_nandif.h b/direct/yaffs_nandif.h index 9009b62..c38834d 100644 --- a/direct/yaffs_nandif.h +++ b/direct/yaffs_nandif.h @@ -21,52 +21,52 @@ typedef struct { - unsigned startBlock; - unsigned endBlock; + unsigned start_block; + unsigned end_block; unsigned dataSize; unsigned spareSize; unsigned pagesPerBlock; unsigned hasECC; - unsigned inbandTags; + unsigned inband_tags; unsigned useYaffs2; - int (*initialise)(yaffs_Device *dev); - int (*deinitialise)(yaffs_Device *dev); + int (*initialise)(yaffs_dev_t *dev); + int (*deinitialise)(yaffs_dev_t *dev); - int (*readChunk) (yaffs_Device *dev, + int (*readChunk) (yaffs_dev_t *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_Device *dev, + int (*writeChunk)(yaffs_dev_t *dev, unsigned pageId, const unsigned char *data, unsigned dataLength, const unsigned char *spare, unsigned spareLength); - int (*eraseBlock)(yaffs_Device *dev, unsigned blockId); + int (*eraseBlock)(yaffs_dev_t *dev, unsigned blockId); - int (*checkBlockOk)(yaffs_Device *dev, unsigned blockId); - int (*markBlockBad)(yaffs_Device *dev, unsigned blockId); + int (*checkBlockOk)(yaffs_dev_t *dev, unsigned blockId); + int (*markBlockBad)(yaffs_dev_t *dev, unsigned blockId); void *privateData; } ynandif_Geometry; -struct yaffs_DeviceStruct * +struct yaffs_dev_s * yaffs_add_dev_from_geometry(const YCHAR *name, const ynandif_Geometry *geometry); #if 0 -int ynandif_WriteChunkWithTagsToNAND(yaffs_Device *dev,int chunkInNAND,const __u8 *data, const yaffs_ExtendedTags *tags); -int ynandif_ReadChunkWithTagsFromNAND(yaffs_Device *dev,int chunkInNAND, __u8 *data, yaffs_ExtendedTags *tags); -int ynandif_EraseBlockInNAND(yaffs_Device *dev, int blockNumber); -int ynandif_InitialiseNAND(yaffs_Device *dev); -int ynandif_MarkNANDBlockBad(yaffs_Device *dev,int blockNumber); -int ynandif_QueryNANDBlock(yaffs_Device *dev, int blockNo, yaffs_BlockState *state, __u32 *sequenceNumber); -int ynandif_GetGeometry(yaffs_Device *dev, ynandif_Geometry *geometry); +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); #endif diff --git a/direct/yaffscfg.h b/direct/yaffscfg.h index a14797f..c4cd48b 100644 --- a/direct/yaffscfg.h +++ b/direct/yaffscfg.h @@ -31,7 +31,7 @@ typedef struct yaffsfs_DeviceConfigurationStruct { const YCHAR *prefix; - struct yaffs_DeviceStruct *dev; + struct yaffs_dev_s *dev; } yaffsfs_DeviceConfiguration; diff --git a/direct/yaffsfs.c b/direct/yaffsfs.c index b8e49bb..191ac8d 100644 --- a/direct/yaffsfs.c +++ b/direct/yaffsfs.c @@ -31,8 +31,8 @@ #define YAFFSFS_RW_SIZE (1<<YAFFSFS_RW_SHIFT) /* Some forward references */ -static yaffs_Object *yaffsfs_FindObject(yaffs_Object *relativeDirectory, const YCHAR *path, int symDepth); -static void yaffsfs_RemoveObjectCallback(yaffs_Object *obj); +static yaffs_obj_t *yaffsfs_FindObject(yaffs_obj_t *relativeDirectory, const YCHAR *path, int symDepth); +static void yaffsfs_RemoveObjectCallback(yaffs_obj_t *obj); unsigned int yaffs_wr_attempts; @@ -49,7 +49,7 @@ unsigned int yaffs_wr_attempts; typedef struct { int count; /* Number of handles accessing this inode */ - yaffs_Object *iObj; + yaffs_obj_t *iObj; } yaffsfs_Inode; typedef struct{ @@ -102,7 +102,7 @@ yaffsfs_Inode *yaffsfs_GetInodePointer(int handle) return NULL; } -yaffs_Object *yaffsfs_GetHandleObject(int handle) +yaffs_obj_t *yaffsfs_GetHandleObject(int handle) { yaffsfs_Inode *in = yaffsfs_GetInodePointer(handle); @@ -117,7 +117,7 @@ yaffs_Object *yaffsfs_GetHandleObject(int handle) * Find the inode entry for an object, if it exists. */ -static int yaffsfs_FindInodeIdForObject(yaffs_Object *obj) +static int yaffsfs_FindInodeIdForObject(yaffs_obj_t *obj) { int i; int ret = -1; @@ -137,7 +137,7 @@ static int yaffsfs_FindInodeIdForObject(yaffs_Object *obj) * yaffsfs_GetInodeIdForObject * Grab an inode entry when opening a new inode. */ -static int yaffsfs_GetInodeIdForObject(yaffs_Object *obj) +static int yaffsfs_GetInodeIdForObject(yaffs_obj_t *obj) { int i; int ret; @@ -166,7 +166,7 @@ static int yaffsfs_GetInodeIdForObject(yaffs_Object *obj) } -static int yaffsfs_CountHandles(yaffs_Object *obj) +static int yaffsfs_CountHandles(yaffs_obj_t *obj) { int i = yaffsfs_FindInodeIdForObject(obj); @@ -178,14 +178,14 @@ static int yaffsfs_CountHandles(yaffs_Object *obj) static void yaffsfs_ReleaseInode(yaffsfs_Inode *in) { - yaffs_Object *obj; + yaffs_obj_t *obj; obj = in->iObj; if(obj->unlinked) yaffs_del_obj(obj); - obj->myInode = NULL; + obj->my_inode = NULL; in->iObj = NULL; } @@ -299,13 +299,13 @@ YLIST_HEAD(yaffsfs_deviceList); * Curveballs: Should match paths that end in '/' too * Curveball2 Might have "/x/ and "/x/y". Need to return the longest match */ -static yaffs_Device *yaffsfs_FindDevice(const YCHAR *path, YCHAR **restOfPath) +static yaffs_dev_t *yaffsfs_FindDevice(const YCHAR *path, YCHAR **restOfPath) { struct ylist_head *cfg; const YCHAR *leftOver; const YCHAR *p; - yaffs_Device *retval = NULL; - yaffs_Device *dev = NULL; + yaffs_dev_t *retval = NULL; + yaffs_dev_t *dev = NULL; int thisMatchLength; int longestMatch = -1; int matching; @@ -316,7 +316,7 @@ static yaffs_Device *yaffsfs_FindDevice(const YCHAR *path, YCHAR **restOfPath) * 2) Matches the longest. */ ylist_for_each(cfg, &yaffsfs_deviceList){ - dev = ylist_entry(cfg, yaffs_Device, devList); + dev = ylist_entry(cfg, yaffs_dev_t, dev_list); leftOver = path; p = dev->param.name; thisMatchLength = 0; @@ -371,12 +371,12 @@ static yaffs_Device *yaffsfs_FindDevice(const YCHAR *path, YCHAR **restOfPath) } #if 0 -static yaffs_Device *yaffsfs_FindDevice(const YCHAR *path, YCHAR **restOfPath) +static yaffs_dev_t *yaffsfs_FindDevice(const YCHAR *path, YCHAR **restOfPath) { yaffsfs_DeviceConfiguration *cfg = yaffsfs_configurationList; const YCHAR *leftOver; const YCHAR *p; - yaffs_Device *retval = NULL; + yaffs_dev_t *retval = NULL; int thisMatchLength; int longestMatch = -1; @@ -413,23 +413,23 @@ static yaffs_Device *yaffsfs_FindDevice(const YCHAR *path, YCHAR **restOfPath) } #endif -static yaffs_Object *yaffsfs_FindRoot(const YCHAR *path, YCHAR **restOfPath) +static yaffs_obj_t *yaffsfs_FindRoot(const YCHAR *path, YCHAR **restOfPath) { - yaffs_Device *dev; + yaffs_dev_t *dev; dev= yaffsfs_FindDevice(path,restOfPath); - if(dev && dev->isMounted){ - return dev->rootDir; + if(dev && dev->is_mounted){ + return dev->root_dir; } return NULL; } -static yaffs_Object *yaffsfs_FollowLink(yaffs_Object *obj,int symDepth) +static yaffs_obj_t *yaffsfs_FollowLink(yaffs_obj_t *obj,int symDepth) { - while(obj && obj->variantType == YAFFS_OBJECT_TYPE_SYMLINK){ - YCHAR *alias = obj->variant.symLinkVariant.alias; + while(obj && obj->variant_type == YAFFS_OBJECT_TYPE_SYMLINK){ + YCHAR *alias = obj->variant.symlink_variant.alias; if(yaffsfs_IsPathDivider(*alias)) /* Starts with a /, need to scan from root up */ @@ -448,10 +448,10 @@ static yaffs_Object *yaffsfs_FollowLink(yaffs_Object *obj,int symDepth) * * eg. "/data/xx/ff" --> puts name="ff" and returns the directory "/data/xx" */ -static yaffs_Object *yaffsfs_DoFindDirectory(yaffs_Object *startDir, +static yaffs_obj_t *yaffsfs_DoFindDirectory(yaffs_obj_t *startDir, const YCHAR *path, YCHAR **name, int symDepth) { - yaffs_Object *dir; + yaffs_obj_t *dir; YCHAR *restOfPath; YCHAR str[YAFFS_MAX_NAME_LENGTH+1]; int i; @@ -500,11 +500,11 @@ static yaffs_Object *yaffsfs_DoFindDirectory(yaffs_Object *startDir, else{ dir = yaffs_find_by_name(dir,str); - while(dir && dir->variantType == YAFFS_OBJECT_TYPE_SYMLINK) + while(dir && dir->variant_type == YAFFS_OBJECT_TYPE_SYMLINK) dir = yaffsfs_FollowLink(dir,symDepth); - if(dir && dir->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) + if(dir && dir->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) dir = NULL; } } @@ -513,7 +513,7 @@ static yaffs_Object *yaffsfs_DoFindDirectory(yaffs_Object *startDir, return NULL; } -static yaffs_Object *yaffsfs_FindDirectory(yaffs_Object *relativeDirectory, +static yaffs_obj_t *yaffsfs_FindDirectory(yaffs_obj_t *relativeDirectory, const YCHAR *path,YCHAR **name,int symDepth) { return yaffsfs_DoFindDirectory(relativeDirectory,path,name,symDepth); @@ -522,9 +522,9 @@ static yaffs_Object *yaffsfs_FindDirectory(yaffs_Object *relativeDirectory, /* * yaffsfs_FindObject turns a path for an existing object into the object */ -static yaffs_Object *yaffsfs_FindObject(yaffs_Object *relativeDirectory, const YCHAR *path,int symDepth) +static yaffs_obj_t *yaffsfs_FindObject(yaffs_obj_t *relativeDirectory, const YCHAR *path,int symDepth) { - yaffs_Object *dir; + yaffs_obj_t *dir; YCHAR *name; dir = yaffsfs_FindDirectory(relativeDirectory,path,&name,symDepth); @@ -566,8 +566,8 @@ int yaffs_dup(int fd) int yaffs_open_sharing(const YCHAR *path, int oflag, int mode, int sharing) { - yaffs_Object *obj = NULL; - yaffs_Object *dir = NULL; + yaffs_obj_t *obj = NULL; + yaffs_obj_t *dir = NULL; YCHAR *name; int handle = -1; yaffsfs_Handle *h = NULL; @@ -605,15 +605,15 @@ int yaffs_open_sharing(const YCHAR *path, int oflag, int mode, int sharing) /* try to find the exisiting object */ obj = yaffsfs_FindObject(NULL,path,0); - if(obj && obj->variantType == YAFFS_OBJECT_TYPE_SYMLINK) + if(obj && obj->variant_type == YAFFS_OBJECT_TYPE_SYMLINK) obj = yaffsfs_FollowLink(obj,symDepth++); if(obj) obj = yaffs_get_equivalent_obj(obj); if(obj && - obj->variantType != YAFFS_OBJECT_TYPE_FILE && - obj->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) + obj->variant_type != YAFFS_OBJECT_TYPE_FILE && + obj->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) obj = NULL; if(obj){ @@ -621,7 +621,7 @@ int yaffs_open_sharing(const YCHAR *path, int oflag, int mode, int sharing) /* The file already exists or it might be a directory */ /* If it is a directory then we can't open it as a file */ - if(obj->variantType == YAFFS_OBJECT_TYPE_DIRECTORY){ + if(obj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY){ openDenied = 1; yaffsfs_SetError(-EISDIR); errorReported = 1; @@ -689,7 +689,7 @@ int yaffs_open_sharing(const YCHAR *path, int oflag, int mode, int sharing) } else if((oflag & O_CREAT)) { /* Let's see if we can create this file */ dir = yaffsfs_FindDirectory(NULL,path,&name,0); - if(dir && dir->myDev->readOnly){ + if(dir && dir->my_dev->read_only){ yaffsfs_SetError(-EINVAL); errorReported = 1; } else if(dir) @@ -719,7 +719,7 @@ int yaffs_open_sharing(const YCHAR *path, int oflag, int mode, int sharing) h->shareWrite = shareWrite; /* Hook inode to object */ - obj->myInode = (void*) &yaffsfs_inode[inodeId]; + obj->my_inode = (void*) &yaffsfs_inode[inodeId]; if((oflag & O_TRUNC) && h->writing) yaffs_resize_file(obj,0); @@ -811,7 +811,7 @@ int yaffs_close(int fd) int yaffsfs_do_read(int fd, void *vbuf, unsigned int nbyte, int isPread, int offset) { yaffsfs_Handle *h = NULL; - yaffs_Object *obj = NULL; + yaffs_obj_t *obj = NULL; int pos = 0; int startPos = 0; int nRead = 0; @@ -903,12 +903,12 @@ int yaffs_pread(int fd, void *buf, unsigned int nbyte, unsigned int offset) int yaffsfs_do_write(int fd, const void *vbuf, unsigned int nbyte, int isPwrite, int offset) { yaffsfs_Handle *h = NULL; - yaffs_Object *obj = NULL; + yaffs_obj_t *obj = NULL; int pos = 0; int startPos = 0; int nWritten = 0; int totalWritten = 0; - int writeThrough = 0; + int write_trhrough = 0; int nToWrite = 0; const __u8 *buf = (const __u8 *)vbuf; @@ -920,7 +920,7 @@ int yaffsfs_do_write(int fd, const void *vbuf, unsigned int nbyte, int isPwrite, /* bad handle */ yaffsfs_SetError(-EBADF); totalWritten = -1; - } else if( h && obj && (!h->writing || obj->myDev->readOnly)){ + } else if( h && obj && (!h->writing || obj->my_dev->read_only)){ yaffsfs_SetError(-EINVAL); totalWritten=-1; } else if( h && obj){ @@ -938,7 +938,7 @@ int yaffsfs_do_write(int fd, const void *vbuf, unsigned int nbyte, int isPwrite, if(nToWrite > nbyte) nToWrite = nbyte; - nWritten = yaffs_wr_file(obj,buf,pos,nToWrite,writeThrough); + nWritten = yaffs_wr_file(obj,buf,pos,nToWrite,write_trhrough); if(nWritten > 0){ totalWritten += nWritten; pos += nWritten; @@ -988,9 +988,9 @@ int yaffs_pwrite(int fd, const void *buf, unsigned int nbyte, unsigned int offse } -int yaffs_truncate(const YCHAR *path,off_t newSize) +int yaffs_truncate(const YCHAR *path,off_t new_size) { - yaffs_Object *obj = NULL; + yaffs_obj_t *obj = NULL; int result = YAFFS_FAIL; yaffsfs_Lock(); @@ -1001,12 +1001,12 @@ int yaffs_truncate(const YCHAR *path,off_t newSize) if(!obj) yaffsfs_SetError(-ENOENT); - else if(obj->variantType != YAFFS_OBJECT_TYPE_FILE) + else if(obj->variant_type != YAFFS_OBJECT_TYPE_FILE) yaffsfs_SetError(-EISDIR); - else if(obj->myDev->readOnly) + else if(obj->my_dev->read_only) yaffsfs_SetError(-EINVAL); else - result = yaffs_resize_file(obj,newSize); + result = yaffs_resize_file(obj,new_size); yaffsfs_Unlock(); @@ -1014,10 +1014,10 @@ int yaffs_truncate(const YCHAR *path,off_t newSize) return (result) ? 0 : -1; } -int yaffs_ftruncate(int fd, off_t newSize) +int yaffs_ftruncate(int fd, off_t new_size) { yaffsfs_Handle *h = NULL; - yaffs_Object *obj = NULL; + yaffs_obj_t *obj = NULL; int result = 0; yaffsfs_Lock(); @@ -1027,11 +1027,11 @@ int yaffs_ftruncate(int fd, off_t newSize) if(!h || !obj) /* bad handle */ yaffsfs_SetError(-EBADF); - else if(obj->myDev->readOnly) + else if(obj->my_dev->read_only) yaffsfs_SetError(-EINVAL); else /* resize the file */ - result = yaffs_resize_file(obj,newSize); + result = yaffs_resize_file(obj,new_size); yaffsfs_Unlock(); @@ -1042,7 +1042,7 @@ int yaffs_ftruncate(int fd, off_t newSize) off_t yaffs_lseek(int fd, off_t offset, int whence) { yaffsfs_Handle *h = NULL; - yaffs_Object *obj = NULL; + yaffs_obj_t *obj = NULL; int pos = -1; int fSize = -1; @@ -1082,8 +1082,8 @@ off_t yaffs_lseek(int fd, off_t offset, int whence) int yaffsfs_DoUnlink(const YCHAR *path,int isDirectory) { - yaffs_Object *dir = NULL; - yaffs_Object *obj = NULL; + yaffs_obj_t *dir = NULL; + yaffs_obj_t *obj = NULL; YCHAR *name; int result = YAFFS_FAIL; @@ -1095,11 +1095,11 @@ int yaffsfs_DoUnlink(const YCHAR *path,int isDirectory) yaffsfs_SetError(-ENOTDIR); else if(!obj) yaffsfs_SetError(-ENOENT); - else if(obj->myDev->readOnly) + else if(obj->my_dev->read_only) yaffsfs_SetError(-EINVAL); - else if(!isDirectory && obj->variantType == YAFFS_OBJECT_TYPE_DIRECTORY) + else if(!isDirectory && obj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY) yaffsfs_SetError(-EISDIR); - else if(isDirectory && obj->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) + else if(isDirectory && obj->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) yaffsfs_SetError(-ENOTDIR); else { result = yaffs_unlinker(dir,name); @@ -1128,13 +1128,13 @@ int yaffs_unlink(const YCHAR *path) int yaffs_rename(const YCHAR *oldPath, const YCHAR *newPath) { - yaffs_Object *olddir = NULL; - yaffs_Object *newdir = NULL; - yaffs_Object *obj = NULL; + yaffs_obj_t *olddir = NULL; + yaffs_obj_t *newdir = NULL; + yaffs_obj_t *obj = NULL; YCHAR *oldname; YCHAR *newname; int result= YAFFS_FAIL; - int renameAllowed = 1; + int rename_allowed = 1; yaffsfs_Lock(); @@ -1145,34 +1145,34 @@ int yaffs_rename(const YCHAR *oldPath, const YCHAR *newPath) if(!olddir || !newdir || !obj) { /* bad file */ yaffsfs_SetError(-EBADF); - renameAllowed = 0; - } else if(obj->myDev->readOnly){ + rename_allowed = 0; + } else if(obj->my_dev->read_only){ yaffsfs_SetError(-EINVAL); - renameAllowed = 0; - } else if(olddir->myDev != newdir->myDev) { + rename_allowed = 0; + } else if(olddir->my_dev != newdir->my_dev) { /* oops must be on same device */ /* todo error */ yaffsfs_SetError(-EXDEV); - renameAllowed = 0; - } else if(obj && obj->variantType == YAFFS_OBJECT_TYPE_DIRECTORY) { + rename_allowed = 0; + } else if(obj && obj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY) { /* * It is a directory, check that it is not being renamed to * being its own decendent. * Do this by tracing from the new directory back to the root, checking for obj */ - yaffs_Object *xx = newdir; + yaffs_obj_t *xx = newdir; - while( renameAllowed && xx){ + while( rename_allowed && xx){ if(xx == obj) - renameAllowed = 0; + rename_allowed = 0; xx = xx->parent; } - if(!renameAllowed) + if(!rename_allowed) yaffsfs_SetError(-EACCES); } - if(renameAllowed) + if(rename_allowed) result = yaffs_rename_obj(olddir,oldname,newdir,newname); yaffsfs_Unlock(); @@ -1181,7 +1181,7 @@ int yaffs_rename(const YCHAR *oldPath, const YCHAR *newPath) } -static int yaffsfs_DoStat(yaffs_Object *obj,struct yaffs_stat *buf) +static int yaffsfs_DoStat(yaffs_obj_t *obj,struct yaffs_stat *buf) { int retVal = -1; @@ -1189,15 +1189,15 @@ static int yaffsfs_DoStat(yaffs_Object *obj,struct yaffs_stat *buf) obj = yaffs_get_equivalent_obj(obj); if(obj && buf){ - buf->st_dev = (int)obj->myDev->osContext; - buf->st_ino = obj->objectId; + buf->st_dev = (int)obj->my_dev->os_context; + buf->st_ino = obj->obj_id; buf->st_mode = obj->yst_mode & ~S_IFMT; /* clear out file type bits */ - if(obj->variantType == YAFFS_OBJECT_TYPE_DIRECTORY) + if(obj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY) buf->st_mode |= S_IFDIR; - else if(obj->variantType == YAFFS_OBJECT_TYPE_SYMLINK) + else if(obj->variant_type == YAFFS_OBJECT_TYPE_SYMLINK) buf->st_mode |= S_IFLNK; - else if(obj->variantType == YAFFS_OBJECT_TYPE_FILE) + else if(obj->variant_type == YAFFS_OBJECT_TYPE_FILE) buf->st_mode |= S_IFREG; buf->st_nlink = yaffs_get_obj_link_count(obj); @@ -1205,7 +1205,7 @@ static int yaffsfs_DoStat(yaffs_Object *obj,struct yaffs_stat *buf) buf->st_gid = 0;; buf->st_rdev = obj->yst_rdev; buf->st_size = yaffs_get_obj_length(obj); - buf->st_blksize = obj->myDev->nDataBytesPerChunk; + buf->st_blksize = obj->my_dev->data_bytes_per_chunk; buf->st_blocks = (buf->st_size + buf->st_blksize -1)/buf->st_blksize; #if CONFIG_YAFFS_WINCE buf->yst_wince_atime[0] = obj->win_atime[0]; @@ -1226,7 +1226,7 @@ static int yaffsfs_DoStat(yaffs_Object *obj,struct yaffs_stat *buf) static int yaffsfs_DoStatOrLStat(const YCHAR *path, struct yaffs_stat *buf,int doLStat) { - yaffs_Object *obj; + yaffs_obj_t *obj; int retVal = -1; @@ -1260,7 +1260,7 @@ int yaffs_lstat(const YCHAR *path, struct yaffs_stat *buf) int yaffs_fstat(int fd, struct yaffs_stat *buf) { - yaffs_Object *obj; + yaffs_obj_t *obj; int retVal = -1; @@ -1284,7 +1284,7 @@ int yaffs_fstat(int fd, struct yaffs_stat *buf) static int yaffs_do_setxattr(const YCHAR *path, const char *name, const void *data, int size, int flags, int follow) { - yaffs_Object *obj; + yaffs_obj_t *obj; int retVal = -1; @@ -1324,7 +1324,7 @@ int yaffs_lsetxattr(const YCHAR *path, const char *name, const void *data, int s int yaffs_fsetxattr(int fd, const char *name, const void *data, int size, int flags) { - yaffs_Object *obj; + yaffs_obj_t *obj; int retVal = -1; @@ -1348,7 +1348,7 @@ int yaffs_fsetxattr(int fd, const char *name, const void *data, int size, int fl static int yaffs_do_getxattr(const YCHAR *path, const char *name, void *data, int size, int follow) { - yaffs_Object *obj; + yaffs_obj_t *obj; int retVal = -1; @@ -1387,7 +1387,7 @@ int yaffs_lgetxattr(const YCHAR *path, const char *name, void *data, int size) int yaffs_fgetxattr(int fd, const char *name, void *data, int size) { - yaffs_Object *obj; + yaffs_obj_t *obj; int retVal = -1; @@ -1411,7 +1411,7 @@ int yaffs_fgetxattr(int fd, const char *name, void *data, int size) static int yaffs_do_listxattr(const YCHAR *path, char *data, int size, int follow) { - yaffs_Object *obj; + yaffs_obj_t *obj; int retVal = -1; @@ -1449,7 +1449,7 @@ int yaffs_llistxattr(const YCHAR *path, char *data, int size) int yaffs_flistxattr(int fd, char *data, int size) { - yaffs_Object *obj; + yaffs_obj_t *obj; int retVal = -1; @@ -1473,7 +1473,7 @@ int yaffs_flistxattr(int fd, char *data, int size) static int yaffs_do_removexattr(const YCHAR *path, const char *name, int follow) { - yaffs_Object *obj; + yaffs_obj_t *obj; int retVal = -1; @@ -1511,7 +1511,7 @@ int yaffs_lremovexattr(const YCHAR *path, const char *name) int yaffs_fremovexattr(int fd, const char *name) { - yaffs_Object *obj; + yaffs_obj_t *obj; int retVal = -1; @@ -1537,7 +1537,7 @@ int yaffs_fremovexattr(int fd, const char *name) #ifdef CONFIG_YAFFS_WINCE int yaffs_get_wince_times(int fd, unsigned *wctime, unsigned *watime, unsigned *wmtime) { - yaffs_Object *obj; + yaffs_obj_t *obj; int retVal = -1; @@ -1576,7 +1576,7 @@ int yaffs_set_wince_times(int fd, const unsigned *watime, const unsigned *wmtime) { - yaffs_Object *obj; + yaffs_obj_t *obj; int result; int retVal = -1; @@ -1613,7 +1613,7 @@ int yaffs_set_wince_times(int fd, #endif -static int yaffsfs_DoChMod(yaffs_Object *obj,mode_t mode) +static int yaffsfs_DoChMod(yaffs_obj_t *obj,mode_t mode) { int result = -1; @@ -1632,7 +1632,7 @@ static int yaffsfs_DoChMod(yaffs_Object *obj,mode_t mode) int yaffs_access(const YCHAR *path, int amode) { - yaffs_Object *obj; + yaffs_obj_t *obj; int retval = 0; @@ -1668,7 +1668,7 @@ int yaffs_access(const YCHAR *path, int amode) int yaffs_chmod(const YCHAR *path, mode_t mode) { - yaffs_Object *obj; + yaffs_obj_t *obj; int retVal = -1; @@ -1677,7 +1677,7 @@ int yaffs_chmod(const YCHAR *path, mode_t mode) if(!obj) yaffsfs_SetError(-ENOENT); - else if(obj->myDev->readOnly) + else if(obj->my_dev->read_only) yaffsfs_SetError(-EINVAL); else retVal = yaffsfs_DoChMod(obj,mode); @@ -1691,7 +1691,7 @@ int yaffs_chmod(const YCHAR *path, mode_t mode) int yaffs_fchmod(int fd, mode_t mode) { - yaffs_Object *obj; + yaffs_obj_t *obj; int retVal = -1; @@ -1700,7 +1700,7 @@ int yaffs_fchmod(int fd, mode_t mode) if(!obj) yaffsfs_SetError(-ENOENT); - else if(obj->myDev->readOnly) + else if(obj->my_dev->read_only) yaffsfs_SetError(-EINVAL); else retVal = yaffsfs_DoChMod(obj,mode); @@ -1713,8 +1713,8 @@ int yaffs_fchmod(int fd, mode_t mode) int yaffs_mkdir(const YCHAR *path, mode_t mode) { - yaffs_Object *parent = NULL; - yaffs_Object *dir = NULL; + yaffs_obj_t *parent = NULL; + yaffs_obj_t *dir = NULL; YCHAR *name; int retVal= -1; @@ -1723,7 +1723,7 @@ int yaffs_mkdir(const YCHAR *path, mode_t mode) if(parent && yaffs_strnlen(name,5) == 0){ /* Trying to make the root itself */ yaffsfs_SetError(-EEXIST); - } else if(parent && parent->myDev->readOnly){ + } else if(parent && parent->my_dev->read_only){ yaffsfs_SetError(-EINVAL); } else { if(parent) @@ -1748,17 +1748,17 @@ int yaffs_mkdir(const YCHAR *path, mode_t mode) void * yaffs_getdev(const YCHAR *path) { - yaffs_Device *dev=NULL; + yaffs_dev_t *dev=NULL; YCHAR *dummy; dev = yaffsfs_FindDevice(path,&dummy); return (void *)dev; } -int yaffs_mount2(const YCHAR *path,int readOnly) +int yaffs_mount2(const YCHAR *path,int read_only) { int retVal=-1; int result=YAFFS_FAIL; - yaffs_Device *dev=NULL; + yaffs_dev_t *dev=NULL; YCHAR *dummy; T(YAFFS_TRACE_ALWAYS,(TSTR("yaffs: Mounting %s" TENDSTR),path)); @@ -1769,8 +1769,8 @@ int yaffs_mount2(const YCHAR *path,int readOnly) dev = yaffsfs_FindDevice(path,&dummy); if(dev){ - if(!dev->isMounted){ - dev->readOnly = readOnly ? 1 : 0; + if(!dev->is_mounted){ + dev->read_only = read_only ? 1 : 0; result = yaffs_guts_initialise(dev); if(result == YAFFS_FAIL) /* todo error - mount failed */ @@ -1798,13 +1798,13 @@ int yaffs_mount(const YCHAR *path) int yaffs_sync(const YCHAR *path) { int retVal=-1; - yaffs_Device *dev=NULL; + yaffs_dev_t *dev=NULL; YCHAR *dummy; yaffsfs_Lock(); dev = yaffsfs_FindDevice(path,&dummy); if(dev){ - if(dev->isMounted){ + if(dev->is_mounted){ yaffs_flush_whole_cache(dev); yaffs_checkpoint_save(dev); @@ -1823,30 +1823,30 @@ int yaffs_sync(const YCHAR *path) } -int yaffs_remount(const YCHAR *path, int force, int readOnly) +int yaffs_remount(const YCHAR *path, int force, int read_only) { int retVal=-1; - yaffs_Device *dev=NULL; + yaffs_dev_t *dev=NULL; YCHAR *dummy; yaffsfs_Lock(); dev = yaffsfs_FindDevice(path,&dummy); if(dev){ - if(dev->isMounted){ + if(dev->is_mounted){ int i; int inUse; yaffs_flush_whole_cache(dev); for(i = inUse = 0; i < YAFFSFS_N_HANDLES && !inUse && !force; i++){ - if(yaffsfs_handle[i].useCount>0 && yaffsfs_inode[yaffsfs_handle[i].inodeId].iObj->myDev == dev) + if(yaffsfs_handle[i].useCount>0 && yaffsfs_inode[yaffsfs_handle[i].inodeId].iObj->my_dev == dev) inUse = 1; /* the device is in use, can't unmount */ } if(!inUse || force){ - if(readOnly) + if(read_only) yaffs_checkpoint_save(dev); - dev->readOnly = readOnly ? 1 : 0; + dev->read_only = read_only ? 1 : 0; retVal = 0; } else yaffsfs_SetError(-EBUSY); @@ -1866,13 +1866,13 @@ int yaffs_remount(const YCHAR *path, int force, int readOnly) int yaffs_unmount2(const YCHAR *path, int force) { int retVal=-1; - yaffs_Device *dev=NULL; + yaffs_dev_t *dev=NULL; YCHAR *dummy; yaffsfs_Lock(); dev = yaffsfs_FindDevice(path,&dummy); if(dev){ - if(dev->isMounted){ + if(dev->is_mounted){ int i; int inUse; @@ -1880,7 +1880,7 @@ int yaffs_unmount2(const YCHAR *path, int force) yaffs_checkpoint_save(dev); for(i = inUse = 0; i < YAFFSFS_N_HANDLES && !inUse; i++){ - if(yaffsfs_handle[i].useCount > 0 && yaffsfs_inode[yaffsfs_handle[i].inodeId].iObj->myDev == dev) + if(yaffsfs_handle[i].useCount > 0 && yaffsfs_inode[yaffsfs_handle[i].inodeId].iObj->my_dev == dev) inUse = 1; /* the device is in use, can't unmount */ } @@ -1914,14 +1914,14 @@ int yaffs_unmount(const YCHAR *path) loff_t yaffs_freespace(const YCHAR *path) { loff_t retVal=-1; - yaffs_Device *dev=NULL; + yaffs_dev_t *dev=NULL; YCHAR *dummy; yaffsfs_Lock(); dev = yaffsfs_FindDevice(path,&dummy); - if(dev && dev->isMounted){ + if(dev && dev->is_mounted){ retVal = yaffs_get_n_free_chunks(dev); - retVal *= dev->nDataBytesPerChunk; + retVal *= dev->data_bytes_per_chunk; } else yaffsfs_SetError(-EINVAL); @@ -1933,15 +1933,15 @@ loff_t yaffs_freespace(const YCHAR *path) loff_t yaffs_totalspace(const YCHAR *path) { loff_t retVal=-1; - yaffs_Device *dev=NULL; + yaffs_dev_t *dev=NULL; YCHAR *dummy; yaffsfs_Lock(); dev = yaffsfs_FindDevice(path,&dummy); - if(dev && dev->isMounted){ - retVal = (dev->param.endBlock - dev->param.startBlock + 1) - dev->param.nReservedBlocks; - retVal *= dev->param.nChunksPerBlock; - retVal *= dev->nDataBytesPerChunk; + if(dev && dev->is_mounted){ + retVal = (dev->param.end_block - dev->param.start_block + 1) - dev->param.n_reserved_blocks; + retVal *= dev->param.chunks_per_block; + retVal *= dev->data_bytes_per_chunk; } else yaffsfs_SetError(-EINVAL); @@ -1953,15 +1953,15 @@ loff_t yaffs_totalspace(const YCHAR *path) int yaffs_inodecount(const YCHAR *path) { loff_t retVal= -1; - yaffs_Device *dev=NULL; + yaffs_dev_t *dev=NULL; YCHAR *dummy; yaffsfs_Lock(); dev = yaffsfs_FindDevice(path,&dummy); - if(dev && dev->isMounted) { - int nObjects = dev->nObjects; - if(nObjects > dev->nHardLinks) - retVal = nObjects - dev->nHardLinks; + if(dev && dev->is_mounted) { + int n_obj = dev->n_obj; + if(n_obj > dev->n_hardlinks) + retVal = n_obj - dev->n_hardlinks; } if(retVal < 0) @@ -1972,20 +1972,20 @@ int yaffs_inodecount(const YCHAR *path) } -void yaffs_add_device(yaffs_Device *dev) +void yaffs_add_device(yaffs_dev_t *dev) { - dev->isMounted = 0; - dev->param.removeObjectCallback = yaffsfs_RemoveObjectCallback; + dev->is_mounted = 0; + dev->param.remove_obj_fn = yaffsfs_RemoveObjectCallback; - if(!dev->devList.next) - YINIT_LIST_HEAD(&dev->devList); + if(!dev->dev_list.next) + YINIT_LIST_HEAD(&dev->dev_list); - ylist_add(&dev->devList,&yaffsfs_deviceList); + ylist_add(&dev->dev_list,&yaffsfs_deviceList); } -void yaffs_remove_device(yaffs_Device *dev) +void yaffs_remove_device(yaffs_dev_t *dev) { - ylist_del_init(&dev->devList); + ylist_del_init(&dev->dev_list); } @@ -2005,8 +2005,8 @@ typedef struct __u32 magic; yaffs_dirent de; /* directory entry being used by this dsc */ YCHAR name[NAME_MAX+1]; /* name of directory being searched */ - yaffs_Object *dirObj; /* ptr to directory being searched */ - yaffs_Object *nextReturn; /* obj to be returned by next readddir */ + yaffs_obj_t *dirObj; /* ptr to directory being searched */ + yaffs_obj_t *nextReturn; /* obj to be returned by next readddir */ int offset; struct ylist_head others; } yaffsfs_DirectorySearchContext; @@ -2020,15 +2020,15 @@ static void yaffsfs_SetDirRewound(yaffsfs_DirectorySearchContext *dsc) { if(dsc && dsc->dirObj && - dsc->dirObj->variantType == YAFFS_OBJECT_TYPE_DIRECTORY){ + dsc->dirObj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY){ dsc->offset = 0; - if( ylist_empty(&dsc->dirObj->variant.directoryVariant.children)) + if( ylist_empty(&dsc->dirObj->variant.dir_variant.children)) dsc->nextReturn = NULL; else - dsc->nextReturn = ylist_entry(dsc->dirObj->variant.directoryVariant.children.next, - yaffs_Object,siblings); + dsc->nextReturn = ylist_entry(dsc->dirObj->variant.dir_variant.children.next, + yaffs_obj_t,siblings); } else { /* Hey someone isn't playing nice! */ } @@ -2038,25 +2038,25 @@ static void yaffsfs_DirAdvance(yaffsfs_DirectorySearchContext *dsc) { if(dsc && dsc->dirObj && - dsc->dirObj->variantType == YAFFS_OBJECT_TYPE_DIRECTORY){ + dsc->dirObj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY){ if( dsc->nextReturn == NULL || - ylist_empty(&dsc->dirObj->variant.directoryVariant.children)) + ylist_empty(&dsc->dirObj->variant.dir_variant.children)) dsc->nextReturn = NULL; else { struct ylist_head *next = dsc->nextReturn->siblings.next; - if( next == &dsc->dirObj->variant.directoryVariant.children) + if( next == &dsc->dirObj->variant.dir_variant.children) dsc->nextReturn = NULL; /* end of list */ else - dsc->nextReturn = ylist_entry(next,yaffs_Object,siblings); + dsc->nextReturn = ylist_entry(next,yaffs_obj_t,siblings); } } else { /* Hey someone isn't playing nice! */ } } -static void yaffsfs_RemoveObjectCallback(yaffs_Object *obj) +static void yaffsfs_RemoveObjectCallback(yaffs_obj_t *obj) { struct ylist_head *i; @@ -2083,14 +2083,14 @@ static void yaffsfs_RemoveObjectCallback(yaffs_Object *obj) yaffs_DIR *yaffs_opendir(const YCHAR *dirname) { yaffs_DIR *dir = NULL; - yaffs_Object *obj = NULL; + yaffs_obj_t *obj = NULL; yaffsfs_DirectorySearchContext *dsc = NULL; yaffsfs_Lock(); obj = yaffsfs_FindObject(NULL,dirname,0); - if(obj && obj->variantType == YAFFS_OBJECT_TYPE_DIRECTORY){ + if(obj && obj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY){ dsc = YMALLOC(sizeof(yaffsfs_DirectorySearchContext)); dir = (yaffs_DIR *)dsc; @@ -2126,7 +2126,7 @@ struct yaffs_dirent *yaffs_readdir(yaffs_DIR *dirp) if(dsc && dsc->magic == YAFFS_MAGIC){ yaffsfs_SetError(0); if(dsc->nextReturn){ - dsc->de.d_ino = yaffs_get_equivalent_obj(dsc->nextReturn)->objectId; + dsc->de.d_ino = yaffs_get_equivalent_obj(dsc->nextReturn)->obj_id; dsc->de.d_dont_use = (unsigned)dsc->nextReturn; dsc->de.d_off = dsc->offset++; yaffs_get_obj_name(dsc->nextReturn,dsc->de.d_name,NAME_MAX); @@ -2179,15 +2179,15 @@ int yaffs_closedir(yaffs_DIR *dirp) int yaffs_symlink(const YCHAR *oldpath, const YCHAR *newpath) { - yaffs_Object *parent = NULL; - yaffs_Object *obj; + yaffs_obj_t *parent = NULL; + yaffs_obj_t *obj; YCHAR *name; int retVal= -1; int mode = 0; /* ignore for now */ yaffsfs_Lock(); parent = yaffsfs_FindDirectory(NULL,newpath,&name,0); - if(parent && parent->myDev->readOnly) + if(parent && parent->my_dev->read_only) yaffsfs_SetError(-EINVAL); else if(parent){ obj = yaffs_create_symlink(parent,name,mode,0,0,oldpath); @@ -2210,7 +2210,7 @@ int yaffs_symlink(const YCHAR *oldpath, const YCHAR *newpath) int yaffs_readlink(const YCHAR *path, YCHAR *buf, int bufsiz) { - yaffs_Object *obj = NULL; + yaffs_obj_t *obj = NULL; int retVal; @@ -2221,11 +2221,11 @@ int yaffs_readlink(const YCHAR *path, YCHAR *buf, int bufsiz) if(!obj) { yaffsfs_SetError(-ENOENT); retVal = -1; - } else if(obj->variantType != YAFFS_OBJECT_TYPE_SYMLINK) { + } else if(obj->variant_type != YAFFS_OBJECT_TYPE_SYMLINK) { yaffsfs_SetError(-EINVAL); retVal = -1; } else { - YCHAR *alias = obj->variant.symLinkVariant.alias; + YCHAR *alias = obj->variant.symlink_variant.alias; memset(buf,0,bufsiz); yaffs_strncpy(buf,alias,bufsiz - 1); retVal = 0; @@ -2237,10 +2237,10 @@ int yaffs_readlink(const YCHAR *path, YCHAR *buf, int bufsiz) int yaffs_link(const YCHAR *oldpath, const YCHAR *newpath) { /* Creates a link called newpath to existing oldpath */ - yaffs_Object *obj = NULL; - yaffs_Object *target = NULL; + yaffs_obj_t *obj = NULL; + yaffs_obj_t *target = NULL; int retVal = 0; - int newNameLength = 0; + int new_nameLength = 0; yaffsfs_Lock(); @@ -2251,15 +2251,15 @@ int yaffs_link(const YCHAR *oldpath, const YCHAR *newpath) if(!obj) { yaffsfs_SetError(-ENOENT); retVal = -1; - } else if(obj->myDev->readOnly){ + } else if(obj->my_dev->read_only){ yaffsfs_SetError(-EINVAL); retVal= -1; } else if(target) { yaffsfs_SetError(-EEXIST); retVal = -1; } else { - yaffs_Object *newdir = NULL; - yaffs_Object *link = NULL; + yaffs_obj_t *newdir = NULL; + yaffs_obj_t *link = NULL; YCHAR *newname; @@ -2268,23 +2268,23 @@ int yaffs_link(const YCHAR *oldpath, const YCHAR *newpath) if(!newdir){ yaffsfs_SetError(-ENOTDIR); retVal = -1; - }else if(newdir->myDev != obj->myDev){ + }else if(newdir->my_dev != obj->my_dev){ yaffsfs_SetError(-EXDEV); retVal = -1; } - newNameLength = yaffs_strnlen(newname,YAFFS_MAX_NAME_LENGTH+1); + new_nameLength = yaffs_strnlen(newname,YAFFS_MAX_NAME_LENGTH+1); - if(newNameLength == 0){ + if(new_nameLength == 0){ yaffsfs_SetError(-ENOENT); retVal = -1; - } else if (newNameLength > YAFFS_MAX_NAME_LENGTH){ + } else if (new_nameLength > YAFFS_MAX_NAME_LENGTH){ yaffsfs_SetError(-ENAMETOOLONG); retVal = -1; } if(retVal == 0) { - link = yaffs_Link(newdir,newname,obj); + link = yaffs_link_obj(newdir,newname,obj); if(link) retVal = 0; else{ @@ -2312,7 +2312,7 @@ int yaffs_mknod(const YCHAR *pathname, mode_t mode, dev_t dev) */ int yaffs_n_handles(const YCHAR *path) { - yaffs_Object *obj; + yaffs_obj_t *obj; obj = yaffsfs_FindObject(NULL,path,0); if(obj) @@ -2326,23 +2326,23 @@ int yaffs_dump_dev(const YCHAR *path) #if 0 YCHAR *rest; - yaffs_Object *obj = yaffsfs_FindRoot(path,&rest); + yaffs_obj_t *obj = yaffsfs_FindRoot(path,&rest); if(obj){ - yaffs_Device *dev = obj->myDev; + yaffs_dev_t *dev = obj->my_dev; printf("\n" - "nPageWrites.......... %d\n" - "nPageReads........... %d\n" - "nBlockErasures....... %d\n" - "nGCCopies............ %d\n" + "n_page_writes.......... %d\n" + "n_page_reads........... %d\n" + "n_erasures....... %d\n" + "n_gc_copies............ %d\n" "garbageCollections... %d\n" "passiveGarbageColl'ns %d\n" "\n", - dev->nPageWrites, - dev->nPageReads, - dev->nBlockErasures, - dev->nGCCopies, + dev->n_page_writes, + dev->n_page_reads, + dev->n_erasures, + dev->n_gc_copies, dev->garbageCollections, dev->passiveGarbageCollections ); diff --git a/direct/yaffsfs.h b/direct/yaffsfs.h index 2a450e9..5f47a2d 100644 --- a/direct/yaffsfs.h +++ b/direct/yaffsfs.h @@ -94,8 +94,8 @@ int yaffs_pwrite(int fd, const void *buf, unsigned int nbyte, unsigned int offse off_t yaffs_lseek(int fd, off_t offset, int whence) ; -int yaffs_truncate(const YCHAR *path, off_t newSize); -int yaffs_ftruncate(int fd, off_t newSize); +int yaffs_truncate(const YCHAR *path, off_t new_size); +int yaffs_ftruncate(int fd, off_t new_size); int yaffs_unlink(const YCHAR *path) ; int yaffs_rename(const YCHAR *oldPath, const YCHAR *newPath) ; @@ -140,10 +140,10 @@ void yaffs_rewinddir(yaffs_DIR *dirp) ; int yaffs_closedir(yaffs_DIR *dirp) ; int yaffs_mount(const YCHAR *path) ; -int yaffs_mount2(const YCHAR *path, int readOnly); +int yaffs_mount2(const YCHAR *path, int read_only); int yaffs_unmount(const YCHAR *path) ; int yaffs_unmount2(const YCHAR *path, int force); -int yaffs_remount(const YCHAR *path, int force, int readOnly); +int yaffs_remount(const YCHAR *path, int force, int read_only); int yaffs_sync(const YCHAR *path) ; @@ -166,8 +166,8 @@ int yaffs_n_handles(const YCHAR *path); int yaffs_open_sharing(const YCHAR *path, int oflag, int mode, int shareMode) ; -struct yaffs_DeviceStruct; -void yaffs_add_device(struct yaffs_DeviceStruct *dev); +struct yaffs_dev_s; +void yaffs_add_device(struct yaffs_dev_s *dev); int yaffs_start_up(void); diff --git a/moduleconfig.h b/moduleconfig.h index 43f1144..4b4d642 100644 --- a/moduleconfig.h +++ b/moduleconfig.h @@ -68,7 +68,7 @@ #define CONFIG_YAFFS_XATTR /* -Older-style on-NAND data format has a "pageStatus" byte to record +Older-style on-NAND data format has a "page_status" byte to record chunk/page state. This byte is zeroed when the page is discarded. Choose this option if you have existing on-NAND data in this format that you need to continue to support. New data written also uses the @@ -78,7 +78,7 @@ adjusted to use the older-style format. See notes on tags formats and MTD versions in yaffs_mtdif1.c. */ /* Default: Not selected */ -/* Meaning: Use older-style on-NAND data format with pageStatus byte */ +/* Meaning: Use older-style on-NAND data format with page_status byte */ /* #define CONFIG_YAFFS_9BYTE_TAGS */ #endif /* YAFFS_OUT_OF_TREE */ diff --git a/mtdemul/nandemul2k.c b/mtdemul/nandemul2k.c index 7efa8d4..a877cbe 100644 --- a/mtdemul/nandemul2k.c +++ b/mtdemul/nandemul2k.c @@ -99,18 +99,18 @@ static void nandemul_yield(int n) } -static void nandemul2k_Read(void *buffer, int page, int start, int nBytes) +static void nandemul2k_Read(void *buffer, int page, int start, int n_bytes) { int pg = page%PAGES_PER_BLOCK; int blk = page/PAGES_PER_BLOCK; - if(buffer && nBytes > 0) + if(buffer && n_bytes > 0) { - memcpy(buffer,&ned.block[blk]->page[pg]->data[start],nBytes); + memcpy(buffer,&ned.block[blk]->page[pg]->data[start],n_bytes); } } -static void nandemul2k_Program(const void *buffer, int page, int start, int nBytes) +static void nandemul2k_Program(const void *buffer, int page, int start, int n_bytes) { int pg = page%PAGES_PER_BLOCK; int blk = page/PAGES_PER_BLOCK; @@ -119,12 +119,12 @@ static void nandemul2k_Program(const void *buffer, int page, int start, int nByt p = &ned.block[blk]->page[pg]->data[start]; - while(buffer && nBytes>0) + while(buffer && n_bytes>0) { *p = *p & *b; p++; b++; - nBytes--; + n_bytes--; } } diff --git a/patches/yaffs_mtdif2.c b/patches/yaffs_mtdif2.c index 6d95651..71fb027 100644 --- a/patches/yaffs_mtdif2.c +++ b/patches/yaffs_mtdif2.c @@ -28,7 +28,7 @@ const char *yaffs_mtdif2_c_version = #include "yaffs_packedtags2.h" -void nandmtd2_pt2buf(yaffs_Device *dev, yaffs_PackedTags2 *pt, int is_raw) +void nandmtd2_pt2buf(yaffs_dev_t *dev, yaffs_PackedTags2 *pt, int is_raw) { struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice); __u8 *ptab = (__u8 *)pt; /* packed tags as bytes */ @@ -69,7 +69,7 @@ void nandmtd2_pt2buf(yaffs_Device *dev, yaffs_PackedTags2 *pt, int is_raw) } -void nandmtd2_buf2pt(yaffs_Device *dev, yaffs_PackedTags2 *pt, int is_raw) +void nandmtd2_buf2pt(yaffs_dev_t *dev, yaffs_PackedTags2 *pt, int is_raw) { struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice); int i, j = 0, k, n; @@ -107,22 +107,22 @@ void nandmtd2_buf2pt(yaffs_Device *dev, yaffs_PackedTags2 *pt, int is_raw) } -int nandmtd2_WriteChunkWithTagsToNAND(yaffs_Device * dev, int chunkInNAND, +int nandmtd2_WriteChunkWithTagsToNAND(yaffs_dev_t * dev, int nand_chunk, const __u8 * data, - const yaffs_ExtendedTags * tags) + const yaffs_ext_tags * tags) { struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice); size_t dummy; int retval = 0; - loff_t addr = ((loff_t) chunkInNAND) * dev->nBytesPerChunk; + loff_t addr = ((loff_t) nand_chunk) * dev->n_bytesPerChunk; yaffs_PackedTags2 pt; T(YAFFS_TRACE_MTD, (TSTR ("nandmtd2_WriteChunkWithTagsToNAND chunk %d data %p tags %p" - TENDSTR), chunkInNAND, data, tags)); + TENDSTR), nand_chunk, data, tags)); if (tags) { yaffs_PackTags2(&pt, tags); @@ -131,7 +131,7 @@ int nandmtd2_WriteChunkWithTagsToNAND(yaffs_Device * dev, int chunkInNAND, if (data && tags) { nandmtd2_pt2buf(dev, &pt, 0); retval = - mtd->write_ecc(mtd, addr, dev->nBytesPerChunk, + mtd->write_ecc(mtd, addr, dev->n_bytesPerChunk, &dummy, data, dev->spareBuffer, NULL); @@ -149,32 +149,32 @@ int nandmtd2_WriteChunkWithTagsToNAND(yaffs_Device * dev, int chunkInNAND, return YAFFS_FAIL; } -int nandmtd2_ReadChunkWithTagsFromNAND(yaffs_Device * dev, int chunkInNAND, - __u8 * data, yaffs_ExtendedTags * tags) +int nandmtd2_ReadChunkWithTagsFromNAND(yaffs_dev_t * dev, int nand_chunk, + __u8 * data, yaffs_ext_tags * tags) { struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice); size_t dummy; int retval = 0; - loff_t addr = ((loff_t) chunkInNAND) * dev->nBytesPerChunk; + loff_t addr = ((loff_t) nand_chunk) * dev->n_bytesPerChunk; yaffs_PackedTags2 pt; T(YAFFS_TRACE_MTD, (TSTR ("nandmtd2_ReadChunkWithTagsToNAND chunk %d data %p tags %p" - TENDSTR), chunkInNAND, data, tags)); + TENDSTR), nand_chunk, data, tags)); if (0 && data && tags) { retval = - mtd->read_ecc(mtd, addr, dev->nBytesPerChunk, + mtd->read_ecc(mtd, addr, dev->n_bytesPerChunk, &dummy, data, dev->spareBuffer, NULL); nandmtd2_buf2pt(dev, &pt, 0); } else { if (data) retval = - mtd->read(mtd, addr, dev->nBytesPerChunk, &dummy, + mtd->read(mtd, addr, dev->n_bytesPerChunk, &dummy, data); if (tags) { retval = @@ -193,17 +193,17 @@ int nandmtd2_ReadChunkWithTagsFromNAND(yaffs_Device * dev, int chunkInNAND, return YAFFS_FAIL; } -int nandmtd2_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo) +int nandmtd2_MarkNANDBlockBad(struct yaffs_dev_s *dev, int block_no) { struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice); int retval; T(YAFFS_TRACE_MTD, - (TSTR("nandmtd2_MarkNANDBlockBad %d" TENDSTR), blockNo)); + (TSTR("nandmtd2_MarkNANDBlockBad %d" TENDSTR), block_no)); retval = mtd->block_markbad(mtd, - blockNo * dev->nChunksPerBlock * - dev->nBytesPerChunk); + block_no * dev->chunks_per_block * + dev->n_bytesPerChunk); if (retval == 0) return YAFFS_OK; @@ -212,41 +212,41 @@ int nandmtd2_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo) } -int nandmtd2_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockNo, - yaffs_BlockState * state, int *sequenceNumber) +int nandmtd2_QueryNANDBlock(struct yaffs_dev_s *dev, int block_no, + yaffs_block_state_t * state, int *seq_number) { struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice); int retval; T(YAFFS_TRACE_MTD, - (TSTR("nandmtd2_QueryNANDBlock %d" TENDSTR), blockNo)); + (TSTR("nandmtd2_QueryNANDBlock %d" TENDSTR), block_no)); retval = mtd->block_isbad(mtd, - blockNo * dev->nChunksPerBlock * - dev->nBytesPerChunk); + block_no * dev->chunks_per_block * + dev->n_bytesPerChunk); if (retval) { T(YAFFS_TRACE_MTD, (TSTR("block is bad" TENDSTR))); *state = YAFFS_BLOCK_STATE_DEAD; - *sequenceNumber = 0; + *seq_number = 0; } else { - yaffs_ExtendedTags t; + yaffs_ext_tags t; nandmtd2_ReadChunkWithTagsFromNAND(dev, - blockNo * - dev->nChunksPerBlock, NULL, + block_no * + dev->chunks_per_block, NULL, &t); - if (t.chunkUsed) { - *sequenceNumber = t.sequenceNumber; + if (t.chunk_used) { + *seq_number = t.seq_number; *state = YAFFS_BLOCK_STATE_NEEDS_SCANNING; } else { - *sequenceNumber = 0; + *seq_number = 0; *state = YAFFS_BLOCK_STATE_EMPTY; } T(YAFFS_TRACE_MTD, - (TSTR("block is OK seq %d state %d" TENDSTR), *sequenceNumber, + (TSTR("block is OK seq %d state %d" TENDSTR), *seq_number, *state)); } diff --git a/utils/mkyaffs2image.c b/utils/mkyaffs2image.c index ac658b1..df9b044 100644 --- a/utils/mkyaffs2image.c +++ b/utils/mkyaffs2image.c @@ -61,7 +61,7 @@ static objItem obj_list[MAX_OBJECTS]; static int n_obj = 0; static int obj_id = YAFFS_NOBJECT_BUCKETS + 1; -static int nObjects, nDirectories, nPages; +static int n_obj, nDirectories, nPages; static int outFile; @@ -145,7 +145,7 @@ static int find_obj_in_list(dev_t dev, ino_t ino) * NOTE: The tag is not usable after this other than calculating the CRC * with. */ -static void little_to_big_endian(yaffs_Tags *tagsPtr) +static void little_to_big_endian(yaffs_tags_t *tagsPtr) { #if 0 // FIXME NCB yaffs_tags_union_t * tags = (yaffs_tags_union_t* )tagsPtr; // Work in bytes. @@ -153,24 +153,24 @@ static void little_to_big_endian(yaffs_Tags *tagsPtr) memset(&temp, 0, sizeof(temp)); // Ick, I hate magic numbers. - temp.asBytes[0] = ((tags->asBytes[2] & 0x0F) << 4) | ((tags->asBytes[1] & 0xF0) >> 4); - temp.asBytes[1] = ((tags->asBytes[1] & 0x0F) << 4) | ((tags->asBytes[0] & 0xF0) >> 4); - temp.asBytes[2] = ((tags->asBytes[0] & 0x0F) << 4) | ((tags->asBytes[2] & 0x30) >> 2) | ((tags->asBytes[3] & 0xC0) >> 6); - temp.asBytes[3] = ((tags->asBytes[3] & 0x3F) << 2) | ((tags->asBytes[2] & 0xC0) >> 6); - temp.asBytes[4] = ((tags->asBytes[6] & 0x03) << 6) | ((tags->asBytes[5] & 0xFC) >> 2); - temp.asBytes[5] = ((tags->asBytes[5] & 0x03) << 6) | ((tags->asBytes[4] & 0xFC) >> 2); - temp.asBytes[6] = ((tags->asBytes[4] & 0x03) << 6) | (tags->asBytes[7] & 0x3F); - temp.asBytes[7] = (tags->asBytes[6] & 0xFC) | ((tags->asBytes[7] & 0xC0) >> 6); + temp.as_bytes[0] = ((tags->as_bytes[2] & 0x0F) << 4) | ((tags->as_bytes[1] & 0xF0) >> 4); + temp.as_bytes[1] = ((tags->as_bytes[1] & 0x0F) << 4) | ((tags->as_bytes[0] & 0xF0) >> 4); + temp.as_bytes[2] = ((tags->as_bytes[0] & 0x0F) << 4) | ((tags->as_bytes[2] & 0x30) >> 2) | ((tags->as_bytes[3] & 0xC0) >> 6); + temp.as_bytes[3] = ((tags->as_bytes[3] & 0x3F) << 2) | ((tags->as_bytes[2] & 0xC0) >> 6); + temp.as_bytes[4] = ((tags->as_bytes[6] & 0x03) << 6) | ((tags->as_bytes[5] & 0xFC) >> 2); + temp.as_bytes[5] = ((tags->as_bytes[5] & 0x03) << 6) | ((tags->as_bytes[4] & 0xFC) >> 2); + temp.as_bytes[6] = ((tags->as_bytes[4] & 0x03) << 6) | (tags->as_bytes[7] & 0x3F); + temp.as_bytes[7] = (tags->as_bytes[6] & 0xFC) | ((tags->as_bytes[7] & 0xC0) >> 6); // Now copy it back. - tags->asBytes[0] = temp.asBytes[0]; - tags->asBytes[1] = temp.asBytes[1]; - tags->asBytes[2] = temp.asBytes[2]; - tags->asBytes[3] = temp.asBytes[3]; - tags->asBytes[4] = temp.asBytes[4]; - tags->asBytes[5] = temp.asBytes[5]; - tags->asBytes[6] = temp.asBytes[6]; - tags->asBytes[7] = temp.asBytes[7]; + tags->as_bytes[0] = temp.as_bytes[0]; + tags->as_bytes[1] = temp.as_bytes[1]; + tags->as_bytes[2] = temp.as_bytes[2]; + tags->as_bytes[3] = temp.as_bytes[3]; + tags->as_bytes[4] = temp.as_bytes[4]; + tags->as_bytes[5] = temp.as_bytes[5]; + tags->as_bytes[6] = temp.as_bytes[6]; + tags->as_bytes[7] = temp.as_bytes[7]; #endif } @@ -181,9 +181,9 @@ static void shuffle_oob(char *spareData, yaffs_PackedTags2 *pt) memcpy(spareData, pt, sizeof(*pt)); } -static int write_chunk(__u8 *data, __u32 objId, __u32 chunkId, __u32 nBytes) +static int write_chunk(__u8 *data, __u32 obj_id, __u32 chunk_id, __u32 n_bytes) { - yaffs_ExtendedTags t; + yaffs_ext_tags t; yaffs_PackedTags2 pt; char spareData[spareSize]; @@ -192,16 +192,16 @@ static int write_chunk(__u8 *data, __u32 objId, __u32 chunkId, __u32 nBytes) yaffs_init_tags(&t); - t.chunkId = chunkId; -// t.serialNumber = 0; - t.serialNumber = 1; // **CHECK** - t.byteCount = nBytes; - t.objectId = objId; + t.chunk_id = chunk_id; +// t.serial_number = 0; + t.serial_number = 1; // **CHECK** + t.n_bytes = n_bytes; + t.obj_id = obj_id; - t.sequenceNumber = YAFFS_LOWEST_SEQUENCE_NUMBER; + t.seq_number = YAFFS_LOWEST_SEQUENCE_NUMBER; // added NCB **CHECK** - t.chunkUsed = 1; + t.chunk_used = 1; if (convert_endian) { @@ -230,12 +230,12 @@ static int write_chunk(__u8 *data, __u32 objId, __u32 chunkId, __u32 nBytes) (((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_ObjectHeader* oh) +static void object_header_little_to_big_endian(yaffs_obj_header* oh) { int i; oh->type = SWAP32(oh->type); // GCC makes enums 32 bits. - oh->parentObjectId = SWAP32(oh->parentObjectId); // int - oh->sum__NoLongerUsed = SWAP16(oh->sum__NoLongerUsed); // __u16 - Not used, but done for completeness. + oh->parent_obj_id = SWAP32(oh->parent_obj_id); // int + oh->sum_no_longer_used = SWAP16(oh->sum_no_longer_used); // __u16 - Not used, but done for completeness. // name = skip. Char array. Not swapped. oh->yst_mode = SWAP32(oh->yst_mode); #ifdef CONFIG_YAFFS_WINCE // WinCE doesn't implement this, but we need to just in case. @@ -243,9 +243,9 @@ static void object_header_little_to_big_endian(yaffs_ObjectHeader* oh) // Why? WINCE is little-endian only. { - int n = sizeof(oh->notForWinCE)/sizeof(oh->notForWinCE[0]); + int n = sizeof(oh->not_for_wince)/sizeof(oh->not_for_wince[0]); for(i = 0; i < n; i++) - oh->notForWinCE[i] = SWAP32(oh->notForWinCE[i]); + oh->not_for_wince[i] = SWAP32(oh->not_for_wince[i]); } #else // Regular POSIX. @@ -256,8 +256,8 @@ static void object_header_little_to_big_endian(yaffs_ObjectHeader* oh) oh->yst_ctime = SWAP32(oh->yst_ctime); #endif - oh->fileSize = SWAP32(oh->fileSize); // Aiee. An int... signed, at that! - oh->equivalentObjectId = SWAP32(oh->equivalentObjectId); + oh->file_size = SWAP32(oh->file_size); // Aiee. An int... signed, at that! + oh->equiv_id = SWAP32(oh->equiv_id); // alias - char array. oh->yst_rdev = SWAP32(oh->yst_rdev); @@ -271,25 +271,25 @@ static void object_header_little_to_big_endian(yaffs_ObjectHeader* oh) #else { - int n = sizeof(oh->roomToGrow)/sizeof(oh->roomToGrow[0]); + int n = sizeof(oh->room_to_grow)/sizeof(oh->room_to_grow[0]); for(i=0; i < n; i++) - oh->roomToGrow[i] = SWAP32(oh->roomToGrow[i]); + oh->room_to_grow[i] = SWAP32(oh->room_to_grow[i]); } #endif } -static int write_object_header(int objId, yaffs_ObjectType t, struct stat *s, int parent, const char *name, int equivalentObj, const char * alias) +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) { __u8 bytes[chunkSize]; - yaffs_ObjectHeader *oh = (yaffs_ObjectHeader *)bytes; + yaffs_obj_header *oh = (yaffs_obj_header *)bytes; memset(bytes,0xff,sizeof(bytes)); oh->type = t; - oh->parentObjectId = parent; + oh->parent_obj_id = parent; if (strlen(name)+1 > sizeof(oh->name)) { @@ -314,12 +314,12 @@ static int write_object_header(int objId, yaffs_ObjectType t, struct stat *s, in if(t == YAFFS_OBJECT_TYPE_FILE) { - oh->fileSize = s->st_size; + oh->file_size = s->st_size; } if(t == YAFFS_OBJECT_TYPE_HARDLINK) { - oh->equivalentObjectId = equivalentObj; + oh->equiv_id = equivalentObj; } if(t == YAFFS_OBJECT_TYPE_SYMLINK) @@ -338,7 +338,7 @@ static int write_object_header(int objId, yaffs_ObjectType t, struct stat *s, in object_header_little_to_big_endian(oh); } - return write_chunk(bytes,objId,0,0xffff); + return write_chunk(bytes,obj_id,0,0xffff); } @@ -407,7 +407,7 @@ static int process_directory(int parent, const char *path) { newObj = obj_id++; - nObjects++; + n_obj++; printf("Object %d, %s is a ",newObj,full_name); @@ -447,20 +447,20 @@ static int process_directory(int parent, const char *path) { int h; __u8 bytes[chunkSize]; - int nBytes; + int n_bytes; int chunk = 0; h = open(full_name,O_RDONLY); if(h >= 0) { memset(bytes,0xff,sizeof(bytes)); - while((nBytes = read(h,bytes,sizeof(bytes))) > 0) + while((n_bytes = read(h,bytes,sizeof(bytes))) > 0) { chunk++; - write_chunk(bytes,newObj,chunk,nBytes); + write_chunk(bytes,newObj,chunk,n_bytes); memset(bytes,0xff,sizeof(bytes)); } - if(nBytes < 0) + if(n_bytes < 0) warn("read"); printf("%d data chunks written\n",chunk); @@ -575,7 +575,7 @@ int main(int argc, char *argv[]) { printf("Operation complete.\n" "%d objects in %d directories\n" - "%d NAND pages\n",nObjects, nDirectories, nPages); + "%d NAND pages\n",n_obj, nDirectories, nPages); } exit(error); diff --git a/utils/mkyaffsimage.c b/utils/mkyaffsimage.c index 8a50da5..640d7ec 100644 --- a/utils/mkyaffsimage.c +++ b/utils/mkyaffsimage.c @@ -48,7 +48,7 @@ static objItem obj_list[MAX_OBJECTS]; static int n_obj = 0; static int obj_id = YAFFS_NOBJECT_BUCKETS + 1; -static int nObjects, nDirectories, nPages; +static int n_obj, nDirectories, nPages; static int outFile; @@ -130,16 +130,16 @@ static __u16 yaffs_calc_name_sum(const char *name) } -static void yaffs_calc_ecc(const __u8 *data, yaffs_Spare *spare) +static void yaffs_calc_ecc(const __u8 *data, yaffs_spare *spare) { yaffs_ecc_cacl(data , spare->ecc1); yaffs_ecc_cacl(&data[256] , spare->ecc2); } -static void yaffs_calc_tags_ecc(yaffs_Tags *tags) +static void yaffs_calc_tags_ecc(yaffs_tags_t *tags) { // Todo don't do anything yet. Need to calculate ecc - unsigned char *b = ((yaffs_tags_union_t *)tags)->asBytes; + unsigned char *b = ((yaffs_tags_union_t *)tags)->as_bytes; unsigned i,j; unsigned ecc = 0; unsigned bit = 0; @@ -181,68 +181,68 @@ static void yaffs_calc_tags_ecc(yaffs_Tags *tags) b[7] |= ((ecc & 0x3F) << 2); } } -static void yaffs_load_tags_to_spare(yaffs_Spare *sparePtr, yaffs_Tags *tagsPtr) +static void yaffs_load_tags_to_spare(yaffs_spare *sparePtr, yaffs_tags_t *tagsPtr) { yaffs_tags_union_t *tu = (yaffs_tags_union_t *)tagsPtr; //yaffs_calc_tags_ecc(tagsPtr); - sparePtr->tb0 = tu->asBytes[0]; - sparePtr->tb1 = tu->asBytes[1]; - sparePtr->tb2 = tu->asBytes[2]; - sparePtr->tb3 = tu->asBytes[3]; - sparePtr->tb4 = tu->asBytes[4]; - sparePtr->tb5 = tu->asBytes[5]; - sparePtr->tb6 = tu->asBytes[6]; - sparePtr->tb7 = tu->asBytes[7]; + sparePtr->tb0 = tu->as_bytes[0]; + sparePtr->tb1 = tu->as_bytes[1]; + sparePtr->tb2 = tu->as_bytes[2]; + sparePtr->tb3 = tu->as_bytes[3]; + sparePtr->tb4 = tu->as_bytes[4]; + sparePtr->tb5 = tu->as_bytes[5]; + sparePtr->tb6 = tu->as_bytes[6]; + sparePtr->tb7 = tu->as_bytes[7]; } /* This little function converts a little endian tag to a big endian tag. * NOTE: The tag is not usable after this other than calculating the CRC * with. */ -static void little_to_big_endian(yaffs_Tags *tagsPtr) +static void little_to_big_endian(yaffs_tags_t *tagsPtr) { yaffs_tags_union_t * tags = (yaffs_tags_union_t* )tagsPtr; // Work in bytes. yaffs_tags_union_t temp; memset(&temp, 0, sizeof(temp)); // Ick, I hate magic numbers. - temp.asBytes[0] = ((tags->asBytes[2] & 0x0F) << 4) | ((tags->asBytes[1] & 0xF0) >> 4); - temp.asBytes[1] = ((tags->asBytes[1] & 0x0F) << 4) | ((tags->asBytes[0] & 0xF0) >> 4); - temp.asBytes[2] = ((tags->asBytes[0] & 0x0F) << 4) | ((tags->asBytes[2] & 0x30) >> 2) | ((tags->asBytes[3] & 0xC0) >> 6); - temp.asBytes[3] = ((tags->asBytes[3] & 0x3F) << 2) | ((tags->asBytes[2] & 0xC0) >> 6); - temp.asBytes[4] = ((tags->asBytes[6] & 0x03) << 6) | ((tags->asBytes[5] & 0xFC) >> 2); - temp.asBytes[5] = ((tags->asBytes[5] & 0x03) << 6) | ((tags->asBytes[4] & 0xFC) >> 2); - temp.asBytes[6] = ((tags->asBytes[4] & 0x03) << 6) | (tags->asBytes[7] & 0x3F); - temp.asBytes[7] = (tags->asBytes[6] & 0xFC) | ((tags->asBytes[7] & 0xC0) >> 6); + temp.as_bytes[0] = ((tags->as_bytes[2] & 0x0F) << 4) | ((tags->as_bytes[1] & 0xF0) >> 4); + temp.as_bytes[1] = ((tags->as_bytes[1] & 0x0F) << 4) | ((tags->as_bytes[0] & 0xF0) >> 4); + temp.as_bytes[2] = ((tags->as_bytes[0] & 0x0F) << 4) | ((tags->as_bytes[2] & 0x30) >> 2) | ((tags->as_bytes[3] & 0xC0) >> 6); + temp.as_bytes[3] = ((tags->as_bytes[3] & 0x3F) << 2) | ((tags->as_bytes[2] & 0xC0) >> 6); + temp.as_bytes[4] = ((tags->as_bytes[6] & 0x03) << 6) | ((tags->as_bytes[5] & 0xFC) >> 2); + temp.as_bytes[5] = ((tags->as_bytes[5] & 0x03) << 6) | ((tags->as_bytes[4] & 0xFC) >> 2); + temp.as_bytes[6] = ((tags->as_bytes[4] & 0x03) << 6) | (tags->as_bytes[7] & 0x3F); + temp.as_bytes[7] = (tags->as_bytes[6] & 0xFC) | ((tags->as_bytes[7] & 0xC0) >> 6); // Now copy it back. - tags->asBytes[0] = temp.asBytes[0]; - tags->asBytes[1] = temp.asBytes[1]; - tags->asBytes[2] = temp.asBytes[2]; - tags->asBytes[3] = temp.asBytes[3]; - tags->asBytes[4] = temp.asBytes[4]; - tags->asBytes[5] = temp.asBytes[5]; - tags->asBytes[6] = temp.asBytes[6]; - tags->asBytes[7] = temp.asBytes[7]; + tags->as_bytes[0] = temp.as_bytes[0]; + tags->as_bytes[1] = temp.as_bytes[1]; + tags->as_bytes[2] = temp.as_bytes[2]; + tags->as_bytes[3] = temp.as_bytes[3]; + tags->as_bytes[4] = temp.as_bytes[4]; + tags->as_bytes[5] = temp.as_bytes[5]; + tags->as_bytes[6] = temp.as_bytes[6]; + tags->as_bytes[7] = temp.as_bytes[7]; } -static int write_chunk(__u8 *data, __u32 objId, __u32 chunkId, __u32 nBytes) +static int write_chunk(__u8 *data, __u32 obj_id, __u32 chunk_id, __u32 n_bytes) { - yaffs_Tags t; - yaffs_Spare s; + yaffs_tags_t t; + yaffs_spare s; error = write(outFile,data,512); if(error < 0) return error; - memset(&t,0xff,sizeof (yaffs_Tags)); - memset(&s,0xff,sizeof (yaffs_Spare)); + memset(&t,0xff,sizeof (yaffs_tags_t)); + memset(&s,0xff,sizeof (yaffs_spare)); - t.chunkId = chunkId; - t.serialNumber = 0; - t.byteCountLSB = nBytes; - t.objectId = objId; + t.chunk_id = chunk_id; + t.serial_number = 0; + t.n_bytes_lsb = n_bytes; + t.obj_id = obj_id; if (convert_endian) { @@ -255,7 +255,7 @@ static int write_chunk(__u8 *data, __u32 objId, __u32 chunkId, __u32 nBytes) nPages++; - return write(outFile,&s,sizeof(yaffs_Spare)); + return write(outFile,&s,sizeof(yaffs_spare)); } @@ -268,20 +268,20 @@ static int write_chunk(__u8 *data, __u32 objId, __u32 chunkId, __u32 nBytes) (((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_ObjectHeader* oh) +static void object_header_little_to_big_endian(yaffs_obj_header* oh) { oh->type = SWAP32(oh->type); // GCC makes enums 32 bits. - oh->parentObjectId = SWAP32(oh->parentObjectId); // int - oh->sum__NoLongerUsed = SWAP16(oh->sum__NoLongerUsed); // __u16 - Not used, but done for completeness. + oh->parent_obj_id = SWAP32(oh->parent_obj_id); // int + oh->sum_no_longer_used = SWAP16(oh->sum_no_longer_used); // __u16 - Not used, but done for completeness. // name = skip. Char array. Not swapped. oh->yst_mode = SWAP32(oh->yst_mode); #ifdef CONFIG_YAFFS_WINCE // WinCE doesn't implement this, but we need to just in case. // In fact, WinCE would be *THE* place where this would be an issue! - oh->notForWinCE[0] = SWAP32(oh->notForWinCE[0]); - oh->notForWinCE[1] = SWAP32(oh->notForWinCE[1]); - oh->notForWinCE[2] = SWAP32(oh->notForWinCE[2]); - oh->notForWinCE[3] = SWAP32(oh->notForWinCE[3]); - oh->notForWinCE[4] = SWAP32(oh->notForWinCE[4]); + oh->not_for_wince[0] = SWAP32(oh->not_for_wince[0]); + oh->not_for_wince[1] = SWAP32(oh->not_for_wince[1]); + oh->not_for_wince[2] = SWAP32(oh->not_for_wince[2]); + oh->not_for_wince[3] = SWAP32(oh->not_for_wince[3]); + oh->not_for_wince[4] = SWAP32(oh->not_for_wince[4]); #else // Regular POSIX. oh->yst_uid = SWAP32(oh->yst_uid); @@ -291,8 +291,8 @@ static void object_header_little_to_big_endian(yaffs_ObjectHeader* oh) oh->yst_ctime = SWAP32(oh->yst_ctime); #endif - oh->fileSize = SWAP32(oh->fileSize); // Aiee. An int... signed, at that! - oh->equivalentObjectId = SWAP32(oh->equivalentObjectId); + oh->file_size = SWAP32(oh->file_size); // Aiee. An int... signed, at that! + oh->equiv_id = SWAP32(oh->equiv_id); // alias - char array. oh->yst_rdev = SWAP32(oh->yst_rdev); @@ -303,40 +303,40 @@ static void object_header_little_to_big_endian(yaffs_ObjectHeader* oh) oh->win_atime[1] = SWAP32(oh->win_atime[1]); oh->win_mtime[0] = SWAP32(oh->win_mtime[0]); oh->win_mtime[1] = SWAP32(oh->win_mtime[1]); - oh->roomToGrow[0] = SWAP32(oh->roomToGrow[0]); - oh->roomToGrow[1] = SWAP32(oh->roomToGrow[1]); - oh->roomToGrow[2] = SWAP32(oh->roomToGrow[2]); - oh->roomToGrow[3] = SWAP32(oh->roomToGrow[3]); - oh->roomToGrow[4] = SWAP32(oh->roomToGrow[4]); - oh->roomToGrow[5] = SWAP32(oh->roomToGrow[5]); + oh->room_to_grow[0] = SWAP32(oh->room_to_grow[0]); + oh->room_to_grow[1] = SWAP32(oh->room_to_grow[1]); + oh->room_to_grow[2] = SWAP32(oh->room_to_grow[2]); + oh->room_to_grow[3] = SWAP32(oh->room_to_grow[3]); + oh->room_to_grow[4] = SWAP32(oh->room_to_grow[4]); + oh->room_to_grow[5] = SWAP32(oh->room_to_grow[5]); #else - oh->roomToGrow[0] = SWAP32(oh->roomToGrow[0]); - oh->roomToGrow[1] = SWAP32(oh->roomToGrow[1]); - oh->roomToGrow[2] = SWAP32(oh->roomToGrow[2]); - oh->roomToGrow[3] = SWAP32(oh->roomToGrow[3]); - oh->roomToGrow[4] = SWAP32(oh->roomToGrow[4]); - oh->roomToGrow[5] = SWAP32(oh->roomToGrow[5]); - oh->roomToGrow[6] = SWAP32(oh->roomToGrow[6]); - oh->roomToGrow[7] = SWAP32(oh->roomToGrow[7]); - oh->roomToGrow[8] = SWAP32(oh->roomToGrow[8]); - oh->roomToGrow[9] = SWAP32(oh->roomToGrow[9]); - oh->roomToGrow[10] = SWAP32(oh->roomToGrow[10]); - oh->roomToGrow[11] = SWAP32(oh->roomToGrow[11]); + oh->room_to_grow[0] = SWAP32(oh->room_to_grow[0]); + oh->room_to_grow[1] = SWAP32(oh->room_to_grow[1]); + oh->room_to_grow[2] = SWAP32(oh->room_to_grow[2]); + oh->room_to_grow[3] = SWAP32(oh->room_to_grow[3]); + oh->room_to_grow[4] = SWAP32(oh->room_to_grow[4]); + oh->room_to_grow[5] = SWAP32(oh->room_to_grow[5]); + oh->room_to_grow[6] = SWAP32(oh->room_to_grow[6]); + oh->room_to_grow[7] = SWAP32(oh->room_to_grow[7]); + oh->room_to_grow[8] = SWAP32(oh->room_to_grow[8]); + oh->room_to_grow[9] = SWAP32(oh->room_to_grow[9]); + oh->room_to_grow[10] = SWAP32(oh->room_to_grow[10]); + oh->room_to_grow[11] = SWAP32(oh->room_to_grow[11]); #endif } -static int write_object_header(int objId, yaffs_ObjectType t, struct stat *s, int parent, const char *name, int equivalentObj, const char * alias) +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) { __u8 bytes[512]; - yaffs_ObjectHeader *oh = (yaffs_ObjectHeader *)bytes; + yaffs_obj_header *oh = (yaffs_obj_header *)bytes; memset(bytes,0xff,512); oh->type = t; - oh->parentObjectId = parent; + oh->parent_obj_id = parent; strncpy(oh->name,name,YAFFS_MAX_NAME_LENGTH); @@ -355,12 +355,12 @@ static int write_object_header(int objId, yaffs_ObjectType t, struct stat *s, in if(t == YAFFS_OBJECT_TYPE_FILE) { - oh->fileSize = s->st_size; + oh->file_size = s->st_size; } if(t == YAFFS_OBJECT_TYPE_HARDLINK) { - oh->equivalentObjectId = equivalentObj; + oh->equiv_id = equivalentObj; } if(t == YAFFS_OBJECT_TYPE_SYMLINK) @@ -373,7 +373,7 @@ static int write_object_header(int objId, yaffs_ObjectType t, struct stat *s, in object_header_little_to_big_endian(oh); } - return write_chunk(bytes,objId,0,0xffff); + return write_chunk(bytes,obj_id,0,0xffff); } @@ -416,7 +416,7 @@ static int process_directory(int parent, const char *path) { newObj = obj_id++; - nObjects++; + n_obj++; printf("Object %d, %s is a ",newObj,full_name); @@ -454,21 +454,21 @@ static int process_directory(int parent, const char *path) { int h; __u8 bytes[512]; - int nBytes; + int n_bytes; int chunk = 0; h = open(full_name,O_RDONLY); if(h >= 0) { memset(bytes,0xff,512); - while((nBytes = read(h,bytes,512)) > 0) + while((n_bytes = read(h,bytes,512)) > 0) { chunk++; - write_chunk(bytes,newObj,chunk,nBytes); + write_chunk(bytes,newObj,chunk,n_bytes); memset(bytes,0xff,512); } - if(nBytes < 0) - error = nBytes; + if(n_bytes < 0) + error = n_bytes; printf("%d data chunks written\n",chunk); } @@ -580,7 +580,7 @@ int main(int argc, char *argv[]) { printf("Operation complete.\n" "%d objects in %d directories\n" - "%d NAND pages\n",nObjects, nDirectories, nPages); + "%d NAND pages\n",n_obj, nDirectories, nPages); } close(outFile); diff --git a/yaffs_allocator.c b/yaffs_allocator.c index 1501a8e..c0513d5 100644 --- a/yaffs_allocator.c +++ b/yaffs_allocator.c @@ -21,45 +21,45 @@ #ifdef CONFIG_YAFFS_YMALLOC_ALLOCATOR -void yaffs_deinit_raw_tnodes_and_objs(yaffs_Device *dev) +void yaffs_deinit_raw_tnodes_and_objs(yaffs_dev_t *dev) { dev = dev; } -void yaffs_init_raw_tnodes_and_objs(yaffs_Device *dev) +void yaffs_init_raw_tnodes_and_objs(yaffs_dev_t *dev) { dev = dev; } -yaffs_tnode_t *yaffs_alloc_raw_tnode(yaffs_Device *dev) +yaffs_tnode_t *yaffs_alloc_raw_tnode(yaffs_dev_t *dev) { - return (yaffs_tnode_t *)YMALLOC(dev->tnodeSize); + return (yaffs_tnode_t *)YMALLOC(dev->tnode_size); } -void yaffs_free_raw_tnode(yaffs_Device *dev, yaffs_tnode_t *tn) +void yaffs_free_raw_tnode(yaffs_dev_t *dev, yaffs_tnode_t *tn) { dev = dev; YFREE(tn); } -void yaffs_init_raw_objs(yaffs_Device *dev) +void yaffs_init_raw_objs(yaffs_dev_t *dev) { dev = dev; } -void yaffs_deinit_raw_objs(yaffs_Device *dev) +void yaffs_deinit_raw_objs(yaffs_dev_t *dev) { dev = dev; } -yaffs_Object *yaffs_alloc_raw_obj(yaffs_Device *dev) +yaffs_obj_t *yaffs_alloc_raw_obj(yaffs_dev_t *dev) { dev = dev; - return (yaffs_Object *) YMALLOC(sizeof(yaffs_Object)); + return (yaffs_obj_t *) YMALLOC(sizeof(yaffs_obj_t)); } -void yaffs_free_raw_obj(yaffs_Device *dev, yaffs_Object *obj) +void yaffs_free_raw_obj(yaffs_dev_t *dev, yaffs_obj_t *obj) { dev = dev; @@ -75,31 +75,31 @@ struct yaffs_tnode_list { typedef struct yaffs_tnode_list yaffs_tnodelist_t; -struct yaffs_ObjectList_struct { - yaffs_Object *objects; - struct yaffs_ObjectList_struct *next; +struct yaffs_obj_tList_struct { + yaffs_obj_t *objects; + struct yaffs_obj_tList_struct *next; }; -typedef struct yaffs_ObjectList_struct yaffs_ObjectList; +typedef struct yaffs_obj_tList_struct yaffs_obj_tList; struct yaffs_AllocatorStruct { - int nTnodesCreated; + int n_tnodesCreated; yaffs_tnode_t *freeTnodes; int nFreeTnodes; yaffs_tnodelist_t *allocatedTnodeList; - int nObjectsCreated; - yaffs_Object *freeObjects; + int n_objCreated; + yaffs_obj_t *freeObjects; int nFreeObjects; - yaffs_ObjectList *allocatedObjectList; + yaffs_obj_tList *allocatedObjectList; }; typedef struct yaffs_AllocatorStruct yaffs_Allocator; -static void yaffs_deinit_raw_tnodes(yaffs_Device *dev) +static void yaffs_deinit_raw_tnodes(yaffs_dev_t *dev) { yaffs_Allocator *allocator = (yaffs_Allocator *)dev->allocator; @@ -122,10 +122,10 @@ static void yaffs_deinit_raw_tnodes(yaffs_Device *dev) allocator->freeTnodes = NULL; allocator->nFreeTnodes = 0; - allocator->nTnodesCreated = 0; + allocator->n_tnodesCreated = 0; } -static void yaffs_init_raw_tnodes(yaffs_Device *dev) +static void yaffs_init_raw_tnodes(yaffs_dev_t *dev) { yaffs_Allocator *allocator = dev->allocator; @@ -133,12 +133,12 @@ static void yaffs_init_raw_tnodes(yaffs_Device *dev) allocator->allocatedTnodeList = NULL; allocator->freeTnodes = NULL; allocator->nFreeTnodes = 0; - allocator->nTnodesCreated = 0; + allocator->n_tnodesCreated = 0; } else YBUG(); } -static int yaffs_create_tnodes(yaffs_Device *dev, int nTnodes) +static int yaffs_create_tnodes(yaffs_dev_t *dev, int n_tnodes) { yaffs_Allocator *allocator = (yaffs_Allocator *)dev->allocator; int i; @@ -153,13 +153,13 @@ static int yaffs_create_tnodes(yaffs_Device *dev, int nTnodes) return YAFFS_FAIL; } - if (nTnodes < 1) + if (n_tnodes < 1) return YAFFS_OK; /* make these things */ - newTnodes = YMALLOC(nTnodes * dev->tnodeSize); + newTnodes = YMALLOC(n_tnodes * dev->tnode_size); mem = (__u8 *)newTnodes; if (!newTnodes) { @@ -169,18 +169,18 @@ static int yaffs_create_tnodes(yaffs_Device *dev, int nTnodes) } /* New hookup for wide tnodes */ - for (i = 0; i < nTnodes - 1; i++) { - curr = (yaffs_tnode_t *) &mem[i * dev->tnodeSize]; - next = (yaffs_tnode_t *) &mem[(i+1) * dev->tnodeSize]; + 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->internal[0] = next; } - curr = (yaffs_tnode_t *) &mem[(nTnodes - 1) * dev->tnodeSize]; + curr = (yaffs_tnode_t *) &mem[(n_tnodes - 1) * dev->tnode_size]; curr->internal[0] = allocator->freeTnodes; allocator->freeTnodes = (yaffs_tnode_t *)mem; - allocator->nFreeTnodes += nTnodes; - allocator->nTnodesCreated += nTnodes; + allocator->nFreeTnodes += n_tnodes; + allocator->n_tnodesCreated += n_tnodes; /* Now add this bunch of tnodes to a list for freeing up. * NB If we can't add this to the management list it isn't fatal @@ -205,7 +205,7 @@ static int yaffs_create_tnodes(yaffs_Device *dev, int nTnodes) } -yaffs_tnode_t *yaffs_alloc_raw_tnode(yaffs_Device *dev) +yaffs_tnode_t *yaffs_alloc_raw_tnode(yaffs_dev_t *dev) { yaffs_Allocator *allocator = (yaffs_Allocator *)dev->allocator; yaffs_tnode_t *tn = NULL; @@ -229,7 +229,7 @@ yaffs_tnode_t *yaffs_alloc_raw_tnode(yaffs_Device *dev) } /* FreeTnode frees up a tnode and puts it back on the free list */ -void yaffs_free_raw_tnode(yaffs_Device *dev, yaffs_tnode_t *tn) +void yaffs_free_raw_tnode(yaffs_dev_t *dev, yaffs_tnode_t *tn) { yaffs_Allocator *allocator = dev->allocator; @@ -243,12 +243,12 @@ void yaffs_free_raw_tnode(yaffs_Device *dev, yaffs_tnode_t *tn) allocator->freeTnodes = tn; allocator->nFreeTnodes++; } - dev->nCheckpointBlocksRequired = 0; /* force recalculation*/ + dev->checkpoint_blocks_required = 0; /* force recalculation*/ } -static void yaffs_init_raw_objs(yaffs_Device *dev) +static void yaffs_init_raw_objs(yaffs_dev_t *dev) { yaffs_Allocator *allocator = dev->allocator; @@ -260,10 +260,10 @@ static void yaffs_init_raw_objs(yaffs_Device *dev) YBUG(); } -static void yaffs_deinit_raw_objs(yaffs_Device *dev) +static void yaffs_deinit_raw_objs(yaffs_dev_t *dev) { yaffs_Allocator *allocator = dev->allocator; - yaffs_ObjectList *tmp; + yaffs_obj_tList *tmp; if(!allocator){ YBUG(); @@ -280,29 +280,29 @@ static void yaffs_deinit_raw_objs(yaffs_Device *dev) allocator->freeObjects = NULL; allocator->nFreeObjects = 0; - allocator->nObjectsCreated = 0; + allocator->n_objCreated = 0; } -static int yaffs_create_free_objs(yaffs_Device *dev, int nObjects) +static int yaffs_create_free_objs(yaffs_dev_t *dev, int n_obj) { yaffs_Allocator *allocator = dev->allocator; int i; - yaffs_Object *newObjects; - yaffs_ObjectList *list; + yaffs_obj_t *newObjects; + yaffs_obj_tList *list; if(!allocator){ YBUG(); return YAFFS_FAIL; } - if (nObjects < 1) + if (n_obj < 1) return YAFFS_OK; /* make these things */ - newObjects = YMALLOC(nObjects * sizeof(yaffs_Object)); - list = YMALLOC(sizeof(yaffs_ObjectList)); + newObjects = YMALLOC(n_obj * sizeof(yaffs_obj_t)); + list = YMALLOC(sizeof(yaffs_obj_tList)); if (!newObjects || !list) { if (newObjects){ @@ -319,15 +319,15 @@ static int yaffs_create_free_objs(yaffs_Device *dev, int nObjects) } /* Hook them into the free list */ - for (i = 0; i < nObjects - 1; i++) { + for (i = 0; i < n_obj - 1; i++) { newObjects[i].siblings.next = (struct ylist_head *)(&newObjects[i + 1]); } - newObjects[nObjects - 1].siblings.next = (void *)allocator->freeObjects; + newObjects[n_obj - 1].siblings.next = (void *)allocator->freeObjects; allocator->freeObjects = newObjects; - allocator->nFreeObjects += nObjects; - allocator->nObjectsCreated += nObjects; + allocator->nFreeObjects += n_obj; + allocator->n_objCreated += n_obj; /* Now add this bunch of Objects to a list for freeing up. */ @@ -338,9 +338,9 @@ static int yaffs_create_free_objs(yaffs_Device *dev, int nObjects) return YAFFS_OK; } -yaffs_Object *yaffs_alloc_raw_obj(yaffs_Device *dev) +yaffs_obj_t *yaffs_alloc_raw_obj(yaffs_dev_t *dev) { - yaffs_Object *obj = NULL; + yaffs_obj_t *obj = NULL; yaffs_Allocator *allocator = dev->allocator; if(!allocator) { @@ -355,7 +355,7 @@ yaffs_Object *yaffs_alloc_raw_obj(yaffs_Device *dev) if (allocator->freeObjects) { obj = allocator->freeObjects; allocator->freeObjects = - (yaffs_Object *) (allocator->freeObjects->siblings.next); + (yaffs_obj_t *) (allocator->freeObjects->siblings.next); allocator->nFreeObjects--; } @@ -363,7 +363,7 @@ yaffs_Object *yaffs_alloc_raw_obj(yaffs_Device *dev) } -void yaffs_free_raw_obj(yaffs_Device *dev, yaffs_Object *obj) +void yaffs_free_raw_obj(yaffs_dev_t *dev, yaffs_obj_t *obj) { yaffs_Allocator *allocator = dev->allocator; @@ -378,7 +378,7 @@ void yaffs_free_raw_obj(yaffs_Device *dev, yaffs_Object *obj) } } -void yaffs_deinit_raw_tnodes_and_objs(yaffs_Device *dev) +void yaffs_deinit_raw_tnodes_and_objs(yaffs_dev_t *dev) { if(dev->allocator){ yaffs_deinit_raw_tnodes(dev); @@ -390,7 +390,7 @@ void yaffs_deinit_raw_tnodes_and_objs(yaffs_Device *dev) YBUG(); } -void yaffs_init_raw_tnodes_and_objs(yaffs_Device *dev) +void yaffs_init_raw_tnodes_and_objs(yaffs_dev_t *dev) { yaffs_Allocator *allocator; diff --git a/yaffs_allocator.h b/yaffs_allocator.h index ec9e1c7..777f3b0 100644 --- a/yaffs_allocator.h +++ b/yaffs_allocator.h @@ -18,13 +18,13 @@ #include "yaffs_guts.h" -void yaffs_init_raw_tnodes_and_objs(yaffs_Device *dev); -void yaffs_deinit_raw_tnodes_and_objs(yaffs_Device *dev); +void yaffs_init_raw_tnodes_and_objs(yaffs_dev_t *dev); +void yaffs_deinit_raw_tnodes_and_objs(yaffs_dev_t *dev); -yaffs_tnode_t *yaffs_alloc_raw_tnode(yaffs_Device *dev); -void yaffs_free_raw_tnode(yaffs_Device *dev, yaffs_tnode_t *tn); +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_Object *yaffs_alloc_raw_obj(yaffs_Device *dev); -void yaffs_free_raw_obj(yaffs_Device *dev, yaffs_Object *obj); +yaffs_obj_t *yaffs_alloc_raw_obj(yaffs_dev_t *dev); +void yaffs_free_raw_obj(yaffs_dev_t *dev, yaffs_obj_t *obj); #endif diff --git a/yaffs_bitmap.c b/yaffs_bitmap.c index a24dbb7..1769e9b 100644 --- a/yaffs_bitmap.c +++ b/yaffs_bitmap.c @@ -17,22 +17,22 @@ * Chunk bitmap manipulations */ -static Y_INLINE __u8 *yaffs_BlockBits(yaffs_Device *dev, int blk) +static Y_INLINE __u8 *yaffs_BlockBits(yaffs_dev_t *dev, int blk) { - if (blk < dev->internalStartBlock || blk > dev->internalEndBlock) { + if (blk < dev->internal_start_block || blk > dev->internal_end_block) { T(YAFFS_TRACE_ERROR, (TSTR("**>> yaffs: BlockBits block %d is not valid" TENDSTR), blk)); YBUG(); } - return dev->chunkBits + - (dev->chunkBitmapStride * (blk - dev->internalStartBlock)); + return dev->chunk_bits + + (dev->chunk_bit_stride * (blk - dev->internal_start_block)); } -void yaffs_verify_chunk_bit_id(yaffs_Device *dev, int blk, int chunk) +void yaffs_verify_chunk_bit_id(yaffs_dev_t *dev, int blk, int chunk) { - if (blk < dev->internalStartBlock || blk > dev->internalEndBlock || - chunk < 0 || chunk >= dev->param.nChunksPerBlock) { + if (blk < dev->internal_start_block || blk > dev->internal_end_block || + chunk < 0 || chunk >= dev->param.chunks_per_block) { T(YAFFS_TRACE_ERROR, (TSTR("**>> yaffs: Chunk Id (%d:%d) invalid"TENDSTR), blk, chunk)); @@ -40,14 +40,14 @@ void yaffs_verify_chunk_bit_id(yaffs_Device *dev, int blk, int chunk) } } -void yaffs_clear_chunk_bits(yaffs_Device *dev, int blk) +void yaffs_clear_chunk_bits(yaffs_dev_t *dev, int blk) { __u8 *blkBits = yaffs_BlockBits(dev, blk); - memset(blkBits, 0, dev->chunkBitmapStride); + memset(blkBits, 0, dev->chunk_bit_stride); } -void yaffs_clear_chunk_bit(yaffs_Device *dev, int blk, int chunk) +void yaffs_clear_chunk_bit(yaffs_dev_t *dev, int blk, int chunk) { __u8 *blkBits = yaffs_BlockBits(dev, blk); @@ -56,7 +56,7 @@ void yaffs_clear_chunk_bit(yaffs_Device *dev, int blk, int chunk) blkBits[chunk / 8] &= ~(1 << (chunk & 7)); } -void yaffs_set_chunk_bit(yaffs_Device *dev, int blk, int chunk) +void yaffs_set_chunk_bit(yaffs_dev_t *dev, int blk, int chunk) { __u8 *blkBits = yaffs_BlockBits(dev, blk); @@ -65,7 +65,7 @@ void yaffs_set_chunk_bit(yaffs_Device *dev, int blk, int chunk) blkBits[chunk / 8] |= (1 << (chunk & 7)); } -int yaffs_check_chunk_bit(yaffs_Device *dev, int blk, int chunk) +int yaffs_check_chunk_bit(yaffs_dev_t *dev, int blk, int chunk) { __u8 *blkBits = yaffs_BlockBits(dev, blk); yaffs_verify_chunk_bit_id(dev, blk, chunk); @@ -73,11 +73,11 @@ int yaffs_check_chunk_bit(yaffs_Device *dev, int blk, int chunk) return (blkBits[chunk / 8] & (1 << (chunk & 7))) ? 1 : 0; } -int yaffs_still_some_chunks(yaffs_Device *dev, int blk) +int yaffs_still_some_chunks(yaffs_dev_t *dev, int blk) { __u8 *blkBits = yaffs_BlockBits(dev, blk); int i; - for (i = 0; i < dev->chunkBitmapStride; i++) { + for (i = 0; i < dev->chunk_bit_stride; i++) { if (*blkBits) return 1; blkBits++; @@ -85,12 +85,12 @@ int yaffs_still_some_chunks(yaffs_Device *dev, int blk) return 0; } -int yaffs_count_chunk_bits(yaffs_Device *dev, int blk) +int yaffs_count_chunk_bits(yaffs_dev_t *dev, int blk) { __u8 *blkBits = yaffs_BlockBits(dev, blk); int i; int n = 0; - for (i = 0; i < dev->chunkBitmapStride; i++) { + for (i = 0; i < dev->chunk_bit_stride; i++) { __u8 x = *blkBits; while (x) { if (x & 1) diff --git a/yaffs_bitmap.h b/yaffs_bitmap.h index d693b31..c11ca2f 100644 --- a/yaffs_bitmap.h +++ b/yaffs_bitmap.h @@ -20,12 +20,12 @@ #include "yaffs_guts.h" -void yaffs_verify_chunk_bit_id(yaffs_Device *dev, int blk, int chunk); -void yaffs_clear_chunk_bits(yaffs_Device *dev, int blk); -void yaffs_clear_chunk_bit(yaffs_Device *dev, int blk, int chunk); -void yaffs_set_chunk_bit(yaffs_Device *dev, int blk, int chunk); -int yaffs_check_chunk_bit(yaffs_Device *dev, int blk, int chunk); -int yaffs_still_some_chunks(yaffs_Device *dev, int blk); -int yaffs_count_chunk_bits(yaffs_Device *dev, int blk); +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); #endif diff --git a/yaffs_checkptrw.c b/yaffs_checkptrw.c index c047caf..d46f563 100644 --- a/yaffs_checkptrw.c +++ b/yaffs_checkptrw.c @@ -14,9 +14,9 @@ #include "yaffs_checkptrw.h" #include "yaffs_getblockinfo.h" -static int yaffs2_checkpt_space_ok(yaffs_Device *dev) +static int yaffs2_checkpt_space_ok(yaffs_dev_t *dev) { - int blocksAvailable = dev->nErasedBlocks - dev->param.nReservedBlocks; + int blocksAvailable = dev->n_erased_blocks - dev->param.n_reserved_blocks; T(YAFFS_TRACE_CHECKPOINT, (TSTR("checkpt blocks available = %d" TENDSTR), @@ -26,56 +26,56 @@ static int yaffs2_checkpt_space_ok(yaffs_Device *dev) } -static int yaffs_checkpt_erase(yaffs_Device *dev) +static int yaffs_checkpt_erase(yaffs_dev_t *dev) { int i; - if (!dev->param.eraseBlockInNAND) + if (!dev->param.erase_fn) return 0; T(YAFFS_TRACE_CHECKPOINT, (TSTR("checking blocks %d to %d"TENDSTR), - dev->internalStartBlock, dev->internalEndBlock)); + dev->internal_start_block, dev->internal_end_block)); - for (i = dev->internalStartBlock; i <= dev->internalEndBlock; i++) { - yaffs_BlockInfo *bi = yaffs_get_block_info(dev, i); - if (bi->blockState == YAFFS_BLOCK_STATE_CHECKPOINT) { + for (i = dev->internal_start_block; i <= dev->internal_end_block; i++) { + yaffs_block_info_t *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)); - dev->nBlockErasures++; + dev->n_erasures++; - if (dev->param.eraseBlockInNAND(dev, i - dev->blockOffset /* realign */)) { - bi->blockState = YAFFS_BLOCK_STATE_EMPTY; - dev->nErasedBlocks++; - dev->nFreeChunks += dev->param.nChunksPerBlock; + if (dev->param.erase_fn(dev, i - dev->block_offset /* realign */)) { + bi->block_state = YAFFS_BLOCK_STATE_EMPTY; + dev->n_erased_blocks++; + dev->n_free_chunks += dev->param.chunks_per_block; } else { - dev->param.markNANDBlockBad(dev, i); - bi->blockState = YAFFS_BLOCK_STATE_DEAD; + dev->param.bad_block_fn(dev, i); + bi->block_state = YAFFS_BLOCK_STATE_DEAD; } } } - dev->blocksInCheckpoint = 0; + dev->blocks_in_checkpt = 0; return 1; } -static void yaffs2_checkpt_find_erased_block(yaffs_Device *dev) +static void yaffs2_checkpt_find_erased_block(yaffs_dev_t *dev) { int i; - int blocksAvailable = dev->nErasedBlocks - dev->param.nReservedBlocks; + int blocksAvailable = dev->n_erased_blocks - dev->param.n_reserved_blocks; T(YAFFS_TRACE_CHECKPOINT, (TSTR("allocating checkpt block: erased %d reserved %d avail %d next %d "TENDSTR), - dev->nErasedBlocks, dev->param.nReservedBlocks, blocksAvailable, dev->checkpointNextBlock)); + dev->n_erased_blocks, dev->param.n_reserved_blocks, blocksAvailable, dev->checkpt_next_block)); - if (dev->checkpointNextBlock >= 0 && - dev->checkpointNextBlock <= dev->internalEndBlock && + if (dev->checkpt_next_block >= 0 && + dev->checkpt_next_block <= dev->internal_end_block && blocksAvailable > 0) { - for (i = dev->checkpointNextBlock; i <= dev->internalEndBlock; i++) { - yaffs_BlockInfo *bi = yaffs_get_block_info(dev, i); - if (bi->blockState == YAFFS_BLOCK_STATE_EMPTY) { - dev->checkpointNextBlock = i + 1; - dev->checkpointCurrentBlock = i; + for (i = dev->checkpt_next_block; i <= dev->internal_end_block; i++) { + yaffs_block_info_t *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; T(YAFFS_TRACE_CHECKPOINT, (TSTR("allocating checkpt block %d"TENDSTR), i)); return; } @@ -83,34 +83,34 @@ static void yaffs2_checkpt_find_erased_block(yaffs_Device *dev) } T(YAFFS_TRACE_CHECKPOINT, (TSTR("out of checkpt blocks"TENDSTR))); - dev->checkpointNextBlock = -1; - dev->checkpointCurrentBlock = -1; + dev->checkpt_next_block = -1; + dev->checkpt_cur_block = -1; } -static void yaffs2_checkpt_find_block(yaffs_Device *dev) +static void yaffs2_checkpt_find_block(yaffs_dev_t *dev) { int i; - yaffs_ExtendedTags tags; + yaffs_ext_tags tags; T(YAFFS_TRACE_CHECKPOINT, (TSTR("find next checkpt block: start: blocks %d next %d" TENDSTR), - dev->blocksInCheckpoint, dev->checkpointNextBlock)); + dev->blocks_in_checkpt, dev->checkpt_next_block)); - if (dev->blocksInCheckpoint < dev->checkpointMaxBlocks) - for (i = dev->checkpointNextBlock; i <= dev->internalEndBlock; i++) { - int chunk = i * dev->param.nChunksPerBlock; - int realignedChunk = chunk - dev->chunkOffset; + if (dev->blocks_in_checkpt < dev->checkpt_max_blocks) + for (i = dev->checkpt_next_block; i <= dev->internal_end_block; i++) { + int chunk = i * dev->param.chunks_per_block; + int realignedChunk = chunk - dev->chunk_offset; - dev->param.readChunkWithTagsFromNAND(dev, realignedChunk, + dev->param.read_chunk_tags_fn(dev, realignedChunk, NULL, &tags); T(YAFFS_TRACE_CHECKPOINT, (TSTR("find next checkpt block: search: block %d oid %d seq %d eccr %d" TENDSTR), - i, tags.objectId, tags.sequenceNumber, tags.eccResult)); + i, tags.obj_id, tags.seq_number, tags.ecc_result)); - if (tags.sequenceNumber == YAFFS_SEQUENCE_CHECKPOINT_DATA) { + if (tags.seq_number == YAFFS_SEQUENCE_CHECKPOINT_DATA) { /* Right kind of block */ - dev->checkpointNextBlock = tags.objectId; - dev->checkpointCurrentBlock = i; - dev->checkpointBlockList[dev->blocksInCheckpoint] = i; - dev->blocksInCheckpoint++; + dev->checkpt_next_block = tags.obj_id; + dev->checkpt_cur_block = i; + dev->checkpt_block_list[dev->blocks_in_checkpt] = i; + dev->blocks_in_checkpt++; T(YAFFS_TRACE_CHECKPOINT, (TSTR("found checkpt block %d"TENDSTR), i)); return; } @@ -118,127 +118,127 @@ static void yaffs2_checkpt_find_block(yaffs_Device *dev) T(YAFFS_TRACE_CHECKPOINT, (TSTR("found no more checkpt blocks"TENDSTR))); - dev->checkpointNextBlock = -1; - dev->checkpointCurrentBlock = -1; + dev->checkpt_next_block = -1; + dev->checkpt_cur_block = -1; } -int yaffs2_checkpt_open(yaffs_Device *dev, int forWriting) +int yaffs2_checkpt_open(yaffs_dev_t *dev, int forWriting) { - dev->checkpointOpenForWrite = forWriting; + dev->checkpt_open_write = forWriting; /* Got the functions we need? */ - if (!dev->param.writeChunkWithTagsToNAND || - !dev->param.readChunkWithTagsFromNAND || - !dev->param.eraseBlockInNAND || - !dev->param.markNANDBlockBad) + if (!dev->param.write_chunk_tags_fn || + !dev->param.read_chunk_tags_fn || + !dev->param.erase_fn || + !dev->param.bad_block_fn) return 0; if (forWriting && !yaffs2_checkpt_space_ok(dev)) return 0; - if (!dev->checkpointBuffer) - dev->checkpointBuffer = YMALLOC_DMA(dev->param.totalBytesPerChunk); - if (!dev->checkpointBuffer) + if (!dev->checkpt_buffer) + dev->checkpt_buffer = YMALLOC_DMA(dev->param.total_bytes_per_chunk); + if (!dev->checkpt_buffer) return 0; - dev->checkpointPageSequence = 0; - dev->checkpointByteCount = 0; - dev->checkpointSum = 0; - dev->checkpointXor = 0; - dev->checkpointCurrentBlock = -1; - dev->checkpointCurrentChunk = -1; - dev->checkpointNextBlock = dev->internalStartBlock; + dev->checkpt_page_seq = 0; + dev->checkpt_byte_count = 0; + dev->checkpt_sum = 0; + dev->checkpt_xor = 0; + dev->checkpt_cur_block = -1; + dev->checkpt_cur_chunk = -1; + dev->checkpt_next_block = dev->internal_start_block; /* Erase all the blocks in the checkpoint area */ if (forWriting) { - memset(dev->checkpointBuffer, 0, dev->nDataBytesPerChunk); - dev->checkpointByteOffset = 0; + memset(dev->checkpt_buffer, 0, dev->data_bytes_per_chunk); + dev->checkpt_byte_offs = 0; return yaffs_checkpt_erase(dev); } else { int i; /* Set to a value that will kick off a read */ - dev->checkpointByteOffset = dev->nDataBytesPerChunk; + dev->checkpt_byte_offs = dev->data_bytes_per_chunk; /* A checkpoint block list of 1 checkpoint block per 16 block is (hopefully) * going to be way more than we need */ - dev->blocksInCheckpoint = 0; - dev->checkpointMaxBlocks = (dev->internalEndBlock - dev->internalStartBlock)/16 + 2; - dev->checkpointBlockList = YMALLOC(sizeof(int) * dev->checkpointMaxBlocks); - if(!dev->checkpointBlockList) + dev->blocks_in_checkpt = 0; + dev->checkpt_max_blocks = (dev->internal_end_block - dev->internal_start_block)/16 + 2; + dev->checkpt_block_list = YMALLOC(sizeof(int) * dev->checkpt_max_blocks); + if(!dev->checkpt_block_list) return 0; - for (i = 0; i < dev->checkpointMaxBlocks; i++) - dev->checkpointBlockList[i] = -1; + for (i = 0; i < dev->checkpt_max_blocks; i++) + dev->checkpt_block_list[i] = -1; } return 1; } -int yaffs2_get_checkpt_sum(yaffs_Device *dev, __u32 *sum) +int yaffs2_get_checkpt_sum(yaffs_dev_t *dev, __u32 *sum) { __u32 compositeSum; - compositeSum = (dev->checkpointSum << 8) | (dev->checkpointXor & 0xFF); + compositeSum = (dev->checkpt_sum << 8) | (dev->checkpt_xor & 0xFF); *sum = compositeSum; return 1; } -static int yaffs2_checkpt_flush_buffer(yaffs_Device *dev) +static int yaffs2_checkpt_flush_buffer(yaffs_dev_t *dev) { int chunk; int realignedChunk; - yaffs_ExtendedTags tags; + yaffs_ext_tags tags; - if (dev->checkpointCurrentBlock < 0) { + if (dev->checkpt_cur_block < 0) { yaffs2_checkpt_find_erased_block(dev); - dev->checkpointCurrentChunk = 0; + dev->checkpt_cur_chunk = 0; } - if (dev->checkpointCurrentBlock < 0) + if (dev->checkpt_cur_block < 0) return 0; - tags.chunkDeleted = 0; - tags.objectId = dev->checkpointNextBlock; /* Hint to next place to look */ - tags.chunkId = dev->checkpointPageSequence + 1; - tags.sequenceNumber = YAFFS_SEQUENCE_CHECKPOINT_DATA; - tags.byteCount = dev->nDataBytesPerChunk; - if (dev->checkpointCurrentChunk == 0) { + tags.is_deleted = 0; + tags.obj_id = dev->checkpt_next_block; /* Hint to next place to look */ + tags.chunk_id = dev->checkpt_page_seq + 1; + tags.seq_number = YAFFS_SEQUENCE_CHECKPOINT_DATA; + tags.n_bytes = dev->data_bytes_per_chunk; + if (dev->checkpt_cur_chunk == 0) { /* First chunk we write for the block? Set block state to checkpoint */ - yaffs_BlockInfo *bi = yaffs_get_block_info(dev, dev->checkpointCurrentBlock); - bi->blockState = YAFFS_BLOCK_STATE_CHECKPOINT; - dev->blocksInCheckpoint++; + yaffs_block_info_t *bi = yaffs_get_block_info(dev, dev->checkpt_cur_block); + bi->block_state = YAFFS_BLOCK_STATE_CHECKPOINT; + dev->blocks_in_checkpt++; } - chunk = dev->checkpointCurrentBlock * dev->param.nChunksPerBlock + dev->checkpointCurrentChunk; + chunk = dev->checkpt_cur_block * dev->param.chunks_per_block + dev->checkpt_cur_chunk; T(YAFFS_TRACE_CHECKPOINT, (TSTR("checkpoint wite buffer nand %d(%d:%d) objid %d chId %d" TENDSTR), - chunk, dev->checkpointCurrentBlock, dev->checkpointCurrentChunk, tags.objectId, tags.chunkId)); + chunk, dev->checkpt_cur_block, dev->checkpt_cur_chunk, tags.obj_id, tags.chunk_id)); - realignedChunk = chunk - dev->chunkOffset; + realignedChunk = chunk - dev->chunk_offset; - dev->nPageWrites++; + dev->n_page_writes++; - dev->param.writeChunkWithTagsToNAND(dev, realignedChunk, - dev->checkpointBuffer, &tags); - dev->checkpointByteOffset = 0; - dev->checkpointPageSequence++; - dev->checkpointCurrentChunk++; - if (dev->checkpointCurrentChunk >= dev->param.nChunksPerBlock) { - dev->checkpointCurrentChunk = 0; - dev->checkpointCurrentBlock = -1; + dev->param.write_chunk_tags_fn(dev, realignedChunk, + dev->checkpt_buffer, &tags); + dev->checkpt_byte_offs = 0; + dev->checkpt_page_seq++; + dev->checkpt_cur_chunk++; + if (dev->checkpt_cur_chunk >= dev->param.chunks_per_block) { + dev->checkpt_cur_chunk = 0; + dev->checkpt_cur_block = -1; } - memset(dev->checkpointBuffer, 0, dev->nDataBytesPerChunk); + memset(dev->checkpt_buffer, 0, dev->data_bytes_per_chunk); return 1; } -int yaffs2_checkpt_wr(yaffs_Device *dev, const void *data, int nBytes) +int yaffs2_checkpt_wr(yaffs_dev_t *dev, const void *data, int n_bytes) { int i = 0; int ok = 1; @@ -248,36 +248,36 @@ int yaffs2_checkpt_wr(yaffs_Device *dev, const void *data, int nBytes) - if (!dev->checkpointBuffer) + if (!dev->checkpt_buffer) return 0; - if (!dev->checkpointOpenForWrite) + if (!dev->checkpt_open_write) return -1; - while (i < nBytes && ok) { - dev->checkpointBuffer[dev->checkpointByteOffset] = *dataBytes; - dev->checkpointSum += *dataBytes; - dev->checkpointXor ^= *dataBytes; + while (i < n_bytes && ok) { + dev->checkpt_buffer[dev->checkpt_byte_offs] = *dataBytes; + dev->checkpt_sum += *dataBytes; + dev->checkpt_xor ^= *dataBytes; - dev->checkpointByteOffset++; + dev->checkpt_byte_offs++; i++; dataBytes++; - dev->checkpointByteCount++; + dev->checkpt_byte_count++; - if (dev->checkpointByteOffset < 0 || - dev->checkpointByteOffset >= dev->nDataBytesPerChunk) + if (dev->checkpt_byte_offs < 0 || + dev->checkpt_byte_offs >= dev->data_bytes_per_chunk) ok = yaffs2_checkpt_flush_buffer(dev); } return i; } -int yaffs2_checkpt_rd(yaffs_Device *dev, void *data, int nBytes) +int yaffs2_checkpt_rd(yaffs_dev_t *dev, void *data, int n_bytes) { int i = 0; int ok = 1; - yaffs_ExtendedTags tags; + yaffs_ext_tags tags; int chunk; @@ -285,114 +285,114 @@ int yaffs2_checkpt_rd(yaffs_Device *dev, void *data, int nBytes) __u8 *dataBytes = (__u8 *)data; - if (!dev->checkpointBuffer) + if (!dev->checkpt_buffer) return 0; - if (dev->checkpointOpenForWrite) + if (dev->checkpt_open_write) return -1; - while (i < nBytes && ok) { + while (i < n_bytes && ok) { - if (dev->checkpointByteOffset < 0 || - dev->checkpointByteOffset >= dev->nDataBytesPerChunk) { + if (dev->checkpt_byte_offs < 0 || + dev->checkpt_byte_offs >= dev->data_bytes_per_chunk) { - if (dev->checkpointCurrentBlock < 0) { + if (dev->checkpt_cur_block < 0) { yaffs2_checkpt_find_block(dev); - dev->checkpointCurrentChunk = 0; + dev->checkpt_cur_chunk = 0; } - if (dev->checkpointCurrentBlock < 0) + if (dev->checkpt_cur_block < 0) ok = 0; else { - chunk = dev->checkpointCurrentBlock * - dev->param.nChunksPerBlock + - dev->checkpointCurrentChunk; + chunk = dev->checkpt_cur_block * + dev->param.chunks_per_block + + dev->checkpt_cur_chunk; - realignedChunk = chunk - dev->chunkOffset; + realignedChunk = chunk - dev->chunk_offset; - dev->nPageReads++; + dev->n_page_reads++; /* read in the next chunk */ /* printf("read checkpoint page %d\n",dev->checkpointPage); */ - dev->param.readChunkWithTagsFromNAND(dev, + dev->param.read_chunk_tags_fn(dev, realignedChunk, - dev->checkpointBuffer, + dev->checkpt_buffer, &tags); - if (tags.chunkId != (dev->checkpointPageSequence + 1) || - tags.eccResult > YAFFS_ECC_RESULT_FIXED || - tags.sequenceNumber != YAFFS_SEQUENCE_CHECKPOINT_DATA) + if (tags.chunk_id != (dev->checkpt_page_seq + 1) || + tags.ecc_result > YAFFS_ECC_RESULT_FIXED || + tags.seq_number != YAFFS_SEQUENCE_CHECKPOINT_DATA) ok = 0; - dev->checkpointByteOffset = 0; - dev->checkpointPageSequence++; - dev->checkpointCurrentChunk++; + dev->checkpt_byte_offs = 0; + dev->checkpt_page_seq++; + dev->checkpt_cur_chunk++; - if (dev->checkpointCurrentChunk >= dev->param.nChunksPerBlock) - dev->checkpointCurrentBlock = -1; + if (dev->checkpt_cur_chunk >= dev->param.chunks_per_block) + dev->checkpt_cur_block = -1; } } if (ok) { - *dataBytes = dev->checkpointBuffer[dev->checkpointByteOffset]; - dev->checkpointSum += *dataBytes; - dev->checkpointXor ^= *dataBytes; - dev->checkpointByteOffset++; + *dataBytes = dev->checkpt_buffer[dev->checkpt_byte_offs]; + dev->checkpt_sum += *dataBytes; + dev->checkpt_xor ^= *dataBytes; + dev->checkpt_byte_offs++; i++; dataBytes++; - dev->checkpointByteCount++; + dev->checkpt_byte_count++; } } return i; } -int yaffs_checkpt_close(yaffs_Device *dev) +int yaffs_checkpt_close(yaffs_dev_t *dev) { - if (dev->checkpointOpenForWrite) { - if (dev->checkpointByteOffset != 0) + if (dev->checkpt_open_write) { + if (dev->checkpt_byte_offs != 0) yaffs2_checkpt_flush_buffer(dev); - } else if(dev->checkpointBlockList){ + } else if(dev->checkpt_block_list){ int i; - for (i = 0; i < dev->blocksInCheckpoint && dev->checkpointBlockList[i] >= 0; i++) { - int blk = dev->checkpointBlockList[i]; - yaffs_BlockInfo *bi = NULL; - if( dev->internalStartBlock <= blk && blk <= dev->internalEndBlock) + 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; + if( dev->internal_start_block <= blk && blk <= dev->internal_end_block) bi = yaffs_get_block_info(dev, blk); - if (bi && bi->blockState == YAFFS_BLOCK_STATE_EMPTY) - bi->blockState = YAFFS_BLOCK_STATE_CHECKPOINT; + if (bi && bi->block_state == YAFFS_BLOCK_STATE_EMPTY) + bi->block_state = YAFFS_BLOCK_STATE_CHECKPOINT; else { /* Todo this looks odd... */ } } - YFREE(dev->checkpointBlockList); - dev->checkpointBlockList = NULL; + YFREE(dev->checkpt_block_list); + dev->checkpt_block_list = NULL; } - dev->nFreeChunks -= dev->blocksInCheckpoint * dev->param.nChunksPerBlock; - dev->nErasedBlocks -= dev->blocksInCheckpoint; + dev->n_free_chunks -= dev->blocks_in_checkpt * dev->param.chunks_per_block; + dev->n_erased_blocks -= dev->blocks_in_checkpt; T(YAFFS_TRACE_CHECKPOINT, (TSTR("checkpoint byte count %d" TENDSTR), - dev->checkpointByteCount)); + dev->checkpt_byte_count)); - if (dev->checkpointBuffer) { + if (dev->checkpt_buffer) { /* free the buffer */ - YFREE(dev->checkpointBuffer); - dev->checkpointBuffer = NULL; + YFREE(dev->checkpt_buffer); + dev->checkpt_buffer = NULL; return 1; } else return 0; } -int yaffs2_checkpt_invalidate_stream(yaffs_Device *dev) +int yaffs2_checkpt_invalidate_stream(yaffs_dev_t *dev) { /* Erase the checkpoint data */ T(YAFFS_TRACE_CHECKPOINT, (TSTR("checkpoint invalidate of %d blocks"TENDSTR), - dev->blocksInCheckpoint)); + dev->blocks_in_checkpt)); return yaffs_checkpt_erase(dev); } diff --git a/yaffs_checkptrw.h b/yaffs_checkptrw.h index 61ba179..059ba9e 100644 --- a/yaffs_checkptrw.h +++ b/yaffs_checkptrw.h @@ -18,17 +18,17 @@ #include "yaffs_guts.h" -int yaffs2_checkpt_open(yaffs_Device *dev, int forWriting); +int yaffs2_checkpt_open(yaffs_dev_t *dev, int forWriting); -int yaffs2_checkpt_wr(yaffs_Device *dev, const void *data, int nBytes); +int yaffs2_checkpt_wr(yaffs_dev_t *dev, const void *data, int n_bytes); -int yaffs2_checkpt_rd(yaffs_Device *dev, void *data, int nBytes); +int yaffs2_checkpt_rd(yaffs_dev_t *dev, void *data, int n_bytes); -int yaffs2_get_checkpt_sum(yaffs_Device *dev, __u32 *sum); +int yaffs2_get_checkpt_sum(yaffs_dev_t *dev, __u32 *sum); -int yaffs_checkpt_close(yaffs_Device *dev); +int yaffs_checkpt_close(yaffs_dev_t *dev); -int yaffs2_checkpt_invalidate_stream(yaffs_Device *dev); +int yaffs2_checkpt_invalidate_stream(yaffs_dev_t *dev); #endif diff --git a/yaffs_ecc.c b/yaffs_ecc.c index 71ebe76..4030908 100644 --- a/yaffs_ecc.c +++ b/yaffs_ecc.c @@ -245,7 +245,7 @@ int yaffs_ecc_correct(unsigned char *data, unsigned char *read_ecc, /* * ECCxxxOther does ECC calcs on arbitrary n bytes of data */ -void yaffs_ecc_calc_other(const unsigned char *data, unsigned nBytes, +void yaffs_ecc_calc_other(const unsigned char *data, unsigned n_bytes, yaffs_ECCOther *eccOther) { unsigned int i; @@ -255,7 +255,7 @@ void yaffs_ecc_calc_other(const unsigned char *data, unsigned nBytes, unsigned line_parity_prime = 0; unsigned char b; - for (i = 0; i < nBytes; i++) { + for (i = 0; i < n_bytes; i++) { b = column_parity_table[*data++]; col_parity ^= b; @@ -272,7 +272,7 @@ void yaffs_ecc_calc_other(const unsigned char *data, unsigned nBytes, eccOther->lineParityPrime = line_parity_prime; } -int yaffs_ecc_correct_other(unsigned char *data, unsigned nBytes, +int yaffs_ecc_correct_other(unsigned char *data, unsigned n_bytes, yaffs_ECCOther *read_ecc, const yaffs_ECCOther *test_ecc) { @@ -301,7 +301,7 @@ int yaffs_ecc_correct_other(unsigned char *data, unsigned nBytes, if (cDelta & 0x02) bit |= 0x01; - if (lDelta >= nBytes) + if (lDelta >= n_bytes) return -1; data[lDelta] ^= (1 << bit); diff --git a/yaffs_ecc.h b/yaffs_ecc.h index ef1fa60..124e5a0 100644 --- a/yaffs_ecc.h +++ b/yaffs_ecc.h @@ -36,9 +36,9 @@ void yaffs_ecc_cacl(const unsigned char *data, unsigned char *ecc); int yaffs_ecc_correct(unsigned char *data, unsigned char *read_ecc, const unsigned char *test_ecc); -void yaffs_ecc_calc_other(const unsigned char *data, unsigned nBytes, +void yaffs_ecc_calc_other(const unsigned char *data, unsigned n_bytes, yaffs_ECCOther *ecc); -int yaffs_ecc_correct_other(unsigned char *data, unsigned nBytes, +int yaffs_ecc_correct_other(unsigned char *data, unsigned n_bytes, yaffs_ECCOther *read_ecc, const yaffs_ECCOther *test_ecc); #endif diff --git a/yaffs_getblockinfo.h b/yaffs_getblockinfo.h index 781d0ab..432441b 100644 --- a/yaffs_getblockinfo.h +++ b/yaffs_getblockinfo.h @@ -20,16 +20,16 @@ #include "yaffs_trace.h" /* Function to manipulate block info */ -static Y_INLINE yaffs_BlockInfo *yaffs_get_block_info(yaffs_Device * dev, int blk) +static Y_INLINE yaffs_block_info_t *yaffs_get_block_info(yaffs_dev_t * dev, int blk) { - if (blk < dev->internalStartBlock || blk > dev->internalEndBlock) { + if (blk < dev->internal_start_block || blk > dev->internal_end_block) { T(YAFFS_TRACE_ERROR, (TSTR ("**>> yaffs: getBlockInfo block %d is not valid" TENDSTR), blk)); YBUG(); } - return &dev->blockInfo[blk - dev->internalStartBlock]; + return &dev->block_info[blk - dev->internal_start_block]; } #endif diff --git a/yaffs_guts.c b/yaffs_guts.c index 8bb5ed7..36e11f5 100644 --- a/yaffs_guts.c +++ b/yaffs_guts.c @@ -42,86 +42,86 @@ /* Robustification (if it ever comes about...) */ -static void yaffs_retire_block(yaffs_Device *dev, int blockInNAND); -static void yaffs_handle_chunk_wr_error(yaffs_Device *dev, int chunkInNAND, +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, int erasedOk); -static void yaffs_handle_chunk_wr_ok(yaffs_Device *dev, int chunkInNAND, +static void yaffs_handle_chunk_wr_ok(yaffs_dev_t *dev, int nand_chunk, const __u8 *data, - const yaffs_ExtendedTags *tags); -static void yaffs_handle_chunk_update(yaffs_Device *dev, int chunkInNAND, - const yaffs_ExtendedTags *tags); + const yaffs_ext_tags *tags); +static void yaffs_handle_chunk_update(yaffs_dev_t *dev, int nand_chunk, + const yaffs_ext_tags *tags); /* Other local prototypes */ -static void yaffs_update_parent(yaffs_Object *obj); -static int yaffs_unlink_obj(yaffs_Object *obj); -static int yaffs_obj_cache_dirty(yaffs_Object *obj); +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 int yaffs_write_new_chunk(yaffs_Device *dev, +static int yaffs_write_new_chunk(yaffs_dev_t *dev, const __u8 *buffer, - yaffs_ExtendedTags *tags, + yaffs_ext_tags *tags, int useReserve); -static yaffs_Object *yaffs_new_obj(yaffs_Device *dev, int number, - yaffs_ObjectType type); +static yaffs_obj_t *yaffs_new_obj(yaffs_dev_t *dev, int number, + yaffs_obj_type type); -static int yaffs_apply_xattrib_mod(yaffs_Object *obj, char *buffer, yaffs_xattr_mod *xmod); +static int yaffs_apply_xattrib_mod(yaffs_obj_t *obj, char *buffer, yaffs_xattr_mod *xmod); -static void yaffs_remove_obj_from_dir(yaffs_Object *obj); +static void yaffs_remove_obj_from_dir(yaffs_obj_t *obj); static int yaffs_check_structures(void); -static int yaffs_generic_obj_del(yaffs_Object *in); +static int yaffs_generic_obj_del(yaffs_obj_t *in); -static int yaffs_check_chunk_erased(struct yaffs_DeviceStruct *dev, - int chunkInNAND); +static int yaffs_check_chunk_erased(struct yaffs_dev_s *dev, + int nand_chunk); -static int yaffs_unlink_worker(yaffs_Object *obj); +static int yaffs_unlink_worker(yaffs_obj_t *obj); -static int yaffs_tags_match(const yaffs_ExtendedTags *tags, int objectId, +static int yaffs_tags_match(const yaffs_ext_tags *tags, int obj_id, int chunkInObject); -static int yaffs_alloc_chunk(yaffs_Device *dev, int useReserve, - yaffs_BlockInfo **blockUsedPtr); +static int yaffs_alloc_chunk(yaffs_dev_t *dev, int useReserve, + yaffs_block_info_t **blockUsedPtr); -static void yaffs_check_obj_details_loaded(yaffs_Object *in); +static void yaffs_check_obj_details_loaded(yaffs_obj_t *in); -static void yaffs_invalidate_whole_cache(yaffs_Object *in); -static void yaffs_invalidate_chunk_cache(yaffs_Object *object, int chunkId); +static void yaffs_invalidate_whole_cache(yaffs_obj_t *in); +static void yaffs_invalidate_chunk_cache(yaffs_obj_t *object, int chunk_id); -static int yaffs_find_chunk_in_file(yaffs_Object *in, int chunkInInode, - yaffs_ExtendedTags *tags); +static int yaffs_find_chunk_in_file(yaffs_obj_t *in, int inode_chunk, + yaffs_ext_tags *tags); -static int yaffs_verify_chunk_written(yaffs_Device *dev, - int chunkInNAND, +static int yaffs_verify_chunk_written(yaffs_dev_t *dev, + int nand_chunk, const __u8 *data, - yaffs_ExtendedTags *tags); + yaffs_ext_tags *tags); -static void yaffs_load_name_from_oh(yaffs_Device *dev,YCHAR *name, const YCHAR *ohName, int bufferSize); -static void yaffs_load_oh_from_name(yaffs_Device *dev,YCHAR *ohName, const YCHAR *name); +static void yaffs_load_name_from_oh(yaffs_dev_t *dev,YCHAR *name, const YCHAR *ohName, int bufferSize); +static void yaffs_load_oh_from_name(yaffs_dev_t *dev,YCHAR *ohName, const YCHAR *name); /* Function to calculate chunk and offset */ -static void yaffs_addr_to_chunk(yaffs_Device *dev, loff_t addr, int *chunkOut, +static void yaffs_addr_to_chunk(yaffs_dev_t *dev, loff_t addr, int *chunkOut, __u32 *offsetOut) { int chunk; __u32 offset; - chunk = (__u32)(addr >> dev->chunkShift); + chunk = (__u32)(addr >> dev->chunk_shift); - if (dev->chunkDiv == 1) { + if (dev->chunk_div == 1) { /* easy power of 2 case */ - offset = (__u32)(addr & dev->chunkMask); + offset = (__u32)(addr & dev->chunk_mask); } else { /* Non power-of-2 case */ loff_t chunkBase; - chunk /= dev->chunkDiv; + chunk /= dev->chunk_div; - chunkBase = ((loff_t)chunk) * dev->nDataBytesPerChunk; + chunkBase = ((loff_t)chunk) * dev->data_bytes_per_chunk; offset = (__u32)(addr - chunkBase); } @@ -181,49 +181,49 @@ static __u32 Shifts(__u32 x) * Temporary buffer manipulations. */ -static int yaffs_init_tmp_buffers(yaffs_Device *dev) +static int yaffs_init_tmp_buffers(yaffs_dev_t *dev) { int i; __u8 *buf = (__u8 *)1; - memset(dev->tempBuffer, 0, sizeof(dev->tempBuffer)); + memset(dev->temp_buffer, 0, sizeof(dev->temp_buffer)); for (i = 0; buf && i < YAFFS_N_TEMP_BUFFERS; i++) { - dev->tempBuffer[i].line = 0; /* not in use */ - dev->tempBuffer[i].buffer = buf = - YMALLOC_DMA(dev->param.totalBytesPerChunk); + dev->temp_buffer[i].line = 0; /* not in use */ + dev->temp_buffer[i].buffer = buf = + YMALLOC_DMA(dev->param.total_bytes_per_chunk); } return buf ? YAFFS_OK : YAFFS_FAIL; } -__u8 *yaffs_get_temp_buffer(yaffs_Device *dev, int lineNo) +__u8 *yaffs_get_temp_buffer(yaffs_dev_t *dev, int line_no) { int i, j; - dev->tempInUse++; - if (dev->tempInUse > dev->maxTemp) - dev->maxTemp = dev->tempInUse; + dev->temp_in_use++; + if (dev->temp_in_use > dev->max_temp) + dev->max_temp = dev->temp_in_use; for (i = 0; i < YAFFS_N_TEMP_BUFFERS; i++) { - if (dev->tempBuffer[i].line == 0) { - dev->tempBuffer[i].line = lineNo; - if ((i + 1) > dev->maxTemp) { - dev->maxTemp = i + 1; + if (dev->temp_buffer[i].line == 0) { + dev->temp_buffer[i].line = line_no; + if ((i + 1) > dev->max_temp) { + dev->max_temp = i + 1; for (j = 0; j <= i; j++) - dev->tempBuffer[j].maxLine = - dev->tempBuffer[j].line; + dev->temp_buffer[j].max_line = + dev->temp_buffer[j].line; } - return dev->tempBuffer[i].buffer; + return dev->temp_buffer[i].buffer; } } T(YAFFS_TRACE_BUFFERS, (TSTR("Out of temp buffers at line %d, other held by lines:"), - lineNo)); + line_no)); for (i = 0; i < YAFFS_N_TEMP_BUFFERS; i++) - T(YAFFS_TRACE_BUFFERS, (TSTR(" %d "), dev->tempBuffer[i].line)); + T(YAFFS_TRACE_BUFFERS, (TSTR(" %d "), dev->temp_buffer[i].line)); T(YAFFS_TRACE_BUFFERS, (TSTR(" " TENDSTR))); @@ -232,21 +232,21 @@ __u8 *yaffs_get_temp_buffer(yaffs_Device *dev, int lineNo) * This is not good. */ - dev->unmanagedTempAllocations++; - return YMALLOC(dev->nDataBytesPerChunk); + dev->unmanaged_buffer_allocs++; + return YMALLOC(dev->data_bytes_per_chunk); } -void yaffs_release_temp_buffer(yaffs_Device *dev, __u8 *buffer, - int lineNo) +void yaffs_release_temp_buffer(yaffs_dev_t *dev, __u8 *buffer, + int line_no) { int i; - dev->tempInUse--; + dev->temp_in_use--; for (i = 0; i < YAFFS_N_TEMP_BUFFERS; i++) { - if (dev->tempBuffer[i].buffer == buffer) { - dev->tempBuffer[i].line = 0; + if (dev->temp_buffer[i].buffer == buffer) { + dev->temp_buffer[i].line = 0; return; } } @@ -255,9 +255,9 @@ void yaffs_release_temp_buffer(yaffs_Device *dev, __u8 *buffer, /* assume it is an unmanaged one. */ T(YAFFS_TRACE_BUFFERS, (TSTR("Releasing unmanaged temp buffer in line %d" TENDSTR), - lineNo)); + line_no)); YFREE(buffer); - dev->unmanagedTempDeallocations++; + dev->unmanaged_buffer_deallocs++; } } @@ -265,21 +265,21 @@ void yaffs_release_temp_buffer(yaffs_Device *dev, __u8 *buffer, /* * Determine if we have a managed buffer. */ -int yaffs_is_managed_tmp_buffer(yaffs_Device *dev, const __u8 *buffer) +int yaffs_is_managed_tmp_buffer(yaffs_dev_t *dev, const __u8 *buffer) { int i; for (i = 0; i < YAFFS_N_TEMP_BUFFERS; i++) { - if (dev->tempBuffer[i].buffer == buffer) + if (dev->temp_buffer[i].buffer == buffer) return 1; } - for (i = 0; i < dev->param.nShortOpCaches; i++) { - if (dev->srCache[i].data == buffer) + for (i = 0; i < dev->param.n_caches; i++) { + if (dev->cache[i].data == buffer) return 1; } - if (buffer == dev->checkpointBuffer) + if (buffer == dev->checkpt_buffer) return 1; T(YAFFS_TRACE_ALWAYS, @@ -309,14 +309,14 @@ static Y_INLINE int yaffs_hash_fn(int n) * Note that root might have a presence in NAND if permissions are set. */ -yaffs_Object *yaffs_Root(yaffs_Device *dev) +yaffs_obj_t *yaffs_root(yaffs_dev_t *dev) { - return dev->rootDir; + return dev->root_dir; } -yaffs_Object *yaffs_LostNFound(yaffs_Device *dev) +yaffs_obj_t *yaffs_lost_n_found(yaffs_dev_t *dev) { - return dev->lostNFoundDir; + return dev->lost_n_found; } @@ -324,10 +324,10 @@ yaffs_Object *yaffs_LostNFound(yaffs_Device *dev) * Erased NAND checking functions */ -int yaffs_check_ff(__u8 *buffer, int nBytes) +int yaffs_check_ff(__u8 *buffer, int n_bytes) { /* Horrible, slow implementation */ - while (nBytes--) { + while (n_bytes--) { if (*buffer != 0xFF) return 0; buffer++; @@ -335,22 +335,22 @@ int yaffs_check_ff(__u8 *buffer, int nBytes) return 1; } -static int yaffs_check_chunk_erased(struct yaffs_DeviceStruct *dev, - int chunkInNAND) +static int yaffs_check_chunk_erased(struct yaffs_dev_s *dev, + int nand_chunk) { int retval = YAFFS_OK; __u8 *data = yaffs_get_temp_buffer(dev, __LINE__); - yaffs_ExtendedTags tags; + yaffs_ext_tags tags; int result; - result = yaffs_rd_chunk_tags_nand(dev, chunkInNAND, data, &tags); + result = yaffs_rd_chunk_tags_nand(dev, nand_chunk, data, &tags); - if (tags.eccResult > YAFFS_ECC_RESULT_NO_ERROR) + if (tags.ecc_result > YAFFS_ECC_RESULT_NO_ERROR) retval = YAFFS_FAIL; - if (!yaffs_check_ff(data, dev->nDataBytesPerChunk) || tags.chunkUsed) { + if (!yaffs_check_ff(data, dev->data_bytes_per_chunk) || tags.chunk_used) { T(YAFFS_TRACE_NANDACCESS, - (TSTR("Chunk %d not erased" TENDSTR), chunkInNAND)); + (TSTR("Chunk %d not erased" TENDSTR), nand_chunk)); retval = YAFFS_FAIL; } @@ -361,21 +361,21 @@ static int yaffs_check_chunk_erased(struct yaffs_DeviceStruct *dev, } -static int yaffs_verify_chunk_written(yaffs_Device *dev, - int chunkInNAND, +static int yaffs_verify_chunk_written(yaffs_dev_t *dev, + int nand_chunk, const __u8 *data, - yaffs_ExtendedTags *tags) + yaffs_ext_tags *tags) { int retval = YAFFS_OK; - yaffs_ExtendedTags tempTags; + yaffs_ext_tags tempTags; __u8 *buffer = yaffs_get_temp_buffer(dev,__LINE__); int result; - result = yaffs_rd_chunk_tags_nand(dev,chunkInNAND,buffer,&tempTags); - if(memcmp(buffer,data,dev->nDataBytesPerChunk) || - tempTags.objectId != tags->objectId || - tempTags.chunkId != tags->chunkId || - tempTags.byteCount != tags->byteCount) + result = yaffs_rd_chunk_tags_nand(dev,nand_chunk,buffer,&tempTags); + if(memcmp(buffer,data,dev->data_bytes_per_chunk) || + tempTags.obj_id != tags->obj_id || + tempTags.chunk_id != tags->chunk_id || + tempTags.n_bytes != tags->n_bytes) retval = YAFFS_FAIL; yaffs_release_temp_buffer(dev, buffer, __LINE__); @@ -383,9 +383,9 @@ static int yaffs_verify_chunk_written(yaffs_Device *dev, return retval; } -static int yaffs_write_new_chunk(struct yaffs_DeviceStruct *dev, +static int yaffs_write_new_chunk(struct yaffs_dev_s *dev, const __u8 *data, - yaffs_ExtendedTags *tags, + yaffs_ext_tags *tags, int useReserve) { int attempts = 0; @@ -395,7 +395,7 @@ static int yaffs_write_new_chunk(struct yaffs_DeviceStruct *dev, yaffs2_checkpt_invalidate(dev); do { - yaffs_BlockInfo *bi = 0; + yaffs_block_info_t *bi = 0; int erasedOk = 0; chunk = yaffs_alloc_chunk(dev, useReserve, &bi); @@ -431,10 +431,10 @@ static int yaffs_write_new_chunk(struct yaffs_DeviceStruct *dev, /* let's give it a try */ attempts++; - if(dev->param.alwaysCheckErased) - bi->skipErasedCheck = 0; + if(dev->param.always_check_erased) + bi->skip_erased_check = 0; - if (!bi->skipErasedCheck) { + if (!bi->skip_erased_check) { erasedOk = yaffs_check_chunk_erased(dev, chunk); if (erasedOk != YAFFS_OK) { T(YAFFS_TRACE_ERROR, @@ -453,7 +453,7 @@ static int yaffs_write_new_chunk(struct yaffs_DeviceStruct *dev, writeOk = yaffs_wr_chunk_tags_nand(dev, chunk, data, tags); - if(!bi->skipErasedCheck) + if(!bi->skip_erased_check) writeOk = yaffs_verify_chunk_written(dev, chunk, data, tags); if (writeOk != YAFFS_OK) { @@ -463,7 +463,7 @@ static int yaffs_write_new_chunk(struct yaffs_DeviceStruct *dev, continue; } - bi->skipErasedCheck = 1; + bi->skip_erased_check = 1; /* Copy the data into the robustification buffer */ yaffs_handle_chunk_wr_ok(dev, chunk, data, tags); @@ -479,7 +479,7 @@ static int yaffs_write_new_chunk(struct yaffs_DeviceStruct *dev, (TSTR("**>> yaffs write required %d attempts" TENDSTR), attempts)); - dev->nRetriedWrites += (attempts - 1); + dev->n_retired_writes += (attempts - 1); } return chunk; @@ -491,43 +491,43 @@ static int yaffs_write_new_chunk(struct yaffs_DeviceStruct *dev, * Block retiring for handling a broken block. */ -static void yaffs_retire_block(yaffs_Device *dev, int blockInNAND) +static void yaffs_retire_block(yaffs_dev_t *dev, int flash_block) { - yaffs_BlockInfo *bi = yaffs_get_block_info(dev, blockInNAND); + yaffs_block_info_t *bi = yaffs_get_block_info(dev, flash_block); yaffs2_checkpt_invalidate(dev); yaffs2_clear_oldest_dirty_seq(dev,bi); - if (yaffs_mark_bad(dev, blockInNAND) != YAFFS_OK) { - if (yaffs_erase_block(dev, blockInNAND) != YAFFS_OK) { + if (yaffs_mark_bad(dev, flash_block) != YAFFS_OK) { + if (yaffs_erase_block(dev, flash_block) != YAFFS_OK) { T(YAFFS_TRACE_ALWAYS, (TSTR( "yaffs: Failed to mark bad and erase block %d" - TENDSTR), blockInNAND)); + TENDSTR), flash_block)); } else { - yaffs_ExtendedTags tags; - int chunkId = blockInNAND * dev->param.nChunksPerBlock; + yaffs_ext_tags tags; + int chunk_id = flash_block * dev->param.chunks_per_block; __u8 *buffer = yaffs_get_temp_buffer(dev, __LINE__); - memset(buffer, 0xff, dev->nDataBytesPerChunk); + memset(buffer, 0xff, dev->data_bytes_per_chunk); yaffs_init_tags(&tags); - tags.sequenceNumber = YAFFS_SEQUENCE_BAD_BLOCK; - if (dev->param.writeChunkWithTagsToNAND(dev, chunkId - - dev->chunkOffset, buffer, &tags) != YAFFS_OK) + tags.seq_number = YAFFS_SEQUENCE_BAD_BLOCK; + if (dev->param.write_chunk_tags_fn(dev, chunk_id - + dev->chunk_offset, buffer, &tags) != YAFFS_OK) T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: Failed to " TCONT("write bad block marker to block %d") - TENDSTR), blockInNAND)); + TENDSTR), flash_block)); yaffs_release_temp_buffer(dev, buffer, __LINE__); } } - bi->blockState = YAFFS_BLOCK_STATE_DEAD; - bi->gcPrioritise = 0; - bi->needsRetiring = 0; + bi->block_state = YAFFS_BLOCK_STATE_DEAD; + bi->gc_prioritise = 0; + bi->needs_retiring = 0; - dev->nRetiredBlocks++; + dev->n_retired_blocks++; } /* @@ -535,56 +535,56 @@ static void yaffs_retire_block(yaffs_Device *dev, int blockInNAND) * */ -static void yaffs_handle_chunk_wr_ok(yaffs_Device *dev, int chunkInNAND, +static void yaffs_handle_chunk_wr_ok(yaffs_dev_t *dev, int nand_chunk, const __u8 *data, - const yaffs_ExtendedTags *tags) + const yaffs_ext_tags *tags) { dev=dev; - chunkInNAND=chunkInNAND; + nand_chunk=nand_chunk; data=data; tags=tags; } -static void yaffs_handle_chunk_update(yaffs_Device *dev, int chunkInNAND, - const yaffs_ExtendedTags *tags) +static void yaffs_handle_chunk_update(yaffs_dev_t *dev, int nand_chunk, + const yaffs_ext_tags *tags) { dev=dev; - chunkInNAND=chunkInNAND; + nand_chunk=nand_chunk; tags=tags; } -void yaffs_handle_chunk_error(yaffs_Device *dev, yaffs_BlockInfo *bi) +void yaffs_handle_chunk_error(yaffs_dev_t *dev, yaffs_block_info_t *bi) { - if (!bi->gcPrioritise) { - bi->gcPrioritise = 1; - dev->hasPendingPrioritisedGCs = 1; - bi->chunkErrorStrikes++; + if (!bi->gc_prioritise) { + bi->gc_prioritise = 1; + dev->has_pending_prioritised_gc = 1; + bi->chunk_error_strikes++; - if (bi->chunkErrorStrikes > 3) { - bi->needsRetiring = 1; /* Too many stikes, so retire this */ + if (bi->chunk_error_strikes > 3) { + bi->needs_retiring = 1; /* Too many stikes, so retire this */ T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: Block struck out" TENDSTR))); } } } -static void yaffs_handle_chunk_wr_error(yaffs_Device *dev, int chunkInNAND, +static void yaffs_handle_chunk_wr_error(yaffs_dev_t *dev, int nand_chunk, int erasedOk) { - int blockInNAND = chunkInNAND / dev->param.nChunksPerBlock; - yaffs_BlockInfo *bi = yaffs_get_block_info(dev, blockInNAND); + int flash_block = nand_chunk / dev->param.chunks_per_block; + yaffs_block_info_t *bi = yaffs_get_block_info(dev, flash_block); yaffs_handle_chunk_error(dev, bi); if (erasedOk) { /* Was an actual write failure, so mark the block for retirement */ - bi->needsRetiring = 1; + bi->needs_retiring = 1; T(YAFFS_TRACE_ERROR | YAFFS_TRACE_BAD_BLOCKS, - (TSTR("**>> Block %d needs retiring" TENDSTR), blockInNAND)); + (TSTR("**>> Block %d needs retiring" TENDSTR), flash_block)); } /* Delete the chunk */ - yaffs_chunk_del(dev, chunkInNAND, 1, __LINE__); + yaffs_chunk_del(dev, nand_chunk, 1, __LINE__); yaffs_skip_rest_of_block(dev); } @@ -612,24 +612,24 @@ static __u16 yaffs_calc_name_sum(const YCHAR *name) return sum; } -void yaffs_set_obj_name(yaffs_Object *obj, const YCHAR *name) +void yaffs_set_obj_name(yaffs_obj_t *obj, const YCHAR *name) { #ifdef CONFIG_YAFFS_SHORT_NAMES_IN_RAM - memset(obj->shortName, 0, sizeof(YCHAR) * (YAFFS_SHORT_NAME_LENGTH+1)); + memset(obj->short_name, 0, sizeof(YCHAR) * (YAFFS_SHORT_NAME_LENGTH+1)); if (name && yaffs_strnlen(name,YAFFS_SHORT_NAME_LENGTH+1) <= YAFFS_SHORT_NAME_LENGTH) - yaffs_strcpy(obj->shortName, name); + yaffs_strcpy(obj->short_name, name); else - obj->shortName[0] = _Y('\0'); + obj->short_name[0] = _Y('\0'); #endif obj->sum = yaffs_calc_name_sum(name); } -void yaffs_set_obj_name_from_oh(yaffs_Object *obj, const yaffs_ObjectHeader *oh) +void yaffs_set_obj_name_from_oh(yaffs_obj_t *obj, const yaffs_obj_header *oh) { #ifdef CONFIG_YAFFS_AUTO_UNICODE YCHAR tmpName[YAFFS_MAX_NAME_LENGTH+1]; memset(tmpName,0,sizeof(tmpName)); - yaffs_load_name_from_oh(obj->myDev,tmpName,oh->name,YAFFS_MAX_NAME_LENGTH+1); + yaffs_load_name_from_oh(obj->my_dev,tmpName,oh->name,YAFFS_MAX_NAME_LENGTH+1); yaffs_set_obj_name(obj,tmpName); #else yaffs_set_obj_name(obj,oh->name); @@ -644,36 +644,36 @@ void yaffs_set_obj_name_from_oh(yaffs_Object *obj, const yaffs_ObjectHeader *oh) */ -yaffs_tnode_t *yaffs_get_tnode(yaffs_Device *dev) +yaffs_tnode_t *yaffs_get_tnode(yaffs_dev_t *dev) { yaffs_tnode_t *tn = yaffs_alloc_raw_tnode(dev); if (tn){ - memset(tn, 0, dev->tnodeSize); - dev->nTnodes++; + memset(tn, 0, dev->tnode_size); + dev->n_tnodes++; } - dev->nCheckpointBlocksRequired = 0; /* force recalculation*/ + dev->checkpoint_blocks_required = 0; /* force recalculation*/ return tn; } /* FreeTnode frees up a tnode and puts it back on the free list */ -static void yaffs_free_tnode(yaffs_Device *dev, yaffs_tnode_t *tn) +static void yaffs_free_tnode(yaffs_dev_t *dev, yaffs_tnode_t *tn) { yaffs_free_raw_tnode(dev,tn); - dev->nTnodes--; - dev->nCheckpointBlocksRequired = 0; /* force recalculation*/ + dev->n_tnodes--; + dev->checkpoint_blocks_required = 0; /* force recalculation*/ } -static void yaffs_deinit_tnodes_and_objs(yaffs_Device *dev) +static void yaffs_deinit_tnodes_and_objs(yaffs_dev_t *dev) { yaffs_deinit_raw_tnodes_and_objs(dev); - dev->nObjects = 0; - dev->nTnodes = 0; + dev->n_obj = 0; + dev->n_tnodes = 0; } -void yaffs_load_tnode_0(yaffs_Device *dev, yaffs_tnode_t *tn, unsigned pos, +void yaffs_load_tnode_0(yaffs_dev_t *dev, yaffs_tnode_t *tn, unsigned pos, unsigned val) { __u32 *map = (__u32 *)tn; @@ -683,27 +683,27 @@ void yaffs_load_tnode_0(yaffs_Device *dev, yaffs_tnode_t *tn, unsigned pos, __u32 mask; pos &= YAFFS_TNODES_LEVEL0_MASK; - val >>= dev->chunkGroupBits; + val >>= dev->chunk_grp_bits; - bitInMap = pos * dev->tnodeWidth; + bitInMap = pos * dev->tnode_width; wordInMap = bitInMap / 32; bitInWord = bitInMap & (32 - 1); - mask = dev->tnodeMask << bitInWord; + mask = dev->tnode_mask << bitInWord; map[wordInMap] &= ~mask; map[wordInMap] |= (mask & (val << bitInWord)); - if (dev->tnodeWidth > (32 - bitInWord)) { + if (dev->tnode_width > (32 - bitInWord)) { bitInWord = (32 - bitInWord); wordInMap++;; - mask = dev->tnodeMask >> (/*dev->tnodeWidth -*/ bitInWord); + mask = dev->tnode_mask >> (/*dev->tnode_width -*/ bitInWord); map[wordInMap] &= ~mask; map[wordInMap] |= (mask & (val >> bitInWord)); } } -__u32 yaffs_get_group_base(yaffs_Device *dev, yaffs_tnode_t *tn, +__u32 yaffs_get_group_base(yaffs_dev_t *dev, yaffs_tnode_t *tn, unsigned pos) { __u32 *map = (__u32 *)tn; @@ -714,20 +714,20 @@ __u32 yaffs_get_group_base(yaffs_Device *dev, yaffs_tnode_t *tn, pos &= YAFFS_TNODES_LEVEL0_MASK; - bitInMap = pos * dev->tnodeWidth; + bitInMap = pos * dev->tnode_width; wordInMap = bitInMap / 32; bitInWord = bitInMap & (32 - 1); val = map[wordInMap] >> bitInWord; - if (dev->tnodeWidth > (32 - bitInWord)) { + if (dev->tnode_width > (32 - bitInWord)) { bitInWord = (32 - bitInWord); wordInMap++;; val |= (map[wordInMap] << bitInWord); } - val &= dev->tnodeMask; - val <<= dev->chunkGroupBits; + val &= dev->tnode_mask; + val <<= dev->chunk_grp_bits; return val; } @@ -735,19 +735,19 @@ __u32 yaffs_get_group_base(yaffs_Device *dev, yaffs_tnode_t *tn, /* ------------------- End of individual tnode manipulation -----------------*/ /* ---------Functions to manipulate the look-up tree (made up of tnodes) ------ - * The look up tree is represented by the top tnode and the number of topLevel + * The look up tree is represented by the top tnode and the number of top_level * in the tree. 0 means only the level 0 tnode is in the tree. */ /* FindLevel0Tnode finds the level 0 tnode, if one exists. */ -yaffs_tnode_t *yaffs_find_tnode_0(yaffs_Device *dev, - yaffs_FileStructure *fStruct, - __u32 chunkId) +yaffs_tnode_t *yaffs_find_tnode_0(yaffs_dev_t *dev, + yaffs_file_s *file_struct, + __u32 chunk_id) { - yaffs_tnode_t *tn = fStruct->top; + yaffs_tnode_t *tn = file_struct->top; __u32 i; int requiredTallness; - int level = fStruct->topLevel; + int level = file_struct->top_level; dev=dev; @@ -755,24 +755,24 @@ yaffs_tnode_t *yaffs_find_tnode_0(yaffs_Device *dev, if (level < 0 || level > YAFFS_TNODES_MAX_LEVEL) return NULL; - if (chunkId > YAFFS_MAX_CHUNK_ID) + if (chunk_id > YAFFS_MAX_CHUNK_ID) return NULL; - /* First check we're tall enough (ie enough topLevel) */ + /* First check we're tall enough (ie enough top_level) */ - i = chunkId >> YAFFS_TNODES_LEVEL0_BITS; + i = chunk_id >> YAFFS_TNODES_LEVEL0_BITS; requiredTallness = 0; while (i) { i >>= YAFFS_TNODES_INTERNAL_BITS; requiredTallness++; } - if (requiredTallness > fStruct->topLevel) + if (requiredTallness > file_struct->top_level) return NULL; /* Not tall enough, so we can't find it */ /* Traverse down to level 0 */ while (level > 0 && tn) { - tn = tn->internal[(chunkId >> + tn = tn->internal[(chunk_id >> (YAFFS_TNODES_LEVEL0_BITS + (level - 1) * YAFFS_TNODES_INTERNAL_BITS)) & @@ -794,10 +794,10 @@ yaffs_tnode_t *yaffs_find_tnode_0(yaffs_Device *dev, * be plugged into the ttree. */ -yaffs_tnode_t *yaffs_add_find_tnode_0(yaffs_Device *dev, - yaffs_FileStructure *fStruct, - __u32 chunkId, - yaffs_tnode_t *passedTn) +yaffs_tnode_t *yaffs_add_find_tnode_0(yaffs_dev_t *dev, + yaffs_file_s *file_struct, + __u32 chunk_id, + yaffs_tnode_t *passed_tn) { int requiredTallness; int i; @@ -808,15 +808,15 @@ yaffs_tnode_t *yaffs_add_find_tnode_0(yaffs_Device *dev, /* Check sane level and page Id */ - if (fStruct->topLevel < 0 || fStruct->topLevel > YAFFS_TNODES_MAX_LEVEL) + if (file_struct->top_level < 0 || file_struct->top_level > YAFFS_TNODES_MAX_LEVEL) return NULL; - if (chunkId > YAFFS_MAX_CHUNK_ID) + if (chunk_id > YAFFS_MAX_CHUNK_ID) return NULL; - /* First check we're tall enough (ie enough topLevel) */ + /* First check we're tall enough (ie enough top_level) */ - x = chunkId >> YAFFS_TNODES_LEVEL0_BITS; + x = chunk_id >> YAFFS_TNODES_LEVEL0_BITS; requiredTallness = 0; while (x) { x >>= YAFFS_TNODES_INTERNAL_BITS; @@ -824,16 +824,16 @@ yaffs_tnode_t *yaffs_add_find_tnode_0(yaffs_Device *dev, } - if (requiredTallness > fStruct->topLevel) { + if (requiredTallness > file_struct->top_level) { /* Not tall enough, gotta make the tree taller */ - for (i = fStruct->topLevel; i < requiredTallness; i++) { + for (i = file_struct->top_level; i < requiredTallness; i++) { tn = yaffs_get_tnode(dev); if (tn) { - tn->internal[0] = fStruct->top; - fStruct->top = tn; - fStruct->topLevel++; + tn->internal[0] = file_struct->top; + file_struct->top = tn; + file_struct->top_level++; } else { T(YAFFS_TRACE_ERROR, (TSTR("yaffs: no more tnodes" TENDSTR))); @@ -844,12 +844,12 @@ yaffs_tnode_t *yaffs_add_find_tnode_0(yaffs_Device *dev, /* Traverse down to level 0, adding anything we need */ - l = fStruct->topLevel; - tn = fStruct->top; + l = file_struct->top_level; + tn = file_struct->top; if (l > 0) { while (l > 0 && tn) { - x = (chunkId >> + x = (chunk_id >> (YAFFS_TNODES_LEVEL0_BITS + (l - 1) * YAFFS_TNODES_INTERNAL_BITS)) & YAFFS_TNODES_INTERNAL_MASK; @@ -862,11 +862,11 @@ yaffs_tnode_t *yaffs_add_find_tnode_0(yaffs_Device *dev, return NULL; } else if (l == 1) { /* Looking from level 1 at level 0 */ - if (passedTn) { + if (passed_tn) { /* If we already have one, then release it.*/ if (tn->internal[x]) yaffs_free_tnode(dev, tn->internal[x]); - tn->internal[x] = passedTn; + tn->internal[x] = passed_tn; } else if (!tn->internal[x]) { /* Don't have one, none passed in */ @@ -881,31 +881,31 @@ yaffs_tnode_t *yaffs_add_find_tnode_0(yaffs_Device *dev, } } else { /* top is level 0 */ - if (passedTn) { - memcpy(tn, passedTn, (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8); - yaffs_free_tnode(dev, passedTn); + if (passed_tn) { + memcpy(tn, passed_tn, (dev->tnode_width * YAFFS_NTNODES_LEVEL0)/8); + yaffs_free_tnode(dev, passed_tn); } } return tn; } -static int yaffs_find_chunk_in_group(yaffs_Device *dev, int theChunk, - yaffs_ExtendedTags *tags, int objectId, - int chunkInInode) +static int yaffs_find_chunk_in_group(yaffs_dev_t *dev, int theChunk, + yaffs_ext_tags *tags, int obj_id, + int inode_chunk) { int j; - for (j = 0; theChunk && j < dev->chunkGroupSize; j++) { - if (yaffs_check_chunk_bit(dev, theChunk / dev->param.nChunksPerBlock, - theChunk % dev->param.nChunksPerBlock)) { + for (j = 0; theChunk && j < dev->chunk_grp_size; j++) { + if (yaffs_check_chunk_bit(dev, theChunk / dev->param.chunks_per_block, + theChunk % dev->param.chunks_per_block)) { - if(dev->chunkGroupSize == 1) + if(dev->chunk_grp_size == 1) return theChunk; else { yaffs_rd_chunk_tags_nand(dev, theChunk, NULL, tags); - if (yaffs_tags_match(tags, objectId, chunkInInode)) { + if (yaffs_tags_match(tags, obj_id, inode_chunk)) { /* found it; */ return theChunk; } @@ -924,15 +924,15 @@ static int yaffs_find_chunk_in_group(yaffs_Device *dev, int theChunk, * Returns 0 if it stopped early due to hitting the limit and the delete is incomplete. */ -static int yaffs_del_worker(yaffs_Object *in, yaffs_tnode_t *tn, __u32 level, - int chunkOffset, int *limit) +static int yaffs_del_worker(yaffs_obj_t *in, yaffs_tnode_t *tn, __u32 level, + int chunk_offset, int *limit) { int i; - int chunkInInode; + int inode_chunk; int theChunk; - yaffs_ExtendedTags tags; + yaffs_ext_tags tags; int foundChunk; - yaffs_Device *dev = in->myDev; + yaffs_dev_t *dev = in->my_dev; int allDone = 1; @@ -951,7 +951,7 @@ static int yaffs_del_worker(yaffs_Object *in, yaffs_tnode_t *tn, __u32 level, [i], level - 1, - (chunkOffset + (chunk_offset << YAFFS_TNODES_INTERNAL_BITS) + i, @@ -974,21 +974,21 @@ static int yaffs_del_worker(yaffs_Object *in, yaffs_tnode_t *tn, __u32 level, theChunk = yaffs_get_group_base(dev, tn, i); if (theChunk) { - chunkInInode = (chunkOffset << + inode_chunk = (chunk_offset << YAFFS_TNODES_LEVEL0_BITS) + i; foundChunk = yaffs_find_chunk_in_group(dev, theChunk, &tags, - in->objectId, - chunkInInode); + in->obj_id, + inode_chunk); if (foundChunk > 0) { yaffs_chunk_del(dev, foundChunk, 1, __LINE__); - in->nDataChunks--; + in->n_data_chunks--; if (limit) { *limit = *limit - 1; if (*limit <= 0) @@ -1013,19 +1013,19 @@ static int yaffs_del_worker(yaffs_Object *in, yaffs_tnode_t *tn, __u32 level, #endif -static void yaffs_soft_del_chunk(yaffs_Device *dev, int chunk) +static void yaffs_soft_del_chunk(yaffs_dev_t *dev, int chunk) { - yaffs_BlockInfo *theBlock; - unsigned blockNo; + yaffs_block_info_t *theBlock; + unsigned block_no; T(YAFFS_TRACE_DELETION, (TSTR("soft delete chunk %d" TENDSTR), chunk)); - blockNo = chunk / dev->param.nChunksPerBlock; - theBlock = yaffs_get_block_info(dev, blockNo); + block_no = chunk / dev->param.chunks_per_block; + theBlock = yaffs_get_block_info(dev, block_no); if (theBlock) { - theBlock->softDeletions++; - dev->nFreeChunks++; - yaffs2_update_oldest_dirty_seq(dev, blockNo, theBlock); + theBlock->soft_del_pages++; + dev->n_free_chunks++; + yaffs2_update_oldest_dirty_seq(dev, block_no, theBlock); } } @@ -1035,13 +1035,13 @@ static void yaffs_soft_del_chunk(yaffs_Device *dev, int chunk) * Thus, essentially this is the same as DeleteWorker except that the chunks are soft deleted. */ -static int yaffs_soft_del_worker(yaffs_Object *in, yaffs_tnode_t *tn, - __u32 level, int chunkOffset) +static int yaffs_soft_del_worker(yaffs_obj_t *in, yaffs_tnode_t *tn, + __u32 level, int chunk_offset) { int i; int theChunk; int allDone = 1; - yaffs_Device *dev = in->myDev; + yaffs_dev_t *dev = in->my_dev; if (tn) { if (level > 0) { @@ -1054,7 +1054,7 @@ static int yaffs_soft_del_worker(yaffs_Object *in, yaffs_tnode_t *tn, tn-> internal[i], level - 1, - (chunkOffset + (chunk_offset << YAFFS_TNODES_INTERNAL_BITS) + i); @@ -1093,25 +1093,25 @@ static int yaffs_soft_del_worker(yaffs_Object *in, yaffs_tnode_t *tn, } -static void yaffs_soft_del_file(yaffs_Object *obj) +static void yaffs_soft_del_file(yaffs_obj_t *obj) { if (obj->deleted && - obj->variantType == YAFFS_OBJECT_TYPE_FILE && !obj->softDeleted) { - if (obj->nDataChunks <= 0) { + obj->variant_type == YAFFS_OBJECT_TYPE_FILE && !obj->soft_del) { + if (obj->n_data_chunks <= 0) { /* Empty file with no duplicate object headers, just delete it immediately */ - yaffs_free_tnode(obj->myDev, - obj->variant.fileVariant.top); - obj->variant.fileVariant.top = NULL; + yaffs_free_tnode(obj->my_dev, + obj->variant.file_variant.top); + obj->variant.file_variant.top = NULL; T(YAFFS_TRACE_TRACING, (TSTR("yaffs: Deleting empty file %d" TENDSTR), - obj->objectId)); + obj->obj_id)); yaffs_generic_obj_del(obj); } else { yaffs_soft_del_worker(obj, - obj->variant.fileVariant.top, - obj->variant.fileVariant. - topLevel, 0); - obj->softDeleted = 1; + obj->variant.file_variant.top, + obj->variant.file_variant. + top_level, 0); + obj->soft_del = 1; } } } @@ -1131,7 +1131,7 @@ static void yaffs_soft_del_file(yaffs_Object *obj) * If there is no data in a subtree then it is pruned. */ -static yaffs_tnode_t *yaffs_prune_worker(yaffs_Device *dev, yaffs_tnode_t *tn, +static yaffs_tnode_t *yaffs_prune_worker(yaffs_dev_t *dev, yaffs_tnode_t *tn, __u32 level, int del0) { int i; @@ -1153,10 +1153,10 @@ static yaffs_tnode_t *yaffs_prune_worker(yaffs_Device *dev, yaffs_tnode_t *tn, hasData++; } } else { - int tnodeSize_u32 = dev->tnodeSize/sizeof(__u32); + int tnode_size_u32 = dev->tnode_size/sizeof(__u32); __u32 *map = (__u32 *)tn; - for(i = 0; !hasData && i < tnodeSize_u32; i++){ + for(i = 0; !hasData && i < tnode_size_u32; i++){ if(map[i]) hasData++; } @@ -1175,17 +1175,17 @@ static yaffs_tnode_t *yaffs_prune_worker(yaffs_Device *dev, yaffs_tnode_t *tn, } -static int yaffs_prune_tree(yaffs_Device *dev, - yaffs_FileStructure *fStruct) +static int yaffs_prune_tree(yaffs_dev_t *dev, + yaffs_file_s *file_struct) { int i; int hasData; int done = 0; yaffs_tnode_t *tn; - if (fStruct->topLevel > 0) { - fStruct->top = - yaffs_prune_worker(dev, fStruct->top, fStruct->topLevel, 0); + if (file_struct->top_level > 0) { + file_struct->top = + yaffs_prune_worker(dev, file_struct->top, file_struct->top_level, 0); /* Now we have a tree with all the non-zero branches NULL but the height * is the same as it was. @@ -1194,8 +1194,8 @@ static int yaffs_prune_tree(yaffs_Device *dev, * (ie all the non-zero are NULL) */ - while (fStruct->topLevel && !done) { - tn = fStruct->top; + while (file_struct->top_level && !done) { + tn = file_struct->top; hasData = 0; for (i = 1; i < YAFFS_NTNODES_INTERNAL; i++) { @@ -1204,8 +1204,8 @@ static int yaffs_prune_tree(yaffs_Device *dev, } if (!hasData) { - fStruct->top = tn->internal[0]; - fStruct->topLevel--; + file_struct->top = tn->internal[0]; + file_struct->top_level--; yaffs_free_tnode(dev, tn); } else { done = 1; @@ -1220,87 +1220,87 @@ static int yaffs_prune_tree(yaffs_Device *dev, /* AllocateEmptyObject gets us a clean Object. Tries to make allocate more if we run out */ -static yaffs_Object *yaffs_alloc_empty_obj(yaffs_Device *dev) +static yaffs_obj_t *yaffs_alloc_empty_obj(yaffs_dev_t *dev) { - yaffs_Object *obj = yaffs_alloc_raw_obj(dev); + yaffs_obj_t *obj = yaffs_alloc_raw_obj(dev); if (obj) { - dev->nObjects++; + dev->n_obj++; /* Now sweeten it up... */ - memset(obj, 0, sizeof(yaffs_Object)); - obj->beingCreated = 1; + memset(obj, 0, sizeof(yaffs_obj_t)); + obj->being_created = 1; - obj->myDev = dev; - obj->hdrChunk = 0; - obj->variantType = YAFFS_OBJECT_TYPE_UNKNOWN; - YINIT_LIST_HEAD(&(obj->hardLinks)); - YINIT_LIST_HEAD(&(obj->hashLink)); + obj->my_dev = dev; + obj->hdr_chunk = 0; + obj->variant_type = YAFFS_OBJECT_TYPE_UNKNOWN; + YINIT_LIST_HEAD(&(obj->hard_links)); + YINIT_LIST_HEAD(&(obj->hash_link)); YINIT_LIST_HEAD(&obj->siblings); /* Now make the directory sane */ - if (dev->rootDir) { - obj->parent = dev->rootDir; - ylist_add(&(obj->siblings), &dev->rootDir->variant.directoryVariant.children); + if (dev->root_dir) { + obj->parent = dev->root_dir; + ylist_add(&(obj->siblings), &dev->root_dir->variant.dir_variant.children); } /* Add it to the lost and found directory. * NB Can't put root or lostNFound in lostNFound so * check if lostNFound exists first */ - if (dev->lostNFoundDir) - yaffs_add_obj_to_dir(dev->lostNFoundDir, obj); + if (dev->lost_n_found) + yaffs_add_obj_to_dir(dev->lost_n_found, obj); - obj->beingCreated = 0; + obj->being_created = 0; } - dev->nCheckpointBlocksRequired = 0; /* force recalculation*/ + dev->checkpoint_blocks_required = 0; /* force recalculation*/ return obj; } -static yaffs_Object *yaffs_create_fake_dir(yaffs_Device *dev, int number, +static yaffs_obj_t *yaffs_create_fake_dir(yaffs_dev_t *dev, int number, __u32 mode) { - yaffs_Object *obj = + yaffs_obj_t *obj = yaffs_new_obj(dev, number, YAFFS_OBJECT_TYPE_DIRECTORY); if (obj) { obj->fake = 1; /* it is fake so it might have no NAND presence... */ - obj->renameAllowed = 0; /* ... and we're not allowed to rename it... */ - obj->unlinkAllowed = 0; /* ... or unlink it */ + obj->rename_allowed = 0; /* ... and we're not allowed to rename it... */ + obj->unlink_allowed = 0; /* ... or unlink it */ obj->deleted = 0; obj->unlinked = 0; obj->yst_mode = mode; - obj->myDev = dev; - obj->hdrChunk = 0; /* Not a valid chunk. */ + obj->my_dev = dev; + obj->hdr_chunk = 0; /* Not a valid chunk. */ } return obj; } -static void yaffs_unhash_obj(yaffs_Object *obj) +static void yaffs_unhash_obj(yaffs_obj_t *obj) { int bucket; - yaffs_Device *dev = obj->myDev; + yaffs_dev_t *dev = obj->my_dev; /* If it is still linked into the bucket list, free from the list */ - if (!ylist_empty(&obj->hashLink)) { - ylist_del_init(&obj->hashLink); - bucket = yaffs_hash_fn(obj->objectId); - dev->objectBucket[bucket].count--; + if (!ylist_empty(&obj->hash_link)) { + ylist_del_init(&obj->hash_link); + bucket = yaffs_hash_fn(obj->obj_id); + dev->obj_bucket[bucket].count--; } } /* FreeObject frees up a Object and puts it back on the free list */ -static void yaffs_free_obj(yaffs_Object *obj) +static void yaffs_free_obj(yaffs_obj_t *obj) { - yaffs_Device *dev = obj->myDev; + yaffs_dev_t *dev = obj->my_dev; - T(YAFFS_TRACE_OS, (TSTR("FreeObject %p inode %p"TENDSTR), obj, obj->myInode)); + T(YAFFS_TRACE_OS, (TSTR("FreeObject %p inode %p"TENDSTR), obj, obj->my_inode)); if (!obj) YBUG(); @@ -1310,44 +1310,44 @@ static void yaffs_free_obj(yaffs_Object *obj) YBUG(); - if (obj->myInode) { + if (obj->my_inode) { /* We're still hooked up to a cached inode. * Don't delete now, but mark for later deletion */ - obj->deferedFree = 1; + obj->defered_free = 1; return; } yaffs_unhash_obj(obj); yaffs_free_raw_obj(dev,obj); - dev->nObjects--; - dev->nCheckpointBlocksRequired = 0; /* force recalculation*/ + dev->n_obj--; + dev->checkpoint_blocks_required = 0; /* force recalculation*/ } -void yaffs_handle_defered_free(yaffs_Object *obj) +void yaffs_handle_defered_free(yaffs_obj_t *obj) { - if (obj->deferedFree) + if (obj->defered_free) yaffs_free_obj(obj); } -static void yaffs_init_tnodes_and_objs(yaffs_Device *dev) +static void yaffs_init_tnodes_and_objs(yaffs_dev_t *dev) { int i; - dev->nObjects = 0; - dev->nTnodes = 0; + dev->n_obj = 0; + dev->n_tnodes = 0; yaffs_init_raw_tnodes_and_objs(dev); for (i = 0; i < YAFFS_NOBJECT_BUCKETS; i++) { - YINIT_LIST_HEAD(&dev->objectBucket[i].list); - dev->objectBucket[i].count = 0; + YINIT_LIST_HEAD(&dev->obj_bucket[i].list); + dev->obj_bucket[i].count = 0; } } -static int yaffs_find_nice_bucket(yaffs_Device *dev) +static int yaffs_find_nice_bucket(yaffs_dev_t *dev) { int i; int l = 999; @@ -1359,11 +1359,11 @@ static int yaffs_find_nice_bucket(yaffs_Device *dev) */ for (i = 0; i < 10 && lowest > 4; i++) { - dev->bucketFinder++; - dev->bucketFinder %= YAFFS_NOBJECT_BUCKETS; - if (dev->objectBucket[dev->bucketFinder].count < lowest) { - lowest = dev->objectBucket[dev->bucketFinder].count; - l = dev->bucketFinder; + dev->bucket_finder++; + dev->bucket_finder %= YAFFS_NOBJECT_BUCKETS; + if (dev->obj_bucket[dev->bucket_finder].count < lowest) { + lowest = dev->obj_bucket[dev->bucket_finder].count; + l = dev->bucket_finder; } } @@ -1371,7 +1371,7 @@ static int yaffs_find_nice_bucket(yaffs_Device *dev) return l; } -static int yaffs_new_obj_id(yaffs_Device *dev) +static int yaffs_new_obj_id(yaffs_dev_t *dev) { int bucket = yaffs_find_nice_bucket(dev); @@ -1389,11 +1389,11 @@ static int yaffs_new_obj_id(yaffs_Device *dev) while (!found) { found = 1; n += YAFFS_NOBJECT_BUCKETS; - if (1 || dev->objectBucket[bucket].count > 0) { - ylist_for_each(i, &dev->objectBucket[bucket].list) { + 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_Object, - hashLink)->objectId == n) { + if (i && ylist_entry(i, yaffs_obj_t, + hash_link)->obj_id == n) { found = 0; } } @@ -1403,29 +1403,29 @@ static int yaffs_new_obj_id(yaffs_Device *dev) return n; } -static void yaffs_hash_obj(yaffs_Object *in) +static void yaffs_hash_obj(yaffs_obj_t *in) { - int bucket = yaffs_hash_fn(in->objectId); - yaffs_Device *dev = in->myDev; + int bucket = yaffs_hash_fn(in->obj_id); + yaffs_dev_t *dev = in->my_dev; - ylist_add(&in->hashLink, &dev->objectBucket[bucket].list); - dev->objectBucket[bucket].count++; + ylist_add(&in->hash_link, &dev->obj_bucket[bucket].list); + dev->obj_bucket[bucket].count++; } -yaffs_Object *yaffs_find_by_number(yaffs_Device *dev, __u32 number) +yaffs_obj_t *yaffs_find_by_number(yaffs_dev_t *dev, __u32 number) { int bucket = yaffs_hash_fn(number); struct ylist_head *i; - yaffs_Object *in; + yaffs_obj_t *in; - ylist_for_each(i, &dev->objectBucket[bucket].list) { + ylist_for_each(i, &dev->obj_bucket[bucket].list) { /* Look if it is in the list */ if (i) { - in = ylist_entry(i, yaffs_Object, hashLink); - if (in->objectId == number) { + in = ylist_entry(i, yaffs_obj_t, hash_link); + if (in->obj_id == number) { /* Don't tell the VFS about this one if it is defered free */ - if (in->deferedFree) + if (in->defered_free) return NULL; return in; @@ -1436,10 +1436,10 @@ yaffs_Object *yaffs_find_by_number(yaffs_Device *dev, __u32 number) return NULL; } -yaffs_Object *yaffs_new_obj(yaffs_Device *dev, int number, - yaffs_ObjectType type) +yaffs_obj_t *yaffs_new_obj(yaffs_dev_t *dev, int number, + yaffs_obj_type type) { - yaffs_Object *theObject=NULL; + yaffs_obj_t *theObject=NULL; yaffs_tnode_t *tn = NULL; if (number < 0) @@ -1461,11 +1461,11 @@ yaffs_Object *yaffs_new_obj(yaffs_Device *dev, int number, if (theObject) { theObject->fake = 0; - theObject->renameAllowed = 1; - theObject->unlinkAllowed = 1; - theObject->objectId = number; + theObject->rename_allowed = 1; + theObject->unlink_allowed = 1; + theObject->obj_id = number; yaffs_hash_obj(theObject); - theObject->variantType = type; + theObject->variant_type = type; #ifdef CONFIG_YAFFS_WINCE yfsd_win_file_time_now(theObject->win_atime); theObject->win_ctime[0] = theObject->win_mtime[0] = @@ -1480,16 +1480,16 @@ yaffs_Object *yaffs_new_obj(yaffs_Device *dev, int number, #endif switch (type) { case YAFFS_OBJECT_TYPE_FILE: - theObject->variant.fileVariant.fileSize = 0; - theObject->variant.fileVariant.scannedFileSize = 0; - theObject->variant.fileVariant.shrinkSize = 0xFFFFFFFF; /* max __u32 */ - theObject->variant.fileVariant.topLevel = 0; - theObject->variant.fileVariant.top = tn; + theObject->variant.file_variant.file_size = 0; + theObject->variant.file_variant.scanned_size = 0; + theObject->variant.file_variant.shrink_size = 0xFFFFFFFF; /* max __u32 */ + theObject->variant.file_variant.top_level = 0; + theObject->variant.file_variant.top = tn; break; case YAFFS_OBJECT_TYPE_DIRECTORY: - YINIT_LIST_HEAD(&theObject->variant.directoryVariant. + YINIT_LIST_HEAD(&theObject->variant.dir_variant. children); - YINIT_LIST_HEAD(&theObject->variant.directoryVariant. + YINIT_LIST_HEAD(&theObject->variant.dir_variant. dirty); break; case YAFFS_OBJECT_TYPE_SYMLINK: @@ -1506,11 +1506,11 @@ yaffs_Object *yaffs_new_obj(yaffs_Device *dev, int number, return theObject; } -yaffs_Object *yaffs_find_or_create_by_number(yaffs_Device *dev, +yaffs_obj_t *yaffs_find_or_create_by_number(yaffs_dev_t *dev, int number, - yaffs_ObjectType type) + yaffs_obj_type type) { - yaffs_Object *theObject = NULL; + yaffs_obj_t *theObject = NULL; if (number > 0) theObject = yaffs_find_by_number(dev, number); @@ -1543,24 +1543,24 @@ YCHAR *yaffs_clone_str(const YCHAR *str) /* * Mknod (create) a new object. - * equivalentObject only has meaning for a hard link; + * equiv_obj only has meaning for a hard link; * aliasString only has meaning for a symlink. * rdev only has meaning for devices (a subset of special objects) */ -static yaffs_Object *yaffs_create_obj(yaffs_ObjectType type, - yaffs_Object *parent, +static yaffs_obj_t *yaffs_create_obj(yaffs_obj_type type, + yaffs_obj_t *parent, const YCHAR *name, __u32 mode, __u32 uid, __u32 gid, - yaffs_Object *equivalentObject, + yaffs_obj_t *equiv_obj, const YCHAR *aliasString, __u32 rdev) { - yaffs_Object *in; + yaffs_obj_t *in; YCHAR *str = NULL; - yaffs_Device *dev = parent->myDev; + yaffs_dev_t *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)) @@ -1585,9 +1585,9 @@ static yaffs_Object *yaffs_create_obj(yaffs_ObjectType type, if (in) { - in->hdrChunk = 0; + in->hdr_chunk = 0; in->valid = 1; - in->variantType = type; + in->variant_type = type; in->yst_mode = mode; @@ -1603,25 +1603,25 @@ static yaffs_Object *yaffs_create_obj(yaffs_ObjectType type, in->yst_uid = uid; in->yst_gid = gid; #endif - in->nDataChunks = 0; + in->n_data_chunks = 0; yaffs_set_obj_name(in, name); in->dirty = 1; yaffs_add_obj_to_dir(parent, in); - in->myDev = parent->myDev; + in->my_dev = parent->my_dev; switch (type) { case YAFFS_OBJECT_TYPE_SYMLINK: - in->variant.symLinkVariant.alias = str; + in->variant.symlink_variant.alias = str; break; case YAFFS_OBJECT_TYPE_HARDLINK: - in->variant.hardLinkVariant.equivalentObject = - equivalentObject; - in->variant.hardLinkVariant.equivalentObjectId = - equivalentObject->objectId; - ylist_add(&in->hardLinks, &equivalentObject->hardLinks); + in->variant.hardlink_variant.equiv_obj = + equiv_obj; + in->variant.hardlink_variant.equiv_id = + equiv_obj->obj_id; + ylist_add(&in->hard_links, &equiv_obj->hard_links); break; case YAFFS_OBJECT_TYPE_FILE: case YAFFS_OBJECT_TYPE_DIRECTORY: @@ -1643,28 +1643,28 @@ static yaffs_Object *yaffs_create_obj(yaffs_ObjectType type, return in; } -yaffs_Object *yaffs_create_file(yaffs_Object *parent, const YCHAR *name, +yaffs_obj_t *yaffs_create_file(yaffs_obj_t *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_Object *yaffs_create_dir(yaffs_Object *parent, const YCHAR *name, +yaffs_obj_t *yaffs_create_dir(yaffs_obj_t *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_Object *yaffs_create_special(yaffs_Object *parent, const YCHAR *name, +yaffs_obj_t *yaffs_create_special(yaffs_obj_t *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_Object *yaffs_create_symlink(yaffs_Object *parent, const YCHAR *name, +yaffs_obj_t *yaffs_create_symlink(yaffs_obj_t *parent, const YCHAR *name, __u32 mode, __u32 uid, __u32 gid, const YCHAR *alias) { @@ -1672,52 +1672,52 @@ yaffs_Object *yaffs_create_symlink(yaffs_Object *parent, const YCHAR *name, uid, gid, NULL, alias, 0); } -/* yaffs_Link returns the object id of the equivalent object.*/ -yaffs_Object *yaffs_Link(yaffs_Object *parent, const YCHAR *name, - yaffs_Object *equivalentObject) +/* 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) { /* Get the real object in case we were fed a hard link as an equivalent object */ - equivalentObject = yaffs_get_equivalent_obj(equivalentObject); + equiv_obj = yaffs_get_equivalent_obj(equiv_obj); if (yaffs_create_obj (YAFFS_OBJECT_TYPE_HARDLINK, parent, name, 0, 0, 0, - equivalentObject, NULL, 0)) { - return equivalentObject; + equiv_obj, NULL, 0)) { + return equiv_obj; } else { return NULL; } } -static int yaffs_change_obj_name(yaffs_Object *obj, yaffs_Object *newDir, - const YCHAR *newName, int force, int shadows) +static int yaffs_change_obj_name(yaffs_obj_t *obj, yaffs_obj_t *new_dir, + const YCHAR *new_name, int force, int shadows) { int unlinkOp; int deleteOp; - yaffs_Object *existingTarget; + yaffs_obj_t *existingTarget; - if (newDir == NULL) - newDir = obj->parent; /* use the old directory */ + if (new_dir == NULL) + new_dir = obj->parent; /* use the old directory */ - if (newDir->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) { + if (new_dir->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) { T(YAFFS_TRACE_ALWAYS, (TSTR - ("tragedy: yaffs_change_obj_name: newDir is not a directory" + ("tragedy: yaffs_change_obj_name: new_dir is not a directory" TENDSTR))); YBUG(); } /* TODO: Do we need this different handling for YAFFS2 and YAFFS1?? */ - if (obj->myDev->param.isYaffs2) - unlinkOp = (newDir == obj->myDev->unlinkedDir); + if (obj->my_dev->param.is_yaffs2) + unlinkOp = (new_dir == obj->my_dev->unlinked_dir); else - unlinkOp = (newDir == obj->myDev->unlinkedDir - && obj->variantType == YAFFS_OBJECT_TYPE_FILE); + unlinkOp = (new_dir == obj->my_dev->unlinked_dir + && obj->variant_type == YAFFS_OBJECT_TYPE_FILE); - deleteOp = (newDir == obj->myDev->deletedDir); + deleteOp = (new_dir == obj->my_dev->del_dir); - existingTarget = yaffs_find_by_name(newDir, newName); + existingTarget = yaffs_find_by_name(new_dir, new_name); /* If the object is a file going into the unlinked directory, * then it is OK to just stuff it in since duplicate names are allowed. @@ -1729,63 +1729,63 @@ static int yaffs_change_obj_name(yaffs_Object *obj, yaffs_Object *newDir, force || (shadows > 0) || !existingTarget) && - newDir->variantType == YAFFS_OBJECT_TYPE_DIRECTORY) { - yaffs_set_obj_name(obj, newName); + new_dir->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY) { + yaffs_set_obj_name(obj, new_name); obj->dirty = 1; - yaffs_add_obj_to_dir(newDir, obj); + yaffs_add_obj_to_dir(new_dir, obj); if (unlinkOp) obj->unlinked = 1; /* If it is a deletion then we mark it as a shrink for gc purposes. */ - if (yaffs_update_oh(obj, newName, 0, deleteOp, shadows, NULL) >= 0) + if (yaffs_update_oh(obj, new_name, 0, deleteOp, shadows, NULL) >= 0) return YAFFS_OK; } return YAFFS_FAIL; } -int yaffs_rename_obj(yaffs_Object *oldDir, const YCHAR *oldName, - yaffs_Object *newDir, const YCHAR *newName) +int yaffs_rename_obj(yaffs_obj_t *old_dir, const YCHAR *old_name, + yaffs_obj_t *new_dir, const YCHAR *new_name) { - yaffs_Object *obj = NULL; - yaffs_Object *existingTarget = NULL; + yaffs_obj_t *obj = NULL; + yaffs_obj_t *existingTarget = NULL; int force = 0; int result; - yaffs_Device *dev; + yaffs_dev_t *dev; - if (!oldDir || oldDir->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) + if (!old_dir || old_dir->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) YBUG(); - if (!newDir || newDir->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) + if (!new_dir || new_dir->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) YBUG(); - dev = oldDir->myDev; + dev = old_dir->my_dev; #ifdef CONFIG_YAFFS_CASE_INSENSITIVE /* Special case for case insemsitive systems (eg. WinCE). * While look-up is case insensitive, the name isn't. * Therefore we might want to change x.txt to X.txt */ - if (oldDir == newDir && yaffs_strcmp(oldName, newName) == 0) + if (old_dir == new_dir && yaffs_strcmp(old_name, new_name) == 0) force = 1; #endif - if(yaffs_strnlen(newName,YAFFS_MAX_NAME_LENGTH+1) > YAFFS_MAX_NAME_LENGTH) + if(yaffs_strnlen(new_name,YAFFS_MAX_NAME_LENGTH+1) > YAFFS_MAX_NAME_LENGTH) /* ENAMETOOLONG */ return YAFFS_FAIL; - obj = yaffs_find_by_name(oldDir, oldName); + obj = yaffs_find_by_name(old_dir, old_name); - if (obj && obj->renameAllowed) { + if (obj && obj->rename_allowed) { /* Now do the handling for an existing target, if there is one */ - existingTarget = yaffs_find_by_name(newDir, newName); + existingTarget = yaffs_find_by_name(new_dir, new_name); if (existingTarget && - existingTarget->variantType == YAFFS_OBJECT_TYPE_DIRECTORY && - !ylist_empty(&existingTarget->variant.directoryVariant.children)) { + existingTarget->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY && + !ylist_empty(&existingTarget->variant.dir_variant.children)) { /* There is a target that is a non-empty directory, so we fail */ return YAFFS_FAIL; /* EEXIST or ENOTEMPTY */ } else if (existingTarget && existingTarget != obj) { @@ -1795,19 +1795,19 @@ int yaffs_rename_obj(yaffs_Object *oldDir, const YCHAR *oldName, * Note we must disable gc otherwise it can mess up the shadowing. * */ - dev->gcDisable=1; - yaffs_change_obj_name(obj, newDir, newName, force, - existingTarget->objectId); - existingTarget->isShadowed = 1; + dev->gc_disable=1; + yaffs_change_obj_name(obj, new_dir, new_name, force, + existingTarget->obj_id); + existingTarget->is_shadowed = 1; yaffs_unlink_obj(existingTarget); - dev->gcDisable=0; + dev->gc_disable=0; } - result = yaffs_change_obj_name(obj, newDir, newName, 1, 0); + result = yaffs_change_obj_name(obj, new_dir, new_name, 1, 0); - yaffs_update_parent(oldDir); - if(newDir != oldDir) - yaffs_update_parent(newDir); + yaffs_update_parent(old_dir); + if(new_dir != old_dir) + yaffs_update_parent(new_dir); return result; } @@ -1816,65 +1816,65 @@ int yaffs_rename_obj(yaffs_Object *oldDir, const YCHAR *oldName, /*------------------------- Block Management and Page Allocation ----------------*/ -static int yaffs_init_blocks(yaffs_Device *dev) +static int yaffs_init_blocks(yaffs_dev_t *dev) { - int nBlocks = dev->internalEndBlock - dev->internalStartBlock + 1; + int nBlocks = dev->internal_end_block - dev->internal_start_block + 1; - dev->blockInfo = NULL; - dev->chunkBits = NULL; + dev->block_info = NULL; + dev->chunk_bits = NULL; - dev->allocationBlock = -1; /* force it to get a new one */ + dev->alloc_block = -1; /* force it to get a new one */ /* If the first allocation strategy fails, thry the alternate one */ - dev->blockInfo = YMALLOC(nBlocks * sizeof(yaffs_BlockInfo)); - if (!dev->blockInfo) { - dev->blockInfo = YMALLOC_ALT(nBlocks * sizeof(yaffs_BlockInfo)); - dev->blockInfoAlt = 1; + dev->block_info = YMALLOC(nBlocks * sizeof(yaffs_block_info_t)); + if (!dev->block_info) { + dev->block_info = YMALLOC_ALT(nBlocks * sizeof(yaffs_block_info_t)); + dev->block_info_alt = 1; } else - dev->blockInfoAlt = 0; + dev->block_info_alt = 0; - if (dev->blockInfo) { + if (dev->block_info) { /* Set up dynamic blockinfo stuff. */ - dev->chunkBitmapStride = (dev->param.nChunksPerBlock + 7) / 8; /* round up bytes */ - dev->chunkBits = YMALLOC(dev->chunkBitmapStride * nBlocks); - if (!dev->chunkBits) { - dev->chunkBits = YMALLOC_ALT(dev->chunkBitmapStride * nBlocks); - dev->chunkBitsAlt = 1; + dev->chunk_bit_stride = (dev->param.chunks_per_block + 7) / 8; /* round up bytes */ + dev->chunk_bits = YMALLOC(dev->chunk_bit_stride * nBlocks); + if (!dev->chunk_bits) { + dev->chunk_bits = YMALLOC_ALT(dev->chunk_bit_stride * nBlocks); + dev->chunk_bits_alt = 1; } else - dev->chunkBitsAlt = 0; + dev->chunk_bits_alt = 0; } - if (dev->blockInfo && dev->chunkBits) { - memset(dev->blockInfo, 0, nBlocks * sizeof(yaffs_BlockInfo)); - memset(dev->chunkBits, 0, dev->chunkBitmapStride * nBlocks); + if (dev->block_info && dev->chunk_bits) { + memset(dev->block_info, 0, nBlocks * sizeof(yaffs_block_info_t)); + memset(dev->chunk_bits, 0, dev->chunk_bit_stride * nBlocks); return YAFFS_OK; } return YAFFS_FAIL; } -static void yaffs_deinit_blocks(yaffs_Device *dev) +static void yaffs_deinit_blocks(yaffs_dev_t *dev) { - if (dev->blockInfoAlt && dev->blockInfo) - YFREE_ALT(dev->blockInfo); - else if (dev->blockInfo) - YFREE(dev->blockInfo); + if (dev->block_info_alt && dev->block_info) + YFREE_ALT(dev->block_info); + else if (dev->block_info) + YFREE(dev->block_info); - dev->blockInfoAlt = 0; + dev->block_info_alt = 0; - dev->blockInfo = NULL; + dev->block_info = NULL; - if (dev->chunkBitsAlt && dev->chunkBits) - YFREE_ALT(dev->chunkBits); - else if (dev->chunkBits) - YFREE(dev->chunkBits); - dev->chunkBitsAlt = 0; - dev->chunkBits = NULL; + if (dev->chunk_bits_alt && dev->chunk_bits) + YFREE_ALT(dev->chunk_bits); + else if (dev->chunk_bits) + YFREE(dev->chunk_bits); + dev->chunk_bits_alt = 0; + dev->chunk_bits = NULL; } -void yaffs_block_became_dirty(yaffs_Device *dev, int blockNo) +void yaffs_block_became_dirty(yaffs_dev_t *dev, int block_no) { - yaffs_BlockInfo *bi = yaffs_get_block_info(dev, blockNo); + yaffs_block_info_t *bi = yaffs_get_block_info(dev, block_no); int erasedOk = 0; @@ -1884,76 +1884,76 @@ void yaffs_block_became_dirty(yaffs_Device *dev, int blockNo) T(YAFFS_TRACE_GC | YAFFS_TRACE_ERASE, (TSTR("yaffs_block_became_dirty block %d state %d %s"TENDSTR), - blockNo, bi->blockState, (bi->needsRetiring) ? "needs retiring" : "")); + block_no, bi->block_state, (bi->needs_retiring) ? "needs retiring" : "")); yaffs2_clear_oldest_dirty_seq(dev,bi); - bi->blockState = YAFFS_BLOCK_STATE_DIRTY; + bi->block_state = YAFFS_BLOCK_STATE_DIRTY; /* If this is the block being garbage collected then stop gc'ing this block */ - if(blockNo == dev->gcBlock) - dev->gcBlock = 0; + if(block_no == dev->gc_block) + dev->gc_block = 0; /* If this block is currently the best candidate for gc then drop as a candidate */ - if(blockNo == dev->gcDirtiest){ - dev->gcDirtiest = 0; - dev->gcPagesInUse = 0; + if(block_no == dev->gc_dirtiest){ + dev->gc_dirtiest = 0; + dev->gc_pages_in_use = 0; } - if (!bi->needsRetiring) { + if (!bi->needs_retiring) { yaffs2_checkpt_invalidate(dev); - erasedOk = yaffs_erase_block(dev, blockNo); + erasedOk = yaffs_erase_block(dev, block_no); if (!erasedOk) { - dev->nErasureFailures++; + dev->n_erase_failures++; T(YAFFS_TRACE_ERROR | YAFFS_TRACE_BAD_BLOCKS, - (TSTR("**>> Erasure failed %d" TENDSTR), blockNo)); + (TSTR("**>> Erasure failed %d" TENDSTR), block_no)); } } if (erasedOk && ((yaffs_trace_mask & YAFFS_TRACE_ERASE) || !yaffs_skip_verification(dev))) { int i; - for (i = 0; i < dev->param.nChunksPerBlock; i++) { + for (i = 0; i < dev->param.chunks_per_block; i++) { if (!yaffs_check_chunk_erased - (dev, blockNo * dev->param.nChunksPerBlock + i)) { + (dev, block_no * dev->param.chunks_per_block + i)) { T(YAFFS_TRACE_ERROR, (TSTR (">>Block %d erasure supposedly OK, but chunk %d not erased" - TENDSTR), blockNo, i)); + TENDSTR), block_no, i)); } } } if (erasedOk) { /* Clean it up... */ - bi->blockState = YAFFS_BLOCK_STATE_EMPTY; - bi->sequenceNumber = 0; - dev->nErasedBlocks++; - bi->pagesInUse = 0; - bi->softDeletions = 0; - bi->hasShrinkHeader = 0; - bi->skipErasedCheck = 1; /* This is clean, so no need to check */ - bi->gcPrioritise = 0; - yaffs_clear_chunk_bits(dev, blockNo); + bi->block_state = YAFFS_BLOCK_STATE_EMPTY; + bi->seq_number = 0; + dev->n_erased_blocks++; + bi->pages_in_use = 0; + bi->soft_del_pages = 0; + bi->has_shrink_hdr = 0; + bi->skip_erased_check = 1; /* This is clean, so no need to check */ + bi->gc_prioritise = 0; + yaffs_clear_chunk_bits(dev, block_no); T(YAFFS_TRACE_ERASE, - (TSTR("Erased block %d" TENDSTR), blockNo)); + (TSTR("Erased block %d" TENDSTR), block_no)); } else { - dev->nFreeChunks -= dev->param.nChunksPerBlock; /* We lost a block of free space */ + dev->n_free_chunks -= dev->param.chunks_per_block; /* We lost a block of free space */ - yaffs_retire_block(dev, blockNo); + yaffs_retire_block(dev, block_no); T(YAFFS_TRACE_ERROR | YAFFS_TRACE_BAD_BLOCKS, - (TSTR("**>> Block %d retired" TENDSTR), blockNo)); + (TSTR("**>> Block %d retired" TENDSTR), block_no)); } } -static int yaffs_find_alloc_block(yaffs_Device *dev) +static int yaffs_find_alloc_block(yaffs_dev_t *dev) { int i; - yaffs_BlockInfo *bi; + yaffs_block_info_t *bi; - if (dev->nErasedBlocks < 1) { + if (dev->n_erased_blocks < 1) { /* Hoosterman we've got a problem. * Can't get space to gc */ @@ -1965,32 +1965,32 @@ static int yaffs_find_alloc_block(yaffs_Device *dev) /* Find an empty block. */ - for (i = dev->internalStartBlock; i <= dev->internalEndBlock; i++) { - dev->allocationBlockFinder++; - if (dev->allocationBlockFinder < dev->internalStartBlock - || dev->allocationBlockFinder > dev->internalEndBlock) { - dev->allocationBlockFinder = dev->internalStartBlock; + for (i = dev->internal_start_block; i <= dev->internal_end_block; i++) { + dev->alloc_block_finder++; + if (dev->alloc_block_finder < dev->internal_start_block + || dev->alloc_block_finder > dev->internal_end_block) { + dev->alloc_block_finder = dev->internal_start_block; } - bi = yaffs_get_block_info(dev, dev->allocationBlockFinder); + bi = yaffs_get_block_info(dev, dev->alloc_block_finder); - if (bi->blockState == YAFFS_BLOCK_STATE_EMPTY) { - bi->blockState = YAFFS_BLOCK_STATE_ALLOCATING; - dev->sequenceNumber++; - bi->sequenceNumber = dev->sequenceNumber; - dev->nErasedBlocks--; + if (bi->block_state == YAFFS_BLOCK_STATE_EMPTY) { + bi->block_state = YAFFS_BLOCK_STATE_ALLOCATING; + dev->seq_number++; + bi->seq_number = dev->seq_number; + dev->n_erased_blocks--; T(YAFFS_TRACE_ALLOCATE, (TSTR("Allocated block %d, seq %d, %d left" TENDSTR), - dev->allocationBlockFinder, dev->sequenceNumber, - dev->nErasedBlocks)); - return dev->allocationBlockFinder; + dev->alloc_block_finder, dev->seq_number, + dev->n_erased_blocks)); + return dev->alloc_block_finder; } } T(YAFFS_TRACE_ALWAYS, (TSTR ("yaffs tragedy: no more erased blocks, but there should have been %d" - TENDSTR), dev->nErasedBlocks)); + TENDSTR), dev->n_erased_blocks)); return -1; } @@ -2000,29 +2000,29 @@ static int yaffs_find_alloc_block(yaffs_Device *dev) * Check if there's space to allocate... * Thinks.... do we need top make this ths same as yaffs_get_free_chunks()? */ -int yaffs_check_alloc_available(yaffs_Device *dev, int nChunks) +int yaffs_check_alloc_available(yaffs_dev_t *dev, int n_chunks) { int reservedChunks; - int reservedBlocks = dev->param.nReservedBlocks; + int reservedBlocks = dev->param.n_reserved_blocks; int checkpointBlocks; checkpointBlocks = yaffs_calc_checkpt_blocks_required(dev); - reservedChunks = ((reservedBlocks + checkpointBlocks) * dev->param.nChunksPerBlock); + reservedChunks = ((reservedBlocks + checkpointBlocks) * dev->param.chunks_per_block); - return (dev->nFreeChunks > (reservedChunks + nChunks)); + return (dev->n_free_chunks > (reservedChunks + n_chunks)); } -static int yaffs_alloc_chunk(yaffs_Device *dev, int useReserve, - yaffs_BlockInfo **blockUsedPtr) +static int yaffs_alloc_chunk(yaffs_dev_t *dev, int useReserve, + yaffs_block_info_t **blockUsedPtr) { int retVal; - yaffs_BlockInfo *bi; + yaffs_block_info_t *bi; - if (dev->allocationBlock < 0) { + if (dev->alloc_block < 0) { /* Get next block to allocate off */ - dev->allocationBlock = yaffs_find_alloc_block(dev); - dev->allocationPage = 0; + dev->alloc_block = yaffs_find_alloc_block(dev); + dev->alloc_page = 0; } if (!useReserve && !yaffs_check_alloc_available(dev, 1)) { @@ -2030,29 +2030,29 @@ static int yaffs_alloc_chunk(yaffs_Device *dev, int useReserve, return -1; } - if (dev->nErasedBlocks < dev->param.nReservedBlocks - && dev->allocationPage == 0) { + if (dev->n_erased_blocks < dev->param.n_reserved_blocks + && dev->alloc_page == 0) { T(YAFFS_TRACE_ALLOCATE, (TSTR("Allocating reserve" TENDSTR))); } /* Next page please.... */ - if (dev->allocationBlock >= 0) { - bi = yaffs_get_block_info(dev, dev->allocationBlock); + if (dev->alloc_block >= 0) { + bi = yaffs_get_block_info(dev, dev->alloc_block); - retVal = (dev->allocationBlock * dev->param.nChunksPerBlock) + - dev->allocationPage; - bi->pagesInUse++; - yaffs_set_chunk_bit(dev, dev->allocationBlock, - dev->allocationPage); + retVal = (dev->alloc_block * dev->param.chunks_per_block) + + dev->alloc_page; + bi->pages_in_use++; + yaffs_set_chunk_bit(dev, dev->alloc_block, + dev->alloc_page); - dev->allocationPage++; + dev->alloc_page++; - dev->nFreeChunks--; + dev->n_free_chunks--; /* If the block is full set the state to full */ - if (dev->allocationPage >= dev->param.nChunksPerBlock) { - bi->blockState = YAFFS_BLOCK_STATE_FULL; - dev->allocationBlock = -1; + if (dev->alloc_page >= dev->param.chunks_per_block) { + bi->block_state = YAFFS_BLOCK_STATE_FULL; + dev->alloc_block = -1; } if (blockUsedPtr) @@ -2067,14 +2067,14 @@ static int yaffs_alloc_chunk(yaffs_Device *dev, int useReserve, return -1; } -static int yaffs_get_erased_chunks(yaffs_Device *dev) +static int yaffs_get_erased_chunks(yaffs_dev_t *dev) { int n; - n = dev->nErasedBlocks * dev->param.nChunksPerBlock; + n = dev->n_erased_blocks * dev->param.chunks_per_block; - if (dev->allocationBlock > 0) - n += (dev->param.nChunksPerBlock - dev->allocationPage); + if (dev->alloc_block > 0) + n += (dev->param.chunks_per_block - dev->alloc_page); return n; @@ -2084,24 +2084,24 @@ static int yaffs_get_erased_chunks(yaffs_Device *dev) * yaffs_skip_rest_of_block() skips over the rest of the allocation block * if we don't want to write to it. */ -void yaffs_skip_rest_of_block(yaffs_Device *dev) +void yaffs_skip_rest_of_block(yaffs_dev_t *dev) { - if(dev->allocationBlock > 0){ - yaffs_BlockInfo *bi = yaffs_get_block_info(dev, dev->allocationBlock); - if(bi->blockState == YAFFS_BLOCK_STATE_ALLOCATING){ - bi->blockState = YAFFS_BLOCK_STATE_FULL; - dev->allocationBlock = -1; + if(dev->alloc_block > 0){ + yaffs_block_info_t *bi = yaffs_get_block_info(dev, dev->alloc_block); + if(bi->block_state == YAFFS_BLOCK_STATE_ALLOCATING){ + bi->block_state = YAFFS_BLOCK_STATE_FULL; + dev->alloc_block = -1; } } } -static int yaffs_gc_block(yaffs_Device *dev, int block, +static int yaffs_gc_block(yaffs_dev_t *dev, int block, int wholeBlock) { int oldChunk; int newChunk; - int markNAND; + int mark_flash; int retVal = YAFFS_OK; int i; int isCheckpointBlock; @@ -2111,30 +2111,30 @@ static int yaffs_gc_block(yaffs_Device *dev, int block, int chunksBefore = yaffs_get_erased_chunks(dev); int chunksAfter; - yaffs_ExtendedTags tags; + yaffs_ext_tags tags; - yaffs_BlockInfo *bi = yaffs_get_block_info(dev, block); + yaffs_block_info_t *bi = yaffs_get_block_info(dev, block); - yaffs_Object *object; + yaffs_obj_t *object; - isCheckpointBlock = (bi->blockState == YAFFS_BLOCK_STATE_CHECKPOINT); + isCheckpointBlock = (bi->block_state == YAFFS_BLOCK_STATE_CHECKPOINT); T(YAFFS_TRACE_TRACING, (TSTR("Collecting block %d, in use %d, shrink %d, wholeBlock %d" TENDSTR), block, - bi->pagesInUse, - bi->hasShrinkHeader, + bi->pages_in_use, + bi->has_shrink_hdr, wholeBlock)); /*yaffs_verify_free_chunks(dev); */ - if(bi->blockState == YAFFS_BLOCK_STATE_FULL) - bi->blockState = YAFFS_BLOCK_STATE_COLLECTING; + if(bi->block_state == YAFFS_BLOCK_STATE_FULL) + bi->block_state = YAFFS_BLOCK_STATE_COLLECTING; - bi->hasShrinkHeader = 0; /* clear the flag so that the block can erase */ + bi->has_shrink_hdr = 0; /* clear the flag so that the block can erase */ - dev->gcDisable = 1; + dev->gc_disable = 1; if (isCheckpointBlock || !yaffs_still_some_chunks(dev, block)) { @@ -2149,22 +2149,22 @@ static int yaffs_gc_block(yaffs_Device *dev, int block, yaffs_verify_blk(dev, bi, block); - maxCopies = (wholeBlock) ? dev->param.nChunksPerBlock : 5; - oldChunk = block * dev->param.nChunksPerBlock + dev->gcChunk; + maxCopies = (wholeBlock) ? dev->param.chunks_per_block : 5; + oldChunk = block * dev->param.chunks_per_block + dev->gc_chunk; for (/* init already done */; retVal == YAFFS_OK && - dev->gcChunk < dev->param.nChunksPerBlock && - (bi->blockState == YAFFS_BLOCK_STATE_COLLECTING) && + dev->gc_chunk < dev->param.chunks_per_block && + (bi->block_state == YAFFS_BLOCK_STATE_COLLECTING) && maxCopies > 0; - dev->gcChunk++, oldChunk++) { - if (yaffs_check_chunk_bit(dev, block, dev->gcChunk)) { + dev->gc_chunk++, oldChunk++) { + if (yaffs_check_chunk_bit(dev, block, dev->gc_chunk)) { /* This page is in use and might need to be copied off */ maxCopies--; - markNAND = 1; + mark_flash = 1; yaffs_init_tags(&tags); @@ -2173,26 +2173,26 @@ static int yaffs_gc_block(yaffs_Device *dev, int block, object = yaffs_find_by_number(dev, - tags.objectId); + tags.obj_id); T(YAFFS_TRACE_GC_DETAIL, (TSTR ("Collecting chunk in block %d, %d %d %d " TENDSTR), - dev->gcChunk, tags.objectId, tags.chunkId, - tags.byteCount)); + dev->gc_chunk, tags.obj_id, tags.chunk_id, + tags.n_bytes)); if (object && !yaffs_skip_verification(dev)) { - if (tags.chunkId == 0) - matchingChunk = object->hdrChunk; - else if (object->softDeleted) + if (tags.chunk_id == 0) + matchingChunk = object->hdr_chunk; + else if (object->soft_del) matchingChunk = oldChunk; /* Defeat the test */ else - matchingChunk = yaffs_find_chunk_in_file(object, tags.chunkId, NULL); + matchingChunk = yaffs_find_chunk_in_file(object, tags.chunk_id, NULL); if (oldChunk != matchingChunk) T(YAFFS_TRACE_ERROR, (TSTR("gc: page in gc mismatch: %d %d %d %d"TENDSTR), - oldChunk, matchingChunk, tags.objectId, tags.chunkId)); + oldChunk, matchingChunk, tags.obj_id, tags.chunk_id)); } @@ -2201,13 +2201,13 @@ static int yaffs_gc_block(yaffs_Device *dev, int block, (TSTR ("page %d in gc has no object: %d %d %d " TENDSTR), oldChunk, - tags.objectId, tags.chunkId, tags.byteCount)); + tags.obj_id, tags.chunk_id, tags.n_bytes)); } if (object && object->deleted && - object->softDeleted && - tags.chunkId != 0) { + object->soft_del && + tags.chunk_id != 0) { /* Data chunk in a soft deleted file, throw it away * It's a soft deleted data chunk, * No need to copy this, just forget about it and @@ -2219,28 +2219,28 @@ static int yaffs_gc_block(yaffs_Device *dev, int block, * which will increment free chunks. * We have to decrement free chunks so this works out properly. */ - dev->nFreeChunks--; - bi->softDeletions--; + dev->n_free_chunks--; + bi->soft_del_pages--; - object->nDataChunks--; + object->n_data_chunks--; - if (object->nDataChunks <= 0) { + if (object->n_data_chunks <= 0) { /* remeber to clean up the object */ - dev->gcCleanupList[dev->nCleanups] = - tags.objectId; - dev->nCleanups++; + dev->gc_cleanup_list[dev->n_clean_ups] = + tags.obj_id; + dev->n_clean_ups++; } - markNAND = 0; + mark_flash = 0; } else if (0) { - /* Todo object && object->deleted && object->nDataChunks == 0 */ + /* Todo object && object->deleted && object->n_data_chunks == 0 */ /* Deleted object header with no data chunks. * Can be discarded and the file deleted. */ - object->hdrChunk = 0; - yaffs_free_tnode(object->myDev, + object->hdr_chunk = 0; + yaffs_free_tnode(object->my_dev, object->variant. - fileVariant.top); - object->variant.fileVariant.top = NULL; + file_variant.top); + object->variant.file_variant.top = NULL; yaffs_generic_obj_del(object); } else if (object) { @@ -2249,11 +2249,11 @@ static int yaffs_gc_block(yaffs_Device *dev, int block, * NB Need to keep the ObjectHeaders of deleted files * until the whole file has been deleted off */ - tags.serialNumber++; + tags.serial_number++; - dev->nGCCopies++; + dev->n_gc_copies++; - if (tags.chunkId == 0) { + if (tags.chunk_id == 0) { /* It is an object Id, * We need to nuke the shrinkheader flags first * Also need to clean up shadowing. @@ -2261,20 +2261,20 @@ static int yaffs_gc_block(yaffs_Device *dev, int block, * and if it is left in place it will mess up scanning. */ - yaffs_ObjectHeader *oh; - oh = (yaffs_ObjectHeader *)buffer; + yaffs_obj_header *oh; + oh = (yaffs_obj_header *)buffer; - oh->isShrink = 0; - tags.extraIsShrinkHeader = 0; + oh->is_shrink = 0; + tags.extra_is_shrink = 0; - oh->shadowsObject = 0; - oh->inbandShadowsObject = 0; - tags.extraShadows = 0; + oh->shadows_obj = 0; + oh->inband_shadowed_obj_id = 0; + tags.extra_shadows = 0; /* Update file size */ - if(object->variantType == YAFFS_OBJECT_TYPE_FILE){ - oh->fileSize = object->variant.fileVariant.fileSize; - tags.extraFileLength = oh->fileSize; + if(object->variant_type == YAFFS_OBJECT_TYPE_FILE){ + oh->file_size = object->variant.file_variant.file_size; + tags.extra_length = oh->file_size; } yaffs_verify_oh(object, oh, &tags, 1); @@ -2290,23 +2290,23 @@ static int yaffs_gc_block(yaffs_Device *dev, int block, /* Ok, now fix up the Tnodes etc. */ - if (tags.chunkId == 0) { + if (tags.chunk_id == 0) { /* It's a header */ - object->hdrChunk = newChunk; - object->serial = tags.serialNumber; + object->hdr_chunk = newChunk; + object->serial = tags.serial_number; } else { /* It's a data chunk */ int ok; ok = yaffs_put_chunk_in_file (object, - tags.chunkId, + tags.chunk_id, newChunk, 0); } } } if (retVal == YAFFS_OK) - yaffs_chunk_del(dev, oldChunk, markNAND, __LINE__); + yaffs_chunk_del(dev, oldChunk, mark_flash, __LINE__); } } @@ -2321,31 +2321,31 @@ static int yaffs_gc_block(yaffs_Device *dev, int block, - if (bi->blockState == YAFFS_BLOCK_STATE_COLLECTING) { + if (bi->block_state == YAFFS_BLOCK_STATE_COLLECTING) { /* * The gc did not complete. Set block state back to FULL * because checkpointing does not restore gc. */ - bi->blockState = YAFFS_BLOCK_STATE_FULL; + bi->block_state = YAFFS_BLOCK_STATE_FULL; } else { /* The gc completed. */ /* Do any required cleanups */ - for (i = 0; i < dev->nCleanups; i++) { + for (i = 0; i < dev->n_clean_ups; i++) { /* Time to delete the file too */ object = yaffs_find_by_number(dev, - dev->gcCleanupList[i]); + dev->gc_cleanup_list[i]); if (object) { yaffs_free_tnode(dev, - object->variant.fileVariant. + object->variant.file_variant. top); - object->variant.fileVariant.top = NULL; + object->variant.file_variant.top = NULL; T(YAFFS_TRACE_GC, (TSTR ("yaffs: About to finally delete object %d" - TENDSTR), object->objectId)); + TENDSTR), object->obj_id)); yaffs_generic_obj_del(object); - object->myDev->nDeletedFiles--; + object->my_dev->n_deleted_files--; } } @@ -2358,12 +2358,12 @@ static int yaffs_gc_block(yaffs_Device *dev, int block, ("gc did not increase free chunks before %d after %d" TENDSTR), chunksBefore, chunksAfter)); } - dev->gcBlock = 0; - dev->gcChunk = 0; - dev->nCleanups = 0; + dev->gc_block = 0; + dev->gc_chunk = 0; + dev->n_clean_ups = 0; } - dev->gcDisable = 0; + dev->gc_disable = 0; return retVal; } @@ -2373,7 +2373,7 @@ static int yaffs_gc_block(yaffs_Device *dev, int block, * for garbage collection. */ -static unsigned yaffs_find_gc_block(yaffs_Device *dev, +static unsigned yaffs_find_gc_block(yaffs_dev_t *dev, int aggressive, int background) { @@ -2382,20 +2382,20 @@ static unsigned yaffs_find_gc_block(yaffs_Device *dev, unsigned selected = 0; int prioritised = 0; int prioritisedExists = 0; - yaffs_BlockInfo *bi; + yaffs_block_info_t *bi; int threshold; /* First let's see if we need to grab a prioritised block */ - if (dev->hasPendingPrioritisedGCs && !aggressive) { - dev->gcDirtiest = 0; - bi = dev->blockInfo; - for (i = dev->internalStartBlock; - i <= dev->internalEndBlock && !selected; + if (dev->has_pending_prioritised_gc && !aggressive) { + dev->gc_dirtiest = 0; + bi = dev->block_info; + for (i = dev->internal_start_block; + i <= dev->internal_end_block && !selected; i++) { - if (bi->gcPrioritise) { + if (bi->gc_prioritise) { prioritisedExists = 1; - if (bi->blockState == YAFFS_BLOCK_STATE_FULL && + if (bi->block_state == YAFFS_BLOCK_STATE_FULL && yaffs_block_ok_for_gc(dev, bi)) { selected = i; prioritised = 1; @@ -2412,11 +2412,11 @@ static unsigned yaffs_find_gc_block(yaffs_Device *dev, if(prioritisedExists && !selected && - dev->oldestDirtyBlock > 0) - selected = dev->oldestDirtyBlock; + dev->oldest_dirty_block > 0) + selected = dev->oldest_dirty_block; if (!prioritisedExists) /* None found, so we can clear this */ - dev->hasPendingPrioritisedGCs = 0; + dev->has_pending_prioritised_gc = 0; } /* If we're doing aggressive GC then we are happy to take a less-dirty block, and @@ -2427,23 +2427,23 @@ static unsigned yaffs_find_gc_block(yaffs_Device *dev, if (!selected){ int pagesUsed; - int nBlocks = dev->internalEndBlock - dev->internalStartBlock + 1; + int nBlocks = dev->internal_end_block - dev->internal_start_block + 1; if (aggressive){ - threshold = dev->param.nChunksPerBlock; + threshold = dev->param.chunks_per_block; iterations = nBlocks; } else { int maxThreshold; if(background) - maxThreshold = dev->param.nChunksPerBlock/2; + maxThreshold = dev->param.chunks_per_block/2; else - maxThreshold = dev->param.nChunksPerBlock/8; + maxThreshold = dev->param.chunks_per_block/8; if(maxThreshold < YAFFS_GC_PASSIVE_THRESHOLD) maxThreshold = YAFFS_GC_PASSIVE_THRESHOLD; threshold = background ? - (dev->gcNotDone + 2) * 2 : 0; + (dev->gc_not_done + 2) * 2 : 0; if(threshold <YAFFS_GC_PASSIVE_THRESHOLD) threshold = YAFFS_GC_PASSIVE_THRESHOLD; if(threshold > maxThreshold) @@ -2456,29 +2456,29 @@ static unsigned yaffs_find_gc_block(yaffs_Device *dev, for (i = 0; i < iterations && - (dev->gcDirtiest < 1 || - dev->gcPagesInUse > YAFFS_GC_GOOD_ENOUGH); + (dev->gc_dirtiest < 1 || + dev->gc_pages_in_use > YAFFS_GC_GOOD_ENOUGH); i++) { - dev->gcBlockFinder++; - if (dev->gcBlockFinder < dev->internalStartBlock || - dev->gcBlockFinder > dev->internalEndBlock) - dev->gcBlockFinder = dev->internalStartBlock; + dev->gc_block_finder++; + if (dev->gc_block_finder < dev->internal_start_block || + dev->gc_block_finder > dev->internal_end_block) + dev->gc_block_finder = dev->internal_start_block; - bi = yaffs_get_block_info(dev, dev->gcBlockFinder); + bi = yaffs_get_block_info(dev, dev->gc_block_finder); - pagesUsed = bi->pagesInUse - bi->softDeletions; + pagesUsed = bi->pages_in_use - bi->soft_del_pages; - if (bi->blockState == YAFFS_BLOCK_STATE_FULL && - pagesUsed < dev->param.nChunksPerBlock && - (dev->gcDirtiest < 1 || pagesUsed < dev->gcPagesInUse) && + if (bi->block_state == YAFFS_BLOCK_STATE_FULL && + pagesUsed < dev->param.chunks_per_block && + (dev->gc_dirtiest < 1 || pagesUsed < dev->gc_pages_in_use) && yaffs_block_ok_for_gc(dev, bi)) { - dev->gcDirtiest = dev->gcBlockFinder; - dev->gcPagesInUse = pagesUsed; + dev->gc_dirtiest = dev->gc_block_finder; + dev->gc_pages_in_use = pagesUsed; } } - if(dev->gcDirtiest > 0 && dev->gcPagesInUse <= threshold) - selected = dev->gcDirtiest; + if(dev->gc_dirtiest > 0 && dev->gc_pages_in_use <= threshold) + selected = dev->gc_dirtiest; } /* @@ -2486,43 +2486,43 @@ static unsigned yaffs_find_gc_block(yaffs_Device *dev, * because that's gumming up the works. */ - if(!selected && dev->param.isYaffs2 && - dev->gcNotDone >= ( background ? 10 : 20)){ + if(!selected && dev->param.is_yaffs2 && + dev->gc_not_done >= ( background ? 10 : 20)){ yaffs2_find_oldest_dirty_seq(dev); - if(dev->oldestDirtyBlock > 0) { - selected = dev->oldestDirtyBlock; - dev->gcDirtiest = selected; - dev->oldestDirtyGCs++; + if(dev->oldest_dirty_block > 0) { + selected = dev->oldest_dirty_block; + dev->gc_dirtiest = selected; + dev->oldest_dirty_gc_count++; bi = yaffs_get_block_info(dev, selected); - dev->gcPagesInUse = bi->pagesInUse - bi->softDeletions; + dev->gc_pages_in_use = bi->pages_in_use - bi->soft_del_pages; } else - dev->gcNotDone = 0; + dev->gc_not_done = 0; } if(selected){ T(YAFFS_TRACE_GC, (TSTR("GC Selected block %d with %d free, prioritised:%d" TENDSTR), selected, - dev->param.nChunksPerBlock - dev->gcPagesInUse, + dev->param.chunks_per_block - dev->gc_pages_in_use, prioritised)); - dev->nGCBlocks++; + dev->n_gc_blocks++; if(background) - dev->backgroundGCs++; + dev->bg_gcs++; - dev->gcDirtiest = 0; - dev->gcPagesInUse = 0; - dev->gcNotDone = 0; - if(dev->refreshSkip > 0) - dev->refreshSkip--; + dev->gc_dirtiest = 0; + dev->gc_pages_in_use = 0; + dev->gc_not_done = 0; + if(dev->refresh_skip > 0) + dev->refresh_skip--; } else{ - dev->gcNotDone++; + dev->gc_not_done++; T(YAFFS_TRACE_GC, (TSTR("GC none: finder %d skip %d threshold %d dirtiest %d using %d oldest %d%s" TENDSTR), - dev->gcBlockFinder, dev->gcNotDone, + dev->gc_block_finder, dev->gc_not_done, threshold, - dev->gcDirtiest, dev->gcPagesInUse, - dev->oldestDirtyBlock, + dev->gc_dirtiest, dev->gc_pages_in_use, + dev->oldest_dirty_block, background ? " bg" : "")); } @@ -2538,7 +2538,7 @@ static unsigned yaffs_find_gc_block(yaffs_Device *dev, * The idea is to help clear out space in a more spread-out manner. * Dunno if it really does anything useful. */ -static int yaffs_check_gc(yaffs_Device *dev, int background) +static int yaffs_check_gc(yaffs_dev_t *dev, int background) { int aggressive = 0; int gcOk = YAFFS_OK; @@ -2547,11 +2547,11 @@ static int yaffs_check_gc(yaffs_Device *dev, int background) int erasedChunks; int checkpointBlockAdjust; - if(dev->param.gcControl && - (dev->param.gcControl(dev) & 1) == 0) + if(dev->param.gc_control && + (dev->param.gc_control(dev) & 1) == 0) return YAFFS_OK; - if (dev->gcDisable) { + if (dev->gc_disable) { /* Bail out so we don't get recursive gc */ return YAFFS_OK; } @@ -2565,64 +2565,64 @@ static int yaffs_check_gc(yaffs_Device *dev, int background) checkpointBlockAdjust = yaffs_calc_checkpt_blocks_required(dev); - minErased = dev->param.nReservedBlocks + checkpointBlockAdjust + 1; - erasedChunks = dev->nErasedBlocks * dev->param.nChunksPerBlock; + minErased = dev->param.n_reserved_blocks + checkpointBlockAdjust + 1; + erasedChunks = dev->n_erased_blocks * dev->param.chunks_per_block; /* If we need a block soon then do aggressive gc.*/ - if (dev->nErasedBlocks < minErased) + if (dev->n_erased_blocks < minErased) aggressive = 1; else { - if(!background && erasedChunks > (dev->nFreeChunks / 4)) + if(!background && erasedChunks > (dev->n_free_chunks / 4)) break; - if(dev->gcSkip > 20) - dev->gcSkip = 20; - if(erasedChunks < dev->nFreeChunks/2 || - dev->gcSkip < 1 || + if(dev->gc_skip > 20) + dev->gc_skip = 20; + if(erasedChunks < dev->n_free_chunks/2 || + dev->gc_skip < 1 || background) aggressive = 0; else { - dev->gcSkip--; + dev->gc_skip--; break; } } - dev->gcSkip = 5; + dev->gc_skip = 5; /* If we don't already have a block being gc'd then see if we should start another */ - if (dev->gcBlock < 1 && !aggressive) { - dev->gcBlock = yaffs2_find_refresh_block(dev); - dev->gcChunk = 0; - dev->nCleanups=0; + if (dev->gc_block < 1 && !aggressive) { + dev->gc_block = yaffs2_find_refresh_block(dev); + dev->gc_chunk = 0; + dev->n_clean_ups=0; } - if (dev->gcBlock < 1) { - dev->gcBlock = yaffs_find_gc_block(dev, aggressive, background); - dev->gcChunk = 0; - dev->nCleanups=0; + if (dev->gc_block < 1) { + dev->gc_block = yaffs_find_gc_block(dev, aggressive, background); + dev->gc_chunk = 0; + dev->n_clean_ups=0; } - if (dev->gcBlock > 0) { - dev->allGCs++; + if (dev->gc_block > 0) { + dev->all_gcs++; if (!aggressive) - dev->passiveGCs++; + dev->passive_gc_count++; T(YAFFS_TRACE_GC, (TSTR ("yaffs: GC erasedBlocks %d aggressive %d" TENDSTR), - dev->nErasedBlocks, aggressive)); + dev->n_erased_blocks, aggressive)); - gcOk = yaffs_gc_block(dev, dev->gcBlock, aggressive); + gcOk = yaffs_gc_block(dev, dev->gc_block, aggressive); } - if (dev->nErasedBlocks < (dev->param.nReservedBlocks) && dev->gcBlock > 0) { + if (dev->n_erased_blocks < (dev->param.n_reserved_blocks) && dev->gc_block > 0) { T(YAFFS_TRACE_GC, (TSTR ("yaffs: GC !!!no reclaim!!! erasedBlocks %d after try %d block %d" - TENDSTR), dev->nErasedBlocks, maxTries, dev->gcBlock)); + TENDSTR), dev->n_erased_blocks, maxTries, dev->gc_block)); } - } while ((dev->nErasedBlocks < dev->param.nReservedBlocks) && - (dev->gcBlock > 0) && + } while ((dev->n_erased_blocks < dev->param.n_reserved_blocks) && + (dev->gc_block > 0) && (maxTries < 2)); return aggressive ? gcOk : YAFFS_OK; @@ -2633,66 +2633,66 @@ static int yaffs_check_gc(yaffs_Device *dev, int background) * Garbage collects. Intended to be called from a background thread. * Returns non-zero if at least half the free chunks are erased. */ -int yaffs_bg_gc(yaffs_Device *dev, unsigned urgency) +int yaffs_bg_gc(yaffs_dev_t *dev, unsigned urgency) { - int erasedChunks = dev->nErasedBlocks * dev->param.nChunksPerBlock; + int erasedChunks = dev->n_erased_blocks * dev->param.chunks_per_block; T(YAFFS_TRACE_BACKGROUND, (TSTR("Background gc %u" TENDSTR),urgency)); yaffs_check_gc(dev, 1); - return erasedChunks > dev->nFreeChunks/2; + return erasedChunks > dev->n_free_chunks/2; } /*------------------------- TAGS --------------------------------*/ -static int yaffs_tags_match(const yaffs_ExtendedTags *tags, int objectId, +static int yaffs_tags_match(const yaffs_ext_tags *tags, int obj_id, int chunkInObject) { - return (tags->chunkId == chunkInObject && - tags->objectId == objectId && !tags->chunkDeleted) ? 1 : 0; + return (tags->chunk_id == chunkInObject && + tags->obj_id == obj_id && !tags->is_deleted) ? 1 : 0; } /*-------------------- Data file manipulation -----------------*/ -static int yaffs_find_chunk_in_file(yaffs_Object *in, int chunkInInode, - yaffs_ExtendedTags *tags) +static int yaffs_find_chunk_in_file(yaffs_obj_t *in, int inode_chunk, + yaffs_ext_tags *tags) { /*Get the Tnode, then get the level 0 offset chunk offset */ yaffs_tnode_t *tn; int theChunk = -1; - yaffs_ExtendedTags localTags; + yaffs_ext_tags localTags; int retVal = -1; - yaffs_Device *dev = in->myDev; + yaffs_dev_t *dev = in->my_dev; if (!tags) { /* Passed a NULL, so use our own tags space */ tags = &localTags; } - tn = yaffs_find_tnode_0(dev, &in->variant.fileVariant, chunkInInode); + tn = yaffs_find_tnode_0(dev, &in->variant.file_variant, inode_chunk); if (tn) { - theChunk = yaffs_get_group_base(dev, tn, chunkInInode); + theChunk = yaffs_get_group_base(dev, tn, inode_chunk); retVal = - yaffs_find_chunk_in_group(dev, theChunk, tags, in->objectId, - chunkInInode); + yaffs_find_chunk_in_group(dev, theChunk, tags, in->obj_id, + inode_chunk); } return retVal; } -static int yaffs_find_del_file_chunk(yaffs_Object *in, int chunkInInode, - yaffs_ExtendedTags *tags) +static int yaffs_find_del_file_chunk(yaffs_obj_t *in, int inode_chunk, + yaffs_ext_tags *tags) { /* Get the Tnode, then get the level 0 offset chunk offset */ yaffs_tnode_t *tn; int theChunk = -1; - yaffs_ExtendedTags localTags; + yaffs_ext_tags localTags; - yaffs_Device *dev = in->myDev; + yaffs_dev_t *dev = in->my_dev; int retVal = -1; if (!tags) { @@ -2700,47 +2700,47 @@ static int yaffs_find_del_file_chunk(yaffs_Object *in, int chunkInInode, tags = &localTags; } - tn = yaffs_find_tnode_0(dev, &in->variant.fileVariant, chunkInInode); + tn = yaffs_find_tnode_0(dev, &in->variant.file_variant, inode_chunk); if (tn) { - theChunk = yaffs_get_group_base(dev, tn, chunkInInode); + theChunk = yaffs_get_group_base(dev, tn, inode_chunk); retVal = - yaffs_find_chunk_in_group(dev, theChunk, tags, in->objectId, - chunkInInode); + yaffs_find_chunk_in_group(dev, theChunk, tags, in->obj_id, + inode_chunk); /* Delete the entry in the filestructure (if found) */ if (retVal != -1) - yaffs_load_tnode_0(dev, tn, chunkInInode, 0); + yaffs_load_tnode_0(dev, tn, inode_chunk, 0); } return retVal; } -int yaffs_put_chunk_in_file(yaffs_Object *in, int chunkInInode, - int chunkInNAND, int inScan) +int yaffs_put_chunk_in_file(yaffs_obj_t *in, int inode_chunk, + int nand_chunk, int in_scan) { - /* NB inScan is zero unless scanning. - * For forward scanning, inScan is > 0; - * for backward scanning inScan is < 0 + /* NB in_scan is zero unless scanning. + * For forward scanning, in_scan is > 0; + * for backward scanning in_scan is < 0 * - * chunkInNAND = 0 is a dummy insert to make sure the tnodes are there. + * nand_chunk = 0 is a dummy insert to make sure the tnodes are there. */ yaffs_tnode_t *tn; - yaffs_Device *dev = in->myDev; + yaffs_dev_t *dev = in->my_dev; int existingChunk; - yaffs_ExtendedTags existingTags; - yaffs_ExtendedTags newTags; + yaffs_ext_tags existingTags; + yaffs_ext_tags newTags; unsigned existingSerial, newSerial; - if (in->variantType != YAFFS_OBJECT_TYPE_FILE) { + if (in->variant_type != YAFFS_OBJECT_TYPE_FILE) { /* Just ignore an attempt at putting a chunk into a non-file during scanning * If it is not during Scanning then something went wrong! */ - if (!inScan) { + if (!in_scan) { T(YAFFS_TRACE_ERROR, (TSTR ("yaffs tragedy:attempt to put data chunk into a non-file" @@ -2748,24 +2748,24 @@ int yaffs_put_chunk_in_file(yaffs_Object *in, int chunkInInode, YBUG(); } - yaffs_chunk_del(dev, chunkInNAND, 1, __LINE__); + yaffs_chunk_del(dev, nand_chunk, 1, __LINE__); return YAFFS_OK; } tn = yaffs_add_find_tnode_0(dev, - &in->variant.fileVariant, - chunkInInode, + &in->variant.file_variant, + inode_chunk, NULL); if (!tn) return YAFFS_FAIL; - if(!chunkInNAND) + if(!nand_chunk) /* Dummy insert, bail now */ return YAFFS_OK; - existingChunk = yaffs_get_group_base(dev, tn, chunkInInode); + existingChunk = yaffs_get_group_base(dev, tn, inode_chunk); - if (inScan != 0) { + if (in_scan != 0) { /* If we're scanning then we need to test for duplicates * NB This does not need to be efficient since it should only ever * happen when the power fails during a write, then only one @@ -2776,7 +2776,7 @@ int yaffs_put_chunk_in_file(yaffs_Object *in, int chunkInInode, */ if (existingChunk > 0) { - /* NB Right now existing chunk will not be real chunkId if the chunk group size > 1 + /* NB Right now existing chunk will not be real chunk_id if the chunk group size > 1 * thus we have to do a FindChunkInFile to get the real chunk id. * * We have a duplicate now we need to decide which one to use: @@ -2786,15 +2786,15 @@ int yaffs_put_chunk_in_file(yaffs_Object *in, int chunkInInode, * YAFFS1: Get both sets of tags and compare serial numbers. */ - if (inScan > 0) { + if (in_scan > 0) { /* Only do this for forward scanning */ yaffs_rd_chunk_tags_nand(dev, - chunkInNAND, + nand_chunk, NULL, &newTags); /* Do a proper find */ existingChunk = - yaffs_find_chunk_in_file(in, chunkInInode, + yaffs_find_chunk_in_file(in, inode_chunk, &existingTags); } @@ -2812,12 +2812,12 @@ int yaffs_put_chunk_in_file(yaffs_Object *in, int chunkInInode, * not be loaded during a scan */ - if (inScan > 0) { - newSerial = newTags.serialNumber; - existingSerial = existingTags.serialNumber; + if (in_scan > 0) { + newSerial = newTags.serial_number; + existingSerial = existingTags.serial_number; } - if ((inScan > 0) && + if ((in_scan > 0) && (existingChunk <= 0 || ((existingSerial + 1) & 3) == newSerial)) { /* Forward scanning. @@ -2831,7 +2831,7 @@ int yaffs_put_chunk_in_file(yaffs_Object *in, int chunkInInode, * Use existing. * Delete the new one and return early so that the tnode isn't changed */ - yaffs_chunk_del(dev, chunkInNAND, 1, + yaffs_chunk_del(dev, nand_chunk, 1, __LINE__); return YAFFS_OK; } @@ -2840,89 +2840,89 @@ int yaffs_put_chunk_in_file(yaffs_Object *in, int chunkInInode, } if (existingChunk == 0) - in->nDataChunks++; + in->n_data_chunks++; - yaffs_load_tnode_0(dev, tn, chunkInInode, chunkInNAND); + yaffs_load_tnode_0(dev, tn, inode_chunk, nand_chunk); return YAFFS_OK; } -static int yaffs_rd_data_obj(yaffs_Object *in, int chunkInInode, +static int yaffs_rd_data_obj(yaffs_obj_t *in, int inode_chunk, __u8 *buffer) { - int chunkInNAND = yaffs_find_chunk_in_file(in, chunkInInode, NULL); + int nand_chunk = yaffs_find_chunk_in_file(in, inode_chunk, NULL); - if (chunkInNAND >= 0) - return yaffs_rd_chunk_tags_nand(in->myDev, chunkInNAND, + if (nand_chunk >= 0) + return yaffs_rd_chunk_tags_nand(in->my_dev, nand_chunk, buffer, NULL); else { T(YAFFS_TRACE_NANDACCESS, (TSTR("Chunk %d not found zero instead" TENDSTR), - chunkInNAND)); + nand_chunk)); /* get sane (zero) data if you read a hole */ - memset(buffer, 0, in->myDev->nDataBytesPerChunk); + memset(buffer, 0, in->my_dev->data_bytes_per_chunk); return 0; } } -void yaffs_chunk_del(yaffs_Device *dev, int chunkId, int markNAND, int lyn) +void yaffs_chunk_del(yaffs_dev_t *dev, int chunk_id, int mark_flash, int lyn) { int block; int page; - yaffs_ExtendedTags tags; - yaffs_BlockInfo *bi; + yaffs_ext_tags tags; + yaffs_block_info_t *bi; - if (chunkId <= 0) + if (chunk_id <= 0) return; - dev->nDeletions++; - block = chunkId / dev->param.nChunksPerBlock; - page = chunkId % dev->param.nChunksPerBlock; + dev->n_deletions++; + block = chunk_id / dev->param.chunks_per_block; + page = chunk_id % dev->param.chunks_per_block; if (!yaffs_check_chunk_bit(dev, block, page)) T(YAFFS_TRACE_VERIFY, (TSTR("Deleting invalid chunk %d"TENDSTR), - chunkId)); + chunk_id)); bi = yaffs_get_block_info(dev, block); yaffs2_update_oldest_dirty_seq(dev, block, bi); T(YAFFS_TRACE_DELETION, - (TSTR("line %d delete of chunk %d" TENDSTR), lyn, chunkId)); + (TSTR("line %d delete of chunk %d" TENDSTR), lyn, chunk_id)); - if (!dev->param.isYaffs2 && markNAND && - bi->blockState != YAFFS_BLOCK_STATE_COLLECTING) { + if (!dev->param.is_yaffs2 && mark_flash && + bi->block_state != YAFFS_BLOCK_STATE_COLLECTING) { yaffs_init_tags(&tags); - tags.chunkDeleted = 1; + tags.is_deleted = 1; - yaffs_wr_chunk_tags_nand(dev, chunkId, NULL, &tags); - yaffs_handle_chunk_update(dev, chunkId, &tags); + yaffs_wr_chunk_tags_nand(dev, chunk_id, NULL, &tags); + yaffs_handle_chunk_update(dev, chunk_id, &tags); } else { - dev->nUnmarkedDeletions++; + dev->n_unmarked_deletions++; } /* Pull out of the management area. * If the whole block became dirty, this will kick off an erasure. */ - if (bi->blockState == YAFFS_BLOCK_STATE_ALLOCATING || - bi->blockState == YAFFS_BLOCK_STATE_FULL || - bi->blockState == YAFFS_BLOCK_STATE_NEEDS_SCANNING || - bi->blockState == YAFFS_BLOCK_STATE_COLLECTING) { - dev->nFreeChunks++; + if (bi->block_state == YAFFS_BLOCK_STATE_ALLOCATING || + bi->block_state == YAFFS_BLOCK_STATE_FULL || + bi->block_state == YAFFS_BLOCK_STATE_NEEDS_SCANNING || + bi->block_state == YAFFS_BLOCK_STATE_COLLECTING) { + dev->n_free_chunks++; yaffs_clear_chunk_bit(dev, block, page); - bi->pagesInUse--; + bi->pages_in_use--; - if (bi->pagesInUse == 0 && - !bi->hasShrinkHeader && - bi->blockState != YAFFS_BLOCK_STATE_ALLOCATING && - bi->blockState != YAFFS_BLOCK_STATE_NEEDS_SCANNING) { + if (bi->pages_in_use == 0 && + !bi->has_shrink_hdr && + bi->block_state != YAFFS_BLOCK_STATE_ALLOCATING && + bi->block_state != YAFFS_BLOCK_STATE_NEEDS_SCANNING) { yaffs_block_became_dirty(dev, block); } @@ -2930,8 +2930,8 @@ void yaffs_chunk_del(yaffs_Device *dev, int chunkId, int markNAND, int lyn) } -static int yaffs_wr_data_obj(yaffs_Object *in, int chunkInInode, - const __u8 *buffer, int nBytes, +static int yaffs_wr_data_obj(yaffs_obj_t *in, int inode_chunk, + const __u8 *buffer, int n_bytes, int useReserve) { /* Find old chunk Need to do this to get serial number @@ -2940,12 +2940,12 @@ static int yaffs_wr_data_obj(yaffs_Object *in, int chunkInInode, */ int prevChunkId; - yaffs_ExtendedTags prevTags; + yaffs_ext_tags prevTags; int newChunkId; - yaffs_ExtendedTags newTags; + yaffs_ext_tags newTags; - yaffs_Device *dev = in->myDev; + yaffs_dev_t *dev = in->my_dev; yaffs_check_gc(dev,0); @@ -2953,23 +2953,23 @@ static int yaffs_wr_data_obj(yaffs_Object *in, int chunkInInode, * If it does not exist then put a zero into the tree. This creates * the tnode now, rather than later when it is harder to clean up. */ - prevChunkId = yaffs_find_chunk_in_file(in, chunkInInode, &prevTags); + prevChunkId = yaffs_find_chunk_in_file(in, inode_chunk, &prevTags); if(prevChunkId < 1 && - !yaffs_put_chunk_in_file(in, chunkInInode, 0, 0)) + !yaffs_put_chunk_in_file(in, inode_chunk, 0, 0)) return 0; /* Set up new tags */ yaffs_init_tags(&newTags); - newTags.chunkId = chunkInInode; - newTags.objectId = in->objectId; - newTags.serialNumber = - (prevChunkId > 0) ? prevTags.serialNumber + 1 : 1; - newTags.byteCount = nBytes; + newTags.chunk_id = inode_chunk; + newTags.obj_id = in->obj_id; + newTags.serial_number = + (prevChunkId > 0) ? prevTags.serial_number + 1 : 1; + newTags.n_bytes = n_bytes; - if (nBytes < 1 || nBytes > dev->param.totalBytesPerChunk) { + if (n_bytes < 1 || n_bytes > dev->param.total_bytes_per_chunk) { T(YAFFS_TRACE_ERROR, - (TSTR("Writing %d bytes to chunk!!!!!!!!!" TENDSTR), nBytes)); + (TSTR("Writing %d bytes to chunk!!!!!!!!!" TENDSTR), n_bytes)); YBUG(); } @@ -2979,7 +2979,7 @@ static int yaffs_wr_data_obj(yaffs_Object *in, int chunkInInode, useReserve); if (newChunkId > 0) { - yaffs_put_chunk_in_file(in, chunkInInode, newChunkId, 0); + yaffs_put_chunk_in_file(in, inode_chunk, newChunkId, 0); if (prevChunkId > 0) yaffs_chunk_del(dev, prevChunkId, 1, __LINE__); @@ -2993,42 +2993,42 @@ static int yaffs_wr_data_obj(yaffs_Object *in, int chunkInInode, /* 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_Object *in, const YCHAR *name, int force, - int isShrink, int shadows, yaffs_xattr_mod *xmod) +int yaffs_update_oh(yaffs_obj_t *in, const YCHAR *name, int force, + int is_shrink, int shadows, yaffs_xattr_mod *xmod) { - yaffs_BlockInfo *bi; + yaffs_block_info_t *bi; - yaffs_Device *dev = in->myDev; + yaffs_dev_t *dev = in->my_dev; int prevChunkId; int retVal = 0; int result = 0; int newChunkId; - yaffs_ExtendedTags newTags; - yaffs_ExtendedTags oldTags; + yaffs_ext_tags newTags; + yaffs_ext_tags oldTags; const YCHAR *alias = NULL; __u8 *buffer = NULL; - YCHAR oldName[YAFFS_MAX_NAME_LENGTH + 1]; + YCHAR old_name[YAFFS_MAX_NAME_LENGTH + 1]; - yaffs_ObjectHeader *oh = NULL; + yaffs_obj_header *oh = NULL; - yaffs_strcpy(oldName, _Y("silly old name")); + yaffs_strcpy(old_name, _Y("silly old name")); if (!in->fake || - in == dev->rootDir || /* The rootDir should also be saved */ + in == dev->root_dir || /* The root_dir should also be saved */ force || xmod) { yaffs_check_gc(dev,0); yaffs_check_obj_details_loaded(in); - buffer = yaffs_get_temp_buffer(in->myDev, __LINE__); - oh = (yaffs_ObjectHeader *) buffer; + buffer = yaffs_get_temp_buffer(in->my_dev, __LINE__); + oh = (yaffs_obj_header *) buffer; - prevChunkId = in->hdrChunk; + prevChunkId = in->hdr_chunk; if (prevChunkId > 0) { result = yaffs_rd_chunk_tags_nand(dev, prevChunkId, @@ -3036,14 +3036,14 @@ int yaffs_update_oh(yaffs_Object *in, const YCHAR *name, int force, yaffs_verify_oh(in, oh, &oldTags, 0); - memcpy(oldName, oh->name, sizeof(oh->name)); - memset(buffer, 0xFF, sizeof(yaffs_ObjectHeader)); + memcpy(old_name, oh->name, sizeof(oh->name)); + memset(buffer, 0xFF, sizeof(yaffs_obj_header)); } else - memset(buffer, 0xFF, dev->nDataBytesPerChunk); + memset(buffer, 0xFF, dev->data_bytes_per_chunk); - oh->type = in->variantType; + oh->type = in->variant_type; oh->yst_mode = in->yst_mode; - oh->shadowsObject = oh->inbandShadowsObject = shadows; + oh->shadows_obj = oh->inband_shadowed_obj_id = shadows; #ifdef CONFIG_YAFFS_WINCE oh->win_atime[0] = in->win_atime[0]; @@ -3061,34 +3061,34 @@ int yaffs_update_oh(yaffs_Object *in, const YCHAR *name, int force, oh->yst_rdev = in->yst_rdev; #endif if (in->parent) - oh->parentObjectId = in->parent->objectId; + oh->parent_obj_id = in->parent->obj_id; else - oh->parentObjectId = 0; + oh->parent_obj_id = 0; if (name && *name) { memset(oh->name, 0, sizeof(oh->name)); yaffs_load_oh_from_name(dev,oh->name,name); } else if (prevChunkId > 0) - memcpy(oh->name, oldName, sizeof(oh->name)); + memcpy(oh->name, old_name, sizeof(oh->name)); else memset(oh->name, 0, sizeof(oh->name)); - oh->isShrink = isShrink; + oh->is_shrink = is_shrink; - switch (in->variantType) { + switch (in->variant_type) { case YAFFS_OBJECT_TYPE_UNKNOWN: /* Should not happen */ break; case YAFFS_OBJECT_TYPE_FILE: - oh->fileSize = - (oh->parentObjectId == YAFFS_OBJECTID_DELETED - || oh->parentObjectId == + oh->file_size = + (oh->parent_obj_id == YAFFS_OBJECTID_DELETED + || oh->parent_obj_id == YAFFS_OBJECTID_UNLINKED) ? 0 : in->variant. - fileVariant.fileSize; + file_variant.file_size; break; case YAFFS_OBJECT_TYPE_HARDLINK: - oh->equivalentObjectId = - in->variant.hardLinkVariant.equivalentObjectId; + oh->equiv_id = + in->variant.hardlink_variant.equiv_id; break; case YAFFS_OBJECT_TYPE_SPECIAL: /* Do nothing */ @@ -3097,7 +3097,7 @@ int yaffs_update_oh(yaffs_Object *in, const YCHAR *name, int force, /* Do nothing */ break; case YAFFS_OBJECT_TYPE_SYMLINK: - alias = in->variant.symLinkVariant.alias; + alias = in->variant.symlink_variant.alias; if(!alias) alias = _Y("no alias"); yaffs_strncpy(oh->alias, @@ -3115,19 +3115,19 @@ int yaffs_update_oh(yaffs_Object *in, const YCHAR *name, int force, /* Tags */ yaffs_init_tags(&newTags); in->serial++; - newTags.chunkId = 0; - newTags.objectId = in->objectId; - newTags.serialNumber = in->serial; + newTags.chunk_id = 0; + newTags.obj_id = in->obj_id; + newTags.serial_number = in->serial; /* Add extra info for file header */ - newTags.extraHeaderInfoAvailable = 1; - newTags.extraParentObjectId = oh->parentObjectId; - newTags.extraFileLength = oh->fileSize; - newTags.extraIsShrinkHeader = oh->isShrink; - newTags.extraEquivalentObjectId = oh->equivalentObjectId; - newTags.extraShadows = (oh->shadowsObject > 0) ? 1 : 0; - newTags.extraObjectType = in->variantType; + newTags.extra_available = 1; + newTags.extra_parent_id = oh->parent_obj_id; + newTags.extra_length = oh->file_size; + newTags.extra_is_shrink = oh->is_shrink; + newTags.extra_equiv_id = oh->equiv_id; + newTags.extra_shadows = (oh->shadows_obj > 0) ? 1 : 0; + newTags.extra_obj_type = in->variant_type; yaffs_verify_oh(in, oh, &newTags, 1); @@ -3138,7 +3138,7 @@ int yaffs_update_oh(yaffs_Object *in, const YCHAR *name, int force, if (newChunkId >= 0) { - in->hdrChunk = newChunkId; + in->hdr_chunk = newChunkId; if (prevChunkId > 0) { yaffs_chunk_del(dev, prevChunkId, 1, @@ -3149,10 +3149,10 @@ int yaffs_update_oh(yaffs_Object *in, const YCHAR *name, int force, in->dirty = 0; /* If this was a shrink, then mark the block that the chunk lives on */ - if (isShrink) { - bi = yaffs_get_block_info(in->myDev, - newChunkId / in->myDev->param.nChunksPerBlock); - bi->hasShrinkHeader = 1; + if (is_shrink) { + bi = yaffs_get_block_info(in->my_dev, + newChunkId / in->my_dev->param.chunks_per_block); + bi->has_shrink_hdr = 1; } } @@ -3180,15 +3180,15 @@ int yaffs_update_oh(yaffs_Object *in, const YCHAR *name, int force, * need a very intelligent search. */ -static int yaffs_obj_cache_dirty(yaffs_Object *obj) +static int yaffs_obj_cache_dirty(yaffs_obj_t *obj) { - yaffs_Device *dev = obj->myDev; + yaffs_dev_t *dev = obj->my_dev; int i; - yaffs_ChunkCache *cache; - int nCaches = obj->myDev->param.nShortOpCaches; + yaffs_cache_t *cache; + int nCaches = obj->my_dev->param.n_caches; for (i = 0; i < nCaches; i++) { - cache = &dev->srCache[i]; + cache = &dev->cache[i]; if (cache->object == obj && cache->dirty) return 1; @@ -3198,14 +3198,14 @@ static int yaffs_obj_cache_dirty(yaffs_Object *obj) } -static void yaffs_flush_file_cache(yaffs_Object *obj) +static void yaffs_flush_file_cache(yaffs_obj_t *obj) { - yaffs_Device *dev = obj->myDev; + yaffs_dev_t *dev = obj->my_dev; int lowest = -99; /* Stop compiler whining. */ int i; - yaffs_ChunkCache *cache; + yaffs_cache_t *cache; int chunkWritten = 0; - int nCaches = obj->myDev->param.nShortOpCaches; + int nCaches = obj->my_dev->param.n_caches; if (nCaches > 0) { do { @@ -3213,13 +3213,13 @@ static void yaffs_flush_file_cache(yaffs_Object *obj) /* Find the dirty cache for this object with the lowest chunk id. */ for (i = 0; i < nCaches; i++) { - if (dev->srCache[i].object == obj && - dev->srCache[i].dirty) { + if (dev->cache[i].object == obj && + dev->cache[i].dirty) { if (!cache - || dev->srCache[i].chunkId < + || dev->cache[i].chunk_id < lowest) { - cache = &dev->srCache[i]; - lowest = cache->chunkId; + cache = &dev->cache[i]; + lowest = cache->chunk_id; } } } @@ -3229,9 +3229,9 @@ static void yaffs_flush_file_cache(yaffs_Object *obj) chunkWritten = yaffs_wr_data_obj(cache->object, - cache->chunkId, + cache->chunk_id, cache->data, - cache->nBytes, + cache->n_bytes, 1); cache->dirty = 0; cache->object = NULL; @@ -3254,10 +3254,10 @@ static void yaffs_flush_file_cache(yaffs_Object *obj) * */ -void yaffs_flush_whole_cache(yaffs_Device *dev) +void yaffs_flush_whole_cache(yaffs_dev_t *dev) { - yaffs_Object *obj; - int nCaches = dev->param.nShortOpCaches; + yaffs_obj_t *obj; + int nCaches = dev->param.n_caches; int i; /* Find a dirty object in the cache and flush it... @@ -3266,9 +3266,9 @@ void yaffs_flush_whole_cache(yaffs_Device *dev) do { obj = NULL; for (i = 0; i < nCaches && !obj; i++) { - if (dev->srCache[i].object && - dev->srCache[i].dirty) - obj = dev->srCache[i].object; + if (dev->cache[i].object && + dev->cache[i].dirty) + obj = dev->cache[i].object; } if (obj) @@ -3284,29 +3284,29 @@ void yaffs_flush_whole_cache(yaffs_Device *dev) * Then look for the least recently used non-dirty one. * Then look for the least recently used dirty one...., flush and look again. */ -static yaffs_ChunkCache *yaffs_grab_chunk_worker(yaffs_Device *dev) +static yaffs_cache_t *yaffs_grab_chunk_worker(yaffs_dev_t *dev) { int i; - if (dev->param.nShortOpCaches > 0) { - for (i = 0; i < dev->param.nShortOpCaches; i++) { - if (!dev->srCache[i].object) - return &dev->srCache[i]; + if (dev->param.n_caches > 0) { + for (i = 0; i < dev->param.n_caches; i++) { + if (!dev->cache[i].object) + return &dev->cache[i]; } } return NULL; } -static yaffs_ChunkCache *yaffs_grab_chunk_cache(yaffs_Device *dev) +static yaffs_cache_t *yaffs_grab_chunk_cache(yaffs_dev_t *dev) { - yaffs_ChunkCache *cache; - yaffs_Object *theObj; + yaffs_cache_t *cache; + yaffs_obj_t *theObj; int usage; int i; int pushout; - if (dev->param.nShortOpCaches > 0) { + if (dev->param.n_caches > 0) { /* Try find a non-dirty one... */ cache = yaffs_grab_chunk_worker(dev); @@ -3325,13 +3325,13 @@ static yaffs_ChunkCache *yaffs_grab_chunk_cache(yaffs_Device *dev) cache = NULL; pushout = -1; - for (i = 0; i < dev->param.nShortOpCaches; i++) { - if (dev->srCache[i].object && - !dev->srCache[i].locked && - (dev->srCache[i].lastUse < usage || !cache)) { - usage = dev->srCache[i].lastUse; - theObj = dev->srCache[i].object; - cache = &dev->srCache[i]; + for (i = 0; i < dev->param.n_caches; i++) { + if (dev->cache[i].object && + !dev->cache[i].locked && + (dev->cache[i].last_use < usage || !cache)) { + usage = dev->cache[i].last_use; + theObj = dev->cache[i].object; + cache = &dev->cache[i]; pushout = i; } } @@ -3350,18 +3350,18 @@ static yaffs_ChunkCache *yaffs_grab_chunk_cache(yaffs_Device *dev) } /* Find a cached chunk */ -static yaffs_ChunkCache *yaffs_find_chunk_cache(const yaffs_Object *obj, - int chunkId) +static yaffs_cache_t *yaffs_find_chunk_cache(const yaffs_obj_t *obj, + int chunk_id) { - yaffs_Device *dev = obj->myDev; + yaffs_dev_t *dev = obj->my_dev; int i; - if (dev->param.nShortOpCaches > 0) { - for (i = 0; i < dev->param.nShortOpCaches; i++) { - if (dev->srCache[i].object == obj && - dev->srCache[i].chunkId == chunkId) { - dev->cacheHits++; + if (dev->param.n_caches > 0) { + for (i = 0; i < dev->param.n_caches; i++) { + if (dev->cache[i].object == obj && + dev->cache[i].chunk_id == chunk_id) { + dev->cache_hits++; - return &dev->srCache[i]; + return &dev->cache[i]; } } } @@ -3369,23 +3369,23 @@ static yaffs_ChunkCache *yaffs_find_chunk_cache(const yaffs_Object *obj, } /* Mark the chunk for the least recently used algorithym */ -static void yaffs_use_cache(yaffs_Device *dev, yaffs_ChunkCache *cache, +static void yaffs_use_cache(yaffs_dev_t *dev, yaffs_cache_t *cache, int isAWrite) { - if (dev->param.nShortOpCaches > 0) { - if (dev->srLastUse < 0 || dev->srLastUse > 100000000) { + if (dev->param.n_caches > 0) { + if (dev->cache_last_use < 0 || dev->cache_last_use > 100000000) { /* Reset the cache usages */ int i; - for (i = 1; i < dev->param.nShortOpCaches; i++) - dev->srCache[i].lastUse = 0; + for (i = 1; i < dev->param.n_caches; i++) + dev->cache[i].last_use = 0; - dev->srLastUse = 0; + dev->cache_last_use = 0; } - dev->srLastUse++; + dev->cache_last_use++; - cache->lastUse = dev->srLastUse; + cache->last_use = dev->cache_last_use; if (isAWrite) cache->dirty = 1; @@ -3396,10 +3396,10 @@ static void yaffs_use_cache(yaffs_Device *dev, yaffs_ChunkCache *cache, * Do this when a whole page gets written, * ie the short cache for this page is no longer valid. */ -static void yaffs_invalidate_chunk_cache(yaffs_Object *object, int chunkId) +static void yaffs_invalidate_chunk_cache(yaffs_obj_t *object, int chunk_id) { - if (object->myDev->param.nShortOpCaches > 0) { - yaffs_ChunkCache *cache = yaffs_find_chunk_cache(object, chunkId); + if (object->my_dev->param.n_caches > 0) { + yaffs_cache_t *cache = yaffs_find_chunk_cache(object, chunk_id); if (cache) cache->object = NULL; @@ -3409,16 +3409,16 @@ static void yaffs_invalidate_chunk_cache(yaffs_Object *object, int chunkId) /* 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_Object *in) +static void yaffs_invalidate_whole_cache(yaffs_obj_t *in) { int i; - yaffs_Device *dev = in->myDev; + yaffs_dev_t *dev = in->my_dev; - if (dev->param.nShortOpCaches > 0) { + if (dev->param.n_caches > 0) { /* Invalidate it. */ - for (i = 0; i < dev->param.nShortOpCaches; i++) { - if (dev->srCache[i].object == in) - dev->srCache[i].object = NULL; + for (i = 0; i < dev->param.n_caches; i++) { + if (dev->cache[i].object == in) + dev->cache[i].object = NULL; } } } @@ -3434,34 +3434,34 @@ static void yaffs_invalidate_whole_cache(yaffs_Object *in) * Curve-balls: the first chunk might also be the last chunk. */ -int yaffs_file_rd(yaffs_Object *in, __u8 *buffer, loff_t offset, - int nBytes) +int yaffs_file_rd(yaffs_obj_t *in, __u8 *buffer, loff_t offset, + int n_bytes) { int chunk; __u32 start; int nToCopy; - int n = nBytes; + int n = n_bytes; int nDone = 0; - yaffs_ChunkCache *cache; + yaffs_cache_t *cache; - yaffs_Device *dev; + yaffs_dev_t *dev; - dev = in->myDev; + dev = in->my_dev; while (n > 0) { - /* chunk = offset / dev->nDataBytesPerChunk + 1; */ - /* start = offset % dev->nDataBytesPerChunk; */ + /* chunk = offset / dev->data_bytes_per_chunk + 1; */ + /* start = offset % dev->data_bytes_per_chunk; */ yaffs_addr_to_chunk(dev, offset, &chunk, &start); chunk++; /* OK now check for the curveball where the start and end are in * the same chunk. */ - if ((start + n) < dev->nDataBytesPerChunk) + if ((start + n) < dev->data_bytes_per_chunk) nToCopy = n; else - nToCopy = dev->nDataBytesPerChunk - start; + nToCopy = dev->data_bytes_per_chunk - start; cache = yaffs_find_chunk_cache(in, chunk); @@ -3469,21 +3469,21 @@ int yaffs_file_rd(yaffs_Object *in, __u8 *buffer, loff_t offset, * or we're using inband tags then use the cache (if there is caching) * else bypass the cache. */ - if (cache || nToCopy != dev->nDataBytesPerChunk || dev->param.inbandTags) { - if (dev->param.nShortOpCaches > 0) { + if (cache || nToCopy != dev->data_bytes_per_chunk || dev->param.inband_tags) { + if (dev->param.n_caches > 0) { /* If we can't find the data in the cache, then load it up. */ if (!cache) { - cache = yaffs_grab_chunk_cache(in->myDev); + cache = yaffs_grab_chunk_cache(in->my_dev); cache->object = in; - cache->chunkId = chunk; + cache->chunk_id = chunk; cache->dirty = 0; cache->locked = 0; yaffs_rd_data_obj(in, chunk, cache-> data); - cache->nBytes = 0; + cache->n_bytes = 0; } yaffs_use_cache(dev, cache, 0); @@ -3526,30 +3526,30 @@ int yaffs_file_rd(yaffs_Object *in, __u8 *buffer, loff_t offset, return nDone; } -int yaffs_do_file_wr(yaffs_Object *in, const __u8 *buffer, loff_t offset, - int nBytes, int writeThrough) +int yaffs_do_file_wr(yaffs_obj_t *in, const __u8 *buffer, loff_t offset, + int n_bytes, int write_trhrough) { int chunk; __u32 start; int nToCopy; - int n = nBytes; + int n = n_bytes; int nDone = 0; int nToWriteBack; int startOfWrite = offset; int chunkWritten = 0; - __u32 nBytesRead; + __u32 n_bytesRead; __u32 chunkStart; - yaffs_Device *dev; + yaffs_dev_t *dev; - dev = in->myDev; + dev = in->my_dev; while (n > 0 && chunkWritten >= 0) { yaffs_addr_to_chunk(dev, offset, &chunk, &start); - if (chunk * dev->nDataBytesPerChunk + start != offset || - start >= dev->nDataBytesPerChunk) { + if (chunk * dev->data_bytes_per_chunk + start != offset || + start >= dev->data_bytes_per_chunk) { T(YAFFS_TRACE_ERROR, ( TSTR("AddrToChunk of offset %d gives chunk %d start %d" TENDSTR), @@ -3561,7 +3561,7 @@ int yaffs_do_file_wr(yaffs_Object *in, const __u8 *buffer, loff_t offset, * the same chunk. */ - if ((start + n) < dev->nDataBytesPerChunk) { + if ((start + n) < dev->data_bytes_per_chunk) { nToCopy = n; /* Now folks, to calculate how many bytes to write back.... @@ -3569,34 +3569,34 @@ int yaffs_do_file_wr(yaffs_Object *in, const __u8 *buffer, loff_t offset, * we need to write back as much as was there before. */ - chunkStart = ((chunk - 1) * dev->nDataBytesPerChunk); + chunkStart = ((chunk - 1) * dev->data_bytes_per_chunk); - if (chunkStart > in->variant.fileVariant.fileSize) - nBytesRead = 0; /* Past end of file */ + if (chunkStart > in->variant.file_variant.file_size) + n_bytesRead = 0; /* Past end of file */ else - nBytesRead = in->variant.fileVariant.fileSize - chunkStart; + n_bytesRead = in->variant.file_variant.file_size - chunkStart; - if (nBytesRead > dev->nDataBytesPerChunk) - nBytesRead = dev->nDataBytesPerChunk; + if (n_bytesRead > dev->data_bytes_per_chunk) + n_bytesRead = dev->data_bytes_per_chunk; nToWriteBack = - (nBytesRead > - (start + n)) ? nBytesRead : (start + n); + (n_bytesRead > + (start + n)) ? n_bytesRead : (start + n); - if (nToWriteBack < 0 || nToWriteBack > dev->nDataBytesPerChunk) + if (nToWriteBack < 0 || nToWriteBack > dev->data_bytes_per_chunk) YBUG(); } else { - nToCopy = dev->nDataBytesPerChunk - start; - nToWriteBack = dev->nDataBytesPerChunk; + nToCopy = dev->data_bytes_per_chunk - start; + nToWriteBack = dev->data_bytes_per_chunk; } - if (nToCopy != dev->nDataBytesPerChunk || dev->param.inbandTags) { + if (nToCopy != dev->data_bytes_per_chunk || dev->param.inband_tags) { /* An incomplete start or end chunk (or maybe both start and end chunk), * or we're using inband tags, so we want to use the cache buffers. */ - if (dev->param.nShortOpCaches > 0) { - yaffs_ChunkCache *cache; + if (dev->param.n_caches > 0) { + yaffs_cache_t *cache; /* If we can't find the data in the cache, then load the cache */ cache = yaffs_find_chunk_cache(in, chunk); @@ -3604,7 +3604,7 @@ int yaffs_do_file_wr(yaffs_Object *in, const __u8 *buffer, loff_t offset, && yaffs_check_alloc_available(dev, 1)) { cache = yaffs_grab_chunk_cache(dev); cache->object = in; - cache->chunkId = chunk; + cache->chunk_id = chunk; cache->dirty = 0; cache->locked = 0; yaffs_rd_data_obj(in, chunk, @@ -3628,14 +3628,14 @@ int yaffs_do_file_wr(yaffs_Object *in, const __u8 *buffer, loff_t offset, cache->locked = 0; - cache->nBytes = nToWriteBack; + cache->n_bytes = nToWriteBack; - if (writeThrough) { + if (write_trhrough) { chunkWritten = yaffs_wr_data_obj (cache->object, - cache->chunkId, - cache->data, cache->nBytes, + cache->chunk_id, + cache->data, cache->n_bytes, 1); cache->dirty = 0; } @@ -3676,7 +3676,7 @@ int yaffs_do_file_wr(yaffs_Object *in, const __u8 *buffer, loff_t offset, chunkWritten = yaffs_wr_data_obj(in, chunk, buffer, - dev->nDataBytesPerChunk, + dev->data_bytes_per_chunk, 0); /* Since we've overwritten the cached data, we better invalidate it. */ @@ -3694,37 +3694,37 @@ int yaffs_do_file_wr(yaffs_Object *in, const __u8 *buffer, loff_t offset, /* Update file object */ - if ((startOfWrite + nDone) > in->variant.fileVariant.fileSize) - in->variant.fileVariant.fileSize = (startOfWrite + nDone); + if ((startOfWrite + nDone) > in->variant.file_variant.file_size) + in->variant.file_variant.file_size = (startOfWrite + nDone); in->dirty = 1; return nDone; } -int yaffs_wr_file(yaffs_Object *in, const __u8 *buffer, loff_t offset, - int nBytes, int writeThrough) +int yaffs_wr_file(yaffs_obj_t *in, const __u8 *buffer, loff_t offset, + int n_bytes, int write_trhrough) { yaffs2_handle_hole(in,offset); - return yaffs_do_file_wr(in,buffer,offset,nBytes,writeThrough); + return yaffs_do_file_wr(in,buffer,offset,n_bytes,write_trhrough); } /* ---------------------- File resizing stuff ------------------ */ -static void yaffs_prune_chunks(yaffs_Object *in, int newSize) +static void yaffs_prune_chunks(yaffs_obj_t *in, int new_size) { - yaffs_Device *dev = in->myDev; - int oldFileSize = in->variant.fileVariant.fileSize; + yaffs_dev_t *dev = in->my_dev; + int oldFileSize = in->variant.file_variant.file_size; - int lastDel = 1 + (oldFileSize - 1) / dev->nDataBytesPerChunk; + int lastDel = 1 + (oldFileSize - 1) / dev->data_bytes_per_chunk; - int startDel = 1 + (newSize + dev->nDataBytesPerChunk - 1) / - dev->nDataBytesPerChunk; + int startDel = 1 + (new_size + dev->data_bytes_per_chunk - 1) / + dev->data_bytes_per_chunk; int i; - int chunkId; + int chunk_id; /* Delete backwards so that we don't end up with holes if * power is lost part-way through the operation. @@ -3735,19 +3735,19 @@ static void yaffs_prune_chunks(yaffs_Object *in, int newSize) * using yaffs_chunk_del */ - chunkId = yaffs_find_del_file_chunk(in, i, NULL); - if (chunkId > 0) { - if (chunkId < - (dev->internalStartBlock * dev->param.nChunksPerBlock) - || chunkId >= - ((dev->internalEndBlock + - 1) * dev->param.nChunksPerBlock)) { + chunk_id = yaffs_find_del_file_chunk(in, i, NULL); + if (chunk_id > 0) { + if (chunk_id < + (dev->internal_start_block * dev->param.chunks_per_block) + || chunk_id >= + ((dev->internal_end_block + + 1) * dev->param.chunks_per_block)) { T(YAFFS_TRACE_ALWAYS, - (TSTR("Found daft chunkId %d for %d" TENDSTR), - chunkId, i)); + (TSTR("Found daft chunk_id %d for %d" TENDSTR), + chunk_id, i)); } else { - in->nDataChunks--; - yaffs_chunk_del(dev, chunkId, 1, __LINE__); + in->n_data_chunks--; + yaffs_chunk_del(dev, chunk_id, 1, __LINE__); } } } @@ -3755,59 +3755,59 @@ static void yaffs_prune_chunks(yaffs_Object *in, int newSize) } -void yaffs_resize_file_down( yaffs_Object *obj, loff_t newSize) +void yaffs_resize_file_down( yaffs_obj_t *obj, loff_t new_size) { int newFullChunks; - __u32 newSizeOfPartialChunk; - yaffs_Device *dev = obj->myDev; + __u32 new_sizeOfPartialChunk; + yaffs_dev_t *dev = obj->my_dev; - yaffs_addr_to_chunk(dev, newSize, &newFullChunks, &newSizeOfPartialChunk); + yaffs_addr_to_chunk(dev, new_size, &newFullChunks, &new_sizeOfPartialChunk); - yaffs_prune_chunks(obj, newSize); + yaffs_prune_chunks(obj, new_size); - if (newSizeOfPartialChunk != 0) { + if (new_sizeOfPartialChunk != 0) { int lastChunk = 1 + newFullChunks; __u8 *localBuffer = yaffs_get_temp_buffer(dev, __LINE__); /* Got to read and rewrite the last chunk with its new size and zero pad */ yaffs_rd_data_obj(obj, lastChunk, localBuffer); - memset(localBuffer + newSizeOfPartialChunk, 0, - dev->nDataBytesPerChunk - newSizeOfPartialChunk); + memset(localBuffer + new_sizeOfPartialChunk, 0, + dev->data_bytes_per_chunk - new_sizeOfPartialChunk); yaffs_wr_data_obj(obj, lastChunk, localBuffer, - newSizeOfPartialChunk, 1); + new_sizeOfPartialChunk, 1); yaffs_release_temp_buffer(dev, localBuffer, __LINE__); } - obj->variant.fileVariant.fileSize = newSize; + obj->variant.file_variant.file_size = new_size; - yaffs_prune_tree(dev, &obj->variant.fileVariant); + yaffs_prune_tree(dev, &obj->variant.file_variant); } -int yaffs_resize_file(yaffs_Object *in, loff_t newSize) +int yaffs_resize_file(yaffs_obj_t *in, loff_t new_size) { - yaffs_Device *dev = in->myDev; - int oldFileSize = in->variant.fileVariant.fileSize; + yaffs_dev_t *dev = in->my_dev; + int oldFileSize = in->variant.file_variant.file_size; yaffs_flush_file_cache(in); yaffs_invalidate_whole_cache(in); yaffs_check_gc(dev,0); - if (in->variantType != YAFFS_OBJECT_TYPE_FILE) + if (in->variant_type != YAFFS_OBJECT_TYPE_FILE) return YAFFS_FAIL; - if (newSize == oldFileSize) + if (new_size == oldFileSize) return YAFFS_OK; - if(newSize > oldFileSize){ - yaffs2_handle_hole(in,newSize); - in->variant.fileVariant.fileSize = newSize; + if(new_size > oldFileSize){ + yaffs2_handle_hole(in,new_size); + in->variant.file_variant.file_size = new_size; } else { - /* newSize < oldFileSize */ - yaffs_resize_file_down(in, newSize); + /* new_size < oldFileSize */ + yaffs_resize_file_down(in, new_size); } /* Write a new object header to reflect the resize. @@ -3816,25 +3816,25 @@ int yaffs_resize_file(yaffs_Object *in, loff_t newSize) * and is not shadowed. */ if (in->parent && - !in->isShadowed && - in->parent->objectId != YAFFS_OBJECTID_UNLINKED && - in->parent->objectId != YAFFS_OBJECTID_DELETED) + !in->is_shadowed && + in->parent->obj_id != YAFFS_OBJECTID_UNLINKED && + in->parent->obj_id != YAFFS_OBJECTID_DELETED) yaffs_update_oh(in, NULL, 0, 0, 0, NULL); return YAFFS_OK; } -loff_t yaffs_get_file_size(yaffs_Object *obj) +loff_t yaffs_get_file_size(yaffs_obj_t *obj) { YCHAR *alias = NULL; obj = yaffs_get_equivalent_obj(obj); - switch (obj->variantType) { + switch (obj->variant_type) { case YAFFS_OBJECT_TYPE_FILE: - return obj->variant.fileVariant.fileSize; + return obj->variant.file_variant.file_size; case YAFFS_OBJECT_TYPE_SYMLINK: - alias = obj->variant.symLinkVariant.alias; + alias = obj->variant.symlink_variant.alias; if(!alias) return 0; return yaffs_strnlen(alias,YAFFS_MAX_ALIAS_LENGTH); @@ -3845,15 +3845,15 @@ loff_t yaffs_get_file_size(yaffs_Object *obj) -int yaffs_flush_file(yaffs_Object *in, int updateTime, int dataSync) +int yaffs_flush_file(yaffs_obj_t *in, int update_time, int data_sync) { int retVal; if (in->dirty) { yaffs_flush_file_cache(in); - if(dataSync) /* Only sync data */ + if(data_sync) /* Only sync data */ retVal=YAFFS_OK; else { - if (updateTime) { + if (update_time) { #ifdef CONFIG_YAFFS_WINCE yfsd_win_file_time_now(in->win_mtime); #else @@ -3874,21 +3874,21 @@ int yaffs_flush_file(yaffs_Object *in, int updateTime, int dataSync) } -static int yaffs_generic_obj_del(yaffs_Object *in) +static int yaffs_generic_obj_del(yaffs_obj_t *in) { /* First off, invalidate the file's data in the cache, without flushing. */ yaffs_invalidate_whole_cache(in); - if (in->myDev->param.isYaffs2 && (in->parent != in->myDev->deletedDir)) { + if (in->my_dev->param.is_yaffs2 && (in->parent != in->my_dev->del_dir)) { /* Move to the unlinked directory so we have a record that it was deleted. */ - yaffs_change_obj_name(in, in->myDev->deletedDir, _Y("deleted"), 0, 0); + yaffs_change_obj_name(in, in->my_dev->del_dir, _Y("deleted"), 0, 0); } yaffs_remove_obj_from_dir(in); - yaffs_chunk_del(in->myDev, in->hdrChunk, 1, __LINE__); - in->hdrChunk = 0; + yaffs_chunk_del(in->my_dev, in->hdr_chunk, 1, __LINE__); + in->hdr_chunk = 0; yaffs_free_obj(in); return YAFFS_OK; @@ -3899,31 +3899,31 @@ static int yaffs_generic_obj_del(yaffs_Object *in) * and the inode associated with the file. * It does not delete the links associated with the file. */ -static int yaffs_unlink_file_if_needed(yaffs_Object *in) +static int yaffs_unlink_file_if_needed(yaffs_obj_t *in) { int retVal; int immediateDeletion = 0; - yaffs_Device *dev = in->myDev; + yaffs_dev_t *dev = in->my_dev; - if (!in->myInode) + if (!in->my_inode) immediateDeletion = 1; if (immediateDeletion) { retVal = - yaffs_change_obj_name(in, in->myDev->deletedDir, + yaffs_change_obj_name(in, in->my_dev->del_dir, _Y("deleted"), 0, 0); T(YAFFS_TRACE_TRACING, (TSTR("yaffs: immediate deletion of file %d" TENDSTR), - in->objectId)); + in->obj_id)); in->deleted = 1; - in->myDev->nDeletedFiles++; - if (dev->param.disableSoftDelete || dev->param.isYaffs2) + in->my_dev->n_deleted_files++; + if (dev->param.disable_soft_del || dev->param.is_yaffs2) yaffs_resize_file(in, 0); yaffs_soft_del_file(in); } else { retVal = - yaffs_change_obj_name(in, in->myDev->unlinkedDir, + yaffs_change_obj_name(in, in->my_dev->unlinked_dir, _Y("unlinked"), 0, 0); } @@ -3931,16 +3931,16 @@ static int yaffs_unlink_file_if_needed(yaffs_Object *in) return retVal; } -int yaffs_del_file(yaffs_Object *in) +int yaffs_del_file(yaffs_obj_t *in) { int retVal = YAFFS_OK; int deleted; /* Need to cache value on stack if in is freed */ - yaffs_Device *dev = in->myDev; + yaffs_dev_t *dev = in->my_dev; - if (dev->param.disableSoftDelete || dev->param.isYaffs2) + if (dev->param.disable_soft_del || dev->param.is_yaffs2) yaffs_resize_file(in, 0); - if (in->nDataChunks > 0) { + if (in->n_data_chunks > 0) { /* Use soft deletion if there is data in the file. * That won't be the case if it has been resized to zero. */ @@ -3952,27 +3952,27 @@ int yaffs_del_file(yaffs_Object *in) if (retVal == YAFFS_OK && in->unlinked && !in->deleted) { in->deleted = 1; deleted = 1; - in->myDev->nDeletedFiles++; + in->my_dev->n_deleted_files++; yaffs_soft_del_file(in); } return deleted ? YAFFS_OK : YAFFS_FAIL; } else { /* The file has no data chunks so we toss it immediately */ - yaffs_free_tnode(in->myDev, in->variant.fileVariant.top); - in->variant.fileVariant.top = NULL; + yaffs_free_tnode(in->my_dev, in->variant.file_variant.top); + in->variant.file_variant.top = NULL; yaffs_generic_obj_del(in); return YAFFS_OK; } } -static int yaffs_is_non_empty_dir(yaffs_Object *obj) +static int yaffs_is_non_empty_dir(yaffs_obj_t *obj) { - return (obj->variantType == YAFFS_OBJECT_TYPE_DIRECTORY) && - !(ylist_empty(&obj->variant.directoryVariant.children)); + return (obj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY) && + !(ylist_empty(&obj->variant.dir_variant.children)); } -static int yaffs_del_dir(yaffs_Object *obj) +static int yaffs_del_dir(yaffs_obj_t *obj) { /* First check that the directory is empty. */ if (yaffs_is_non_empty_dir(obj)) @@ -3981,35 +3981,35 @@ static int yaffs_del_dir(yaffs_Object *obj) return yaffs_generic_obj_del(obj); } -static int yaffs_del_symlink(yaffs_Object *in) +static int yaffs_del_symlink(yaffs_obj_t *in) { - if(in->variant.symLinkVariant.alias) - YFREE(in->variant.symLinkVariant.alias); - in->variant.symLinkVariant.alias=NULL; + if(in->variant.symlink_variant.alias) + YFREE(in->variant.symlink_variant.alias); + in->variant.symlink_variant.alias=NULL; return yaffs_generic_obj_del(in); } -static int yaffs_del_link(yaffs_Object *in) +static int yaffs_del_link(yaffs_obj_t *in) { /* remove this hardlink from the list assocaited with the equivalent * object */ - ylist_del_init(&in->hardLinks); + ylist_del_init(&in->hard_links); return yaffs_generic_obj_del(in); } -int yaffs_del_obj(yaffs_Object *obj) +int yaffs_del_obj(yaffs_obj_t *obj) { int retVal = -1; - switch (obj->variantType) { + switch (obj->variant_type) { case YAFFS_OBJECT_TYPE_FILE: retVal = yaffs_del_file(obj); break; case YAFFS_OBJECT_TYPE_DIRECTORY: - if(!ylist_empty(&obj->variant.directoryVariant.dirty)){ - T(YAFFS_TRACE_BACKGROUND, (TSTR("Remove object %d from dirty directories" TENDSTR),obj->objectId)); - ylist_del_init(&obj->variant.directoryVariant.dirty); + if(!ylist_empty(&obj->variant.dir_variant.dirty)){ + T(YAFFS_TRACE_BACKGROUND, (TSTR("Remove object %d from dirty directories" TENDSTR),obj->obj_id)); + ylist_del_init(&obj->variant.dir_variant.dirty); } return yaffs_del_dir(obj); break; @@ -4030,20 +4030,20 @@ int retVal = -1; return retVal; } -static int yaffs_unlink_worker(yaffs_Object *obj) +static int yaffs_unlink_worker(yaffs_obj_t *obj) { int immediateDeletion = 0; - if (!obj->myInode) + if (!obj->my_inode) immediateDeletion = 1; if(obj) yaffs_update_parent(obj->parent); - if (obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK) { + if (obj->variant_type == YAFFS_OBJECT_TYPE_HARDLINK) { return yaffs_del_link(obj); - } else if (!ylist_empty(&obj->hardLinks)) { + } else if (!ylist_empty(&obj->hard_links)) { /* Curve ball: We're unlinking an object that has a hardlink. * * This problem arises because we are not strictly following @@ -4058,19 +4058,19 @@ static int yaffs_unlink_worker(yaffs_Object *obj) * - Delete the hardlink */ - yaffs_Object *hl; - yaffs_Object *parent; + yaffs_obj_t *hl; + yaffs_obj_t *parent; int retVal; YCHAR name[YAFFS_MAX_NAME_LENGTH + 1]; - hl = ylist_entry(obj->hardLinks.next, yaffs_Object, hardLinks); + hl = ylist_entry(obj->hard_links.next, yaffs_obj_t, hard_links); yaffs_get_obj_name(hl, name, YAFFS_MAX_NAME_LENGTH + 1); parent = hl->parent; - ylist_del_init(&hl->hardLinks); + ylist_del_init(&hl->hard_links); - yaffs_add_obj_to_dir(obj->myDev->unlinkedDir, hl); + yaffs_add_obj_to_dir(obj->my_dev->unlinked_dir, hl); retVal = yaffs_change_obj_name(obj,parent, name, 0, 0); @@ -4080,12 +4080,12 @@ static int yaffs_unlink_worker(yaffs_Object *obj) return retVal; } else if (immediateDeletion) { - switch (obj->variantType) { + switch (obj->variant_type) { case YAFFS_OBJECT_TYPE_FILE: return yaffs_del_file(obj); break; case YAFFS_OBJECT_TYPE_DIRECTORY: - ylist_del_init(&obj->variant.directoryVariant.dirty); + ylist_del_init(&obj->variant.dir_variant.dirty); return yaffs_del_dir(obj); break; case YAFFS_OBJECT_TYPE_SYMLINK: @@ -4102,23 +4102,23 @@ static int yaffs_unlink_worker(yaffs_Object *obj) } else if(yaffs_is_non_empty_dir(obj)) return YAFFS_FAIL; else - return yaffs_change_obj_name(obj, obj->myDev->unlinkedDir, + return yaffs_change_obj_name(obj, obj->my_dev->unlinked_dir, _Y("unlinked"), 0, 0); } -static int yaffs_unlink_obj(yaffs_Object *obj) +static int yaffs_unlink_obj(yaffs_obj_t *obj) { - if (obj && obj->unlinkAllowed) + if (obj && obj->unlink_allowed) return yaffs_unlink_worker(obj); return YAFFS_FAIL; } -int yaffs_unlinker(yaffs_Object *dir, const YCHAR *name) +int yaffs_unlinker(yaffs_obj_t *dir, const YCHAR *name) { - yaffs_Object *obj; + yaffs_obj_t *obj; obj = yaffs_find_by_name(dir, name); return yaffs_unlink_obj(obj); @@ -4126,12 +4126,12 @@ int yaffs_unlinker(yaffs_Object *dir, const YCHAR *name) /*----------------------- Initialisation Scanning ---------------------- */ -void yaffs_handle_shadowed_obj(yaffs_Device *dev, int objId, - int backwardScanning) +void yaffs_handle_shadowed_obj(yaffs_dev_t *dev, int obj_id, + int backward_scanning) { - yaffs_Object *obj; + yaffs_obj_t *obj; - if (!backwardScanning) { + if (!backward_scanning) { /* Handle YAFFS1 forward scanning case * For YAFFS1 we always do the deletion */ @@ -4140,7 +4140,7 @@ void yaffs_handle_shadowed_obj(yaffs_Device *dev, int objId, /* Handle YAFFS2 case (backward scanning) * If the shadowed object exists then ignore. */ - obj = yaffs_find_by_number(dev, objId); + obj = yaffs_find_by_number(dev, obj_id); if(obj) return; } @@ -4149,72 +4149,72 @@ void yaffs_handle_shadowed_obj(yaffs_Device *dev, int objId, * We put it in unlinked dir to be cleaned up after the scanning */ obj = - yaffs_find_or_create_by_number(dev, objId, + yaffs_find_or_create_by_number(dev, obj_id, YAFFS_OBJECT_TYPE_FILE); if (!obj) return; - obj->isShadowed = 1; - yaffs_add_obj_to_dir(dev->unlinkedDir, obj); - obj->variant.fileVariant.shrinkSize = 0; + obj->is_shadowed = 1; + yaffs_add_obj_to_dir(dev->unlinked_dir, obj); + obj->variant.file_variant.shrink_size = 0; obj->valid = 1; /* So that we don't read any other info for this file */ } -void yaffs_link_fixup(yaffs_Device *dev, yaffs_Object *hardList) +void yaffs_link_fixup(yaffs_dev_t *dev, yaffs_obj_t *hard_list) { - yaffs_Object *hl; - yaffs_Object *in; + yaffs_obj_t *hl; + yaffs_obj_t *in; - while (hardList) { - hl = hardList; - hardList = (yaffs_Object *) (hardList->hardLinks.next); + while (hard_list) { + hl = hard_list; + hard_list = (yaffs_obj_t *) (hard_list->hard_links.next); in = yaffs_find_by_number(dev, - hl->variant.hardLinkVariant. - equivalentObjectId); + hl->variant.hardlink_variant. + equiv_id); if (in) { /* Add the hardlink pointers */ - hl->variant.hardLinkVariant.equivalentObject = in; - ylist_add(&hl->hardLinks, &in->hardLinks); + hl->variant.hardlink_variant.equiv_obj = in; + ylist_add(&hl->hard_links, &in->hard_links); } else { /* Todo Need to report/handle this better. * Got a problem... hardlink to a non-existant object */ - hl->variant.hardLinkVariant.equivalentObject = NULL; - YINIT_LIST_HEAD(&hl->hardLinks); + hl->variant.hardlink_variant.equiv_obj = NULL; + YINIT_LIST_HEAD(&hl->hard_links); } } } -static void yaffs_strip_deleted_objs(yaffs_Device *dev) +static void yaffs_strip_deleted_objs(yaffs_dev_t *dev) { /* * Sort out state of unlinked and deleted objects after scanning. */ struct ylist_head *i; struct ylist_head *n; - yaffs_Object *l; + yaffs_obj_t *l; - if (dev->readOnly) + if (dev->read_only) return; /* Soft delete all the unlinked files */ ylist_for_each_safe(i, n, - &dev->unlinkedDir->variant.directoryVariant.children) { + &dev->unlinked_dir->variant.dir_variant.children) { if (i) { - l = ylist_entry(i, yaffs_Object, siblings); + l = ylist_entry(i, yaffs_obj_t, siblings); yaffs_del_obj(l); } } ylist_for_each_safe(i, n, - &dev->deletedDir->variant.directoryVariant.children) { + &dev->del_dir->variant.dir_variant.children) { if (i) { - l = ylist_entry(i, yaffs_Object, siblings); + l = ylist_entry(i, yaffs_obj_t, siblings); yaffs_del_obj(l); } } @@ -4231,31 +4231,31 @@ static void yaffs_strip_deleted_objs(yaffs_Device *dev) * Note: * This code assumes that we don't ever change the current relationships between * directories: - * rootDir->parent == unlinkedDir->parent == deletedDir->parent == NULL - * lostNfound->parent == rootDir + * root_dir->parent == unlinked_dir->parent == del_dir->parent == NULL + * lostNfound->parent == root_dir * * This fixes the problem where directories might have inadvertently been deleted * leaving the object "hanging" without being rooted in the directory tree. */ -static int yaffs_has_null_parent(yaffs_Device *dev, yaffs_Object *obj) +static int yaffs_has_null_parent(yaffs_dev_t *dev, yaffs_obj_t *obj) { - return (obj == dev->deletedDir || - obj == dev->unlinkedDir|| - obj == dev->rootDir); + return (obj == dev->del_dir || + obj == dev->unlinked_dir|| + obj == dev->root_dir); } -static void yaffs_fix_hanging_objs(yaffs_Device *dev) +static void yaffs_fix_hanging_objs(yaffs_dev_t *dev) { - yaffs_Object *obj; - yaffs_Object *parent; + yaffs_obj_t *obj; + yaffs_obj_t *parent; int i; struct ylist_head *lh; struct ylist_head *n; int depthLimit; int hanging; - if (dev->readOnly) + if (dev->read_only) return; /* Iterate through the objects in each hash entry, @@ -4264,16 +4264,16 @@ static void yaffs_fix_hanging_objs(yaffs_Device *dev) */ for (i = 0; i < YAFFS_NOBJECT_BUCKETS; i++) { - ylist_for_each_safe(lh, n, &dev->objectBucket[i].list) { + ylist_for_each_safe(lh, n, &dev->obj_bucket[i].list) { if (lh) { - obj = ylist_entry(lh, yaffs_Object, hashLink); + obj = ylist_entry(lh, yaffs_obj_t, hash_link); parent= obj->parent; if(yaffs_has_null_parent(dev,obj)){ /* These directories are not hanging */ hanging = 0; } - else if(!parent || parent->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) + else if(!parent || parent->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) hanging = 1; else if(yaffs_has_null_parent(dev,parent)) hanging = 0; @@ -4284,21 +4284,21 @@ static void yaffs_fix_hanging_objs(yaffs_Device *dev) hanging = 0; depthLimit=100; - while(parent != dev->rootDir && + while(parent != dev->root_dir && parent->parent && - parent->parent->variantType == YAFFS_OBJECT_TYPE_DIRECTORY && + parent->parent->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY && depthLimit > 0){ parent = parent->parent; depthLimit--; } - if(parent != dev->rootDir) + if(parent != dev->root_dir) hanging = 1; } if(hanging){ T(YAFFS_TRACE_SCAN, (TSTR("Hanging object %d moved to lost and found" TENDSTR), - obj->objectId)); - yaffs_add_obj_to_dir(dev->lostNFoundDir,obj); + obj->obj_id)); + yaffs_add_obj_to_dir(dev->lost_n_found,obj); } } } @@ -4309,24 +4309,24 @@ static void yaffs_fix_hanging_objs(yaffs_Device *dev) /* * Delete directory contents for cleaning up lost and found. */ -static void yaffs_del_dir_contents(yaffs_Object *dir) +static void yaffs_del_dir_contents(yaffs_obj_t *dir) { - yaffs_Object *obj; + yaffs_obj_t *obj; struct ylist_head *lh; struct ylist_head *n; - if(dir->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) + if(dir->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) YBUG(); - ylist_for_each_safe(lh, n, &dir->variant.directoryVariant.children) { + ylist_for_each_safe(lh, n, &dir->variant.dir_variant.children) { if (lh) { - obj = ylist_entry(lh, yaffs_Object, siblings); - if(obj->variantType == YAFFS_OBJECT_TYPE_DIRECTORY) + obj = ylist_entry(lh, yaffs_obj_t, siblings); + if(obj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY) yaffs_del_dir_contents(obj); T(YAFFS_TRACE_SCAN, (TSTR("Deleting lost_found object %d" TENDSTR), - obj->objectId)); + obj->obj_id)); /* Need to use UnlinkObject since Delete would not handle * hardlinked objects correctly. @@ -4337,37 +4337,37 @@ static void yaffs_del_dir_contents(yaffs_Object *dir) } -static void yaffs_empty_l_n_f(yaffs_Device *dev) +static void yaffs_empty_l_n_f(yaffs_dev_t *dev) { - yaffs_del_dir_contents(dev->lostNFoundDir); + yaffs_del_dir_contents(dev->lost_n_found); } -static void yaffs_check_obj_details_loaded(yaffs_Object *in) +static void yaffs_check_obj_details_loaded(yaffs_obj_t *in) { __u8 *chunkData; - yaffs_ObjectHeader *oh; - yaffs_Device *dev; - yaffs_ExtendedTags tags; + yaffs_obj_header *oh; + yaffs_dev_t *dev; + yaffs_ext_tags tags; int result; int alloc_failed = 0; if (!in) return; - dev = in->myDev; + dev = in->my_dev; #if 0 T(YAFFS_TRACE_SCAN, (TSTR("details for object %d %s loaded" TENDSTR), - in->objectId, - in->lazyLoaded ? "not yet" : "already")); + in->obj_id, + in->lazy_loaded ? "not yet" : "already")); #endif - if (in->lazyLoaded && in->hdrChunk > 0) { - in->lazyLoaded = 0; + if (in->lazy_loaded && in->hdr_chunk > 0) { + in->lazy_loaded = 0; chunkData = yaffs_get_temp_buffer(dev, __LINE__); - result = yaffs_rd_chunk_tags_nand(dev, in->hdrChunk, chunkData, &tags); - oh = (yaffs_ObjectHeader *) chunkData; + result = yaffs_rd_chunk_tags_nand(dev, in->hdr_chunk, chunkData, &tags); + oh = (yaffs_obj_header *) chunkData; in->yst_mode = oh->yst_mode; #ifdef CONFIG_YAFFS_WINCE @@ -4388,10 +4388,10 @@ static void yaffs_check_obj_details_loaded(yaffs_Object *in) #endif yaffs_set_obj_name_from_oh(in, oh); - if (in->variantType == YAFFS_OBJECT_TYPE_SYMLINK) { - in->variant.symLinkVariant.alias = + if (in->variant_type == YAFFS_OBJECT_TYPE_SYMLINK) { + in->variant.symlink_variant.alias = yaffs_clone_str(oh->alias); - if (!in->variant.symLinkVariant.alias) + if (!in->variant.symlink_variant.alias) alloc_failed = 1; /* Not returned to caller */ } @@ -4417,22 +4417,22 @@ static void yaffs_check_obj_details_loaded(yaffs_Object *in) * called periodically. */ -static void yaffs_update_parent(yaffs_Object *obj) +static void yaffs_update_parent(yaffs_obj_t *obj) { - yaffs_Device *dev; + yaffs_dev_t *dev; if(!obj) return; #ifndef CONFIG_YAFFS_WINCE - dev = obj->myDev; + dev = obj->my_dev; obj->dirty = 1; obj->yst_mtime = obj->yst_ctime = Y_CURRENT_TIME; - if(dev->param.deferDirectoryUpdate){ - struct ylist_head *link = &obj->variant.directoryVariant.dirty; + if(dev->param.defered_dir_update){ + struct ylist_head *link = &obj->variant.dir_variant.dirty; if(ylist_empty(link)){ - ylist_add(link,&dev->dirtyDirectories); - T(YAFFS_TRACE_BACKGROUND, (TSTR("Added object %d to dirty directories" TENDSTR),obj->objectId)); + ylist_add(link,&dev->dirty_dirs); + T(YAFFS_TRACE_BACKGROUND, (TSTR("Added object %d to dirty directories" TENDSTR),obj->obj_id)); } } else @@ -4440,42 +4440,42 @@ static void yaffs_update_parent(yaffs_Object *obj) #endif } -void yaffs_update_dirty_dirs(yaffs_Device *dev) +void yaffs_update_dirty_dirs(yaffs_dev_t *dev) { struct ylist_head *link; - yaffs_Object *obj; - yaffs_DirectoryStructure *dS; - yaffs_ObjectVariant *oV; + yaffs_obj_t *obj; + yaffs_dir_s *dS; + yaffs_obj_variant *oV; T(YAFFS_TRACE_BACKGROUND, (TSTR("Update dirty directories" TENDSTR))); - while(!ylist_empty(&dev->dirtyDirectories)){ - link = dev->dirtyDirectories.next; + while(!ylist_empty(&dev->dirty_dirs)){ + link = dev->dirty_dirs.next; ylist_del_init(link); - dS=ylist_entry(link,yaffs_DirectoryStructure,dirty); - oV = ylist_entry(dS,yaffs_ObjectVariant,directoryVariant); - obj = ylist_entry(oV,yaffs_Object,variant); + dS=ylist_entry(link,yaffs_dir_s,dirty); + oV = ylist_entry(dS,yaffs_obj_variant,dir_variant); + obj = ylist_entry(oV,yaffs_obj_t,variant); - T(YAFFS_TRACE_BACKGROUND, (TSTR("Update directory %d" TENDSTR), obj->objectId)); + T(YAFFS_TRACE_BACKGROUND, (TSTR("Update directory %d" TENDSTR), obj->obj_id)); if(obj->dirty) yaffs_update_oh(obj, NULL, 0, 0, 0, NULL); } } -static void yaffs_remove_obj_from_dir(yaffs_Object *obj) +static void yaffs_remove_obj_from_dir(yaffs_obj_t *obj) { - yaffs_Device *dev = obj->myDev; - yaffs_Object *parent; + yaffs_dev_t *dev = obj->my_dev; + yaffs_obj_t *parent; yaffs_verify_obj_in_dir(obj); parent = obj->parent; yaffs_verify_dir(parent); - if (dev && dev->param.removeObjectCallback) - dev->param.removeObjectCallback(obj); + if (dev && dev->param.remove_obj_fn) + dev->param.remove_obj_fn(obj); ylist_del_init(&obj->siblings); @@ -4484,8 +4484,8 @@ static void yaffs_remove_obj_from_dir(yaffs_Object *obj) yaffs_verify_dir(parent); } -void yaffs_add_obj_to_dir(yaffs_Object *directory, - yaffs_Object *obj) +void yaffs_add_obj_to_dir(yaffs_obj_t *directory, + yaffs_obj_t *obj) { if (!directory) { T(YAFFS_TRACE_ALWAYS, @@ -4495,7 +4495,7 @@ void yaffs_add_obj_to_dir(yaffs_Object *directory, YBUG(); return; } - if (directory->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) { + if (directory->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) { T(YAFFS_TRACE_ALWAYS, (TSTR ("tragedy: Trying to add an object to a non-directory" @@ -4515,21 +4515,21 @@ void yaffs_add_obj_to_dir(yaffs_Object *directory, /* Now add it */ - ylist_add(&obj->siblings, &directory->variant.directoryVariant.children); + ylist_add(&obj->siblings, &directory->variant.dir_variant.children); obj->parent = directory; - if (directory == obj->myDev->unlinkedDir - || directory == obj->myDev->deletedDir) { + if (directory == obj->my_dev->unlinked_dir + || directory == obj->my_dev->del_dir) { obj->unlinked = 1; - obj->myDev->nUnlinkedFiles++; - obj->renameAllowed = 0; + obj->my_dev->n_unlinked_files++; + obj->rename_allowed = 0; } yaffs_verify_dir(directory); yaffs_verify_obj_in_dir(obj); } -yaffs_Object *yaffs_find_by_name(yaffs_Object *directory, +yaffs_obj_t *yaffs_find_by_name(yaffs_obj_t *directory, const YCHAR *name) { int sum; @@ -4537,7 +4537,7 @@ yaffs_Object *yaffs_find_by_name(yaffs_Object *directory, struct ylist_head *i; YCHAR buffer[YAFFS_MAX_NAME_LENGTH + 1]; - yaffs_Object *l; + yaffs_obj_t *l; if (!name) return NULL; @@ -4550,7 +4550,7 @@ yaffs_Object *yaffs_find_by_name(yaffs_Object *directory, YBUG(); return NULL; } - if (directory->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) { + if (directory->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) { T(YAFFS_TRACE_ALWAYS, (TSTR ("tragedy: yaffs_find_by_name: non-directory" TENDSTR))); @@ -4559,9 +4559,9 @@ yaffs_Object *yaffs_find_by_name(yaffs_Object *directory, sum = yaffs_calc_name_sum(name); - ylist_for_each(i, &directory->variant.directoryVariant.children) { + ylist_for_each(i, &directory->variant.dir_variant.children) { if (i) { - l = ylist_entry(i, yaffs_Object, siblings); + l = ylist_entry(i, yaffs_obj_t, siblings); if (l->parent != directory) YBUG(); @@ -4569,10 +4569,10 @@ yaffs_Object *yaffs_find_by_name(yaffs_Object *directory, yaffs_check_obj_details_loaded(l); /* Special case for lost-n-found */ - if (l->objectId == YAFFS_OBJECTID_LOSTNFOUND) { + if (l->obj_id == YAFFS_OBJECTID_LOSTNFOUND) { if (yaffs_strcmp(name, YAFFS_LOSTNFOUND_NAME) == 0) return l; - } else if (yaffs_sum_cmp(l->sum, sum) || l->hdrChunk <= 0) { + } else if (yaffs_sum_cmp(l->sum, sum) || l->hdr_chunk <= 0) { /* LostnFound chunk called Objxxx * Do a real check */ @@ -4589,13 +4589,13 @@ yaffs_Object *yaffs_find_by_name(yaffs_Object *directory, #if 0 -int yaffs_ApplyToDirectoryChildren(yaffs_Object *theDir, - int (*fn) (yaffs_Object *)) +int yaffs_ApplyToDirectoryChildren(yaffs_obj_t *the_dir, + int (*fn) (yaffs_obj_t *)) { struct ylist_head *i; - yaffs_Object *l; + yaffs_obj_t *l; - if (!theDir) { + if (!the_dir) { T(YAFFS_TRACE_ALWAYS, (TSTR ("tragedy: yaffs_find_by_name: null pointer directory" @@ -4603,7 +4603,7 @@ int yaffs_ApplyToDirectoryChildren(yaffs_Object *theDir, YBUG(); return YAFFS_FAIL; } - if (theDir->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) { + if (the_dir->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) { T(YAFFS_TRACE_ALWAYS, (TSTR ("tragedy: yaffs_find_by_name: non-directory" TENDSTR))); @@ -4611,9 +4611,9 @@ int yaffs_ApplyToDirectoryChildren(yaffs_Object *theDir, return YAFFS_FAIL; } - ylist_for_each(i, &theDir->variant.directoryVariant.children) { + ylist_for_each(i, &the_dir->variant.dir_variant.children) { if (i) { - l = ylist_entry(i, yaffs_Object, siblings); + l = ylist_entry(i, yaffs_obj_t, siblings); if (l && !fn(l)) return YAFFS_FAIL; } @@ -4628,11 +4628,11 @@ int yaffs_ApplyToDirectoryChildren(yaffs_Object *theDir, * actual object. */ -yaffs_Object *yaffs_get_equivalent_obj(yaffs_Object *obj) +yaffs_obj_t *yaffs_get_equivalent_obj(yaffs_obj_t *obj) { - if (obj && obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK) { + if (obj && obj->variant_type == YAFFS_OBJECT_TYPE_HARDLINK) { /* We want the object id of the equivalent object, not this one */ - obj = obj->variant.hardLinkVariant.equivalentObject; + obj = obj->variant.hardlink_variant.equiv_obj; yaffs_check_obj_details_loaded(obj); } return obj; @@ -4657,14 +4657,14 @@ yaffs_Object *yaffs_get_equivalent_obj(yaffs_Object *obj) * starting at oh->name[1]. */ -static void yaffs_fix_null_name(yaffs_Object * obj,YCHAR * name, int buffSize) +static void yaffs_fix_null_name(yaffs_obj_t * 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){ YCHAR locName[20]; YCHAR numString[20]; YCHAR *x = &numString[19]; - unsigned v = obj->objectId; + unsigned v = obj->obj_id; numString[19] = 0; while(v>0){ x--; @@ -4674,14 +4674,14 @@ static void yaffs_fix_null_name(yaffs_Object * obj,YCHAR * name, int buffSize) /* make up a name */ yaffs_strcpy(locName, YAFFS_LOSTNFOUND_PREFIX); yaffs_strcat(locName,x); - yaffs_strncpy(name, locName, buffSize - 1); + yaffs_strncpy(name, locName, buffer_size - 1); } } -static void yaffs_load_name_from_oh(yaffs_Device *dev,YCHAR *name, const YCHAR *ohName, int bufferSize) +static void yaffs_load_name_from_oh(yaffs_dev_t *dev,YCHAR *name, const YCHAR *ohName, int bufferSize) { #ifdef CONFIG_YAFFS_AUTO_UNICODE - if(dev->param.autoUnicode){ + if(dev->param.auto_unicode){ if(*ohName){ /* It is an ASCII name, so do an ASCII to unicode conversion */ const char *asciiOhName = (const char *)ohName; @@ -4700,14 +4700,14 @@ static void yaffs_load_name_from_oh(yaffs_Device *dev,YCHAR *name, const YCHAR * } -static void yaffs_load_oh_from_name(yaffs_Device *dev, YCHAR *ohName, const YCHAR *name) +static void yaffs_load_oh_from_name(yaffs_dev_t *dev, YCHAR *ohName, const YCHAR *name) { #ifdef CONFIG_YAFFS_AUTO_UNICODE int isAscii; YCHAR *w; - if(dev->param.autoUnicode){ + if(dev->param.auto_unicode){ isAscii = 1; w = name; @@ -4741,62 +4741,62 @@ static void yaffs_load_oh_from_name(yaffs_Device *dev, YCHAR *ohName, const YCHA } -int yaffs_get_obj_name(yaffs_Object * obj, YCHAR * name, int buffSize) +int yaffs_get_obj_name(yaffs_obj_t * obj, YCHAR * name, int buffer_size) { - memset(name, 0, buffSize * sizeof(YCHAR)); + memset(name, 0, buffer_size * sizeof(YCHAR)); yaffs_check_obj_details_loaded(obj); - if (obj->objectId == YAFFS_OBJECTID_LOSTNFOUND) { - yaffs_strncpy(name, YAFFS_LOSTNFOUND_NAME, buffSize - 1); + if (obj->obj_id == YAFFS_OBJECTID_LOSTNFOUND) { + yaffs_strncpy(name, YAFFS_LOSTNFOUND_NAME, buffer_size - 1); } #ifdef CONFIG_YAFFS_SHORT_NAMES_IN_RAM - else if (obj->shortName[0]) { - yaffs_strcpy(name, obj->shortName); + else if (obj->short_name[0]) { + yaffs_strcpy(name, obj->short_name); } #endif - else if(obj->hdrChunk > 0) { + else if(obj->hdr_chunk > 0) { int result; - __u8 *buffer = yaffs_get_temp_buffer(obj->myDev, __LINE__); + __u8 *buffer = yaffs_get_temp_buffer(obj->my_dev, __LINE__); - yaffs_ObjectHeader *oh = (yaffs_ObjectHeader *) buffer; + yaffs_obj_header *oh = (yaffs_obj_header *) buffer; - memset(buffer, 0, obj->myDev->nDataBytesPerChunk); + memset(buffer, 0, obj->my_dev->data_bytes_per_chunk); - if (obj->hdrChunk > 0) { - result = yaffs_rd_chunk_tags_nand(obj->myDev, - obj->hdrChunk, buffer, + if (obj->hdr_chunk > 0) { + result = yaffs_rd_chunk_tags_nand(obj->my_dev, + obj->hdr_chunk, buffer, NULL); } - yaffs_load_name_from_oh(obj->myDev,name,oh->name,buffSize); + yaffs_load_name_from_oh(obj->my_dev,name,oh->name,buffer_size); - yaffs_release_temp_buffer(obj->myDev, buffer, __LINE__); + yaffs_release_temp_buffer(obj->my_dev, buffer, __LINE__); } - yaffs_fix_null_name(obj,name,buffSize); + yaffs_fix_null_name(obj,name,buffer_size); return yaffs_strnlen(name,YAFFS_MAX_NAME_LENGTH); } -int yaffs_get_obj_length(yaffs_Object *obj) +int yaffs_get_obj_length(yaffs_obj_t *obj) { /* Dereference any hard linking */ obj = yaffs_get_equivalent_obj(obj); - if (obj->variantType == YAFFS_OBJECT_TYPE_FILE) - return obj->variant.fileVariant.fileSize; - if (obj->variantType == YAFFS_OBJECT_TYPE_SYMLINK){ - if(!obj->variant.symLinkVariant.alias) + if (obj->variant_type == YAFFS_OBJECT_TYPE_FILE) + return obj->variant.file_variant.file_size; + if (obj->variant_type == YAFFS_OBJECT_TYPE_SYMLINK){ + if(!obj->variant.symlink_variant.alias) return 0; - return yaffs_strnlen(obj->variant.symLinkVariant.alias,YAFFS_MAX_ALIAS_LENGTH); + return yaffs_strnlen(obj->variant.symlink_variant.alias,YAFFS_MAX_ALIAS_LENGTH); } else { /* Only a directory should drop through to here */ - return obj->myDev->nDataBytesPerChunk; + return obj->my_dev->data_bytes_per_chunk; } } -int yaffs_get_obj_link_count(yaffs_Object *obj) +int yaffs_get_obj_link_count(yaffs_obj_t *obj) { int count = 0; struct ylist_head *i; @@ -4804,24 +4804,24 @@ int yaffs_get_obj_link_count(yaffs_Object *obj) if (!obj->unlinked) count++; /* the object itself */ - ylist_for_each(i, &obj->hardLinks) + ylist_for_each(i, &obj->hard_links) count++; /* add the hard links; */ return count; } -int yaffs_get_obj_inode(yaffs_Object *obj) +int yaffs_get_obj_inode(yaffs_obj_t *obj) { obj = yaffs_get_equivalent_obj(obj); - return obj->objectId; + return obj->obj_id; } -unsigned yaffs_get_obj_type(yaffs_Object *obj) +unsigned yaffs_get_obj_type(yaffs_obj_t *obj) { obj = yaffs_get_equivalent_obj(obj); - switch (obj->variantType) { + switch (obj->variant_type) { case YAFFS_OBJECT_TYPE_FILE: return DT_REG; break; @@ -4849,18 +4849,18 @@ unsigned yaffs_get_obj_type(yaffs_Object *obj) } } -YCHAR *yaffs_get_symlink_alias(yaffs_Object *obj) +YCHAR *yaffs_get_symlink_alias(yaffs_obj_t *obj) { obj = yaffs_get_equivalent_obj(obj); - if (obj->variantType == YAFFS_OBJECT_TYPE_SYMLINK) - return yaffs_clone_str(obj->variant.symLinkVariant.alias); + if (obj->variant_type == YAFFS_OBJECT_TYPE_SYMLINK) + return yaffs_clone_str(obj->variant.symlink_variant.alias); else return yaffs_clone_str(_Y("")); } #ifndef CONFIG_YAFFS_WINCE -int yaffs_set_attribs(yaffs_Object *obj, struct iattr *attr) +int yaffs_set_attribs(yaffs_obj_t *obj, struct iattr *attr) { unsigned int valid = attr->ia_valid; @@ -4886,7 +4886,7 @@ int yaffs_set_attribs(yaffs_Object *obj, struct iattr *attr) return YAFFS_OK; } -int yaffs_get_attribs(yaffs_Object *obj, struct iattr *attr) +int yaffs_get_attribs(yaffs_obj_t *obj, struct iattr *attr) { unsigned int valid = 0; @@ -4915,7 +4915,7 @@ int yaffs_get_attribs(yaffs_Object *obj, struct iattr *attr) #endif -static int yaffs_do_xattrib_mod(yaffs_Object *obj, int set, const YCHAR *name, const void *value, int size, int flags) +static int yaffs_do_xattrib_mod(yaffs_obj_t *obj, int set, const YCHAR *name, const void *value, int size, int flags) { yaffs_xattr_mod xmod; @@ -4936,12 +4936,12 @@ static int yaffs_do_xattrib_mod(yaffs_Object *obj, int set, const YCHAR *name, c return -ENOSPC; } -static int yaffs_apply_xattrib_mod(yaffs_Object *obj, char *buffer, yaffs_xattr_mod *xmod) +static int yaffs_apply_xattrib_mod(yaffs_obj_t *obj, char *buffer, yaffs_xattr_mod *xmod) { int retval = 0; - int x_offs = sizeof(yaffs_ObjectHeader); - yaffs_Device *dev = obj->myDev; - int x_size = dev->nDataBytesPerChunk - sizeof(yaffs_ObjectHeader); + 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); char * x_buffer = buffer + x_offs; @@ -4950,34 +4950,34 @@ static int yaffs_apply_xattrib_mod(yaffs_Object *obj, char *buffer, yaffs_xattr_ else retval = nval_del(x_buffer, x_size, xmod->name); - obj->hasXattr = nval_hasvalues(x_buffer, x_size); - obj->xattrKnown = 1; + obj->has_xattr = nval_hasvalues(x_buffer, x_size); + obj->xattr_known = 1; xmod->result = retval; return retval; } -static int yaffs_do_xattrib_fetch(yaffs_Object *obj, const YCHAR *name, void *value, int size) +static int yaffs_do_xattrib_fetch(yaffs_obj_t *obj, const YCHAR *name, void *value, int size) { char *buffer = NULL; int result; - yaffs_ExtendedTags tags; - yaffs_Device *dev = obj->myDev; - int x_offs = sizeof(yaffs_ObjectHeader); - int x_size = dev->nDataBytesPerChunk - sizeof(yaffs_ObjectHeader); + 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); char * x_buffer; int retval = 0; - if(obj->hdrChunk < 1) + if(obj->hdr_chunk < 1) return -ENODATA; /* If we know that the object has no xattribs then don't do all the * reading and parsing. */ - if(obj->xattrKnown && !obj->hasXattr){ + if(obj->xattr_known && !obj->has_xattr){ if(name) return -ENODATA; else @@ -4988,16 +4988,16 @@ static int yaffs_do_xattrib_fetch(yaffs_Object *obj, const YCHAR *name, void *va if(!buffer) return -ENOMEM; - result = yaffs_rd_chunk_tags_nand(dev,obj->hdrChunk, (__u8 *)buffer, &tags); + result = yaffs_rd_chunk_tags_nand(dev,obj->hdr_chunk, (__u8 *)buffer, &tags); if(result != YAFFS_OK) retval = -ENOENT; else{ x_buffer = buffer + x_offs; - if (!obj->xattrKnown){ - obj->hasXattr = nval_hasvalues(x_buffer, x_size); - obj->xattrKnown = 1; + if (!obj->xattr_known){ + obj->has_xattr = nval_hasvalues(x_buffer, x_size); + obj->xattr_known = 1; } if(name) @@ -5009,22 +5009,22 @@ static int yaffs_do_xattrib_fetch(yaffs_Object *obj, const YCHAR *name, void *va return retval; } -int yaffs_set_xattrib(yaffs_Object *obj, const YCHAR *name, const void * value, int size, int flags) +int yaffs_set_xattrib(yaffs_obj_t *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_Object *obj, const YCHAR *name) +int yaffs_remove_xattrib(yaffs_obj_t *obj, const YCHAR *name) { return yaffs_do_xattrib_mod(obj, 0, name, NULL, 0, 0); } -int yaffs_get_xattrib(yaffs_Object *obj, const YCHAR *name, void *value, int size) +int yaffs_get_xattrib(yaffs_obj_t *obj, const YCHAR *name, void *value, int size) { return yaffs_do_xattrib_fetch(obj, name, value, size); } -int yaffs_list_xattrib(yaffs_Object *obj, char *buffer, int size) +int yaffs_list_xattrib(yaffs_obj_t *obj, char *buffer, int size) { return yaffs_do_xattrib_fetch(obj, NULL, buffer,size); } @@ -5032,7 +5032,7 @@ int yaffs_list_xattrib(yaffs_Object *obj, char *buffer, int size) #if 0 -int yaffs_dump_obj(yaffs_Object *obj) +int yaffs_dump_obj(yaffs_obj_t *obj) { YCHAR name[257]; @@ -5042,8 +5042,8 @@ int yaffs_dump_obj(yaffs_Object *obj) (TSTR ("Object %d, inode %d \"%s\"\n dirty %d valid %d serial %d sum %d" " chunk %d type %d size %d\n" - TENDSTR), obj->objectId, yaffs_get_obj_inode(obj), name, - obj->dirty, obj->valid, obj->serial, obj->sum, obj->hdrChunk, + TENDSTR), obj->obj_id, yaffs_get_obj_inode(obj), name, + obj->dirty, obj->valid, obj->serial, obj->sum, obj->hdr_chunk, yaffs_get_obj_type(obj), yaffs_get_obj_length(obj))); return YAFFS_OK; @@ -5052,68 +5052,68 @@ int yaffs_dump_obj(yaffs_Object *obj) /*---------------------------- Initialisation code -------------------------------------- */ -static int yaffs_cehck_dev_fns(const yaffs_Device *dev) +static int yaffs_cehck_dev_fns(const yaffs_dev_t *dev) { /* Common functions, gotta have */ - if (!dev->param.eraseBlockInNAND || !dev->param.initialiseNAND) + if (!dev->param.erase_fn || !dev->param.initialise_flash_fn) return 0; #ifdef CONFIG_YAFFS_YAFFS2 /* Can use the "with tags" style interface for yaffs1 or yaffs2 */ - if (dev->param.writeChunkWithTagsToNAND && - dev->param.readChunkWithTagsFromNAND && - !dev->param.writeChunkToNAND && - !dev->param.readChunkFromNAND && - dev->param.markNANDBlockBad && - dev->param.queryNANDBlock) + if (dev->param.write_chunk_tags_fn && + dev->param.read_chunk_tags_fn && + !dev->param.write_chunk_fn && + !dev->param.read_chunk_fn && + dev->param.bad_block_fn && + dev->param.query_block_fn) return 1; #endif /* Can use the "spare" style interface for yaffs1 */ - if (!dev->param.isYaffs2 && - !dev->param.writeChunkWithTagsToNAND && - !dev->param.readChunkWithTagsFromNAND && - dev->param.writeChunkToNAND && - dev->param.readChunkFromNAND && - !dev->param.markNANDBlockBad && - !dev->param.queryNANDBlock) + if (!dev->param.is_yaffs2 && + !dev->param.write_chunk_tags_fn && + !dev->param.read_chunk_tags_fn && + dev->param.write_chunk_fn && + dev->param.read_chunk_fn && + !dev->param.bad_block_fn && + !dev->param.query_block_fn) return 1; return 0; /* bad */ } -static int yaffs_create_initial_dir(yaffs_Device *dev) +static int yaffs_create_initial_dir(yaffs_dev_t *dev) { /* Initialise the unlinked, deleted, root and lost and found directories */ - dev->lostNFoundDir = dev->rootDir = NULL; - dev->unlinkedDir = dev->deletedDir = NULL; + dev->lost_n_found = dev->root_dir = NULL; + dev->unlinked_dir = dev->del_dir = NULL; - dev->unlinkedDir = + dev->unlinked_dir = yaffs_create_fake_dir(dev, YAFFS_OBJECTID_UNLINKED, S_IFDIR); - dev->deletedDir = + dev->del_dir = yaffs_create_fake_dir(dev, YAFFS_OBJECTID_DELETED, S_IFDIR); - dev->rootDir = + dev->root_dir = yaffs_create_fake_dir(dev, YAFFS_OBJECTID_ROOT, YAFFS_ROOT_MODE | S_IFDIR); - dev->lostNFoundDir = + dev->lost_n_found = yaffs_create_fake_dir(dev, YAFFS_OBJECTID_LOSTNFOUND, YAFFS_LOSTNFOUND_MODE | S_IFDIR); - if (dev->lostNFoundDir && dev->rootDir && dev->unlinkedDir && dev->deletedDir) { - yaffs_add_obj_to_dir(dev->rootDir, dev->lostNFoundDir); + if (dev->lost_n_found && dev->root_dir && dev->unlinked_dir && dev->del_dir) { + yaffs_add_obj_to_dir(dev->root_dir, dev->lost_n_found); return YAFFS_OK; } return YAFFS_FAIL; } -int yaffs_guts_initialise(yaffs_Device *dev) +int yaffs_guts_initialise(yaffs_dev_t *dev) { int init_failed = 0; unsigned x; @@ -5128,35 +5128,35 @@ int yaffs_guts_initialise(yaffs_Device *dev) return YAFFS_FAIL; } - dev->internalStartBlock = dev->param.startBlock; - dev->internalEndBlock = dev->param.endBlock; - dev->blockOffset = 0; - dev->chunkOffset = 0; - dev->nFreeChunks = 0; + dev->internal_start_block = dev->param.start_block; + dev->internal_end_block = dev->param.end_block; + dev->block_offset = 0; + dev->chunk_offset = 0; + dev->n_free_chunks = 0; - dev->gcBlock = 0; + dev->gc_block = 0; - if (dev->param.startBlock == 0) { - dev->internalStartBlock = dev->param.startBlock + 1; - dev->internalEndBlock = dev->param.endBlock + 1; - dev->blockOffset = 1; - dev->chunkOffset = dev->param.nChunksPerBlock; + if (dev->param.start_block == 0) { + dev->internal_start_block = dev->param.start_block + 1; + dev->internal_end_block = dev->param.end_block + 1; + dev->block_offset = 1; + dev->chunk_offset = dev->param.chunks_per_block; } /* Check geometry parameters. */ - if ((!dev->param.inbandTags && dev->param.isYaffs2 && dev->param.totalBytesPerChunk < 1024) || - (!dev->param.isYaffs2 && dev->param.totalBytesPerChunk < 512) || - (dev->param.inbandTags && !dev->param.isYaffs2) || - dev->param.nChunksPerBlock < 2 || - dev->param.nReservedBlocks < 2 || - dev->internalStartBlock <= 0 || - dev->internalEndBlock <= 0 || - dev->internalEndBlock <= (dev->internalStartBlock + dev->param.nReservedBlocks + 2)) { /* otherwise it is too small */ + if ((!dev->param.inband_tags && dev->param.is_yaffs2 && dev->param.total_bytes_per_chunk < 1024) || + (!dev->param.is_yaffs2 && dev->param.total_bytes_per_chunk < 512) || + (dev->param.inband_tags && !dev->param.is_yaffs2) || + dev->param.chunks_per_block < 2 || + dev->param.n_reserved_blocks < 2 || + dev->internal_start_block <= 0 || + dev->internal_end_block <= 0 || + dev->internal_end_block <= (dev->internal_start_block + dev->param.n_reserved_blocks + 2)) { /* otherwise it is too small */ T(YAFFS_TRACE_ALWAYS, (TSTR - ("yaffs: NAND geometry problems: chunk size %d, type is yaffs%s, inbandTags %d " - TENDSTR), dev->param.totalBytesPerChunk, dev->param.isYaffs2 ? "2" : "", dev->param.inbandTags)); + ("yaffs: NAND geometry problems: chunk size %d, type is yaffs%s, inband_tags %d " + TENDSTR), dev->param.total_bytes_per_chunk, dev->param.is_yaffs2 ? "2" : "", dev->param.inband_tags)); return YAFFS_FAIL; } @@ -5167,10 +5167,10 @@ int yaffs_guts_initialise(yaffs_Device *dev) } /* Sort out space for inband tags, if required */ - if (dev->param.inbandTags) - dev->nDataBytesPerChunk = dev->param.totalBytesPerChunk - sizeof(yaffs_PackedTags2TagsPart); + if (dev->param.inband_tags) + dev->data_bytes_per_chunk = dev->param.total_bytes_per_chunk - sizeof(yaffs_PackedTags2TagsPart); else - dev->nDataBytesPerChunk = dev->param.totalBytesPerChunk; + dev->data_bytes_per_chunk = dev->param.total_bytes_per_chunk; /* Got the right mix of functions? */ if (!yaffs_cehck_dev_fns(dev)) { @@ -5189,7 +5189,7 @@ int yaffs_guts_initialise(yaffs_Device *dev) return YAFFS_FAIL; } - if (dev->isMounted) { + if (dev->is_mounted) { T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: device already mounted\n" TENDSTR))); return YAFFS_FAIL; @@ -5197,62 +5197,62 @@ int yaffs_guts_initialise(yaffs_Device *dev) /* Finished with most checks. One or two more checks happen later on too. */ - dev->isMounted = 1; + dev->is_mounted = 1; /* OK now calculate a few things for the device */ /* * Calculate all the chunk size manipulation numbers: */ - x = dev->nDataBytesPerChunk; - /* We always use dev->chunkShift and dev->chunkDiv */ - dev->chunkShift = Shifts(x); - x >>= dev->chunkShift; - dev->chunkDiv = x; - /* We only use chunk mask if chunkDiv is 1 */ - dev->chunkMask = (1<<dev->chunkShift) - 1; + x = dev->data_bytes_per_chunk; + /* We always use dev->chunk_shift and dev->chunk_div */ + dev->chunk_shift = Shifts(x); + x >>= dev->chunk_shift; + dev->chunk_div = x; + /* We only use chunk mask if chunk_div is 1 */ + dev->chunk_mask = (1<<dev->chunk_shift) - 1; /* - * Calculate chunkGroupBits. - * We need to find the next power of 2 > than internalEndBlock + * Calculate chunk_grp_bits. + * We need to find the next power of 2 > than internal_end_block */ - x = dev->param.nChunksPerBlock * (dev->internalEndBlock + 1); + x = dev->param.chunks_per_block * (dev->internal_end_block + 1); bits = ShiftsGE(x); /* Set up tnode width if wide tnodes are enabled. */ - if (!dev->param.wideTnodesDisabled) { + if (!dev->param.wide_tnodes_disabled) { /* bits must be even so that we end up with 32-bit words */ if (bits & 1) bits++; if (bits < 16) - dev->tnodeWidth = 16; + dev->tnode_width = 16; else - dev->tnodeWidth = bits; + dev->tnode_width = bits; } else - dev->tnodeWidth = 16; + dev->tnode_width = 16; - dev->tnodeMask = (1<<dev->tnodeWidth)-1; + dev->tnode_mask = (1<<dev->tnode_width)-1; /* Level0 Tnodes are 16 bits or wider (if wide tnodes are enabled), * so if the bitwidth of the * chunk range we're using is greater than 16 we need - * to figure out chunk shift and chunkGroupSize + * to figure out chunk shift and chunk_grp_size */ - if (bits <= dev->tnodeWidth) - dev->chunkGroupBits = 0; + if (bits <= dev->tnode_width) + dev->chunk_grp_bits = 0; else - dev->chunkGroupBits = bits - dev->tnodeWidth; + dev->chunk_grp_bits = bits - dev->tnode_width; - dev->tnodeSize = (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8; - if(dev->tnodeSize < sizeof(yaffs_tnode_t)) - dev->tnodeSize = sizeof(yaffs_tnode_t); + 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); - dev->chunkGroupSize = 1 << dev->chunkGroupBits; + dev->chunk_grp_size = 1 << dev->chunk_grp_bits; - if (dev->param.nChunksPerBlock < dev->chunkGroupSize) { + if (dev->param.chunks_per_block < dev->chunk_grp_size) { /* We have a problem because the soft delete won't work if * the chunk group size > chunks per block. * This can be remedied by using larger "virtual blocks". @@ -5266,74 +5266,74 @@ int yaffs_guts_initialise(yaffs_Device *dev) /* OK, we've finished verifying the device, lets continue with initialisation */ /* More device initialisation */ - dev->allGCs = 0; - dev->passiveGCs = 0; - dev->oldestDirtyGCs = 0; - dev->backgroundGCs = 0; - dev->gcBlockFinder = 0; - dev->bufferedBlock = -1; - dev->doingBufferedBlockRewrite = 0; - dev->nDeletedFiles = 0; - dev->nBackgroundDeletions = 0; - dev->nUnlinkedFiles = 0; - dev->eccFixed = 0; - dev->eccUnfixed = 0; - dev->tagsEccFixed = 0; - dev->tagsEccUnfixed = 0; - dev->nErasureFailures = 0; - dev->nErasedBlocks = 0; - dev->gcDisable= 0; - dev->hasPendingPrioritisedGCs = 1; /* Assume the worst for now, will get fixed on first GC */ - YINIT_LIST_HEAD(&dev->dirtyDirectories); - dev->oldestDirtySequence = 0; - dev->oldestDirtyBlock = 0; + dev->all_gcs = 0; + dev->passive_gc_count = 0; + dev->oldest_dirty_gc_count = 0; + dev->bg_gcs = 0; + dev->gc_block_finder = 0; + dev->buffered_block = -1; + dev->doing_buffered_block_rewrite = 0; + dev->n_deleted_files = 0; + dev->n_bg_deletions = 0; + dev->n_unlinked_files = 0; + dev->n_ecc_fixed = 0; + dev->n_ecc_unfixed = 0; + dev->n_tags_ecc_fixed = 0; + dev->n_tags_ecc_unfixed = 0; + dev->n_erase_failures = 0; + dev->n_erased_blocks = 0; + dev->gc_disable= 0; + dev->has_pending_prioritised_gc = 1; /* Assume the worst for now, will get fixed on first GC */ + YINIT_LIST_HEAD(&dev->dirty_dirs); + dev->oldest_dirty_seq = 0; + dev->oldest_dirty_block = 0; /* Initialise temporary buffers and caches. */ if (!yaffs_init_tmp_buffers(dev)) init_failed = 1; - dev->srCache = NULL; - dev->gcCleanupList = NULL; + dev->cache = NULL; + dev->gc_cleanup_list = NULL; if (!init_failed && - dev->param.nShortOpCaches > 0) { + dev->param.n_caches > 0) { int i; void *buf; - int srCacheBytes = dev->param.nShortOpCaches * sizeof(yaffs_ChunkCache); + int cacheBytes = dev->param.n_caches * sizeof(yaffs_cache_t); - if (dev->param.nShortOpCaches > YAFFS_MAX_SHORT_OP_CACHES) - dev->param.nShortOpCaches = YAFFS_MAX_SHORT_OP_CACHES; + if (dev->param.n_caches > YAFFS_MAX_SHORT_OP_CACHES) + dev->param.n_caches = YAFFS_MAX_SHORT_OP_CACHES; - dev->srCache = YMALLOC(srCacheBytes); + dev->cache = YMALLOC(cacheBytes); - buf = (__u8 *) dev->srCache; + buf = (__u8 *) dev->cache; - if (dev->srCache) - memset(dev->srCache, 0, srCacheBytes); + if (dev->cache) + memset(dev->cache, 0, cacheBytes); - for (i = 0; i < dev->param.nShortOpCaches && buf; i++) { - dev->srCache[i].object = NULL; - dev->srCache[i].lastUse = 0; - dev->srCache[i].dirty = 0; - dev->srCache[i].data = buf = YMALLOC_DMA(dev->param.totalBytesPerChunk); + for (i = 0; i < dev->param.n_caches && buf; i++) { + dev->cache[i].object = NULL; + dev->cache[i].last_use = 0; + dev->cache[i].dirty = 0; + dev->cache[i].data = buf = YMALLOC_DMA(dev->param.total_bytes_per_chunk); } if (!buf) init_failed = 1; - dev->srLastUse = 0; + dev->cache_last_use = 0; } - dev->cacheHits = 0; + dev->cache_hits = 0; if (!init_failed) { - dev->gcCleanupList = YMALLOC(dev->param.nChunksPerBlock * sizeof(__u32)); - if (!dev->gcCleanupList) + dev->gc_cleanup_list = YMALLOC(dev->param.chunks_per_block * sizeof(__u32)); + if (!dev->gc_cleanup_list) init_failed = 1; } - if (dev->param.isYaffs2) - dev->param.useHeaderFileSize = 1; + if (dev->param.is_yaffs2) + dev->param.use_header_file_size = 1; if (!init_failed && !yaffs_init_blocks(dev)) init_failed = 1; @@ -5346,9 +5346,9 @@ int yaffs_guts_initialise(yaffs_Device *dev) if (!init_failed) { /* Now scan the flash. */ - if (dev->param.isYaffs2) { + if (dev->param.is_yaffs2) { if (yaffs2_checkpt_restore(dev)) { - yaffs_check_obj_details_loaded(dev->rootDir); + yaffs_check_obj_details_loaded(dev->root_dir); T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: restored from checkpoint" TENDSTR))); } else { @@ -5360,13 +5360,13 @@ int yaffs_guts_initialise(yaffs_Device *dev) yaffs_deinit_tnodes_and_objs(dev); - dev->nErasedBlocks = 0; - dev->nFreeChunks = 0; - dev->allocationBlock = -1; - dev->allocationPage = -1; - dev->nDeletedFiles = 0; - dev->nUnlinkedFiles = 0; - dev->nBackgroundDeletions = 0; + dev->n_erased_blocks = 0; + dev->n_free_chunks = 0; + dev->alloc_block = -1; + dev->alloc_page = -1; + dev->n_deleted_files = 0; + dev->n_unlinked_files = 0; + dev->n_bg_deletions = 0; if (!init_failed && !yaffs_init_blocks(dev)) init_failed = 1; @@ -5384,7 +5384,7 @@ int yaffs_guts_initialise(yaffs_Device *dev) yaffs_strip_deleted_objs(dev); yaffs_fix_hanging_objs(dev); - if(dev->param.emptyLostAndFound) + if(dev->param.empty_lost_n_found) yaffs_empty_l_n_f(dev); } @@ -5398,19 +5398,19 @@ int yaffs_guts_initialise(yaffs_Device *dev) } /* Zero out stats */ - dev->nPageReads = 0; - dev->nPageWrites = 0; - dev->nBlockErasures = 0; - dev->nGCCopies = 0; - dev->nRetriedWrites = 0; + dev->n_page_reads = 0; + dev->n_page_writes = 0; + dev->n_erasures = 0; + dev->n_gc_copies = 0; + dev->n_retired_writes = 0; - dev->nRetiredBlocks = 0; + dev->n_retired_blocks = 0; yaffs_verify_free_chunks(dev); yaffs_verify_blocks(dev); /* Clean up any aborted checkpoint data */ - if(!dev->isCheckpointed && dev->blocksInCheckpoint > 0) + if(!dev->is_checkpointed && dev->blocks_in_checkpt > 0) yaffs2_checkpt_invalidate(dev); T(YAFFS_TRACE_TRACING, @@ -5419,55 +5419,55 @@ int yaffs_guts_initialise(yaffs_Device *dev) } -void yaffs_deinitialise(yaffs_Device *dev) +void yaffs_deinitialise(yaffs_dev_t *dev) { - if (dev->isMounted) { + if (dev->is_mounted) { int i; yaffs_deinit_blocks(dev); yaffs_deinit_tnodes_and_objs(dev); - if (dev->param.nShortOpCaches > 0 && - dev->srCache) { + if (dev->param.n_caches > 0 && + dev->cache) { - for (i = 0; i < dev->param.nShortOpCaches; i++) { - if (dev->srCache[i].data) - YFREE(dev->srCache[i].data); - dev->srCache[i].data = NULL; + for (i = 0; i < dev->param.n_caches; i++) { + if (dev->cache[i].data) + YFREE(dev->cache[i].data); + dev->cache[i].data = NULL; } - YFREE(dev->srCache); - dev->srCache = NULL; + YFREE(dev->cache); + dev->cache = NULL; } - YFREE(dev->gcCleanupList); + YFREE(dev->gc_cleanup_list); for (i = 0; i < YAFFS_N_TEMP_BUFFERS; i++) - YFREE(dev->tempBuffer[i].buffer); + YFREE(dev->temp_buffer[i].buffer); - dev->isMounted = 0; + dev->is_mounted = 0; - if (dev->param.deinitialiseNAND) - dev->param.deinitialiseNAND(dev); + if (dev->param.deinitialise_flash_fn) + dev->param.deinitialise_flash_fn(dev); } } -int yaffs_count_free_chunks(yaffs_Device *dev) +int yaffs_count_free_chunks(yaffs_dev_t *dev) { int nFree=0; int b; - yaffs_BlockInfo *blk; + yaffs_block_info_t *blk; - blk = dev->blockInfo; - for (b = dev->internalStartBlock; b <= dev->internalEndBlock; b++) { - switch (blk->blockState) { + blk = dev->block_info; + for (b = dev->internal_start_block; b <= dev->internal_end_block; b++) { + switch (blk->block_state) { case YAFFS_BLOCK_STATE_EMPTY: case YAFFS_BLOCK_STATE_ALLOCATING: case YAFFS_BLOCK_STATE_COLLECTING: case YAFFS_BLOCK_STATE_FULL: nFree += - (dev->param.nChunksPerBlock - blk->pagesInUse + - blk->softDeletions); + (dev->param.chunks_per_block - blk->pages_in_use + + blk->soft_del_pages); break; default: break; @@ -5478,7 +5478,7 @@ int yaffs_count_free_chunks(yaffs_Device *dev) return nFree; } -int yaffs_get_n_free_chunks(yaffs_Device *dev) +int yaffs_get_n_free_chunks(yaffs_dev_t *dev) { /* This is what we report to the outside world */ @@ -5488,28 +5488,28 @@ int yaffs_get_n_free_chunks(yaffs_Device *dev) int i; #if 1 - nFree = dev->nFreeChunks; + nFree = dev->n_free_chunks; #else nFree = yaffs_count_free_chunks(dev); #endif - nFree += dev->nDeletedFiles; + nFree += dev->n_deleted_files; /* Now count the number of dirty chunks in the cache and subtract those */ - for (nDirtyCacheChunks = 0, i = 0; i < dev->param.nShortOpCaches; i++) { - if (dev->srCache[i].dirty) + for (nDirtyCacheChunks = 0, i = 0; i < dev->param.n_caches; i++) { + if (dev->cache[i].dirty) nDirtyCacheChunks++; } nFree -= nDirtyCacheChunks; - nFree -= ((dev->param.nReservedBlocks + 1) * dev->param.nChunksPerBlock); + nFree -= ((dev->param.n_reserved_blocks + 1) * dev->param.chunks_per_block); /* Now we figure out how much to reserve for the checkpoint and report that... */ blocksForCheckpoint = yaffs_calc_checkpt_blocks_required(dev); - nFree -= (blocksForCheckpoint * dev->param.nChunksPerBlock); + nFree -= (blocksForCheckpoint * dev->param.chunks_per_block); if (nFree < 0) nFree = 0; @@ -5532,13 +5532,13 @@ int yaffs_get_n_free_chunks(yaffs_Device *dev) static int yaffs_check_structures(void) { -/* yaffs_check_struct(yaffs_Tags,8,"yaffs_Tags"); */ +/* yaffs_check_struct(yaffs_tags_t,8,"yaffs_tags_t"); */ /* yaffs_check_struct(yaffs_tags_union_t,8,"yaffs_tags_union_t"); */ -/* yaffs_check_struct(yaffs_Spare,16,"yaffs_Spare"); */ +/* 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_ObjectHeader, 512, "yaffs_ObjectHeader"); + yaffs_check_struct(yaffs_obj_header, 512, "yaffs_obj_header"); #endif return YAFFS_OK; } diff --git a/yaffs_guts.h b/yaffs_guts.h index b6cbb8b..88075a7 100644 --- a/yaffs_guts.h +++ b/yaffs_guts.h @@ -113,14 +113,14 @@ /* ChunkCache is used for short read/write operations.*/ typedef struct { - struct yaffs_ObjectStruct *object; - int chunkId; - int lastUse; + struct yaffs_obj_s *object; + int chunk_id; + int last_use; int dirty; - int nBytes; /* Only valid if the cache is dirty */ + int n_bytes; /* Only valid if the cache is dirty */ int locked; /* Can't push out or flush while locked. */ __u8 *data; -} yaffs_ChunkCache; +} yaffs_cache_t; @@ -131,17 +131,17 @@ typedef struct { #ifndef CONFIG_YAFFS_NO_YAFFS1 typedef struct { - unsigned chunkId:20; - unsigned serialNumber:2; - unsigned byteCountLSB:10; - unsigned objectId:18; + unsigned chunk_id:20; + unsigned serial_number:2; + unsigned n_bytes_lsb:10; + unsigned obj_id:18; unsigned ecc:12; - unsigned byteCountMSB:2; -} yaffs_Tags; + unsigned n_bytes_msb:2; +} yaffs_tags_t; typedef union { - yaffs_Tags asTags; - __u8 asBytes[8]; + yaffs_tags_t as_tags; + __u8 as_bytes[8]; } yaffs_tags_union_t; #endif @@ -153,7 +153,7 @@ typedef enum { YAFFS_ECC_RESULT_NO_ERROR, YAFFS_ECC_RESULT_FIXED, YAFFS_ECC_RESULT_UNFIXED -} yaffs_ECCResult; +} yaffs_ecc_result; typedef enum { YAFFS_OBJECT_TYPE_UNKNOWN, @@ -162,44 +162,44 @@ typedef enum { YAFFS_OBJECT_TYPE_DIRECTORY, YAFFS_OBJECT_TYPE_HARDLINK, YAFFS_OBJECT_TYPE_SPECIAL -} yaffs_ObjectType; +} yaffs_obj_type; #define YAFFS_OBJECT_TYPE_MAX YAFFS_OBJECT_TYPE_SPECIAL typedef struct { - unsigned validMarker0; - unsigned chunkUsed; /* Status of the chunk: used or unused */ - unsigned objectId; /* If 0 then this is not part of an object (unused) */ - unsigned chunkId; /* If 0 then this is a header, else a data chunk */ - unsigned byteCount; /* Only valid for data chunks */ + unsigned validity1; + 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_ECCResult eccResult; - unsigned blockBad; + yaffs_ecc_result ecc_result; + unsigned block_bad; /* YAFFS 1 stuff */ - unsigned chunkDeleted; /* The chunk is marked deleted */ - unsigned serialNumber; /* Yaffs1 2-bit serial number */ + unsigned is_deleted; /* The chunk is marked deleted */ + unsigned serial_number; /* Yaffs1 2-bit serial number */ /* YAFFS2 stuff */ - unsigned sequenceNumber; /* The sequence number of this block */ + unsigned seq_number; /* The sequence number of this block */ /* Extra info if this is an object header (YAFFS2 only) */ - unsigned extraHeaderInfoAvailable; /* There is extra info available if this is not zero */ - unsigned extraParentObjectId; /* The parent object */ - unsigned extraIsShrinkHeader; /* Is it a shrink header? */ - unsigned extraShadows; /* Does this shadow another object? */ + unsigned extra_available; /* There is extra info available if this is not zero */ + unsigned extra_parent_id; /* The parent object */ + unsigned extra_is_shrink; /* Is it a shrink header? */ + unsigned extra_shadows; /* Does this shadow another object? */ - yaffs_ObjectType extraObjectType; /* What object type? */ + yaffs_obj_type extra_obj_type; /* What object type? */ - unsigned extraFileLength; /* Length if it is a file */ - unsigned extraEquivalentObjectId; /* Equivalent object Id if it is a hard link */ + unsigned extra_length; /* Length if it is a file */ + unsigned extra_equiv_id; /* Equivalent object Id if it is a hard link */ - unsigned validMarker1; + unsigned validty1; -} yaffs_ExtendedTags; +} yaffs_ext_tags; /* Spare structure for YAFFS1 */ typedef struct { @@ -207,19 +207,19 @@ typedef struct { __u8 tb1; __u8 tb2; __u8 tb3; - __u8 pageStatus; /* set to 0 to delete the chunk */ - __u8 blockStatus; + __u8 page_status; /* set to 0 to delete the chunk */ + __u8 block_status; __u8 tb4; __u8 tb5; __u8 ecc1[3]; __u8 tb6; __u8 tb7; __u8 ecc2[3]; -} yaffs_Spare; +} yaffs_spare; /*Special structure for passing through to mtd */ -struct yaffs_NANDSpare { - yaffs_Spare spare; +struct yaffs_nand_spare { + yaffs_spare spare; int eccres1; int eccres2; }; @@ -270,46 +270,46 @@ typedef enum { YAFFS_BLOCK_STATE_DEAD /* This block has failed and is not in use */ -} yaffs_BlockState; +} yaffs_block_state_t; #define YAFFS_NUMBER_OF_BLOCK_STATES (YAFFS_BLOCK_STATE_DEAD + 1) typedef struct { - int softDeletions:10; /* number of soft deleted pages */ - int pagesInUse:10; /* number of pages in use */ - unsigned blockState:4; /* One of the above block states. NB use unsigned because enum is sometimes an int */ - __u32 needsRetiring:1; /* Data has failed on this block, need to get valid data off */ + int soft_del_pages:10; /* number of soft deleted pages */ + int pages_in_use:10; /* number of pages in use */ + unsigned block_state:4; /* One of the above block states. NB use unsigned because enum is sometimes an int */ + __u32 needs_retiring:1; /* Data has failed on this block, need to get valid data off */ /* and retire the block. */ - __u32 skipErasedCheck:1; /* If this is set we can skip the erased check on this block */ - __u32 gcPrioritise:1; /* An ECC check or blank check has failed on this block. + __u32 skip_erased_check:1; /* If this is set we can skip the erased check on this block */ + __u32 gc_prioritise:1; /* An ECC check or blank check has failed on this block. It should be prioritised for GC */ - __u32 chunkErrorStrikes:3; /* How many times we've had ecc etc failures on this block and tried to reuse it */ + __u32 chunk_error_strikes:3; /* How many times we've had ecc etc failures on this block and tried to reuse it */ #ifdef CONFIG_YAFFS_YAFFS2 - __u32 hasShrinkHeader:1; /* This block has at least one shrink object header */ - __u32 sequenceNumber; /* block sequence number for yaffs2 */ + __u32 has_shrink_hdr:1; /* This block has at least one shrink object header */ + __u32 seq_number; /* block sequence number for yaffs2 */ #endif -} yaffs_BlockInfo; +} yaffs_block_info_t; /* -------------------------- Object structure -------------------------------*/ /* This is the object structure as stored on NAND */ typedef struct { - yaffs_ObjectType type; + yaffs_obj_type type; /* Apply to everything */ - int parentObjectId; - __u16 sum__NoLongerUsed; /* checksum of name. No longer used */ + int parent_obj_id; + __u16 sum_no_longer_used; /* checksum of name. No longer used */ YCHAR name[YAFFS_MAX_NAME_LENGTH + 1]; /* The following apply to directories, files, symlinks - not hard links */ __u32 yst_mode; /* protection */ #ifdef CONFIG_YAFFS_WINCE - __u32 notForWinCE[5]; + __u32 not_for_wince[5]; #else __u32 yst_uid; __u32 yst_gid; @@ -319,10 +319,10 @@ typedef struct { #endif /* File size applies to files only */ - int fileSize; + int file_size; /* Equivalent object id applies to hard links only. */ - int equivalentObjectId; + int equiv_id; /* Alias is for symlinks only. */ YCHAR alias[YAFFS_MAX_ALIAS_LENGTH + 1]; @@ -334,19 +334,19 @@ typedef struct { __u32 win_atime[2]; __u32 win_mtime[2]; #else - __u32 roomToGrow[6]; + __u32 room_to_grow[6]; #endif - __u32 inbandShadowsObject; - __u32 inbandIsShrink; + __u32 inband_shadowed_obj_id; + __u32 inband_is_shrink; - __u32 reservedSpace[2]; - int shadowsObject; /* This object header shadows the specified object if > 0 */ + __u32 reserved[2]; + int shadows_obj; /* This object header shadows the specified object if > 0 */ - /* isShrink applies to object headers written when we shrink the file (ie resize) */ - __u32 isShrink; + /* is_shrink applies to object headers written when we shrink the file (ie resize) */ + __u32 is_shrink; -} yaffs_ObjectHeader; +} yaffs_obj_header; /*--------------------------- Tnode -------------------------- */ @@ -367,85 +367,85 @@ typedef union yaffs_tnode_union yaffs_tnode_t; */ typedef struct { - __u32 fileSize; - __u32 scannedFileSize; - __u32 shrinkSize; - int topLevel; + __u32 file_size; + __u32 scanned_size; + __u32 shrink_size; + int top_level; yaffs_tnode_t *top; -} yaffs_FileStructure; +} yaffs_file_s; typedef struct { struct ylist_head children; /* list of child links */ struct ylist_head dirty; /* Entry for list of dirty directories */ -} yaffs_DirectoryStructure; +} yaffs_dir_s; typedef struct { YCHAR *alias; -} yaffs_SymLinkStructure; +} yaffs_symlink_t; typedef struct { - struct yaffs_ObjectStruct *equivalentObject; - __u32 equivalentObjectId; -} yaffs_HardLinkStructure; + struct yaffs_obj_s *equiv_obj; + __u32 equiv_id; +} yaffs_hard_link_s; typedef union { - yaffs_FileStructure fileVariant; - yaffs_DirectoryStructure directoryVariant; - yaffs_SymLinkStructure symLinkVariant; - yaffs_HardLinkStructure hardLinkVariant; -} yaffs_ObjectVariant; + yaffs_file_s file_variant; + yaffs_dir_s dir_variant; + yaffs_symlink_t symlink_variant; + yaffs_hard_link_s hardlink_variant; +} yaffs_obj_variant; -struct yaffs_ObjectStruct { +struct yaffs_obj_s { __u8 deleted:1; /* This should only apply to unlinked files. */ - __u8 softDeleted:1; /* it has also been soft deleted */ + __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 fake:1; /* A fake object has no presence on NAND. */ - __u8 renameAllowed:1; /* Some objects are not allowed to be renamed. */ - __u8 unlinkAllowed:1; + __u8 rename_allowed:1; /* Some objects are not allowed to be renamed. */ + __u8 unlink_allowed:1; __u8 dirty:1; /* the object needs to be written to flash */ __u8 valid:1; /* When the file system is being loaded up, this * object might be created before the data * is available (ie. file data records appear before the header). */ - __u8 lazyLoaded:1; /* This object has been lazy loaded and is missing some detail */ + __u8 lazy_loaded:1; /* This object has been lazy loaded and is missing some detail */ - __u8 deferedFree:1; /* For Linux kernel. Object is removed from NAND, but is + __u8 defered_free:1; /* For Linux kernel. Object is removed from NAND, but is * still in the inode cache. Free of object is defered. * until the inode is released. */ - __u8 beingCreated:1; /* This object is still being created so skip some checks. */ - __u8 isShadowed:1; /* This object is shadowed on the way to being renamed. */ + __u8 being_created:1; /* This object is still being created so skip some checks. */ + __u8 is_shadowed:1; /* This object is shadowed on the way to being renamed. */ - __u8 xattrKnown:1; /* We know if this has object has xattribs or not. */ - __u8 hasXattr:1; /* This object has xattribs. Valid if xattrKnown. */ + __u8 xattr_known:1; /* We know if this has object has xattribs or not. */ + __u8 has_xattr:1; /* This object has xattribs. Valid if xattr_known. */ __u8 serial; /* serial number of chunk in NAND. Cached here */ __u16 sum; /* sum of the name to speed searching */ - struct yaffs_DeviceStruct *myDev; /* The device I'm on */ + struct yaffs_dev_s *my_dev; /* The device I'm on */ - struct ylist_head hashLink; /* list of objects in this hash bucket */ + struct ylist_head hash_link; /* list of objects in this hash bucket */ - struct ylist_head hardLinks; /* all the equivalent hard linked objects */ + struct ylist_head hard_links; /* all the equivalent hard linked objects */ /* directory structure stuff */ /* also used for linking up the free list */ - struct yaffs_ObjectStruct *parent; + struct yaffs_obj_s *parent; struct ylist_head siblings; /* Where's my object header in NAND? */ - int hdrChunk; + int hdr_chunk; - int nDataChunks; /* Number of data chunks attached to the file. */ + int n_data_chunks; /* Number of data chunks attached to the file. */ - __u32 objectId; /* the object id value */ + __u32 obj_id; /* the object id value */ __u32 yst_mode; #ifdef CONFIG_YAFFS_SHORT_NAMES_IN_RAM - YCHAR shortName[YAFFS_SHORT_NAME_LENGTH + 1]; + YCHAR short_name[YAFFS_SHORT_NAME_LENGTH + 1]; #endif #ifdef CONFIG_YAFFS_WINCE @@ -462,43 +462,43 @@ struct yaffs_ObjectStruct { __u32 yst_rdev; - void *myInode; + void *my_inode; - yaffs_ObjectType variantType; + yaffs_obj_type variant_type; - yaffs_ObjectVariant variant; + yaffs_obj_variant variant; }; -typedef struct yaffs_ObjectStruct yaffs_Object; +typedef struct yaffs_obj_s yaffs_obj_t; typedef struct { struct ylist_head list; int count; -} yaffs_ObjectBucket; +} yaffs_obj_bucket; -/* yaffs_CheckpointObject holds the definition of an object as dumped +/* yaffs_checkpt_obj_t holds the definition of an object as dumped * by checkpointing. */ typedef struct { - int structType; - __u32 objectId; - __u32 parentId; - int hdrChunk; - yaffs_ObjectType variantType:3; + int struct_type; + __u32 obj_id; + __u32 parent_id; + int hdr_chunk; + yaffs_obj_type variant_type:3; __u8 deleted:1; - __u8 softDeleted:1; + __u8 soft_del:1; __u8 unlinked:1; __u8 fake:1; - __u8 renameAllowed:1; - __u8 unlinkAllowed:1; + __u8 rename_allowed:1; + __u8 unlink_allowed:1; __u8 serial; - int nDataChunks; - __u32 fileSizeOrEquivalentObjectId; -} yaffs_CheckpointObject; + int n_data_chunks; + __u32 size_or_equiv_obj; +} yaffs_checkpt_obj_t; /*--------------------- Temporary buffers ---------------- * @@ -508,13 +508,13 @@ typedef struct { typedef struct { __u8 *buffer; int line; /* track from whence this buffer was allocated */ - int maxLine; + int max_line; } yaffs_buffer_t; /*----------------- Device ---------------------------------*/ -struct yaffs_DeviceParamStruct { +struct yaffs_param_s { const YCHAR *name; /* @@ -523,300 +523,300 @@ struct yaffs_DeviceParamStruct { * and defualt values are zero. */ - int inbandTags; /* Use unband tags */ - __u32 totalBytesPerChunk; /* Should be >= 512, does not need to be a power of 2 */ - int nChunksPerBlock; /* does not need to be a power of 2 */ - int spareBytesPerChunk; /* spare area size */ - int startBlock; /* Start block we're allowed to use */ - int endBlock; /* End block we're allowed to use */ - int nReservedBlocks; /* We want this tuneable so that we can reduce */ + int inband_tags; /* Use unband tags */ + __u32 total_bytes_per_chunk; /* Should be >= 512, does not need to be a power of 2 */ + int chunks_per_block; /* does not need to be a power of 2 */ + int spare_bytes_per_chunk; /* spare area size */ + int start_block; /* Start block we're allowed to use */ + int end_block; /* End block we're allowed to use */ + int n_reserved_blocks; /* We want this tuneable so that we can reduce */ /* reserved blocks on NOR and RAM. */ - int nShortOpCaches; /* If <= 0, then short op caching is disabled, else + int n_caches; /* If <= 0, then short op caching is disabled, else * the number of short op caches (don't use too many). * 10 to 20 is a good bet. */ - int useNANDECC; /* Flag to decide whether or not to use NANDECC on data (yaffs1) */ - int noTagsECC; /* Flag to decide whether or not to do ECC on packed tags (yaffs2) */ + int use_nand_ecc; /* Flag to decide whether or not to use NANDECC on data (yaffs1) */ + int no_tags_ecc; /* Flag to decide whether or not to do ECC on packed tags (yaffs2) */ - int isYaffs2; /* Use yaffs2 mode on this device */ + int is_yaffs2; /* Use yaffs2 mode on this device */ - int emptyLostAndFound; /* Auto-empty lost+found directory on mount */ + int empty_lost_n_found; /* Auto-empty lost+found directory on mount */ - int refreshPeriod; /* How often we should check to do a block refresh */ + int refresh_period; /* How often we should check to do a block refresh */ /* Checkpoint control. Can be set before or after initialisation */ - __u8 skipCheckpointRead; - __u8 skipCheckpointWrite; + __u8 skip_checkpt_rd; + __u8 skip_checkpt_wr; - int enableXattr; /* Enable xattribs */ + int enable_xattr; /* Enable xattribs */ /* NAND access functions (Must be set before calling YAFFS)*/ - int (*writeChunkToNAND) (struct yaffs_DeviceStruct *dev, - int chunkInNAND, const __u8 *data, - const yaffs_Spare *spare); - int (*readChunkFromNAND) (struct yaffs_DeviceStruct *dev, - int chunkInNAND, __u8 *data, - yaffs_Spare *spare); - int (*eraseBlockInNAND) (struct yaffs_DeviceStruct *dev, - int blockInNAND); - int (*initialiseNAND) (struct yaffs_DeviceStruct *dev); - int (*deinitialiseNAND) (struct yaffs_DeviceStruct *dev); + int (*write_chunk_fn) (struct yaffs_dev_s *dev, + int nand_chunk, const __u8 *data, + const yaffs_spare *spare); + int (*read_chunk_fn) (struct yaffs_dev_s *dev, + int nand_chunk, __u8 *data, + yaffs_spare *spare); + int (*erase_fn) (struct yaffs_dev_s *dev, + int flash_block); + int (*initialise_flash_fn) (struct yaffs_dev_s *dev); + int (*deinitialise_flash_fn) (struct yaffs_dev_s *dev); #ifdef CONFIG_YAFFS_YAFFS2 - int (*writeChunkWithTagsToNAND) (struct yaffs_DeviceStruct *dev, - int chunkInNAND, const __u8 *data, - const yaffs_ExtendedTags *tags); - int (*readChunkWithTagsFromNAND) (struct yaffs_DeviceStruct *dev, - int chunkInNAND, __u8 *data, - yaffs_ExtendedTags *tags); - int (*markNANDBlockBad) (struct yaffs_DeviceStruct *dev, int blockNo); - int (*queryNANDBlock) (struct yaffs_DeviceStruct *dev, int blockNo, - yaffs_BlockState *state, __u32 *sequenceNumber); + int (*write_chunk_tags_fn) (struct yaffs_dev_s *dev, + int nand_chunk, const __u8 *data, + const yaffs_ext_tags *tags); + int (*read_chunk_tags_fn) (struct yaffs_dev_s *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, + yaffs_block_state_t *state, __u32 *seq_number); #endif - /* The removeObjectCallback function must be supplied by OS flavours that + /* The remove_obj_fn function must be supplied by OS flavours that * need it. * yaffs direct uses it to implement the faster readdir. * Linux uses it to protect the directory during unlocking. */ - void (*removeObjectCallback)(struct yaffs_ObjectStruct *obj); + void (*remove_obj_fn)(struct yaffs_obj_s *obj); /* Callback to mark the superblock dirty */ - void (*markSuperBlockDirty)(struct yaffs_DeviceStruct *dev); + void (*sb_dirty_fn)(struct yaffs_dev_s *dev); /* Callback to control garbage collection. */ - unsigned (*gcControl)(struct yaffs_DeviceStruct *dev); + unsigned (*gc_control)(struct yaffs_dev_s *dev); /* Debug control flags. Don't use unless you know what you're doing */ - int useHeaderFileSize; /* Flag to determine if we should use file sizes from the header */ - int disableLazyLoad; /* Disable lazy loading on this device */ - int wideTnodesDisabled; /* Set to disable wide tnodes */ - int disableSoftDelete; /* yaffs 1 only: Set to disable the use of softdeletion. */ + int use_header_file_size; /* Flag to determine if we should use file sizes from the header */ + int disable_lazy_load; /* Disable lazy loading on this device */ + int wide_tnodes_disabled; /* Set to disable wide tnodes */ + int disable_soft_del; /* yaffs 1 only: Set to disable the use of softdeletion. */ - int deferDirectoryUpdate; /* Set to defer directory updates */ + int defered_dir_update; /* Set to defer directory updates */ #ifdef CONFIG_YAFFS_AUTO_UNICODE - int autoUnicode; + int auto_unicode; #endif - int alwaysCheckErased; /* Force chunk erased check always on */ + int always_check_erased; /* Force chunk erased check always on */ }; -typedef struct yaffs_DeviceParamStruct yaffs_DeviceParam; +typedef struct yaffs_param_s yaffs_param_t; -struct yaffs_DeviceStruct { - struct yaffs_DeviceParamStruct param; +struct yaffs_dev_s { + struct yaffs_param_s param; /* Context storage. Holds extra OS specific data for this device */ - void *osContext; - void *driverContext; + void *os_context; + void *driver_context; - struct ylist_head devList; + struct ylist_head dev_list; /* Runtime parameters. Set up by YAFFS. */ - int nDataBytesPerChunk; + int data_bytes_per_chunk; /* Non-wide tnode stuff */ - __u16 chunkGroupBits; /* Number of bits that need to be resolved if + __u16 chunk_grp_bits; /* Number of bits that need to be resolved if * the tnodes are not wide enough. */ - __u16 chunkGroupSize; /* == 2^^chunkGroupBits */ + __u16 chunk_grp_size; /* == 2^^chunk_grp_bits */ /* Stuff to support wide tnodes */ - __u32 tnodeWidth; - __u32 tnodeMask; - __u32 tnodeSize; + __u32 tnode_width; + __u32 tnode_mask; + __u32 tnode_size; /* Stuff for figuring out file offset to chunk conversions */ - __u32 chunkShift; /* Shift value */ - __u32 chunkDiv; /* Divisor after shifting: 1 for power-of-2 sizes */ - __u32 chunkMask; /* Mask to use for power-of-2 case */ + __u32 chunk_shift; /* Shift value */ + __u32 chunk_div; /* Divisor after shifting: 1 for power-of-2 sizes */ + __u32 chunk_mask; /* Mask to use for power-of-2 case */ - int isMounted; - int readOnly; - int isCheckpointed; + int is_mounted; + int read_only; + int is_checkpointed; /* Stuff to support block offsetting to support start block zero */ - int internalStartBlock; - int internalEndBlock; - int blockOffset; - int chunkOffset; + int internal_start_block; + int internal_end_block; + int block_offset; + int chunk_offset; /* Runtime checkpointing stuff */ - int checkpointPageSequence; /* running sequence number of checkpoint pages */ - int checkpointByteCount; - int checkpointByteOffset; - __u8 *checkpointBuffer; - int checkpointOpenForWrite; - int blocksInCheckpoint; - int checkpointCurrentChunk; - int checkpointCurrentBlock; - int checkpointNextBlock; - int *checkpointBlockList; - int checkpointMaxBlocks; - __u32 checkpointSum; - __u32 checkpointXor; - - int nCheckpointBlocksRequired; /* Number of blocks needed to store current checkpoint set */ + int checkpt_page_seq; /* running sequence number of checkpoint pages */ + int checkpt_byte_count; + int checkpt_byte_offs; + __u8 *checkpt_buffer; + int checkpt_open_write; + int blocks_in_checkpt; + int checkpt_cur_chunk; + int checkpt_cur_block; + int checkpt_next_block; + int *checkpt_block_list; + int checkpt_max_blocks; + __u32 checkpt_sum; + __u32 checkpt_xor; + + int checkpoint_blocks_required; /* Number of blocks needed to store current checkpoint set */ /* Block Info */ - yaffs_BlockInfo *blockInfo; - __u8 *chunkBits; /* bitmap of chunks in use */ - unsigned blockInfoAlt:1; /* was allocated using alternative strategy */ - unsigned chunkBitsAlt:1; /* was allocated using alternative strategy */ - int chunkBitmapStride; /* Number of bytes of chunkBits per block. - * Must be consistent with nChunksPerBlock. + yaffs_block_info_t *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 */ + int chunk_bit_stride; /* Number of bytes of chunk_bits per block. + * Must be consistent with chunks_per_block. */ - int nErasedBlocks; - int allocationBlock; /* Current block being allocated off */ - __u32 allocationPage; - int allocationBlockFinder; /* Used to search for next allocation block */ + int n_erased_blocks; + int alloc_block; /* Current block being allocated off */ + __u32 alloc_page; + int alloc_block_finder; /* Used to search for next allocation block */ /* Object and Tnode memory management */ void *allocator; - int nObjects; - int nTnodes; + int n_obj; + int n_tnodes; - int nHardLinks; + int n_hardlinks; - yaffs_ObjectBucket objectBucket[YAFFS_NOBJECT_BUCKETS]; - __u32 bucketFinder; + yaffs_obj_bucket obj_bucket[YAFFS_NOBJECT_BUCKETS]; + __u32 bucket_finder; - int nFreeChunks; + int n_free_chunks; /* Garbage collection control */ - __u32 *gcCleanupList; /* objects to delete at the end of a GC. */ - __u32 nCleanups; - - unsigned hasPendingPrioritisedGCs; /* We think this device might have pending prioritised gcs */ - unsigned gcDisable; - unsigned gcBlockFinder; - unsigned gcDirtiest; - unsigned gcPagesInUse; - unsigned gcNotDone; - unsigned gcBlock; - unsigned gcChunk; - unsigned gcSkip; + __u32 *gc_cleanup_list; /* objects to delete at the end of a GC. */ + __u32 n_clean_ups; + + unsigned has_pending_prioritised_gc; /* We think this device might have pending prioritised gcs */ + unsigned gc_disable; + unsigned gc_block_finder; + unsigned gc_dirtiest; + unsigned gc_pages_in_use; + unsigned gc_not_done; + unsigned gc_block; + unsigned gc_chunk; + unsigned gc_skip; /* Special directories */ - yaffs_Object *rootDir; - yaffs_Object *lostNFoundDir; + yaffs_obj_t *root_dir; + yaffs_obj_t *lost_n_found; /* Buffer areas for storing data to recover from write failures TODO - * __u8 bufferedData[YAFFS_CHUNKS_PER_BLOCK][YAFFS_BYTES_PER_CHUNK]; - * yaffs_Spare bufferedSpare[YAFFS_CHUNKS_PER_BLOCK]; + * __u8 buffered_data[YAFFS_CHUNKS_PER_BLOCK][YAFFS_BYTES_PER_CHUNK]; + * yaffs_spare buffered_spare[YAFFS_CHUNKS_PER_BLOCK]; */ - int bufferedBlock; /* Which block is buffered here? */ - int doingBufferedBlockRewrite; + int buffered_block; /* Which block is buffered here? */ + int doing_buffered_block_rewrite; - yaffs_ChunkCache *srCache; - int srLastUse; + yaffs_cache_t *cache; + int cache_last_use; /* Stuff for background deletion and unlinked files.*/ - yaffs_Object *unlinkedDir; /* Directory where unlinked and deleted files live. */ - yaffs_Object *deletedDir; /* Directory where deleted objects are sent to disappear. */ - yaffs_Object *unlinkedDeletion; /* Current file being background deleted.*/ - int nDeletedFiles; /* Count of files awaiting deletion;*/ - int nUnlinkedFiles; /* Count of unlinked files. */ - int nBackgroundDeletions; /* Count of background deletions. */ + 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.*/ + 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. */ /* Temporary buffer management */ - yaffs_buffer_t tempBuffer[YAFFS_N_TEMP_BUFFERS]; - int maxTemp; - int tempInUse; - int unmanagedTempAllocations; - int unmanagedTempDeallocations; + yaffs_buffer_t temp_buffer[YAFFS_N_TEMP_BUFFERS]; + int max_temp; + int temp_in_use; + int unmanaged_buffer_allocs; + int unmanaged_buffer_deallocs; /* yaffs2 runtime stuff */ - unsigned sequenceNumber; /* Sequence number of currently allocating block */ - unsigned oldestDirtySequence; - unsigned oldestDirtyBlock; + unsigned seq_number; /* Sequence number of currently allocating block */ + unsigned oldest_dirty_seq; + unsigned oldest_dirty_block; /* Block refreshing */ - int refreshSkip; /* A skip down counter. Refresh happens when this gets to zero. */ + int refresh_skip; /* A skip down counter. Refresh happens when this gets to zero. */ /* Dirty directory handling */ - struct ylist_head dirtyDirectories; /* List of dirty directories */ + struct ylist_head dirty_dirs; /* List of dirty directories */ /* Statistcs */ - __u32 nPageWrites; - __u32 nPageReads; - __u32 nBlockErasures; - __u32 nErasureFailures; - __u32 nGCCopies; - __u32 allGCs; - __u32 passiveGCs; - __u32 oldestDirtyGCs; - __u32 nGCBlocks; - __u32 backgroundGCs; - __u32 nRetriedWrites; - __u32 nRetiredBlocks; - __u32 eccFixed; - __u32 eccUnfixed; - __u32 tagsEccFixed; - __u32 tagsEccUnfixed; - __u32 nDeletions; - __u32 nUnmarkedDeletions; - __u32 refreshCount; - __u32 cacheHits; + __u32 n_page_writes; + __u32 n_page_reads; + __u32 n_erasures; + __u32 n_erase_failures; + __u32 n_gc_copies; + __u32 all_gcs; + __u32 passive_gc_count; + __u32 oldest_dirty_gc_count; + __u32 n_gc_blocks; + __u32 bg_gcs; + __u32 n_retired_writes; + __u32 n_retired_blocks; + __u32 n_ecc_fixed; + __u32 n_ecc_unfixed; + __u32 n_tags_ecc_fixed; + __u32 n_tags_ecc_unfixed; + __u32 n_deletions; + __u32 n_unmarked_deletions; + __u32 refresh_count; + __u32 cache_hits; }; -typedef struct yaffs_DeviceStruct yaffs_Device; +typedef struct yaffs_dev_s yaffs_dev_t; /* The static layout of block usage etc is stored in the super block header */ typedef struct { int StructType; int version; - int checkpointStartBlock; - int checkpointEndBlock; - int startBlock; - int endBlock; + int checkpt_start_block; + int checkpt_end_block; + int start_block; + int end_block; int rfu[100]; -} yaffs_SuperBlockHeader; +} yaffs_sb_header; /* The CheckpointDevice structure holds the device information that changes at runtime and * must be preserved over unmount/mount cycles. */ typedef struct { - int structType; - int nErasedBlocks; - int allocationBlock; /* Current block being allocated off */ - __u32 allocationPage; - int nFreeChunks; + int struct_type; + int n_erased_blocks; + int alloc_block; /* Current block being allocated off */ + __u32 alloc_page; + int n_free_chunks; - int nDeletedFiles; /* Count of files awaiting deletion;*/ - int nUnlinkedFiles; /* Count of unlinked files. */ - int nBackgroundDeletions; /* Count of background deletions. */ + 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. */ /* yaffs2 runtime stuff */ - unsigned sequenceNumber; /* Sequence number of currently allocating block */ + unsigned seq_number; /* Sequence number of currently allocating block */ -} yaffs_CheckpointDevice; +} yaffs_checkpt_dev_t; typedef struct { - int structType; + int struct_type; __u32 magic; __u32 version; __u32 head; -} yaffs_CheckpointValidity; +} yaffs_checkpt_validty_t; -struct yaffs_ShadowFixerStruct { - int objectId; - int shadowedId; - struct yaffs_ShadowFixerStruct *next; +struct yaffs_shadow_fixer_s { + int obj_id; + int shadowed_id; + struct yaffs_shadow_fixer_s *next; }; /* Structure for doing xattr modifications */ @@ -832,138 +832,138 @@ typedef struct { /*----------------------- YAFFS Functions -----------------------*/ -int yaffs_guts_initialise(yaffs_Device *dev); -void yaffs_deinitialise(yaffs_Device *dev); +int yaffs_guts_initialise(yaffs_dev_t *dev); +void yaffs_deinitialise(yaffs_dev_t *dev); -int yaffs_get_n_free_chunks(yaffs_Device *dev); +int yaffs_get_n_free_chunks(yaffs_dev_t *dev); -int yaffs_rename_obj(yaffs_Object *oldDir, const YCHAR *oldName, - yaffs_Object *newDir, const YCHAR *newName); +int yaffs_rename_obj(yaffs_obj_t *old_dir, const YCHAR *old_name, + yaffs_obj_t *new_dir, const YCHAR *new_name); -int yaffs_unlinker(yaffs_Object *dir, const YCHAR *name); -int yaffs_del_obj(yaffs_Object *obj); +int yaffs_unlinker(yaffs_obj_t *dir, const YCHAR *name); +int yaffs_del_obj(yaffs_obj_t *obj); -int yaffs_get_obj_name(yaffs_Object *obj, YCHAR *name, int buffSize); -int yaffs_get_obj_length(yaffs_Object *obj); -int yaffs_get_obj_inode(yaffs_Object *obj); -unsigned yaffs_get_obj_type(yaffs_Object *obj); -int yaffs_get_obj_link_count(yaffs_Object *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_set_attribs(yaffs_Object *obj, struct iattr *attr); -int yaffs_get_attribs(yaffs_Object *obj, struct iattr *attr); +int yaffs_set_attribs(yaffs_obj_t *obj, struct iattr *attr); +int yaffs_get_attribs(yaffs_obj_t *obj, struct iattr *attr); /* File operations */ -int yaffs_file_rd(yaffs_Object *obj, __u8 *buffer, loff_t offset, - int nBytes); -int yaffs_wr_file(yaffs_Object *obj, const __u8 *buffer, loff_t offset, - int nBytes, int writeThrough); -int yaffs_resize_file(yaffs_Object *obj, loff_t newSize); +int yaffs_file_rd(yaffs_obj_t *obj, __u8 *buffer, loff_t offset, + int n_bytes); +int yaffs_wr_file(yaffs_obj_t *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); -yaffs_Object *yaffs_create_file(yaffs_Object *parent, const YCHAR *name, +yaffs_obj_t *yaffs_create_file(yaffs_obj_t *parent, const YCHAR *name, __u32 mode, __u32 uid, __u32 gid); -int yaffs_flush_file(yaffs_Object *obj, int updateTime, int dataSync); +int yaffs_flush_file(yaffs_obj_t *obj, int update_time, int data_sync); /* Flushing and checkpointing */ -void yaffs_flush_whole_cache(yaffs_Device *dev); +void yaffs_flush_whole_cache(yaffs_dev_t *dev); -int yaffs_checkpoint_save(yaffs_Device *dev); -int yaffs_checkpoint_restore(yaffs_Device *dev); +int yaffs_checkpoint_save(yaffs_dev_t *dev); +int yaffs_checkpoint_restore(yaffs_dev_t *dev); /* Directory operations */ -yaffs_Object *yaffs_create_dir(yaffs_Object *parent, const YCHAR *name, +yaffs_obj_t *yaffs_create_dir(yaffs_obj_t *parent, const YCHAR *name, __u32 mode, __u32 uid, __u32 gid); -yaffs_Object *yaffs_find_by_name(yaffs_Object *theDir, const YCHAR *name); -int yaffs_ApplyToDirectoryChildren(yaffs_Object *theDir, - int (*fn) (yaffs_Object *)); +yaffs_obj_t *yaffs_find_by_name(yaffs_obj_t *the_dir, const YCHAR *name); +int yaffs_ApplyToDirectoryChildren(yaffs_obj_t *the_dir, + int (*fn) (yaffs_obj_t *)); -yaffs_Object *yaffs_find_by_number(yaffs_Device *dev, __u32 number); +yaffs_obj_t *yaffs_find_by_number(yaffs_dev_t *dev, __u32 number); /* Link operations */ -yaffs_Object *yaffs_Link(yaffs_Object *parent, const YCHAR *name, - yaffs_Object *equivalentObject); +yaffs_obj_t *yaffs_link_obj(yaffs_obj_t *parent, const YCHAR *name, + yaffs_obj_t *equiv_obj); -yaffs_Object *yaffs_get_equivalent_obj(yaffs_Object *obj); +yaffs_obj_t *yaffs_get_equivalent_obj(yaffs_obj_t *obj); /* Symlink operations */ -yaffs_Object *yaffs_create_symlink(yaffs_Object *parent, const YCHAR *name, +yaffs_obj_t *yaffs_create_symlink(yaffs_obj_t *parent, const YCHAR *name, __u32 mode, __u32 uid, __u32 gid, const YCHAR *alias); -YCHAR *yaffs_get_symlink_alias(yaffs_Object *obj); +YCHAR *yaffs_get_symlink_alias(yaffs_obj_t *obj); /* Special inodes (fifos, sockets and devices) */ -yaffs_Object *yaffs_create_special(yaffs_Object *parent, const YCHAR *name, +yaffs_obj_t *yaffs_create_special(yaffs_obj_t *parent, const YCHAR *name, __u32 mode, __u32 uid, __u32 gid, __u32 rdev); -int yaffs_set_xattrib(yaffs_Object *obj, const YCHAR *name, const void * value, int size, int flags); -int yaffs_get_xattrib(yaffs_Object *obj, const YCHAR *name, void *value, int size); -int yaffs_list_xattrib(yaffs_Object *obj, char *buffer, int size); -int yaffs_remove_xattrib(yaffs_Object *obj, const YCHAR *name); +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); /* Special directories */ -yaffs_Object *yaffs_Root(yaffs_Device *dev); -yaffs_Object *yaffs_LostNFound(yaffs_Device *dev); +yaffs_obj_t *yaffs_root(yaffs_dev_t *dev); +yaffs_obj_t *yaffs_lost_n_found(yaffs_dev_t *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_Object *obj); +void yaffs_handle_defered_free(yaffs_obj_t *obj); -void yaffs_update_dirty_dirs(yaffs_Device *dev); +void yaffs_update_dirty_dirs(yaffs_dev_t *dev); -int yaffs_bg_gc(yaffs_Device *dev, unsigned urgency); +int yaffs_bg_gc(yaffs_dev_t *dev, unsigned urgency); /* Debug dump */ -int yaffs_dump_obj(yaffs_Object *obj); +int yaffs_dump_obj(yaffs_obj_t *obj); -void yaffs_guts_test(yaffs_Device *dev); +void yaffs_guts_test(yaffs_dev_t *dev); /* A few useful functions to be used within the core files*/ -void yaffs_chunk_del(yaffs_Device *dev, int chunkId, int markNAND, int lyn); -int yaffs_check_ff(__u8 *buffer, int nBytes); -void yaffs_handle_chunk_error(yaffs_Device *dev, yaffs_BlockInfo *bi); +void yaffs_chunk_del(yaffs_dev_t *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); -__u8 *yaffs_get_temp_buffer(yaffs_Device *dev, int lineNo); -void yaffs_release_temp_buffer(yaffs_Device *dev, __u8 *buffer, int lineNo); +__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); -yaffs_Object *yaffs_find_or_create_by_number(yaffs_Device *dev, +yaffs_obj_t *yaffs_find_or_create_by_number(yaffs_dev_t *dev, int number, - yaffs_ObjectType type); -int yaffs_put_chunk_in_file(yaffs_Object *in, int chunkInInode, - int chunkInNAND, int inScan); -void yaffs_set_obj_name(yaffs_Object *obj, const YCHAR *name); -void yaffs_set_obj_name_from_oh(yaffs_Object *obj, const yaffs_ObjectHeader *oh); -void yaffs_add_obj_to_dir(yaffs_Object *directory, - yaffs_Object *obj); + yaffs_obj_type type); +int yaffs_put_chunk_in_file(yaffs_obj_t *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); YCHAR *yaffs_clone_str(const YCHAR *str); -void yaffs_link_fixup(yaffs_Device *dev, yaffs_Object *hardList); -void yaffs_block_became_dirty(yaffs_Device *dev, int blockNo); -int yaffs_update_oh(yaffs_Object *in, const YCHAR *name, - int force, int isShrink, int shadows, +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, + int force, int is_shrink, int shadows, yaffs_xattr_mod *xop); -void yaffs_handle_shadowed_obj(yaffs_Device *dev, int objId, - int backwardScanning); -int yaffs_check_alloc_available(yaffs_Device *dev, int nChunks); -yaffs_tnode_t *yaffs_get_tnode(yaffs_Device *dev); -yaffs_tnode_t *yaffs_add_find_tnode_0(yaffs_Device *dev, - yaffs_FileStructure *fStruct, - __u32 chunkId, - yaffs_tnode_t *passedTn); - -int yaffs_do_file_wr(yaffs_Object *in, const __u8 *buffer, loff_t offset, - int nBytes, int writeThrough); -void yaffs_resize_file_down( yaffs_Object *obj, loff_t newSize); -void yaffs_skip_rest_of_block(yaffs_Device *dev); - -int yaffs_count_free_chunks(yaffs_Device *dev); - -yaffs_tnode_t *yaffs_find_tnode_0(yaffs_Device *dev, - yaffs_FileStructure *fStruct, - __u32 chunkId); - -__u32 yaffs_get_group_base(yaffs_Device *dev, yaffs_tnode_t *tn, unsigned pos); +void yaffs_handle_shadowed_obj(yaffs_dev_t *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, + 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 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); + +int yaffs_count_free_chunks(yaffs_dev_t *dev); + +yaffs_tnode_t *yaffs_find_tnode_0(yaffs_dev_t *dev, + yaffs_file_s *file_struct, + __u32 chunk_id); + +__u32 yaffs_get_group_base(yaffs_dev_t *dev, yaffs_tnode_t *tn, unsigned pos); #endif diff --git a/yaffs_linux.h b/yaffs_linux.h index 5e08c07..19d7b82 100644 --- a/yaffs_linux.h +++ b/yaffs_linux.h @@ -21,7 +21,7 @@ struct yaffs_LinuxContext { struct ylist_head contextList; /* List of these we have mounted */ - struct yaffs_DeviceStruct *dev; + struct yaffs_dev_s *dev; struct super_block * superBlock; struct task_struct *bgThread; /* Background thread for this device */ int bgRunning; @@ -36,8 +36,8 @@ struct yaffs_LinuxContext { unsigned mount_id; }; -#define yaffs_dev_to_lc(dev) ((struct yaffs_LinuxContext *)((dev)->osContext)) -#define yaffs_dev_to_mtd(dev) ((struct mtd_info *)((dev)->driverContext)) +#define yaffs_dev_to_lc(dev) ((struct yaffs_LinuxContext *)((dev)->os_context)) +#define yaffs_dev_to_mtd(dev) ((struct mtd_info *)((dev)->driver_context)) #endif diff --git a/yaffs_linux_allocator.c b/yaffs_linux_allocator.c index a7984e2..f39b9aa 100644 --- a/yaffs_linux_allocator.c +++ b/yaffs_linux_allocator.c @@ -40,7 +40,7 @@ typedef struct yaffs_AllocatorStruct yaffs_Allocator; int mount_id; -void yaffs_deinit_raw_tnodes_and_objs(yaffs_Device *dev) +void yaffs_deinit_raw_tnodes_and_objs(yaffs_dev_t *dev) { yaffs_Allocator *allocator = (yaffs_Allocator *)dev->allocator; @@ -100,7 +100,7 @@ static void (*fake_ctor_list[10]) (void *) = { fake_ctor9, }; -void yaffs_init_raw_tnodes_and_objs(yaffs_Device *dev) +void yaffs_init_raw_tnodes_and_objs(yaffs_dev_t *dev) { yaffs_Allocator *allocator; unsigned mount_id = yaffs_dev_to_lc(dev)->mount_id; @@ -129,7 +129,7 @@ void yaffs_init_raw_tnodes_and_objs(yaffs_Device *dev) allocator->tnode_cache = kmem_cache_create(allocator->tnode_name, - dev->tnodeSize, + dev->tnode_size, 0, 0, fake_ctor_list[mount_id]); if(allocator->tnode_cache) @@ -145,7 +145,7 @@ void yaffs_init_raw_tnodes_and_objs(yaffs_Device *dev) allocator->object_cache = kmem_cache_create(allocator->object_name, - sizeof(yaffs_Object), + sizeof(yaffs_obj_t), 0, 0, fake_ctor_list[mount_id]); @@ -163,7 +163,7 @@ void yaffs_init_raw_tnodes_and_objs(yaffs_Device *dev) } -yaffs_tnode_t *yaffs_alloc_raw_tnode(yaffs_Device *dev) +yaffs_tnode_t *yaffs_alloc_raw_tnode(yaffs_dev_t *dev) { yaffs_Allocator *allocator = dev->allocator; if(!allocator || !allocator->tnode_cache){ @@ -173,13 +173,13 @@ yaffs_tnode_t *yaffs_alloc_raw_tnode(yaffs_Device *dev) return kmem_cache_alloc(allocator->tnode_cache, GFP_NOFS); } -void yaffs_free_raw_tnode(yaffs_Device *dev, yaffs_tnode_t *tn) +void yaffs_free_raw_tnode(yaffs_dev_t *dev, yaffs_tnode_t *tn) { yaffs_Allocator *allocator = dev->allocator; kmem_cache_free(allocator->tnode_cache,tn); } -yaffs_Object *yaffs_alloc_raw_obj(yaffs_Device *dev) +yaffs_obj_t *yaffs_alloc_raw_obj(yaffs_dev_t *dev) { yaffs_Allocator *allocator = dev->allocator; if(!allocator){ @@ -193,7 +193,7 @@ yaffs_Object *yaffs_alloc_raw_obj(yaffs_Device *dev) return kmem_cache_alloc(allocator->object_cache, GFP_NOFS); } -void yaffs_free_raw_obj(yaffs_Device *dev, yaffs_Object *obj) +void yaffs_free_raw_obj(yaffs_dev_t *dev, yaffs_obj_t *obj) { yaffs_Allocator *allocator = dev->allocator; kmem_cache_free(allocator->object_cache,obj); diff --git a/yaffs_mtdif.c b/yaffs_mtdif.c index 48d9058..b2d4318 100644 --- a/yaffs_mtdif.c +++ b/yaffs_mtdif.c @@ -23,19 +23,19 @@ #include "yaffs_linux.h" -int nandmtd_EraseBlockInNAND(yaffs_Device *dev, int blockNumber) +int nandmtd_EraseBlockInNAND(yaffs_dev_t *dev, int blockNumber) { struct mtd_info *mtd = yaffs_dev_to_mtd(dev); __u32 addr = - ((loff_t) blockNumber) * dev->param.totalBytesPerChunk - * dev->param.nChunksPerBlock; + ((loff_t) blockNumber) * dev->param.total_bytes_per_chunk + * dev->param.chunks_per_block; struct erase_info ei; int retval = 0; ei.mtd = mtd; ei.addr = addr; - ei.len = dev->param.totalBytesPerChunk * dev->param.nChunksPerBlock; + ei.len = dev->param.total_bytes_per_chunk * dev->param.chunks_per_block; ei.time = 1000; ei.retries = 2; ei.callback = NULL; @@ -49,7 +49,7 @@ int nandmtd_EraseBlockInNAND(yaffs_Device *dev, int blockNumber) return YAFFS_FAIL; } -int nandmtd_InitialiseNAND(yaffs_Device *dev) +int nandmtd_InitialiseNAND(yaffs_dev_t *dev) { return YAFFS_OK; } diff --git a/yaffs_mtdif.h b/yaffs_mtdif.h index fad9d28..31fc383 100644 --- a/yaffs_mtdif.h +++ b/yaffs_mtdif.h @@ -22,6 +22,6 @@ extern struct nand_oobinfo yaffs_oobinfo; extern struct nand_oobinfo yaffs_noeccinfo; #endif -int nandmtd_EraseBlockInNAND(yaffs_Device *dev, int blockNumber); -int nandmtd_InitialiseNAND(yaffs_Device *dev); +int nandmtd_EraseBlockInNAND(yaffs_dev_t *dev, int blockNumber); +int nandmtd_InitialiseNAND(yaffs_dev_t *dev); #endif diff --git a/yaffs_mtdif1.c b/yaffs_mtdif1.c index 70876bc..ca7b0a3 100644 --- a/yaffs_mtdif1.c +++ b/yaffs_mtdif1.c @@ -18,9 +18,9 @@ * * These functions are invoked via function pointers in yaffs_nand.c. * This replaces functionality provided by functions in yaffs_mtdif.c - * and the yaffs_TagsCompatability functions in yaffs_tagscompat.c that are + * and the yaffs_tags_tCompatability functions in yaffs_tagscompat.c that are * called in yaffs_mtdif.c when the function pointers are NULL. - * We assume the MTD layer is performing ECC (useNANDECC is true). + * We assume the MTD layer is performing ECC (use_nand_ecc is true). */ #include "yportenv.h" @@ -51,12 +51,12 @@ * adjust 'oobfree' to match your existing Yaffs data. * * This nand_ecclayout scatters/gathers to/from the old-yaffs layout with the - * pageStatus byte (at NAND spare offset 4) scattered/gathered from/to + * page_status byte (at NAND spare offset 4) scattered/gathered from/to * the 9th byte. * * Old-style on-NAND format: T0,T1,T2,T3,P,B,T4,T5,E0,E1,E2,T6,T7,E3,E4,E5 - * We have/need PackedTags1 plus pageStatus: T0,T1,T2,T3,T4,T5,T6,T7,P - * where Tn are the tag bytes, En are MTD's ECC bytes, P is the pageStatus + * We have/need PackedTags1 plus page_status: T0,T1,T2,T3,T4,T5,T6,T7,P + * where Tn are the tag bytes, En are MTD's ECC bytes, P is the page_status * byte and B is the small-page bad-block indicator byte. */ static struct nand_ecclayout nand_oob_16 = { @@ -88,40 +88,40 @@ static struct nand_ecclayout nand_oob_16 = { * Any underlying MTD error results in YAFFS_FAIL. * Returns YAFFS_OK or YAFFS_FAIL. */ -int nandmtd1_WriteChunkWithTagsToNAND(yaffs_Device *dev, - int chunkInNAND, const __u8 *data, const yaffs_ExtendedTags *etags) +int nandmtd1_WriteChunkWithTagsToNAND(yaffs_dev_t *dev, + int nand_chunk, const __u8 *data, const yaffs_ext_tags *etags) { struct mtd_info *mtd = yaffs_dev_to_mtd(dev); - int chunkBytes = dev->nDataBytesPerChunk; - loff_t addr = ((loff_t)chunkInNAND) * chunkBytes; + int chunkBytes = dev->data_bytes_per_chunk; + loff_t addr = ((loff_t)nand_chunk) * chunkBytes; struct mtd_oob_ops ops; yaffs_PackedTags1 pt1; int retval; - /* we assume that PackedTags1 and yaffs_Tags are compatible */ + /* we assume that PackedTags1 and yaffs_tags_t are compatible */ compile_time_assertion(sizeof(yaffs_PackedTags1) == 12); - compile_time_assertion(sizeof(yaffs_Tags) == 8); + compile_time_assertion(sizeof(yaffs_tags_t) == 8); yaffs_PackTags1(&pt1, etags); - yaffs_calc_tags_ecc((yaffs_Tags *)&pt1); + yaffs_calc_tags_ecc((yaffs_tags_t *)&pt1); /* When deleting a chunk, the upper layer provides only skeletal - * etags, one with chunkDeleted set. However, we need to update the + * etags, one with is_deleted set. However, we need to update the * tags, not erase them completely. So we use the NAND write property * that only zeroed-bits stick and set tag bytes to all-ones and * zero just the (not) deleted bit. */ #ifndef CONFIG_YAFFS_9BYTE_TAGS - if (etags->chunkDeleted) { + if (etags->is_deleted) { memset(&pt1, 0xff, 8); /* clear delete status bit to indicate deleted */ pt1.deleted = 0; } #else ((__u8 *)&pt1)[8] = 0xff; - if (etags->chunkDeleted) { + if (etags->is_deleted) { memset(&pt1, 0xff, 8); - /* zero pageStatus byte to indicate deleted */ + /* zero page_status byte to indicate deleted */ ((__u8 *)&pt1)[8] = 0; } #endif @@ -137,18 +137,18 @@ int nandmtd1_WriteChunkWithTagsToNAND(yaffs_Device *dev, if (retval) { T(YAFFS_TRACE_MTD, (TSTR("write_oob failed, chunk %d, mtd error %d"TENDSTR), - chunkInNAND, retval)); + nand_chunk, retval)); } return retval ? YAFFS_FAIL : YAFFS_OK; } -/* Return with empty ExtendedTags but add eccResult. +/* Return with empty ExtendedTags but add ecc_result. */ -static int rettags(yaffs_ExtendedTags *etags, int eccResult, int retval) +static int rettags(yaffs_ext_tags *etags, int ecc_result, int retval) { if (etags) { memset(etags, 0, sizeof(*etags)); - etags->eccResult = eccResult; + etags->ecc_result = ecc_result; } return retval; } @@ -156,22 +156,22 @@ static int rettags(yaffs_ExtendedTags *etags, int eccResult, int retval) /* Read a chunk (page) from NAND. * * Caller expects ExtendedTags data to be usable even on error; that is, - * all members except eccResult and blockBad are zeroed. + * all members except ecc_result and block_bad are zeroed. * * - Check ECC results for data (if applicable) * - Check for blank/erased block (return empty ExtendedTags if blank) * - Check the PackedTags1 mini-ECC (correct if necessary/possible) * - Convert PackedTags1 to ExtendedTags - * - Update eccResult and blockBad members to refect state. + * - Update ecc_result and block_bad members to refect state. * * Returns YAFFS_OK or YAFFS_FAIL. */ -int nandmtd1_ReadChunkWithTagsFromNAND(yaffs_Device *dev, - int chunkInNAND, __u8 *data, yaffs_ExtendedTags *etags) +int nandmtd1_ReadChunkWithTagsFromNAND(yaffs_dev_t *dev, + int nand_chunk, __u8 *data, yaffs_ext_tags *etags) { struct mtd_info *mtd = yaffs_dev_to_mtd(dev); - int chunkBytes = dev->nDataBytesPerChunk; - loff_t addr = ((loff_t)chunkInNAND) * chunkBytes; + int chunkBytes = dev->data_bytes_per_chunk; + loff_t addr = ((loff_t)nand_chunk) * chunkBytes; int eccres = YAFFS_ECC_RESULT_NO_ERROR; struct mtd_oob_ops ops; yaffs_PackedTags1 pt1; @@ -198,7 +198,7 @@ int nandmtd1_ReadChunkWithTagsFromNAND(yaffs_Device *dev, if (retval) { T(YAFFS_TRACE_MTD, (TSTR("read_oob failed, chunk %d, mtd error %d"TENDSTR), - chunkInNAND, retval)); + nand_chunk, retval)); } switch (retval) { @@ -209,23 +209,23 @@ int nandmtd1_ReadChunkWithTagsFromNAND(yaffs_Device *dev, case -EUCLEAN: /* MTD's ECC fixed the data */ eccres = YAFFS_ECC_RESULT_FIXED; - dev->eccFixed++; + dev->n_ecc_fixed++; break; case -EBADMSG: /* MTD's ECC could not fix the data */ - dev->eccUnfixed++; + dev->n_ecc_unfixed++; /* fall into... */ default: rettags(etags, YAFFS_ECC_RESULT_UNFIXED, 0); - etags->blockBad = (mtd->block_isbad)(mtd, addr); + etags->block_bad = (mtd->block_isbad)(mtd, addr); return YAFFS_FAIL; } /* Check for a blank/erased chunk. */ if (yaffs_check_ff((__u8 *)&pt1, 8)) { - /* when blank, upper layers want eccResult to be <= NO_ERROR */ + /* when blank, upper layers want ecc_result to be <= NO_ERROR */ return rettags(etags, YAFFS_ECC_RESULT_NO_ERROR, YAFFS_OK); } @@ -242,20 +242,20 @@ int nandmtd1_ReadChunkWithTagsFromNAND(yaffs_Device *dev, /* Check the packed tags mini-ECC and correct if necessary/possible. */ - retval = yaffs_check_tags_ecc((yaffs_Tags *)&pt1); + retval = yaffs_check_tags_ecc((yaffs_tags_t *)&pt1); switch (retval) { case 0: /* no tags error, use MTD result */ break; case 1: /* recovered tags-ECC error */ - dev->tagsEccFixed++; + dev->n_tags_ecc_fixed++; if (eccres == YAFFS_ECC_RESULT_NO_ERROR) eccres = YAFFS_ECC_RESULT_FIXED; break; default: /* unrecovered tags-ECC error */ - dev->tagsEccUnfixed++; + dev->n_tags_ecc_unfixed++; return rettags(etags, YAFFS_ECC_RESULT_UNFIXED, YAFFS_FAIL); } @@ -264,10 +264,10 @@ int nandmtd1_ReadChunkWithTagsFromNAND(yaffs_Device *dev, */ pt1.shouldBeFF = 0xFFFFFFFF; yaffs_unpack_tags1(etags, &pt1); - etags->eccResult = eccres; + etags->ecc_result = eccres; /* Set deleted state */ - etags->chunkDeleted = deleted; + etags->is_deleted = deleted; return YAFFS_OK; } @@ -278,15 +278,15 @@ int nandmtd1_ReadChunkWithTagsFromNAND(yaffs_Device *dev, * * Returns YAFFS_OK or YAFFS_FAIL. */ -int nandmtd1_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo) +int nandmtd1_MarkNANDBlockBad(struct yaffs_dev_s *dev, int block_no) { struct mtd_info *mtd = yaffs_dev_to_mtd(dev); - int blocksize = dev->param.nChunksPerBlock * dev->nDataBytesPerChunk; + int blocksize = dev->param.chunks_per_block * dev->data_bytes_per_chunk; int retval; - T(YAFFS_TRACE_BAD_BLOCKS,(TSTR("marking block %d bad"TENDSTR), blockNo)); + T(YAFFS_TRACE_BAD_BLOCKS,(TSTR("marking block %d bad"TENDSTR), block_no)); - retval = mtd->block_markbad(mtd, (loff_t)blocksize * blockNo); + retval = mtd->block_markbad(mtd, (loff_t)blocksize * block_no); return (retval) ? YAFFS_FAIL : YAFFS_OK; } @@ -318,13 +318,13 @@ static int nandmtd1_TestPrerequists(struct mtd_info *mtd) * * Always returns YAFFS_OK. */ -int nandmtd1_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockNo, - yaffs_BlockState *pState, __u32 *pSequenceNumber) +int nandmtd1_QueryNANDBlock(struct yaffs_dev_s *dev, int block_no, + yaffs_block_state_t *pState, __u32 *pSequenceNumber) { struct mtd_info *mtd = yaffs_dev_to_mtd(dev); - int chunkNo = blockNo * dev->param.nChunksPerBlock; - loff_t addr = (loff_t)chunkNo * dev->nDataBytesPerChunk; - yaffs_ExtendedTags etags; + int chunkNo = block_no * dev->param.chunks_per_block; + loff_t addr = (loff_t)chunkNo * dev->data_bytes_per_chunk; + yaffs_ext_tags etags; int state = YAFFS_BLOCK_STATE_DEAD; int seqnum = 0; int retval; @@ -336,17 +336,17 @@ int nandmtd1_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockNo, return YAFFS_FAIL; retval = nandmtd1_ReadChunkWithTagsFromNAND(dev, chunkNo, NULL, &etags); - etags.blockBad = (mtd->block_isbad)(mtd, addr); - if (etags.blockBad) { + etags.block_bad = (mtd->block_isbad)(mtd, addr); + if (etags.block_bad) { T(YAFFS_TRACE_BAD_BLOCKS, - (TSTR("block %d is marked bad"TENDSTR), blockNo)); + (TSTR("block %d is marked bad"TENDSTR), block_no)); state = YAFFS_BLOCK_STATE_DEAD; - } else if (etags.eccResult != YAFFS_ECC_RESULT_NO_ERROR) { + } else if (etags.ecc_result != YAFFS_ECC_RESULT_NO_ERROR) { /* bad tags, need to look more closely */ state = YAFFS_BLOCK_STATE_NEEDS_SCANNING; - } else if (etags.chunkUsed) { + } else if (etags.chunk_used) { state = YAFFS_BLOCK_STATE_NEEDS_SCANNING; - seqnum = etags.sequenceNumber; + seqnum = etags.seq_number; } else { state = YAFFS_BLOCK_STATE_EMPTY; } diff --git a/yaffs_mtdif1.h b/yaffs_mtdif1.h index 0e6a56f..1b2befe 100644 --- a/yaffs_mtdif1.h +++ b/yaffs_mtdif1.h @@ -14,15 +14,15 @@ #ifndef __YAFFS_MTDIF1_H__ #define __YAFFS_MTDIF1_H__ -int nandmtd1_WriteChunkWithTagsToNAND(yaffs_Device *dev, int chunkInNAND, - const __u8 *data, const yaffs_ExtendedTags *tags); +int nandmtd1_WriteChunkWithTagsToNAND(yaffs_dev_t *dev, int nand_chunk, + const __u8 *data, const yaffs_ext_tags *tags); -int nandmtd1_ReadChunkWithTagsFromNAND(yaffs_Device *dev, int chunkInNAND, - __u8 *data, yaffs_ExtendedTags *tags); +int nandmtd1_ReadChunkWithTagsFromNAND(yaffs_dev_t *dev, int nand_chunk, + __u8 *data, yaffs_ext_tags *tags); -int nandmtd1_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo); +int nandmtd1_MarkNANDBlockBad(struct yaffs_dev_s *dev, int block_no); -int nandmtd1_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockNo, - yaffs_BlockState *state, __u32 *sequenceNumber); +int nandmtd1_QueryNANDBlock(struct yaffs_dev_s *dev, int block_no, + yaffs_block_state_t *state, __u32 *seq_number); #endif diff --git a/yaffs_mtdif2.c b/yaffs_mtdif2.c index 5f3e34c..c6ebdaa 100644 --- a/yaffs_mtdif2.c +++ b/yaffs_mtdif2.c @@ -30,9 +30,9 @@ * We assume that the data buffer is of size totalBytersPerChunk so that we can also * use it to load the tags. */ -int nandmtd2_WriteChunkWithTagsToNAND(yaffs_Device *dev, int chunkInNAND, +int nandmtd2_WriteChunkWithTagsToNAND(yaffs_dev_t *dev, int nand_chunk, const __u8 *data, - const yaffs_ExtendedTags *tags) + const yaffs_ext_tags *tags) { struct mtd_info *mtd = yaffs_dev_to_mtd(dev); #if (MTD_VERSION_CODE > MTD_VERSION(2, 6, 17)) @@ -46,16 +46,16 @@ int nandmtd2_WriteChunkWithTagsToNAND(yaffs_Device *dev, int chunkInNAND, yaffs_PackedTags2 pt; - int packed_tags_size = dev->param.noTagsECC ? sizeof(pt.t) : sizeof(pt); - void * packed_tags_ptr = dev->param.noTagsECC ? (void *) &pt.t : (void *)&pt; + int packed_tags_size = dev->param.no_tags_ecc ? sizeof(pt.t) : sizeof(pt); + void * packed_tags_ptr = dev->param.no_tags_ecc ? (void *) &pt.t : (void *)&pt; T(YAFFS_TRACE_MTD, (TSTR ("nandmtd2_WriteChunkWithTagsToNAND chunk %d data %p tags %p" - TENDSTR), chunkInNAND, data, tags)); + TENDSTR), nand_chunk, data, tags)); - addr = ((loff_t) chunkInNAND) * dev->param.totalBytesPerChunk; + addr = ((loff_t) nand_chunk) * dev->param.total_bytes_per_chunk; /* For yaffs2 writing there must be both data and tags. * If we're using inband tags, then the tags are stuffed into @@ -63,30 +63,30 @@ int nandmtd2_WriteChunkWithTagsToNAND(yaffs_Device *dev, int chunkInNAND, */ if (!data || !tags) BUG(); - else if (dev->param.inbandTags) { + else if (dev->param.inband_tags) { yaffs_PackedTags2TagsPart *pt2tp; - pt2tp = (yaffs_PackedTags2TagsPart *)(data + dev->nDataBytesPerChunk); + pt2tp = (yaffs_PackedTags2TagsPart *)(data + dev->data_bytes_per_chunk); yaffs_PackTags2TagsPart(pt2tp, tags); } else - yaffs_PackTags2(&pt, tags, !dev->param.noTagsECC); + yaffs_PackTags2(&pt, tags, !dev->param.no_tags_ecc); #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17)) ops.mode = MTD_OOB_AUTO; - ops.ooblen = (dev->param.inbandTags) ? 0 : packed_tags_size; - ops.len = dev->param.totalBytesPerChunk; + ops.ooblen = (dev->param.inband_tags) ? 0 : packed_tags_size; + ops.len = dev->param.total_bytes_per_chunk; ops.ooboffs = 0; ops.datbuf = (__u8 *)data; - ops.oobbuf = (dev->param.inbandTags) ? NULL : packed_tags_ptr; + ops.oobbuf = (dev->param.inband_tags) ? NULL : packed_tags_ptr; retval = mtd->write_oob(mtd, addr, &ops); #else - if (!dev->param.inbandTags) { + if (!dev->param.inband_tags) { retval = - mtd->write_ecc(mtd, addr, dev->nDataBytesPerChunk, + mtd->write_ecc(mtd, addr, dev->data_bytes_per_chunk, &dummy, data, (__u8 *) packed_tags_ptr, NULL); } else { retval = - mtd->write(mtd, addr, dev->param.totalBytesPerChunk, &dummy, + mtd->write(mtd, addr, dev->param.total_bytes_per_chunk, &dummy, data); } #endif @@ -97,8 +97,8 @@ int nandmtd2_WriteChunkWithTagsToNAND(yaffs_Device *dev, int chunkInNAND, return YAFFS_FAIL; } -int nandmtd2_ReadChunkWithTagsFromNAND(yaffs_Device *dev, int chunkInNAND, - __u8 *data, yaffs_ExtendedTags *tags) +int nandmtd2_ReadChunkWithTagsFromNAND(yaffs_dev_t *dev, int nand_chunk, + __u8 *data, yaffs_ext_tags *tags) { struct mtd_info *mtd = yaffs_dev_to_mtd(dev); #if (MTD_VERSION_CODE > MTD_VERSION(2, 6, 17)) @@ -108,19 +108,19 @@ int nandmtd2_ReadChunkWithTagsFromNAND(yaffs_Device *dev, int chunkInNAND, int retval = 0; int localData = 0; - loff_t addr = ((loff_t) chunkInNAND) * dev->param.totalBytesPerChunk; + loff_t addr = ((loff_t) nand_chunk) * dev->param.total_bytes_per_chunk; yaffs_PackedTags2 pt; - int packed_tags_size = dev->param.noTagsECC ? sizeof(pt.t) : sizeof(pt); - void * packed_tags_ptr = dev->param.noTagsECC ? (void *) &pt.t: (void *)&pt; + int packed_tags_size = dev->param.no_tags_ecc ? sizeof(pt.t) : sizeof(pt); + void * packed_tags_ptr = dev->param.no_tags_ecc ? (void *) &pt.t: (void *)&pt; T(YAFFS_TRACE_MTD, (TSTR ("nandmtd2_ReadChunkWithTagsFromNAND chunk %d data %p tags %p" - TENDSTR), chunkInNAND, data, tags)); + TENDSTR), nand_chunk, data, tags)); - if (dev->param.inbandTags) { + if (dev->param.inband_tags) { if (!data) { localData = 1; @@ -132,30 +132,30 @@ int nandmtd2_ReadChunkWithTagsFromNAND(yaffs_Device *dev, int chunkInNAND, #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17)) - if (dev->param.inbandTags || (data && !tags)) - retval = mtd->read(mtd, addr, dev->param.totalBytesPerChunk, + if (dev->param.inband_tags || (data && !tags)) + retval = mtd->read(mtd, addr, dev->param.total_bytes_per_chunk, &dummy, data); else if (tags) { ops.mode = MTD_OOB_AUTO; ops.ooblen = packed_tags_size; - ops.len = data ? dev->nDataBytesPerChunk : packed_tags_size; + ops.len = data ? dev->data_bytes_per_chunk : packed_tags_size; ops.ooboffs = 0; ops.datbuf = data; ops.oobbuf = yaffs_dev_to_lc(dev)->spareBuffer; retval = mtd->read_oob(mtd, addr, &ops); } #else - if (!dev->param.inbandTags && data && tags) { + if (!dev->param.inband_tags && data && tags) { - retval = mtd->read_ecc(mtd, addr, dev->nDataBytesPerChunk, + retval = mtd->read_ecc(mtd, addr, dev->data_bytes_per_chunk, &dummy, data, dev->spareBuffer, NULL); } else { if (data) retval = - mtd->read(mtd, addr, dev->nDataBytesPerChunk, &dummy, + mtd->read(mtd, addr, dev->data_bytes_per_chunk, &dummy, data); - if (!dev->param.inbandTags && tags) + if (!dev->param.inband_tags && tags) retval = mtd->read_oob(mtd, addr, mtd->oobsize, &dummy, dev->spareBuffer); @@ -163,29 +163,29 @@ int nandmtd2_ReadChunkWithTagsFromNAND(yaffs_Device *dev, int chunkInNAND, #endif - if (dev->param.inbandTags) { + if (dev->param.inband_tags) { if (tags) { yaffs_PackedTags2TagsPart *pt2tp; - pt2tp = (yaffs_PackedTags2TagsPart *)&data[dev->nDataBytesPerChunk]; + pt2tp = (yaffs_PackedTags2TagsPart *)&data[dev->data_bytes_per_chunk]; yaffs_unpack_tags2tags_part(tags, pt2tp); } } else { if (tags) { memcpy(packed_tags_ptr, yaffs_dev_to_lc(dev)->spareBuffer, packed_tags_size); - yaffs_unpack_tags2(tags, &pt, !dev->param.noTagsECC); + yaffs_unpack_tags2(tags, &pt, !dev->param.no_tags_ecc); } } if (localData) yaffs_release_temp_buffer(dev, data, __LINE__); - if (tags && retval == -EBADMSG && tags->eccResult == YAFFS_ECC_RESULT_NO_ERROR) { - tags->eccResult = YAFFS_ECC_RESULT_UNFIXED; - dev->eccUnfixed++; + if (tags && retval == -EBADMSG && tags->ecc_result == YAFFS_ECC_RESULT_NO_ERROR) { + tags->ecc_result = YAFFS_ECC_RESULT_UNFIXED; + dev->n_ecc_unfixed++; } - if(tags && retval == -EUCLEAN && tags->eccResult == YAFFS_ECC_RESULT_NO_ERROR) { - tags->eccResult = YAFFS_ECC_RESULT_FIXED; - dev->eccFixed++; + if(tags && retval == -EUCLEAN && tags->ecc_result == YAFFS_ECC_RESULT_NO_ERROR) { + tags->ecc_result = YAFFS_ECC_RESULT_FIXED; + dev->n_ecc_fixed++; } if (retval == 0) return YAFFS_OK; @@ -193,17 +193,17 @@ int nandmtd2_ReadChunkWithTagsFromNAND(yaffs_Device *dev, int chunkInNAND, return YAFFS_FAIL; } -int nandmtd2_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo) +int nandmtd2_MarkNANDBlockBad(struct yaffs_dev_s *dev, int block_no) { struct mtd_info *mtd = yaffs_dev_to_mtd(dev); int retval; T(YAFFS_TRACE_MTD, - (TSTR("nandmtd2_MarkNANDBlockBad %d" TENDSTR), blockNo)); + (TSTR("nandmtd2_MarkNANDBlockBad %d" TENDSTR), block_no)); retval = mtd->block_markbad(mtd, - blockNo * dev->param.nChunksPerBlock * - dev->param.totalBytesPerChunk); + block_no * dev->param.chunks_per_block * + dev->param.total_bytes_per_chunk); if (retval == 0) return YAFFS_OK; @@ -212,41 +212,41 @@ int nandmtd2_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo) } -int nandmtd2_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockNo, - yaffs_BlockState *state, __u32 *sequenceNumber) +int nandmtd2_QueryNANDBlock(struct yaffs_dev_s *dev, int block_no, + yaffs_block_state_t *state, __u32 *seq_number) { struct mtd_info *mtd = yaffs_dev_to_mtd(dev); int retval; T(YAFFS_TRACE_MTD, - (TSTR("nandmtd2_QueryNANDBlock %d" TENDSTR), blockNo)); + (TSTR("nandmtd2_QueryNANDBlock %d" TENDSTR), block_no)); retval = mtd->block_isbad(mtd, - blockNo * dev->param.nChunksPerBlock * - dev->param.totalBytesPerChunk); + block_no * dev->param.chunks_per_block * + dev->param.total_bytes_per_chunk); if (retval) { T(YAFFS_TRACE_MTD, (TSTR("block is bad" TENDSTR))); *state = YAFFS_BLOCK_STATE_DEAD; - *sequenceNumber = 0; + *seq_number = 0; } else { - yaffs_ExtendedTags t; + yaffs_ext_tags t; nandmtd2_ReadChunkWithTagsFromNAND(dev, - blockNo * - dev->param.nChunksPerBlock, NULL, + block_no * + dev->param.chunks_per_block, NULL, &t); - if (t.chunkUsed) { - *sequenceNumber = t.sequenceNumber; + if (t.chunk_used) { + *seq_number = t.seq_number; *state = YAFFS_BLOCK_STATE_NEEDS_SCANNING; } else { - *sequenceNumber = 0; + *seq_number = 0; *state = YAFFS_BLOCK_STATE_EMPTY; } } T(YAFFS_TRACE_MTD, - (TSTR("block is bad seq %d state %d" TENDSTR), *sequenceNumber, + (TSTR("block is bad seq %d state %d" TENDSTR), *seq_number, *state)); if (retval == 0) diff --git a/yaffs_mtdif2.h b/yaffs_mtdif2.h index 5691267..31c8216 100644 --- a/yaffs_mtdif2.h +++ b/yaffs_mtdif2.h @@ -17,13 +17,13 @@ #define __YAFFS_MTDIF2_H__ #include "yaffs_guts.h" -int nandmtd2_WriteChunkWithTagsToNAND(yaffs_Device *dev, int chunkInNAND, +int nandmtd2_WriteChunkWithTagsToNAND(yaffs_dev_t *dev, int nand_chunk, const __u8 *data, - const yaffs_ExtendedTags *tags); -int nandmtd2_ReadChunkWithTagsFromNAND(yaffs_Device *dev, int chunkInNAND, - __u8 *data, yaffs_ExtendedTags *tags); -int nandmtd2_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo); -int nandmtd2_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockNo, - yaffs_BlockState *state, __u32 *sequenceNumber); + const yaffs_ext_tags *tags); +int nandmtd2_ReadChunkWithTagsFromNAND(yaffs_dev_t *dev, int nand_chunk, + __u8 *data, yaffs_ext_tags *tags); +int nandmtd2_MarkNANDBlockBad(struct yaffs_dev_s *dev, int block_no); +int nandmtd2_QueryNANDBlock(struct yaffs_dev_s *dev, int block_no, + yaffs_block_state_t *state, __u32 *seq_number); #endif diff --git a/yaffs_nand.c b/yaffs_nand.c index bd1f058..d1fe84a 100644 --- a/yaffs_nand.c +++ b/yaffs_nand.c @@ -17,23 +17,23 @@ #include "yaffs_getblockinfo.h" -int yaffs_rd_chunk_tags_nand(yaffs_Device *dev, int chunkInNAND, +int yaffs_rd_chunk_tags_nand(yaffs_dev_t *dev, int nand_chunk, __u8 *buffer, - yaffs_ExtendedTags *tags) + yaffs_ext_tags *tags) { int result; - yaffs_ExtendedTags localTags; + yaffs_ext_tags localTags; - int realignedChunkInNAND = chunkInNAND - dev->chunkOffset; + int realignedChunkInNAND = nand_chunk - dev->chunk_offset; - dev->nPageReads++; + dev->n_page_reads++; /* If there are no tags provided, use local tags to get prioritised gc working */ if (!tags) tags = &localTags; - if (dev->param.readChunkWithTagsFromNAND) - result = dev->param.readChunkWithTagsFromNAND(dev, realignedChunkInNAND, buffer, + if (dev->param.read_chunk_tags_fn) + result = dev->param.read_chunk_tags_fn(dev, realignedChunkInNAND, buffer, tags); else result = yaffs_tags_compat_rd(dev, @@ -41,98 +41,98 @@ int yaffs_rd_chunk_tags_nand(yaffs_Device *dev, int chunkInNAND, buffer, tags); if (tags && - tags->eccResult > YAFFS_ECC_RESULT_NO_ERROR) { + tags->ecc_result > YAFFS_ECC_RESULT_NO_ERROR) { - yaffs_BlockInfo *bi; - bi = yaffs_get_block_info(dev, chunkInNAND/dev->param.nChunksPerBlock); + yaffs_block_info_t *bi; + bi = yaffs_get_block_info(dev, nand_chunk/dev->param.chunks_per_block); yaffs_handle_chunk_error(dev, bi); } return result; } -int yaffs_wr_chunk_tags_nand(yaffs_Device *dev, - int chunkInNAND, +int yaffs_wr_chunk_tags_nand(yaffs_dev_t *dev, + int nand_chunk, const __u8 *buffer, - yaffs_ExtendedTags *tags) + yaffs_ext_tags *tags) { - dev->nPageWrites++; + dev->n_page_writes++; - chunkInNAND -= dev->chunkOffset; + nand_chunk -= dev->chunk_offset; if (tags) { - tags->sequenceNumber = dev->sequenceNumber; - tags->chunkUsed = 1; + tags->seq_number = dev->seq_number; + tags->chunk_used = 1; if (!yaffs_validate_tags(tags)) { T(YAFFS_TRACE_ERROR, (TSTR("Writing uninitialised tags" TENDSTR))); YBUG(); } T(YAFFS_TRACE_WRITE, - (TSTR("Writing chunk %d tags %d %d" TENDSTR), chunkInNAND, - tags->objectId, tags->chunkId)); + (TSTR("Writing chunk %d tags %d %d" TENDSTR), nand_chunk, + tags->obj_id, tags->chunk_id)); } else { T(YAFFS_TRACE_ERROR, (TSTR("Writing with no tags" TENDSTR))); YBUG(); } - if (dev->param.writeChunkWithTagsToNAND) - return dev->param.writeChunkWithTagsToNAND(dev, chunkInNAND, buffer, + if (dev->param.write_chunk_tags_fn) + return dev->param.write_chunk_tags_fn(dev, nand_chunk, buffer, tags); else return yaffs_tags_compat_wr(dev, - chunkInNAND, + nand_chunk, buffer, tags); } -int yaffs_mark_bad(yaffs_Device *dev, int blockNo) +int yaffs_mark_bad(yaffs_dev_t *dev, int block_no) { - blockNo -= dev->blockOffset; + block_no -= dev->block_offset; - if (dev->param.markNANDBlockBad) - return dev->param.markNANDBlockBad(dev, blockNo); + if (dev->param.bad_block_fn) + return dev->param.bad_block_fn(dev, block_no); else - return yaffs_tags_compat_mark_bad(dev, blockNo); + return yaffs_tags_compat_mark_bad(dev, block_no); } -int yaffs_query_init_block_state(yaffs_Device *dev, - int blockNo, - yaffs_BlockState *state, - __u32 *sequenceNumber) +int yaffs_query_init_block_state(yaffs_dev_t *dev, + int block_no, + yaffs_block_state_t *state, + __u32 *seq_number) { - blockNo -= dev->blockOffset; + block_no -= dev->block_offset; - if (dev->param.queryNANDBlock) - return dev->param.queryNANDBlock(dev, blockNo, state, sequenceNumber); + if (dev->param.query_block_fn) + return dev->param.query_block_fn(dev, block_no, state, seq_number); else - return yaffs_tags_compat_query_block(dev, blockNo, + return yaffs_tags_compat_query_block(dev, block_no, state, - sequenceNumber); + seq_number); } -int yaffs_erase_block(struct yaffs_DeviceStruct *dev, - int blockInNAND) +int yaffs_erase_block(struct yaffs_dev_s *dev, + int flash_block) { int result; - blockInNAND -= dev->blockOffset; + flash_block -= dev->block_offset; - dev->nBlockErasures++; + dev->n_erasures++; - result = dev->param.eraseBlockInNAND(dev, blockInNAND); + result = dev->param.erase_fn(dev, flash_block); return result; } -int yaffs_init_nand(struct yaffs_DeviceStruct *dev) +int yaffs_init_nand(struct yaffs_dev_s *dev) { - if(dev->param.initialiseNAND) - return dev->param.initialiseNAND(dev); + if(dev->param.initialise_flash_fn) + return dev->param.initialise_flash_fn(dev); return YAFFS_OK; } diff --git a/yaffs_nand.h b/yaffs_nand.h index 520c70a..24cd147 100644 --- a/yaffs_nand.h +++ b/yaffs_nand.h @@ -19,26 +19,26 @@ -int yaffs_rd_chunk_tags_nand(yaffs_Device *dev, int chunkInNAND, +int yaffs_rd_chunk_tags_nand(yaffs_dev_t *dev, int nand_chunk, __u8 *buffer, - yaffs_ExtendedTags *tags); + yaffs_ext_tags *tags); -int yaffs_wr_chunk_tags_nand(yaffs_Device *dev, - int chunkInNAND, +int yaffs_wr_chunk_tags_nand(yaffs_dev_t *dev, + int nand_chunk, const __u8 *buffer, - yaffs_ExtendedTags *tags); + yaffs_ext_tags *tags); -int yaffs_mark_bad(yaffs_Device *dev, int blockNo); +int yaffs_mark_bad(yaffs_dev_t *dev, int block_no); -int yaffs_query_init_block_state(yaffs_Device *dev, - int blockNo, - yaffs_BlockState *state, - unsigned *sequenceNumber); +int yaffs_query_init_block_state(yaffs_dev_t *dev, + int block_no, + yaffs_block_state_t *state, + unsigned *seq_number); -int yaffs_erase_block(struct yaffs_DeviceStruct *dev, - int blockInNAND); +int yaffs_erase_block(struct yaffs_dev_s *dev, + int flash_block); -int yaffs_init_nand(struct yaffs_DeviceStruct *dev); +int yaffs_init_nand(struct yaffs_dev_s *dev); #endif diff --git a/yaffs_nandemul2k.h b/yaffs_nandemul2k.h index 2f4ce97..30b7cbd 100644 --- a/yaffs_nandemul2k.h +++ b/yaffs_nandemul2k.h @@ -20,18 +20,18 @@ #include "yaffs_guts.h" -int nandemul2k_WriteChunkWithTagsToNAND(struct yaffs_DeviceStruct *dev, - int chunkInNAND, const __u8 *data, - const yaffs_ExtendedTags *tags); -int nandemul2k_ReadChunkWithTagsFromNAND(struct yaffs_DeviceStruct *dev, - int chunkInNAND, __u8 *data, - yaffs_ExtendedTags *tags); -int nandemul2k_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo); -int nandemul2k_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockNo, - yaffs_BlockState *state, __u32 *sequenceNumber); -int nandemul2k_EraseBlockInNAND(struct yaffs_DeviceStruct *dev, - int blockInNAND); -int nandemul2k_InitialiseNAND(struct yaffs_DeviceStruct *dev); +int nandemul2k_WriteChunkWithTagsToNAND(struct yaffs_dev_s *dev, + int nand_chunk, const __u8 *data, + const yaffs_ext_tags *tags); +int nandemul2k_ReadChunkWithTagsFromNAND(struct yaffs_dev_s *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, + yaffs_block_state_t *state, __u32 *seq_number); +int nandemul2k_EraseBlockInNAND(struct yaffs_dev_s *dev, + int flash_block); +int nandemul2k_InitialiseNAND(struct yaffs_dev_s *dev); int nandemul2k_GetBytesPerChunk(void); int nandemul2k_GetChunksPerBlock(void); int nandemul2k_GetNumberOfBlocks(void); diff --git a/yaffs_packedtags1.c b/yaffs_packedtags1.c index db136b9..3ad49a9 100644 --- a/yaffs_packedtags1.c +++ b/yaffs_packedtags1.c @@ -14,37 +14,37 @@ #include "yaffs_packedtags1.h" #include "yportenv.h" -void yaffs_PackTags1(yaffs_PackedTags1 *pt, const yaffs_ExtendedTags *t) +void yaffs_PackTags1(yaffs_PackedTags1 *pt, const yaffs_ext_tags *t) { - pt->chunkId = t->chunkId; - pt->serialNumber = t->serialNumber; - pt->byteCount = t->byteCount; - pt->objectId = t->objectId; + pt->chunk_id = t->chunk_id; + pt->serial_number = t->serial_number; + pt->n_bytes = t->n_bytes; + pt->obj_id = t->obj_id; pt->ecc = 0; - pt->deleted = (t->chunkDeleted) ? 0 : 1; + pt->deleted = (t->is_deleted) ? 0 : 1; pt->unusedStuff = 0; pt->shouldBeFF = 0xFFFFFFFF; } -void yaffs_unpack_tags1(yaffs_ExtendedTags *t, const yaffs_PackedTags1 *pt) +void yaffs_unpack_tags1(yaffs_ext_tags *t, const yaffs_PackedTags1 *pt) { static const __u8 allFF[] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }; if (memcmp(allFF, pt, sizeof(yaffs_PackedTags1))) { - t->blockBad = 0; + t->block_bad = 0; if (pt->shouldBeFF != 0xFFFFFFFF) - t->blockBad = 1; - t->chunkUsed = 1; - t->objectId = pt->objectId; - t->chunkId = pt->chunkId; - t->byteCount = pt->byteCount; - t->eccResult = YAFFS_ECC_RESULT_NO_ERROR; - t->chunkDeleted = (pt->deleted) ? 0 : 1; - t->serialNumber = pt->serialNumber; + t->block_bad = 1; + t->chunk_used = 1; + t->obj_id = pt->obj_id; + t->chunk_id = pt->chunk_id; + t->n_bytes = pt->n_bytes; + t->ecc_result = YAFFS_ECC_RESULT_NO_ERROR; + t->is_deleted = (pt->deleted) ? 0 : 1; + t->serial_number = pt->serial_number; } else { - memset(t, 0, sizeof(yaffs_ExtendedTags)); + memset(t, 0, sizeof(yaffs_ext_tags)); } } diff --git a/yaffs_packedtags1.h b/yaffs_packedtags1.h index 3c741b8..881cc75 100644 --- a/yaffs_packedtags1.h +++ b/yaffs_packedtags1.h @@ -21,10 +21,10 @@ #include "yaffs_guts.h" typedef struct { - unsigned chunkId:20; - unsigned serialNumber:2; - unsigned byteCount:10; - unsigned objectId:18; + unsigned chunk_id:20; + unsigned serial_number:2; + unsigned n_bytes:10; + unsigned obj_id:18; unsigned ecc:12; unsigned deleted:1; unsigned unusedStuff:1; @@ -32,6 +32,6 @@ typedef struct { } yaffs_PackedTags1; -void yaffs_PackTags1(yaffs_PackedTags1 *pt, const yaffs_ExtendedTags *t); -void yaffs_unpack_tags1(yaffs_ExtendedTags *t, const yaffs_PackedTags1 *pt); +void yaffs_PackTags1(yaffs_PackedTags1 *pt, const yaffs_ext_tags *t); +void yaffs_unpack_tags1(yaffs_ext_tags *t, const yaffs_PackedTags1 *pt); #endif diff --git a/yaffs_packedtags2.c b/yaffs_packedtags2.c index f8030c7..6b854cb 100644 --- a/yaffs_packedtags2.c +++ b/yaffs_packedtags2.c @@ -25,7 +25,7 @@ * This is defined by having the EXTRA_HEADER_INFO_FLAG set. */ -/* Extra flags applied to chunkId */ +/* Extra flags applied to chunk_id */ #define EXTRA_HEADER_INFO_FLAG 0x80000000 #define EXTRA_SHRINK_FLAG 0x40000000 @@ -43,53 +43,53 @@ static void yaffs_DumpPackedTags2TagsPart(const yaffs_PackedTags2TagsPart *ptt) { T(YAFFS_TRACE_MTD, (TSTR("packed tags obj %d chunk %d byte %d seq %d" TENDSTR), - ptt->objectId, ptt->chunkId, ptt->byteCount, - ptt->sequenceNumber)); + ptt->obj_id, ptt->chunk_id, ptt->n_bytes, + ptt->seq_number)); } static void yaffs_DumpPackedTags2(const yaffs_PackedTags2 *pt) { yaffs_DumpPackedTags2TagsPart(&pt->t); } -static void yaffs_DumpTags2(const yaffs_ExtendedTags *t) +static void yaffs_DumpTags2(const yaffs_ext_tags *t) { T(YAFFS_TRACE_MTD, (TSTR ("ext.tags eccres %d blkbad %d chused %d obj %d chunk%d byte %d del %d ser %d seq %d" - TENDSTR), t->eccResult, t->blockBad, t->chunkUsed, t->objectId, - t->chunkId, t->byteCount, t->chunkDeleted, t->serialNumber, - t->sequenceNumber)); + TENDSTR), t->ecc_result, t->block_bad, t->chunk_used, t->obj_id, + t->chunk_id, t->n_bytes, t->is_deleted, t->serial_number, + t->seq_number)); } void yaffs_PackTags2TagsPart(yaffs_PackedTags2TagsPart *ptt, - const yaffs_ExtendedTags *t) + const yaffs_ext_tags *t) { - ptt->chunkId = t->chunkId; - ptt->sequenceNumber = t->sequenceNumber; - ptt->byteCount = t->byteCount; - ptt->objectId = t->objectId; + ptt->chunk_id = t->chunk_id; + ptt->seq_number = t->seq_number; + ptt->n_bytes = t->n_bytes; + ptt->obj_id = t->obj_id; - if (t->chunkId == 0 && t->extraHeaderInfoAvailable) { + if (t->chunk_id == 0 && t->extra_available) { /* Store the extra header info instead */ - /* We save the parent object in the chunkId */ - ptt->chunkId = EXTRA_HEADER_INFO_FLAG - | t->extraParentObjectId; - if (t->extraIsShrinkHeader) - ptt->chunkId |= EXTRA_SHRINK_FLAG; - if (t->extraShadows) - ptt->chunkId |= EXTRA_SHADOWS_FLAG; - - ptt->objectId &= ~EXTRA_OBJECT_TYPE_MASK; - ptt->objectId |= - (t->extraObjectType << EXTRA_OBJECT_TYPE_SHIFT); - - if (t->extraObjectType == YAFFS_OBJECT_TYPE_HARDLINK) - ptt->byteCount = t->extraEquivalentObjectId; - else if (t->extraObjectType == YAFFS_OBJECT_TYPE_FILE) - ptt->byteCount = t->extraFileLength; + /* We save the parent object in the chunk_id */ + ptt->chunk_id = EXTRA_HEADER_INFO_FLAG + | t->extra_parent_id; + if (t->extra_is_shrink) + ptt->chunk_id |= EXTRA_SHRINK_FLAG; + if (t->extra_shadows) + ptt->chunk_id |= EXTRA_SHADOWS_FLAG; + + ptt->obj_id &= ~EXTRA_OBJECT_TYPE_MASK; + ptt->obj_id |= + (t->extra_obj_type << EXTRA_OBJECT_TYPE_SHIFT); + + if (t->extra_obj_type == YAFFS_OBJECT_TYPE_HARDLINK) + ptt->n_bytes = t->extra_equiv_id; + else if (t->extra_obj_type == YAFFS_OBJECT_TYPE_FILE) + ptt->n_bytes = t->extra_length; else - ptt->byteCount = 0; + ptt->n_bytes = 0; } yaffs_DumpPackedTags2TagsPart(ptt); @@ -97,7 +97,7 @@ void yaffs_PackTags2TagsPart(yaffs_PackedTags2TagsPart *ptt, } -void yaffs_PackTags2(yaffs_PackedTags2 *pt, const yaffs_ExtendedTags *t, int tagsECC) +void yaffs_PackTags2(yaffs_PackedTags2 *pt, const yaffs_ext_tags *t, int tagsECC) { yaffs_PackTags2TagsPart(&pt->t, t); @@ -108,45 +108,45 @@ void yaffs_PackTags2(yaffs_PackedTags2 *pt, const yaffs_ExtendedTags *t, int tag } -void yaffs_unpack_tags2tags_part(yaffs_ExtendedTags *t, +void yaffs_unpack_tags2tags_part(yaffs_ext_tags *t, yaffs_PackedTags2TagsPart *ptt) { - memset(t, 0, sizeof(yaffs_ExtendedTags)); + memset(t, 0, sizeof(yaffs_ext_tags)); yaffs_init_tags(t); - if (ptt->sequenceNumber != 0xFFFFFFFF) { - t->blockBad = 0; - t->chunkUsed = 1; - t->objectId = ptt->objectId; - t->chunkId = ptt->chunkId; - t->byteCount = ptt->byteCount; - t->chunkDeleted = 0; - t->serialNumber = 0; - t->sequenceNumber = ptt->sequenceNumber; + if (ptt->seq_number != 0xFFFFFFFF) { + t->block_bad = 0; + t->chunk_used = 1; + t->obj_id = ptt->obj_id; + t->chunk_id = ptt->chunk_id; + t->n_bytes = ptt->n_bytes; + t->is_deleted = 0; + t->serial_number = 0; + t->seq_number = ptt->seq_number; /* Do extra header info stuff */ - if (ptt->chunkId & EXTRA_HEADER_INFO_FLAG) { - t->chunkId = 0; - t->byteCount = 0; - - t->extraHeaderInfoAvailable = 1; - t->extraParentObjectId = - ptt->chunkId & (~(ALL_EXTRA_FLAGS)); - t->extraIsShrinkHeader = - (ptt->chunkId & EXTRA_SHRINK_FLAG) ? 1 : 0; - t->extraShadows = - (ptt->chunkId & EXTRA_SHADOWS_FLAG) ? 1 : 0; - t->extraObjectType = - ptt->objectId >> EXTRA_OBJECT_TYPE_SHIFT; - t->objectId &= ~EXTRA_OBJECT_TYPE_MASK; - - if (t->extraObjectType == YAFFS_OBJECT_TYPE_HARDLINK) - t->extraEquivalentObjectId = ptt->byteCount; + if (ptt->chunk_id & EXTRA_HEADER_INFO_FLAG) { + t->chunk_id = 0; + t->n_bytes = 0; + + t->extra_available = 1; + t->extra_parent_id = + ptt->chunk_id & (~(ALL_EXTRA_FLAGS)); + t->extra_is_shrink = + (ptt->chunk_id & EXTRA_SHRINK_FLAG) ? 1 : 0; + t->extra_shadows = + (ptt->chunk_id & EXTRA_SHADOWS_FLAG) ? 1 : 0; + t->extra_obj_type = + ptt->obj_id >> EXTRA_OBJECT_TYPE_SHIFT; + t->obj_id &= ~EXTRA_OBJECT_TYPE_MASK; + + if (t->extra_obj_type == YAFFS_OBJECT_TYPE_HARDLINK) + t->extra_equiv_id = ptt->n_bytes; else - t->extraFileLength = ptt->byteCount; + t->extra_length = ptt->n_bytes; } } @@ -156,12 +156,12 @@ void yaffs_unpack_tags2tags_part(yaffs_ExtendedTags *t, } -void yaffs_unpack_tags2(yaffs_ExtendedTags *t, yaffs_PackedTags2 *pt, int tagsECC) +void yaffs_unpack_tags2(yaffs_ext_tags *t, yaffs_PackedTags2 *pt, int tagsECC) { - yaffs_ECCResult eccResult = YAFFS_ECC_RESULT_NO_ERROR; + yaffs_ecc_result ecc_result = YAFFS_ECC_RESULT_NO_ERROR; - if (pt->t.sequenceNumber != 0xFFFFFFFF && + if (pt->t.seq_number != 0xFFFFFFFF && tagsECC){ /* Chunk is in use and we need to do ECC */ @@ -175,22 +175,22 @@ void yaffs_unpack_tags2(yaffs_ExtendedTags *t, yaffs_PackedTags2 *pt, int tagsEC &pt->ecc, &ecc); switch (result) { case 0: - eccResult = YAFFS_ECC_RESULT_NO_ERROR; + ecc_result = YAFFS_ECC_RESULT_NO_ERROR; break; case 1: - eccResult = YAFFS_ECC_RESULT_FIXED; + ecc_result = YAFFS_ECC_RESULT_FIXED; break; case -1: - eccResult = YAFFS_ECC_RESULT_UNFIXED; + ecc_result = YAFFS_ECC_RESULT_UNFIXED; break; default: - eccResult = YAFFS_ECC_RESULT_UNKNOWN; + ecc_result = YAFFS_ECC_RESULT_UNKNOWN; } } yaffs_unpack_tags2tags_part(t, &pt->t); - t->eccResult = eccResult; + t->ecc_result = ecc_result; yaffs_DumpPackedTags2(pt); yaffs_DumpTags2(t); diff --git a/yaffs_packedtags2.h b/yaffs_packedtags2.h index a27fdb1..70bd3c9 100644 --- a/yaffs_packedtags2.h +++ b/yaffs_packedtags2.h @@ -22,10 +22,10 @@ #include "yaffs_ecc.h" typedef struct { - unsigned sequenceNumber; - unsigned objectId; - unsigned chunkId; - unsigned byteCount; + unsigned seq_number; + unsigned obj_id; + unsigned chunk_id; + unsigned n_bytes; } yaffs_PackedTags2TagsPart; typedef struct { @@ -34,10 +34,10 @@ typedef struct { } yaffs_PackedTags2; /* Full packed tags with ECC, used for oob tags */ -void yaffs_PackTags2(yaffs_PackedTags2 *pt, const yaffs_ExtendedTags *t, int tagsECC); -void yaffs_unpack_tags2(yaffs_ExtendedTags *t, yaffs_PackedTags2 *pt, int tagsECC); +void yaffs_PackTags2(yaffs_PackedTags2 *pt, const yaffs_ext_tags *t, int tagsECC); +void yaffs_unpack_tags2(yaffs_ext_tags *t, yaffs_PackedTags2 *pt, int tagsECC); /* Only the tags part (no ECC for use with inband tags */ -void yaffs_PackTags2TagsPart(yaffs_PackedTags2TagsPart *pt, const yaffs_ExtendedTags *t); -void yaffs_unpack_tags2tags_part(yaffs_ExtendedTags *t, yaffs_PackedTags2TagsPart *pt); +void yaffs_PackTags2TagsPart(yaffs_PackedTags2TagsPart *pt, const yaffs_ext_tags *t); +void yaffs_unpack_tags2tags_part(yaffs_ext_tags *t, yaffs_PackedTags2TagsPart *pt); #endif diff --git a/yaffs_tagscompat.c b/yaffs_tagscompat.c index 93d03ab..c04a2fb 100644 --- a/yaffs_tagscompat.c +++ b/yaffs_tagscompat.c @@ -17,15 +17,15 @@ #include "yaffs_getblockinfo.h" #include "yaffs_trace.h" -static void yaffs_handle_rd_data_error(yaffs_Device *dev, int chunkInNAND); +static void yaffs_handle_rd_data_error(yaffs_dev_t *dev, int nand_chunk); #ifdef NOTYET -static void yaffs_check_written_block(yaffs_Device *dev, int chunkInNAND); -static void yaffs_handle_chunk_wr_ok(yaffs_Device *dev, int chunkInNAND, +static void yaffs_check_written_block(yaffs_dev_t *dev, int nand_chunk); +static void yaffs_handle_chunk_wr_ok(yaffs_dev_t *dev, int nand_chunk, const __u8 *data, - const yaffs_Spare *spare); -static void yaffs_handle_chunk_update(yaffs_Device *dev, int chunkInNAND, - const yaffs_Spare *spare); -static void yaffs_handle_chunk_wr_error(yaffs_Device *dev, int chunkInNAND); + const yaffs_spare *spare); +static void yaffs_handle_chunk_update(yaffs_dev_t *dev, int nand_chunk, + const yaffs_spare *spare); +static void yaffs_handle_chunk_wr_error(yaffs_dev_t *dev, int nand_chunk); #endif static const char yaffs_count_bits_table[256] = { @@ -56,17 +56,17 @@ int yaffs_count_bits(__u8 x) /********** Tags ECC calculations *********/ -void yaffs_calc_ecc(const __u8 *data, yaffs_Spare *spare) +void yaffs_calc_ecc(const __u8 *data, yaffs_spare *spare) { yaffs_ecc_cacl(data, spare->ecc1); yaffs_ecc_cacl(&data[256], spare->ecc2); } -void yaffs_calc_tags_ecc(yaffs_Tags *tags) +void yaffs_calc_tags_ecc(yaffs_tags_t *tags) { /* Calculate an ecc */ - unsigned char *b = ((yaffs_tags_union_t *) tags)->asBytes; + unsigned char *b = ((yaffs_tags_union_t *) tags)->as_bytes; unsigned i, j; unsigned ecc = 0; unsigned bit = 0; @@ -85,7 +85,7 @@ void yaffs_calc_tags_ecc(yaffs_Tags *tags) } -int yaffs_check_tags_ecc(yaffs_Tags *tags) +int yaffs_check_tags_ecc(yaffs_tags_t *tags) { unsigned ecc = tags->ecc; @@ -95,7 +95,7 @@ int yaffs_check_tags_ecc(yaffs_Tags *tags) if (ecc && ecc <= 64) { /* TODO: Handle the failure better. Retire? */ - unsigned char *b = ((yaffs_tags_union_t *) tags)->asBytes; + unsigned char *b = ((yaffs_tags_union_t *) tags)->as_bytes; ecc--; @@ -116,73 +116,73 @@ int yaffs_check_tags_ecc(yaffs_Tags *tags) /********** Tags **********/ -static void yaffs_load_tags_to_spare(yaffs_Spare *sparePtr, - yaffs_Tags *tagsPtr) +static void yaffs_load_tags_to_spare(yaffs_spare *sparePtr, + yaffs_tags_t *tagsPtr) { yaffs_tags_union_t *tu = (yaffs_tags_union_t *) tagsPtr; yaffs_calc_tags_ecc(tagsPtr); - sparePtr->tb0 = tu->asBytes[0]; - sparePtr->tb1 = tu->asBytes[1]; - sparePtr->tb2 = tu->asBytes[2]; - sparePtr->tb3 = tu->asBytes[3]; - sparePtr->tb4 = tu->asBytes[4]; - sparePtr->tb5 = tu->asBytes[5]; - sparePtr->tb6 = tu->asBytes[6]; - sparePtr->tb7 = tu->asBytes[7]; + sparePtr->tb0 = tu->as_bytes[0]; + sparePtr->tb1 = tu->as_bytes[1]; + sparePtr->tb2 = tu->as_bytes[2]; + sparePtr->tb3 = tu->as_bytes[3]; + sparePtr->tb4 = tu->as_bytes[4]; + sparePtr->tb5 = tu->as_bytes[5]; + sparePtr->tb6 = tu->as_bytes[6]; + sparePtr->tb7 = tu->as_bytes[7]; } -static void yaffs_get_tags_from_spare(yaffs_Device *dev, yaffs_Spare *sparePtr, - yaffs_Tags *tagsPtr) +static void yaffs_get_tags_from_spare(yaffs_dev_t *dev, yaffs_spare *sparePtr, + yaffs_tags_t *tagsPtr) { yaffs_tags_union_t *tu = (yaffs_tags_union_t *) tagsPtr; int result; - tu->asBytes[0] = sparePtr->tb0; - tu->asBytes[1] = sparePtr->tb1; - tu->asBytes[2] = sparePtr->tb2; - tu->asBytes[3] = sparePtr->tb3; - tu->asBytes[4] = sparePtr->tb4; - tu->asBytes[5] = sparePtr->tb5; - tu->asBytes[6] = sparePtr->tb6; - tu->asBytes[7] = sparePtr->tb7; + tu->as_bytes[0] = sparePtr->tb0; + tu->as_bytes[1] = sparePtr->tb1; + tu->as_bytes[2] = sparePtr->tb2; + tu->as_bytes[3] = sparePtr->tb3; + tu->as_bytes[4] = sparePtr->tb4; + tu->as_bytes[5] = sparePtr->tb5; + tu->as_bytes[6] = sparePtr->tb6; + tu->as_bytes[7] = sparePtr->tb7; result = yaffs_check_tags_ecc(tagsPtr); if (result > 0) - dev->tagsEccFixed++; + dev->n_tags_ecc_fixed++; else if (result < 0) - dev->tagsEccUnfixed++; + dev->n_tags_ecc_unfixed++; } -static void yaffs_spare_init(yaffs_Spare *spare) +static void yaffs_spare_init(yaffs_spare *spare) { - memset(spare, 0xFF, sizeof(yaffs_Spare)); + memset(spare, 0xFF, sizeof(yaffs_spare)); } -static int yaffs_wr_nand(struct yaffs_DeviceStruct *dev, - int chunkInNAND, const __u8 *data, - yaffs_Spare *spare) +static int yaffs_wr_nand(struct yaffs_dev_s *dev, + int nand_chunk, const __u8 *data, + yaffs_spare *spare) { - if (chunkInNAND < dev->param.startBlock * dev->param.nChunksPerBlock) { + if (nand_chunk < dev->param.start_block * dev->param.chunks_per_block) { T(YAFFS_TRACE_ERROR, (TSTR("**>> yaffs chunk %d is not valid" TENDSTR), - chunkInNAND)); + nand_chunk)); return YAFFS_FAIL; } - return dev->param.writeChunkToNAND(dev, chunkInNAND, data, spare); + return dev->param.write_chunk_fn(dev, nand_chunk, data, spare); } -static int yaffs_rd_chunk_nand(struct yaffs_DeviceStruct *dev, - int chunkInNAND, +static int yaffs_rd_chunk_nand(struct yaffs_dev_s *dev, + int nand_chunk, __u8 *data, - yaffs_Spare *spare, - yaffs_ECCResult *eccResult, + yaffs_spare *spare, + yaffs_ecc_result *ecc_result, int doErrorCorrection) { int retVal; - yaffs_Spare localSpare; + yaffs_spare localSpare; if (!spare && data) { /* If we don't have a real spare, then we use a local one. */ @@ -190,107 +190,107 @@ static int yaffs_rd_chunk_nand(struct yaffs_DeviceStruct *dev, spare = &localSpare; } - if (!dev->param.useNANDECC) { - retVal = dev->param.readChunkFromNAND(dev, chunkInNAND, data, spare); + if (!dev->param.use_nand_ecc) { + retVal = dev->param.read_chunk_fn(dev, nand_chunk, data, spare); if (data && doErrorCorrection) { /* Do ECC correction */ /* Todo handle any errors */ - int eccResult1, eccResult2; + int ecc_result1, ecc_result2; __u8 calcEcc[3]; yaffs_ecc_cacl(data, calcEcc); - eccResult1 = + ecc_result1 = yaffs_ecc_correct(data, spare->ecc1, calcEcc); yaffs_ecc_cacl(&data[256], calcEcc); - eccResult2 = + ecc_result2 = yaffs_ecc_correct(&data[256], spare->ecc2, calcEcc); - if (eccResult1 > 0) { + if (ecc_result1 > 0) { T(YAFFS_TRACE_ERROR, (TSTR ("**>>yaffs ecc error fix performed on chunk %d:0" - TENDSTR), chunkInNAND)); - dev->eccFixed++; - } else if (eccResult1 < 0) { + TENDSTR), nand_chunk)); + dev->n_ecc_fixed++; + } else if (ecc_result1 < 0) { T(YAFFS_TRACE_ERROR, (TSTR ("**>>yaffs ecc error unfixed on chunk %d:0" - TENDSTR), chunkInNAND)); - dev->eccUnfixed++; + TENDSTR), nand_chunk)); + dev->n_ecc_unfixed++; } - if (eccResult2 > 0) { + if (ecc_result2 > 0) { T(YAFFS_TRACE_ERROR, (TSTR ("**>>yaffs ecc error fix performed on chunk %d:1" - TENDSTR), chunkInNAND)); - dev->eccFixed++; - } else if (eccResult2 < 0) { + TENDSTR), nand_chunk)); + dev->n_ecc_fixed++; + } else if (ecc_result2 < 0) { T(YAFFS_TRACE_ERROR, (TSTR ("**>>yaffs ecc error unfixed on chunk %d:1" - TENDSTR), chunkInNAND)); - dev->eccUnfixed++; + TENDSTR), nand_chunk)); + dev->n_ecc_unfixed++; } - if (eccResult1 || eccResult2) { + if (ecc_result1 || ecc_result2) { /* We had a data problem on this page */ - yaffs_handle_rd_data_error(dev, chunkInNAND); + yaffs_handle_rd_data_error(dev, nand_chunk); } - if (eccResult1 < 0 || eccResult2 < 0) - *eccResult = YAFFS_ECC_RESULT_UNFIXED; - else if (eccResult1 > 0 || eccResult2 > 0) - *eccResult = YAFFS_ECC_RESULT_FIXED; + if (ecc_result1 < 0 || ecc_result2 < 0) + *ecc_result = YAFFS_ECC_RESULT_UNFIXED; + else if (ecc_result1 > 0 || ecc_result2 > 0) + *ecc_result = YAFFS_ECC_RESULT_FIXED; else - *eccResult = YAFFS_ECC_RESULT_NO_ERROR; + *ecc_result = YAFFS_ECC_RESULT_NO_ERROR; } } else { /* Must allocate enough memory for spare+2*sizeof(int) */ /* for ecc results from device. */ - struct yaffs_NANDSpare nspare; + struct yaffs_nand_spare nspare; memset(&nspare, 0, sizeof(nspare)); - retVal = dev->param.readChunkFromNAND(dev, chunkInNAND, data, - (yaffs_Spare *) &nspare); - memcpy(spare, &nspare, sizeof(yaffs_Spare)); + retVal = dev->param.read_chunk_fn(dev, nand_chunk, data, + (yaffs_spare *) &nspare); + memcpy(spare, &nspare, sizeof(yaffs_spare)); if (data && doErrorCorrection) { if (nspare.eccres1 > 0) { T(YAFFS_TRACE_ERROR, (TSTR ("**>>mtd ecc error fix performed on chunk %d:0" - TENDSTR), chunkInNAND)); + TENDSTR), nand_chunk)); } else if (nspare.eccres1 < 0) { T(YAFFS_TRACE_ERROR, (TSTR ("**>>mtd ecc error unfixed on chunk %d:0" - TENDSTR), chunkInNAND)); + TENDSTR), nand_chunk)); } if (nspare.eccres2 > 0) { T(YAFFS_TRACE_ERROR, (TSTR ("**>>mtd ecc error fix performed on chunk %d:1" - TENDSTR), chunkInNAND)); + TENDSTR), nand_chunk)); } else if (nspare.eccres2 < 0) { T(YAFFS_TRACE_ERROR, (TSTR ("**>>mtd ecc error unfixed on chunk %d:1" - TENDSTR), chunkInNAND)); + TENDSTR), nand_chunk)); } if (nspare.eccres1 || nspare.eccres2) { /* We had a data problem on this page */ - yaffs_handle_rd_data_error(dev, chunkInNAND); + yaffs_handle_rd_data_error(dev, nand_chunk); } if (nspare.eccres1 < 0 || nspare.eccres2 < 0) - *eccResult = YAFFS_ECC_RESULT_UNFIXED; + *ecc_result = YAFFS_ECC_RESULT_UNFIXED; else if (nspare.eccres1 > 0 || nspare.eccres2 > 0) - *eccResult = YAFFS_ECC_RESULT_FIXED; + *ecc_result = YAFFS_ECC_RESULT_FIXED; else - *eccResult = YAFFS_ECC_RESULT_NO_ERROR; + *ecc_result = YAFFS_ECC_RESULT_NO_ERROR; } } @@ -298,17 +298,17 @@ static int yaffs_rd_chunk_nand(struct yaffs_DeviceStruct *dev, } #ifdef NOTYET -static int yaffs_check_chunk_erased(struct yaffs_DeviceStruct *dev, - int chunkInNAND) +static int yaffs_check_chunk_erased(struct yaffs_dev_s *dev, + int nand_chunk) { static int init; static __u8 cmpbuf[YAFFS_BYTES_PER_CHUNK]; static __u8 data[YAFFS_BYTES_PER_CHUNK]; /* Might as well always allocate the larger size for */ - /* dev->param.useNANDECC == true; */ - static __u8 spare[sizeof(struct yaffs_NANDSpare)]; + /* dev->param.use_nand_ecc == true; */ + static __u8 spare[sizeof(struct yaffs_nand_spare)]; - dev->param.readChunkFromNAND(dev, chunkInNAND, data, (yaffs_Spare *) spare); + dev->param.read_chunk_fn(dev, nand_chunk, data, (yaffs_spare *) spare); if (!init) { memset(cmpbuf, 0xff, YAFFS_BYTES_PER_CHUNK); @@ -329,14 +329,14 @@ static int yaffs_check_chunk_erased(struct yaffs_DeviceStruct *dev, * Functions for robustisizing */ -static void yaffs_handle_rd_data_error(yaffs_Device *dev, int chunkInNAND) +static void yaffs_handle_rd_data_error(yaffs_dev_t *dev, int nand_chunk) { - int blockInNAND = chunkInNAND / dev->param.nChunksPerBlock; + int flash_block = nand_chunk / dev->param.chunks_per_block; /* Mark the block for retirement */ - yaffs_get_block_info(dev, blockInNAND + dev->blockOffset)->needsRetiring = 1; + yaffs_get_block_info(dev, flash_block + dev->block_offset)->needs_retiring = 1; T(YAFFS_TRACE_ERROR | YAFFS_TRACE_BAD_BLOCKS, - (TSTR("**>>Block %d marked for retirement" TENDSTR), blockInNAND)); + (TSTR("**>>Block %d marked for retirement" TENDSTR), flash_block)); /* TODO: * Just do a garbage collection on the affected block @@ -346,33 +346,33 @@ static void yaffs_handle_rd_data_error(yaffs_Device *dev, int chunkInNAND) } #ifdef NOTYET -static void yaffs_check_written_block(yaffs_Device *dev, int chunkInNAND) +static void yaffs_check_written_block(yaffs_dev_t *dev, int nand_chunk) { } -static void yaffs_handle_chunk_wr_ok(yaffs_Device *dev, int chunkInNAND, +static void yaffs_handle_chunk_wr_ok(yaffs_dev_t *dev, int nand_chunk, const __u8 *data, - const yaffs_Spare *spare) + const yaffs_spare *spare) { } -static void yaffs_handle_chunk_update(yaffs_Device *dev, int chunkInNAND, - const yaffs_Spare *spare) +static void yaffs_handle_chunk_update(yaffs_dev_t *dev, int nand_chunk, + const yaffs_spare *spare) { } -static void yaffs_handle_chunk_wr_error(yaffs_Device *dev, int chunkInNAND) +static void yaffs_handle_chunk_wr_error(yaffs_dev_t *dev, int nand_chunk) { - int blockInNAND = chunkInNAND / dev->param.nChunksPerBlock; + int flash_block = nand_chunk / dev->param.chunks_per_block; /* Mark the block for retirement */ - yaffs_get_block_info(dev, blockInNAND)->needsRetiring = 1; + yaffs_get_block_info(dev, flash_block)->needs_retiring = 1; /* Delete the chunk */ - yaffs_chunk_del(dev, chunkInNAND, 1, __LINE__); + yaffs_chunk_del(dev, nand_chunk, 1, __LINE__); } static int yaffs_verify_cmp(const __u8 *d0, const __u8 *d1, - const yaffs_Spare *s0, const yaffs_Spare *s1) + const yaffs_spare *s0, const yaffs_spare *s1) { if (memcmp(d0, d1, YAFFS_BYTES_PER_CHUNK) != 0 || @@ -396,53 +396,53 @@ static int yaffs_verify_cmp(const __u8 *d0, const __u8 *d1, } #endif /* NOTYET */ -int yaffs_tags_compat_wr(yaffs_Device *dev, - int chunkInNAND, +int yaffs_tags_compat_wr(yaffs_dev_t *dev, + int nand_chunk, const __u8 *data, - const yaffs_ExtendedTags *eTags) + const yaffs_ext_tags *eTags) { - yaffs_Spare spare; - yaffs_Tags tags; + yaffs_spare spare; + yaffs_tags_t tags; yaffs_spare_init(&spare); - if (eTags->chunkDeleted) - spare.pageStatus = 0; + if (eTags->is_deleted) + spare.page_status = 0; else { - tags.objectId = eTags->objectId; - tags.chunkId = eTags->chunkId; + tags.obj_id = eTags->obj_id; + tags.chunk_id = eTags->chunk_id; - tags.byteCountLSB = eTags->byteCount & 0x3ff; + tags.n_bytes_lsb = eTags->n_bytes & 0x3ff; - if (dev->nDataBytesPerChunk >= 1024) - tags.byteCountMSB = (eTags->byteCount >> 10) & 3; + if (dev->data_bytes_per_chunk >= 1024) + tags.n_bytes_msb = (eTags->n_bytes >> 10) & 3; else - tags.byteCountMSB = 3; + tags.n_bytes_msb = 3; - tags.serialNumber = eTags->serialNumber; + tags.serial_number = eTags->serial_number; - if (!dev->param.useNANDECC && data) + if (!dev->param.use_nand_ecc && data) yaffs_calc_ecc(data, &spare); yaffs_load_tags_to_spare(&spare, &tags); } - return yaffs_wr_nand(dev, chunkInNAND, data, &spare); + return yaffs_wr_nand(dev, nand_chunk, data, &spare); } -int yaffs_tags_compat_rd(yaffs_Device *dev, - int chunkInNAND, +int yaffs_tags_compat_rd(yaffs_dev_t *dev, + int nand_chunk, __u8 *data, - yaffs_ExtendedTags *eTags) + yaffs_ext_tags *eTags) { - yaffs_Spare spare; - yaffs_Tags tags; - yaffs_ECCResult eccResult = YAFFS_ECC_RESULT_UNKNOWN; + yaffs_spare spare; + yaffs_tags_t tags; + yaffs_ecc_result ecc_result = YAFFS_ECC_RESULT_UNKNOWN; - static yaffs_Spare spareFF; + static yaffs_spare spareFF; static int init; if (!init) { @@ -451,32 +451,32 @@ int yaffs_tags_compat_rd(yaffs_Device *dev, } if (yaffs_rd_chunk_nand - (dev, chunkInNAND, data, &spare, &eccResult, 1)) { + (dev, nand_chunk, data, &spare, &ecc_result, 1)) { /* eTags may be NULL */ if (eTags) { int deleted = - (yaffs_count_bits(spare.pageStatus) < 7) ? 1 : 0; + (yaffs_count_bits(spare.page_status) < 7) ? 1 : 0; - eTags->chunkDeleted = deleted; - eTags->eccResult = eccResult; - eTags->blockBad = 0; /* We're reading it */ + eTags->is_deleted = deleted; + eTags->ecc_result = ecc_result; + eTags->block_bad = 0; /* We're reading it */ /* therefore it is not a bad block */ - eTags->chunkUsed = + eTags->chunk_used = (memcmp(&spareFF, &spare, sizeof(spareFF)) != 0) ? 1 : 0; - if (eTags->chunkUsed) { + if (eTags->chunk_used) { yaffs_get_tags_from_spare(dev, &spare, &tags); - eTags->objectId = tags.objectId; - eTags->chunkId = tags.chunkId; - eTags->byteCount = tags.byteCountLSB; + eTags->obj_id = tags.obj_id; + eTags->chunk_id = tags.chunk_id; + eTags->n_bytes = tags.n_bytes_lsb; - if (dev->nDataBytesPerChunk >= 1024) - eTags->byteCount |= (((unsigned) tags.byteCountMSB) << 10); + if (dev->data_bytes_per_chunk >= 1024) + eTags->n_bytes |= (((unsigned) tags.n_bytes_msb) << 10); - eTags->serialNumber = tags.serialNumber; + eTags->serial_number = tags.serial_number; } } @@ -486,49 +486,49 @@ int yaffs_tags_compat_rd(yaffs_Device *dev, } } -int yaffs_tags_compat_mark_bad(struct yaffs_DeviceStruct *dev, - int blockInNAND) +int yaffs_tags_compat_mark_bad(struct yaffs_dev_s *dev, + int flash_block) { - yaffs_Spare spare; + yaffs_spare spare; - memset(&spare, 0xff, sizeof(yaffs_Spare)); + memset(&spare, 0xff, sizeof(yaffs_spare)); - spare.blockStatus = 'Y'; + spare.block_status = 'Y'; - yaffs_wr_nand(dev, blockInNAND * dev->param.nChunksPerBlock, NULL, + yaffs_wr_nand(dev, flash_block * dev->param.chunks_per_block, NULL, &spare); - yaffs_wr_nand(dev, blockInNAND * dev->param.nChunksPerBlock + 1, + yaffs_wr_nand(dev, flash_block * dev->param.chunks_per_block + 1, NULL, &spare); return YAFFS_OK; } -int yaffs_tags_compat_query_block(struct yaffs_DeviceStruct *dev, - int blockNo, - yaffs_BlockState *state, - __u32 *sequenceNumber) +int yaffs_tags_compat_query_block(struct yaffs_dev_s *dev, + int block_no, + yaffs_block_state_t *state, + __u32 *seq_number) { - yaffs_Spare spare0, spare1; - static yaffs_Spare spareFF; + yaffs_spare spare0, spare1; + static yaffs_spare spareFF; static int init; - yaffs_ECCResult dummy; + yaffs_ecc_result dummy; if (!init) { memset(&spareFF, 0xFF, sizeof(spareFF)); init = 1; } - *sequenceNumber = 0; + *seq_number = 0; - yaffs_rd_chunk_nand(dev, blockNo * dev->param.nChunksPerBlock, NULL, + yaffs_rd_chunk_nand(dev, block_no * dev->param.chunks_per_block, NULL, &spare0, &dummy, 1); - yaffs_rd_chunk_nand(dev, blockNo * dev->param.nChunksPerBlock + 1, NULL, + yaffs_rd_chunk_nand(dev, block_no * dev->param.chunks_per_block + 1, NULL, &spare1, &dummy, 1); - if (yaffs_count_bits(spare0.blockStatus & spare1.blockStatus) < 7) + if (yaffs_count_bits(spare0.block_status & spare1.block_status) < 7) *state = YAFFS_BLOCK_STATE_DEAD; else if (memcmp(&spareFF, &spare0, sizeof(spareFF)) == 0) *state = YAFFS_BLOCK_STATE_EMPTY; diff --git a/yaffs_tagscompat.h b/yaffs_tagscompat.h index 300fb67..889bf5f 100644 --- a/yaffs_tagscompat.h +++ b/yaffs_tagscompat.h @@ -17,23 +17,23 @@ #define __YAFFS_TAGSCOMPAT_H__ #include "yaffs_guts.h" -int yaffs_tags_compat_wr(yaffs_Device *dev, - int chunkInNAND, +int yaffs_tags_compat_wr(yaffs_dev_t *dev, + int nand_chunk, const __u8 *data, - const yaffs_ExtendedTags *tags); -int yaffs_tags_compat_rd(yaffs_Device *dev, - int chunkInNAND, + const yaffs_ext_tags *tags); +int yaffs_tags_compat_rd(yaffs_dev_t *dev, + int nand_chunk, __u8 *data, - yaffs_ExtendedTags *tags); -int yaffs_tags_compat_mark_bad(struct yaffs_DeviceStruct *dev, - int blockNo); -int yaffs_tags_compat_query_block(struct yaffs_DeviceStruct *dev, - int blockNo, - yaffs_BlockState *state, - __u32 *sequenceNumber); + yaffs_ext_tags *tags); +int yaffs_tags_compat_mark_bad(struct yaffs_dev_s *dev, + int block_no); +int yaffs_tags_compat_query_block(struct yaffs_dev_s *dev, + int block_no, + yaffs_block_state_t *state, + __u32 *seq_number); -void yaffs_calc_tags_ecc(yaffs_Tags *tags); -int yaffs_check_tags_ecc(yaffs_Tags *tags); +void yaffs_calc_tags_ecc(yaffs_tags_t *tags); +int yaffs_check_tags_ecc(yaffs_tags_t *tags); int yaffs_count_bits(__u8 byte); #endif diff --git a/yaffs_tagsvalidity.c b/yaffs_tagsvalidity.c index 43ce44e..787cdba 100644 --- a/yaffs_tagsvalidity.c +++ b/yaffs_tagsvalidity.c @@ -13,16 +13,16 @@ #include "yaffs_tagsvalidity.h" -void yaffs_init_tags(yaffs_ExtendedTags *tags) +void yaffs_init_tags(yaffs_ext_tags *tags) { - memset(tags, 0, sizeof(yaffs_ExtendedTags)); - tags->validMarker0 = 0xAAAAAAAA; - tags->validMarker1 = 0x55555555; + memset(tags, 0, sizeof(yaffs_ext_tags)); + tags->validity1 = 0xAAAAAAAA; + tags->validty1 = 0x55555555; } -int yaffs_validate_tags(yaffs_ExtendedTags *tags) +int yaffs_validate_tags(yaffs_ext_tags *tags) { - return (tags->validMarker0 == 0xAAAAAAAA && - tags->validMarker1 == 0x55555555); + return (tags->validity1 == 0xAAAAAAAA && + tags->validty1 == 0x55555555); } diff --git a/yaffs_tagsvalidity.h b/yaffs_tagsvalidity.h index 7f0b449..085056c 100644 --- a/yaffs_tagsvalidity.h +++ b/yaffs_tagsvalidity.h @@ -19,6 +19,6 @@ #include "yaffs_guts.h" -void yaffs_init_tags(yaffs_ExtendedTags *tags); -int yaffs_validate_tags(yaffs_ExtendedTags *tags); +void yaffs_init_tags(yaffs_ext_tags *tags); +int yaffs_validate_tags(yaffs_ext_tags *tags); #endif diff --git a/yaffs_verify.c b/yaffs_verify.c index 8285702..39d16e6 100644 --- a/yaffs_verify.c +++ b/yaffs_verify.c @@ -18,26 +18,26 @@ #include "yaffs_getblockinfo.h" #include "yaffs_nand.h" -int yaffs_skip_verification(yaffs_Device *dev) +int yaffs_skip_verification(yaffs_dev_t *dev) { dev=dev; return !(yaffs_trace_mask & (YAFFS_TRACE_VERIFY | YAFFS_TRACE_VERIFY_FULL)); } -static int yaffs_skip_full_verification(yaffs_Device *dev) +static int yaffs_skip_full_verification(yaffs_dev_t *dev) { dev=dev; return !(yaffs_trace_mask & (YAFFS_TRACE_VERIFY_FULL)); } -static int yaffs_skip_nand_verification(yaffs_Device *dev) +static int yaffs_skip_nand_verification(yaffs_dev_t *dev) { dev=dev; return !(yaffs_trace_mask & (YAFFS_TRACE_VERIFY_NAND)); } -static const char *blockStateName[] = { +static const char *block_stateName[] = { "Unknown", "Needs scanning", "Scanning", @@ -51,7 +51,7 @@ static const char *blockStateName[] = { }; -void yaffs_verify_blk(yaffs_Device *dev, yaffs_BlockInfo *bi, int n) +void yaffs_verify_blk(yaffs_dev_t *dev, yaffs_block_info_t *bi, int n) { int actuallyUsed; int inUse; @@ -60,52 +60,52 @@ void yaffs_verify_blk(yaffs_Device *dev, yaffs_BlockInfo *bi, int n) return; /* Report illegal runtime states */ - if (bi->blockState >= YAFFS_NUMBER_OF_BLOCK_STATES) - T(YAFFS_TRACE_VERIFY, (TSTR("Block %d has undefined state %d"TENDSTR), n, bi->blockState)); + if (bi->block_state >= YAFFS_NUMBER_OF_BLOCK_STATES) + T(YAFFS_TRACE_VERIFY, (TSTR("Block %d has undefined state %d"TENDSTR), n, bi->block_state)); - switch (bi->blockState) { + switch (bi->block_state) { case YAFFS_BLOCK_STATE_UNKNOWN: case YAFFS_BLOCK_STATE_SCANNING: case YAFFS_BLOCK_STATE_NEEDS_SCANNING: T(YAFFS_TRACE_VERIFY, (TSTR("Block %d has bad run-state %s"TENDSTR), - n, blockStateName[bi->blockState])); + n, block_stateName[bi->block_state])); } /* Check pages in use and soft deletions are legal */ - actuallyUsed = bi->pagesInUse - bi->softDeletions; + actuallyUsed = bi->pages_in_use - bi->soft_del_pages; - if (bi->pagesInUse < 0 || bi->pagesInUse > dev->param.nChunksPerBlock || - bi->softDeletions < 0 || bi->softDeletions > dev->param.nChunksPerBlock || - actuallyUsed < 0 || actuallyUsed > dev->param.nChunksPerBlock) - T(YAFFS_TRACE_VERIFY, (TSTR("Block %d has illegal values pagesInUsed %d softDeletions %d"TENDSTR), - n, bi->pagesInUse, bi->softDeletions)); + if (bi->pages_in_use < 0 || bi->pages_in_use > dev->param.chunks_per_block || + bi->soft_del_pages < 0 || bi->soft_del_pages > dev->param.chunks_per_block || + actuallyUsed < 0 || actuallyUsed > dev->param.chunks_per_block) + T(YAFFS_TRACE_VERIFY, (TSTR("Block %d has illegal values pages_in_used %d soft_del_pages %d"TENDSTR), + n, bi->pages_in_use, bi->soft_del_pages)); /* Check chunk bitmap legal */ inUse = yaffs_count_chunk_bits(dev, n); - if (inUse != bi->pagesInUse) - T(YAFFS_TRACE_VERIFY, (TSTR("Block %d has inconsistent values pagesInUse %d counted chunk bits %d"TENDSTR), - n, bi->pagesInUse, inUse)); + if (inUse != bi->pages_in_use) + T(YAFFS_TRACE_VERIFY, (TSTR("Block %d has inconsistent values pages_in_use %d counted chunk bits %d"TENDSTR), + n, bi->pages_in_use, inUse)); } -void yaffs_verify_collected_blk(yaffs_Device *dev, yaffs_BlockInfo *bi, int n) +void yaffs_verify_collected_blk(yaffs_dev_t *dev, yaffs_block_info_t *bi, int n) { yaffs_verify_blk(dev, bi, n); /* After collection the block should be in the erased state */ - if (bi->blockState != YAFFS_BLOCK_STATE_COLLECTING && - bi->blockState != YAFFS_BLOCK_STATE_EMPTY) { + if (bi->block_state != YAFFS_BLOCK_STATE_COLLECTING && + bi->block_state != YAFFS_BLOCK_STATE_EMPTY) { T(YAFFS_TRACE_ERROR, (TSTR("Block %d is in state %d after gc, should be erased"TENDSTR), - n, bi->blockState)); + n, bi->block_state)); } } -void yaffs_verify_blocks(yaffs_Device *dev) +void yaffs_verify_blocks(yaffs_dev_t *dev) { int i; int nBlocksPerState[YAFFS_NUMBER_OF_BLOCK_STATES]; @@ -116,12 +116,12 @@ void yaffs_verify_blocks(yaffs_Device *dev) memset(nBlocksPerState, 0, sizeof(nBlocksPerState)); - for (i = dev->internalStartBlock; i <= dev->internalEndBlock; i++) { - yaffs_BlockInfo *bi = yaffs_get_block_info(dev, i); + for (i = dev->internal_start_block; i <= dev->internal_end_block; i++) { + yaffs_block_info_t *bi = yaffs_get_block_info(dev, i); yaffs_verify_blk(dev, bi, i); - if (bi->blockState < YAFFS_NUMBER_OF_BLOCK_STATES) - nBlocksPerState[bi->blockState]++; + if (bi->block_state < YAFFS_NUMBER_OF_BLOCK_STATES) + nBlocksPerState[bi->block_state]++; else nIllegalBlockStates++; } @@ -136,17 +136,17 @@ void yaffs_verify_blocks(yaffs_Device *dev) for (i = 0; i < YAFFS_NUMBER_OF_BLOCK_STATES; i++) T(YAFFS_TRACE_VERIFY, (TSTR("%s %d blocks"TENDSTR), - blockStateName[i], nBlocksPerState[i])); + block_stateName[i], nBlocksPerState[i])); - if (dev->blocksInCheckpoint != nBlocksPerState[YAFFS_BLOCK_STATE_CHECKPOINT]) + if (dev->blocks_in_checkpt != nBlocksPerState[YAFFS_BLOCK_STATE_CHECKPOINT]) T(YAFFS_TRACE_VERIFY, (TSTR("Checkpoint block count wrong dev %d count %d"TENDSTR), - dev->blocksInCheckpoint, nBlocksPerState[YAFFS_BLOCK_STATE_CHECKPOINT])); + dev->blocks_in_checkpt, nBlocksPerState[YAFFS_BLOCK_STATE_CHECKPOINT])); - if (dev->nErasedBlocks != nBlocksPerState[YAFFS_BLOCK_STATE_EMPTY]) + if (dev->n_erased_blocks != nBlocksPerState[YAFFS_BLOCK_STATE_EMPTY]) T(YAFFS_TRACE_VERIFY, (TSTR("Erased block count wrong dev %d count %d"TENDSTR), - dev->nErasedBlocks, nBlocksPerState[YAFFS_BLOCK_STATE_EMPTY])); + dev->n_erased_blocks, nBlocksPerState[YAFFS_BLOCK_STATE_EMPTY])); if (nBlocksPerState[YAFFS_BLOCK_STATE_COLLECTING] > 1) T(YAFFS_TRACE_VERIFY, @@ -161,9 +161,9 @@ void yaffs_verify_blocks(yaffs_Device *dev) * Verify the object header. oh must be valid, but obj and tags may be NULL in which * case those tests will not be performed. */ -void yaffs_verify_oh(yaffs_Object *obj, yaffs_ObjectHeader *oh, yaffs_ExtendedTags *tags, int parentCheck) +void yaffs_verify_oh(yaffs_obj_t *obj, yaffs_obj_header *oh, yaffs_ext_tags *tags, int parentCheck) { - if (obj && yaffs_skip_verification(obj->myDev)) + if (obj && yaffs_skip_verification(obj->my_dev)) return; if (!(tags && obj && oh)) { @@ -177,12 +177,12 @@ void yaffs_verify_oh(yaffs_Object *obj, yaffs_ObjectHeader *oh, yaffs_ExtendedTa oh->type > YAFFS_OBJECT_TYPE_MAX) T(YAFFS_TRACE_VERIFY, (TSTR("Obj %d header type is illegal value 0x%x"TENDSTR), - tags->objectId, oh->type)); + tags->obj_id, oh->type)); - if (tags->objectId != obj->objectId) + if (tags->obj_id != obj->obj_id) T(YAFFS_TRACE_VERIFY, - (TSTR("Obj %d header mismatch objectId %d"TENDSTR), - tags->objectId, obj->objectId)); + (TSTR("Obj %d header mismatch obj_id %d"TENDSTR), + tags->obj_id, obj->obj_id)); /* @@ -191,38 +191,38 @@ void yaffs_verify_oh(yaffs_Object *obj, yaffs_ObjectHeader *oh, yaffs_ExtendedTa * Tests do not apply to the root object. */ - if (parentCheck && tags->objectId > 1 && !obj->parent) + if (parentCheck && tags->obj_id > 1 && !obj->parent) T(YAFFS_TRACE_VERIFY, - (TSTR("Obj %d header mismatch parentId %d obj->parent is NULL"TENDSTR), - tags->objectId, oh->parentObjectId)); + (TSTR("Obj %d header mismatch parent_id %d obj->parent is NULL"TENDSTR), + tags->obj_id, oh->parent_obj_id)); if (parentCheck && obj->parent && - oh->parentObjectId != obj->parent->objectId && - (oh->parentObjectId != YAFFS_OBJECTID_UNLINKED || - obj->parent->objectId != YAFFS_OBJECTID_DELETED)) + oh->parent_obj_id != obj->parent->obj_id && + (oh->parent_obj_id != YAFFS_OBJECTID_UNLINKED || + obj->parent->obj_id != YAFFS_OBJECTID_DELETED)) T(YAFFS_TRACE_VERIFY, - (TSTR("Obj %d header mismatch parentId %d parentObjectId %d"TENDSTR), - tags->objectId, oh->parentObjectId, obj->parent->objectId)); + (TSTR("Obj %d header mismatch parent_id %d parent_obj_id %d"TENDSTR), + tags->obj_id, oh->parent_obj_id, obj->parent->obj_id)); - if (tags->objectId > 1 && oh->name[0] == 0) /* Null name */ + if (tags->obj_id > 1 && oh->name[0] == 0) /* Null name */ T(YAFFS_TRACE_VERIFY, (TSTR("Obj %d header name is NULL"TENDSTR), - obj->objectId)); + obj->obj_id)); - if (tags->objectId > 1 && ((__u8)(oh->name[0])) == 0xff) /* Trashed name */ + if (tags->obj_id > 1 && ((__u8)(oh->name[0])) == 0xff) /* Trashed name */ T(YAFFS_TRACE_VERIFY, (TSTR("Obj %d header name is 0xFF"TENDSTR), - obj->objectId)); + obj->obj_id)); } #if 0 /* Not being used, but don't want to throw away yet */ -int yaffs_verify_tnode_worker(yaffs_Object *obj, yaffs_tnode_t *tn, - __u32 level, int chunkOffset) +int yaffs_verify_tnode_worker(yaffs_obj_t *obj, yaffs_tnode_t *tn, + __u32 level, int chunk_offset) { int i; - yaffs_Device *dev = obj->myDev; + yaffs_dev_t *dev = obj->my_dev; int ok = 1; if (tn) { @@ -233,28 +233,28 @@ int yaffs_verify_tnode_worker(yaffs_Object *obj, yaffs_tnode_t *tn, ok = yaffs_verify_tnode_worker(obj, tn->internal[i], level - 1, - (chunkOffset<<YAFFS_TNODES_INTERNAL_BITS) + i); + (chunk_offset<<YAFFS_TNODES_INTERNAL_BITS) + i); } } } else if (level == 0) { - yaffs_ExtendedTags tags; - __u32 objectId = obj->objectId; + yaffs_ext_tags tags; + __u32 obj_id = obj->obj_id; - chunkOffset <<= YAFFS_TNODES_LEVEL0_BITS; + chunk_offset <<= YAFFS_TNODES_LEVEL0_BITS; for (i = 0; i < YAFFS_NTNODES_LEVEL0; i++) { __u32 theChunk = yaffs_get_group_base(dev, tn, i); if (theChunk > 0) { - /* T(~0,(TSTR("verifying (%d:%d) %d"TENDSTR),tags.objectId,tags.chunkId,theChunk)); */ + /* T(~0,(TSTR("verifying (%d:%d) %d"TENDSTR),tags.obj_id,tags.chunk_id,theChunk)); */ yaffs_rd_chunk_tags_nand(dev, theChunk, NULL, &tags); - if (tags.objectId != objectId || tags.chunkId != chunkOffset) { - T(~0, (TSTR("Object %d chunkId %d NAND mismatch chunk %d tags (%d:%d)"TENDSTR), - objectId, chunkOffset, theChunk, - tags.objectId, tags.chunkId)); + if (tags.obj_id != obj_id || tags.chunk_id != chunk_offset) { + T(~0, (TSTR("Object %d chunk_id %d NAND mismatch chunk %d tags (%d:%d)"TENDSTR), + obj_id, chunk_offset, theChunk, + tags.obj_id, tags.chunk_id)); } } - chunkOffset++; + chunk_offset++; } } } @@ -265,29 +265,29 @@ int yaffs_verify_tnode_worker(yaffs_Object *obj, yaffs_tnode_t *tn, #endif -void yaffs_verify_file(yaffs_Object *obj) +void yaffs_verify_file(yaffs_obj_t *obj) { int requiredTallness; int actualTallness; __u32 lastChunk; __u32 x; __u32 i; - yaffs_Device *dev; - yaffs_ExtendedTags tags; + yaffs_dev_t *dev; + yaffs_ext_tags tags; yaffs_tnode_t *tn; - __u32 objectId; + __u32 obj_id; if (!obj) return; - if (yaffs_skip_verification(obj->myDev)) + if (yaffs_skip_verification(obj->my_dev)) return; - dev = obj->myDev; - objectId = obj->objectId; + dev = obj->my_dev; + obj_id = obj->obj_id; /* Check file size is consistent with tnode depth */ - lastChunk = obj->variant.fileVariant.fileSize / dev->nDataBytesPerChunk + 1; + lastChunk = obj->variant.file_variant.file_size / dev->data_bytes_per_chunk + 1; x = lastChunk >> YAFFS_TNODES_LEVEL0_BITS; requiredTallness = 0; while (x > 0) { @@ -295,7 +295,7 @@ void yaffs_verify_file(yaffs_Object *obj) requiredTallness++; } - actualTallness = obj->variant.fileVariant.topLevel; + actualTallness = obj->variant.file_variant.top_level; /* Check that the chunks in the tnode tree are all correct. * We do this by scanning through the tnode tree and @@ -306,17 +306,17 @@ void yaffs_verify_file(yaffs_Object *obj) return; for (i = 1; i <= lastChunk; i++) { - tn = yaffs_find_tnode_0(dev, &obj->variant.fileVariant, i); + tn = yaffs_find_tnode_0(dev, &obj->variant.file_variant, i); if (tn) { __u32 theChunk = yaffs_get_group_base(dev, tn, i); if (theChunk > 0) { - /* T(~0,(TSTR("verifying (%d:%d) %d"TENDSTR),objectId,i,theChunk)); */ + /* T(~0,(TSTR("verifying (%d:%d) %d"TENDSTR),obj_id,i,theChunk)); */ yaffs_rd_chunk_tags_nand(dev, theChunk, NULL, &tags); - if (tags.objectId != objectId || tags.chunkId != i) { - T(~0, (TSTR("Object %d chunkId %d NAND mismatch chunk %d tags (%d:%d)"TENDSTR), - objectId, i, theChunk, - tags.objectId, tags.chunkId)); + if (tags.obj_id != obj_id || tags.chunk_id != i) { + T(~0, (TSTR("Object %d chunk_id %d NAND mismatch chunk %d tags (%d:%d)"TENDSTR), + obj_id, i, theChunk, + tags.obj_id, tags.chunk_id)); } } } @@ -324,36 +324,36 @@ void yaffs_verify_file(yaffs_Object *obj) } -void yaffs_verify_link(yaffs_Object *obj) +void yaffs_verify_link(yaffs_obj_t *obj) { - if (obj && yaffs_skip_verification(obj->myDev)) + if (obj && yaffs_skip_verification(obj->my_dev)) return; /* Verify sane equivalent object */ } -void yaffs_verify_symlink(yaffs_Object *obj) +void yaffs_verify_symlink(yaffs_obj_t *obj) { - if (obj && yaffs_skip_verification(obj->myDev)) + if (obj && yaffs_skip_verification(obj->my_dev)) return; /* Verify symlink string */ } -void yaffs_verify_special(yaffs_Object *obj) +void yaffs_verify_special(yaffs_obj_t *obj) { - if (obj && yaffs_skip_verification(obj->myDev)) + if (obj && yaffs_skip_verification(obj->my_dev)) return; } -void yaffs_verify_obj(yaffs_Object *obj) +void yaffs_verify_obj(yaffs_obj_t *obj) { - yaffs_Device *dev; + yaffs_dev_t *dev; __u32 chunkMin; __u32 chunkMax; - __u32 chunkIdOk; + __u32 chunk_idOk; __u32 chunkInRange; __u32 chunkShouldNotBeDeleted; __u32 chunkValid; @@ -361,44 +361,44 @@ void yaffs_verify_obj(yaffs_Object *obj) if (!obj) return; - if (obj->beingCreated) + if (obj->being_created) return; - dev = obj->myDev; + dev = obj->my_dev; if (yaffs_skip_verification(dev)) return; /* Check sane object header chunk */ - chunkMin = dev->internalStartBlock * dev->param.nChunksPerBlock; - chunkMax = (dev->internalEndBlock+1) * dev->param.nChunksPerBlock - 1; + chunkMin = dev->internal_start_block * dev->param.chunks_per_block; + chunkMax = (dev->internal_end_block+1) * dev->param.chunks_per_block - 1; - chunkInRange = (((unsigned)(obj->hdrChunk)) >= chunkMin && ((unsigned)(obj->hdrChunk)) <= chunkMax); - chunkIdOk = chunkInRange || (obj->hdrChunk == 0); + chunkInRange = (((unsigned)(obj->hdr_chunk)) >= chunkMin && ((unsigned)(obj->hdr_chunk)) <= chunkMax); + chunk_idOk = chunkInRange || (obj->hdr_chunk == 0); chunkValid = chunkInRange && yaffs_check_chunk_bit(dev, - obj->hdrChunk / dev->param.nChunksPerBlock, - obj->hdrChunk % dev->param.nChunksPerBlock); + obj->hdr_chunk / dev->param.chunks_per_block, + obj->hdr_chunk % dev->param.chunks_per_block); chunkShouldNotBeDeleted = chunkInRange && !chunkValid; if (!obj->fake && - (!chunkIdOk || chunkShouldNotBeDeleted)) { + (!chunk_idOk || chunkShouldNotBeDeleted)) { T(YAFFS_TRACE_VERIFY, - (TSTR("Obj %d has chunkId %d %s %s"TENDSTR), - obj->objectId, obj->hdrChunk, - chunkIdOk ? "" : ",out of range", + (TSTR("Obj %d has chunk_id %d %s %s"TENDSTR), + obj->obj_id, obj->hdr_chunk, + chunk_idOk ? "" : ",out of range", chunkShouldNotBeDeleted ? ",marked as deleted" : "")); } if (chunkValid && !yaffs_skip_nand_verification(dev)) { - yaffs_ExtendedTags tags; - yaffs_ObjectHeader *oh; + yaffs_ext_tags tags; + yaffs_obj_header *oh; __u8 *buffer = yaffs_get_temp_buffer(dev, __LINE__); - oh = (yaffs_ObjectHeader *)buffer; + oh = (yaffs_obj_header *)buffer; - yaffs_rd_chunk_tags_nand(dev, obj->hdrChunk, buffer, + yaffs_rd_chunk_tags_nand(dev, obj->hdr_chunk, buffer, &tags); yaffs_verify_oh(obj, oh, &tags, 1); @@ -408,20 +408,20 @@ void yaffs_verify_obj(yaffs_Object *obj) /* Verify it has a parent */ if (obj && !obj->fake && - (!obj->parent || obj->parent->myDev != dev)) { + (!obj->parent || obj->parent->my_dev != dev)) { T(YAFFS_TRACE_VERIFY, (TSTR("Obj %d has parent pointer %p which does not look like an object"TENDSTR), - obj->objectId, obj->parent)); + obj->obj_id, obj->parent)); } /* Verify parent is a directory */ - if (obj->parent && obj->parent->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) { + if (obj->parent && obj->parent->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) { T(YAFFS_TRACE_VERIFY, (TSTR("Obj %d's parent is not a directory (type %d)"TENDSTR), - obj->objectId, obj->parent->variantType)); + obj->obj_id, obj->parent->variant_type)); } - switch (obj->variantType) { + switch (obj->variant_type) { case YAFFS_OBJECT_TYPE_FILE: yaffs_verify_file(obj); break; @@ -441,14 +441,14 @@ void yaffs_verify_obj(yaffs_Object *obj) default: T(YAFFS_TRACE_VERIFY, (TSTR("Obj %d has illegaltype %d"TENDSTR), - obj->objectId, obj->variantType)); + obj->obj_id, obj->variant_type)); break; } } -void yaffs_verify_objects(yaffs_Device *dev) +void yaffs_verify_objects(yaffs_dev_t *dev) { - yaffs_Object *obj; + yaffs_obj_t *obj; int i; struct ylist_head *lh; @@ -458,9 +458,9 @@ void yaffs_verify_objects(yaffs_Device *dev) /* Iterate through the objects in each hash entry */ for (i = 0; i < YAFFS_NOBJECT_BUCKETS; i++) { - ylist_for_each(lh, &dev->objectBucket[i].list) { + ylist_for_each(lh, &dev->obj_bucket[i].list) { if (lh) { - obj = ylist_entry(lh, yaffs_Object, hashLink); + obj = ylist_entry(lh, yaffs_obj_t, hash_link); yaffs_verify_obj(obj); } } @@ -468,10 +468,10 @@ void yaffs_verify_objects(yaffs_Device *dev) } -void yaffs_verify_obj_in_dir(yaffs_Object *obj) +void yaffs_verify_obj_in_dir(yaffs_obj_t *obj) { struct ylist_head *lh; - yaffs_Object *listObj; + yaffs_obj_t *listObj; int count = 0; @@ -481,7 +481,7 @@ void yaffs_verify_obj_in_dir(yaffs_Object *obj) return; } - if (yaffs_skip_verification(obj->myDev)) + if (yaffs_skip_verification(obj->my_dev)) return; if (!obj->parent) { @@ -490,16 +490,16 @@ void yaffs_verify_obj_in_dir(yaffs_Object *obj) return; } - if (obj->parent->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) { + if (obj->parent->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) { T(YAFFS_TRACE_ALWAYS, (TSTR("Parent is not directory" TENDSTR))); YBUG(); } /* Iterate through the objects in each hash entry */ - ylist_for_each(lh, &obj->parent->variant.directoryVariant.children) { + ylist_for_each(lh, &obj->parent->variant.dir_variant.children) { if (lh) { - listObj = ylist_entry(lh, yaffs_Object, siblings); + listObj = ylist_entry(lh, yaffs_obj_t, siblings); yaffs_verify_obj(listObj); if (obj == listObj) count++; @@ -512,29 +512,29 @@ void yaffs_verify_obj_in_dir(yaffs_Object *obj) } } -void yaffs_verify_dir(yaffs_Object *directory) +void yaffs_verify_dir(yaffs_obj_t *directory) { struct ylist_head *lh; - yaffs_Object *listObj; + yaffs_obj_t *listObj; if (!directory) { YBUG(); return; } - if (yaffs_skip_full_verification(directory->myDev)) + if (yaffs_skip_full_verification(directory->my_dev)) return; - if (directory->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) { - T(YAFFS_TRACE_ALWAYS, (TSTR("Directory has wrong type: %d" TENDSTR), directory->variantType)); + if (directory->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) { + T(YAFFS_TRACE_ALWAYS, (TSTR("Directory has wrong type: %d" TENDSTR), directory->variant_type)); YBUG(); } /* Iterate through the objects in each hash entry */ - ylist_for_each(lh, &directory->variant.directoryVariant.children) { + ylist_for_each(lh, &directory->variant.dir_variant.children) { if (lh) { - listObj = ylist_entry(lh, yaffs_Object, siblings); + listObj = ylist_entry(lh, yaffs_obj_t, siblings); if (listObj->parent != directory) { T(YAFFS_TRACE_ALWAYS, (TSTR("Object in directory list has wrong parent %p" TENDSTR), listObj->parent)); YBUG(); @@ -546,7 +546,7 @@ void yaffs_verify_dir(yaffs_Object *directory) static int yaffs_free_verification_failures; -void yaffs_verify_free_chunks(yaffs_Device *dev) +void yaffs_verify_free_chunks(yaffs_dev_t *dev) { int counted; int difference; @@ -556,40 +556,40 @@ void yaffs_verify_free_chunks(yaffs_Device *dev) counted = yaffs_count_free_chunks(dev); - difference = dev->nFreeChunks - counted; + difference = dev->n_free_chunks - counted; if (difference) { T(YAFFS_TRACE_ALWAYS, (TSTR("Freechunks verification failure %d %d %d" TENDSTR), - dev->nFreeChunks, counted, difference)); + dev->n_free_chunks, counted, difference)); yaffs_free_verification_failures++; } } -int yaffs_verify_file_sane(yaffs_Object *in) +int yaffs_verify_file_sane(yaffs_obj_t *in) { #if 0 int chunk; - int nChunks; + int n_chunks; int fSize; int failed = 0; - int objId; + int obj_id; yaffs_tnode_t *tn; - yaffs_Tags localTags; - yaffs_Tags *tags = &localTags; + yaffs_tags_t localTags; + yaffs_tags_t *tags = &localTags; int theChunk; - int chunkDeleted; + int is_deleted; - if (in->variantType != YAFFS_OBJECT_TYPE_FILE) + if (in->variant_type != YAFFS_OBJECT_TYPE_FILE) return YAFFS_FAIL; - objId = in->objectId; - fSize = in->variant.fileVariant.fileSize; - nChunks = - (fSize + in->myDev->nDataBytesPerChunk - 1) / in->myDev->nDataBytesPerChunk; + obj_id = in->obj_id; + fSize = in->variant.file_variant.file_size; + n_chunks = + (fSize + in->my_dev->data_bytes_per_chunk - 1) / in->my_dev->data_bytes_per_chunk; - for (chunk = 1; chunk <= nChunks; chunk++) { - tn = yaffs_find_tnode_0(in->myDev, &in->variant.fileVariant, + for (chunk = 1; chunk <= n_chunks; chunk++) { + tn = yaffs_find_tnode_0(in->my_dev, &in->variant.file_variant, chunk); if (tn) { @@ -597,14 +597,14 @@ int yaffs_verify_file_sane(yaffs_Object *in) theChunk = yaffs_get_group_base(dev, tn, chunk); if (yaffs_check_chunk_bits - (dev, theChunk / dev->param.nChunksPerBlock, - theChunk % dev->param.nChunksPerBlock)) { + (dev, theChunk / dev->param.chunks_per_block, + theChunk % dev->param.chunks_per_block)) { - yaffs_rd_chunk_tags_nand(in->myDev, theChunk, + yaffs_rd_chunk_tags_nand(in->my_dev, theChunk, tags, - &chunkDeleted); + &is_deleted); if (yaffs_tags_match - (tags, in->objectId, chunk, chunkDeleted)) { + (tags, in->obj_id, chunk, is_deleted)) { /* found it; */ } diff --git a/yaffs_verify.h b/yaffs_verify.h index ba806ec..5ec808a 100644 --- a/yaffs_verify.h +++ b/yaffs_verify.h @@ -16,24 +16,24 @@ #include "yaffs_guts.h" -void yaffs_verify_blk(yaffs_Device *dev, yaffs_BlockInfo *bi, int n); -void yaffs_verify_collected_blk(yaffs_Device *dev, yaffs_BlockInfo *bi, int n); -void yaffs_verify_blocks(yaffs_Device *dev); - -void yaffs_verify_oh(yaffs_Object *obj, yaffs_ObjectHeader *oh, yaffs_ExtendedTags *tags, int parentCheck); -void yaffs_verify_file(yaffs_Object *obj); -void yaffs_verify_link(yaffs_Object *obj); -void yaffs_verify_symlink(yaffs_Object *obj); -void yaffs_verify_special(yaffs_Object *obj); -void yaffs_verify_obj(yaffs_Object *obj); -void yaffs_verify_objects(yaffs_Device *dev); -void yaffs_verify_obj_in_dir(yaffs_Object *obj); -void yaffs_verify_dir(yaffs_Object *directory); -void yaffs_verify_free_chunks(yaffs_Device *dev); - -int yaffs_verify_file_sane(yaffs_Object *obj); - -int yaffs_skip_verification(yaffs_Device *dev); +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 parentCheck); +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); #endif diff --git a/yaffs_vfs.c b/yaffs_vfs.c index 5f51070..6d466ba 100644 --- a/yaffs_vfs.c +++ b/yaffs_vfs.c @@ -24,11 +24,11 @@ * the VFS. * * Special notes: - * >> 2.4: sb->u.generic_sbp points to the yaffs_Device associated with + * >> 2.4: sb->u.generic_sbp points to the yaffs_dev_t associated with * this superblock - * >> 2.6: sb->s_fs_info points to the yaffs_Device associated with this + * >> 2.6: sb->s_fs_info points to the yaffs_dev_t associated with this * superblock - * >> inode->u.generic_ip points to the associated yaffs_Object. + * >> inode->u.generic_ip points to the associated yaffs_obj_t. */ /* @@ -111,9 +111,9 @@ module_param(yaffs_bg_enable, uint, 0644); static struct inode *yaffs_iget(struct super_block *sb, unsigned long ino); #define yaffs_InodeToObjectLV(iptr) ((iptr)->i_private) -#define yaffs_InodeToObject(iptr) ((yaffs_Object *)(yaffs_InodeToObjectLV(iptr))) +#define yaffs_InodeToObject(iptr) ((yaffs_obj_t *)(yaffs_InodeToObjectLV(iptr))) #define yaffs_dentry_to_obj(dptr) yaffs_InodeToObject((dptr)->d_inode) -#define yaffs_SuperToDevice(sb) ((yaffs_Device *)sb->s_fs_info) +#define yaffs_SuperToDevice(sb) ((yaffs_dev_t *)sb->s_fs_info) #define update_dir_time(dir) do {\ @@ -186,7 +186,7 @@ static int yaffs_readlink(struct dentry *dentry, char __user *buffer, void yaffs_put_link(struct dentry *dentry, struct nameidata *nd, void *alias); static void *yaffs_follow_link(struct dentry *dentry, struct nameidata *nd); -static void yaffs_touch_super(yaffs_Device *dev); +static void yaffs_touch_super(yaffs_dev_t *dev); static loff_t yaffs_dir_llseek(struct file *file, loff_t offset, int origin); @@ -289,19 +289,19 @@ static int yaffs_vfs_setsize(struct inode *inode, loff_t newsize) return 0; } -static unsigned yaffs_gc_control_callback(yaffs_Device *dev) +static unsigned yaffs_gc_control_callback(yaffs_dev_t *dev) { return yaffs_gc_control; } -static void yaffs_gross_lock(yaffs_Device *dev) +static void yaffs_gross_lock(yaffs_dev_t *dev) { T(YAFFS_TRACE_LOCK, (TSTR("yaffs locking %p\n"), current)); down(&(yaffs_dev_to_lc(dev)->grossLock)); T(YAFFS_TRACE_LOCK, (TSTR("yaffs locked %p\n"), current)); } -static void yaffs_gross_unlock(yaffs_Device *dev) +static void yaffs_gross_unlock(yaffs_dev_t *dev) { T(YAFFS_TRACE_LOCK, (TSTR("yaffs unlocking %p\n"), current)); up(&(yaffs_dev_to_lc(dev)->grossLock)); @@ -335,8 +335,8 @@ struct dentry *yaffs2_get_parent(struct dentry *dentry) struct dentry *parent = ERR_PTR(-ENOENT); struct inode *inode; unsigned long parent_ino; - yaffs_Object *d_obj; - yaffs_Object *parent_obj; + yaffs_obj_t *d_obj; + yaffs_obj_t *parent_obj; d_obj = yaffs_InodeToObject(dentry->d_inode); @@ -380,11 +380,11 @@ static struct export_operations yaffs_export_ops = * A search context iterates along a doubly linked list of siblings in the * directory. If the iterating object is deleted then this would corrupt * the list iteration, likely causing a crash. The search context avoids - * this by using the removeObjectCallback to move the search context to the + * this by using the remove_obj_fn to move the search context to the * next object before the object is deleted. * * Many readdirs (and thus seach conexts) may be alive simulateously so - * each yaffs_Device has a list of these. + * each yaffs_dev_t has a list of these. * * A seach context lives for the duration of a readdir. * @@ -392,9 +392,9 @@ static struct export_operations yaffs_export_ops = */ struct yaffs_SearchContext { - yaffs_Device *dev; - yaffs_Object *dirObj; - yaffs_Object *nextReturn; + yaffs_dev_t *dev; + yaffs_obj_t *dirObj; + yaffs_obj_t *nextReturn; struct ylist_head others; }; @@ -404,19 +404,19 @@ struct yaffs_SearchContext { * * Called at start of readdir. */ -static struct yaffs_SearchContext * yaffs_NewSearch(yaffs_Object *dir) +static struct yaffs_SearchContext * yaffs_NewSearch(yaffs_obj_t *dir) { - yaffs_Device *dev = dir->myDev; + yaffs_dev_t *dev = dir->my_dev; struct yaffs_SearchContext *sc = YMALLOC(sizeof(struct yaffs_SearchContext)); if(sc){ sc->dirObj = dir; sc->dev = dev; - if( ylist_empty(&sc->dirObj->variant.directoryVariant.children)) + if( ylist_empty(&sc->dirObj->variant.dir_variant.children)) sc->nextReturn = NULL; else sc->nextReturn = ylist_entry( - dir->variant.directoryVariant.children.next, - yaffs_Object,siblings); + dir->variant.dir_variant.children.next, + yaffs_obj_t,siblings); YINIT_LIST_HEAD(&sc->others); ylist_add(&sc->others,&(yaffs_dev_to_lc(dev)->searchContexts)); } @@ -445,15 +445,15 @@ static void yaffs_search_advance(struct yaffs_SearchContext *sc) return; if( sc->nextReturn == NULL || - ylist_empty(&sc->dirObj->variant.directoryVariant.children)) + ylist_empty(&sc->dirObj->variant.dir_variant.children)) sc->nextReturn = NULL; else { struct ylist_head *next = sc->nextReturn->siblings.next; - if( next == &sc->dirObj->variant.directoryVariant.children) + if( next == &sc->dirObj->variant.dir_variant.children) sc->nextReturn = NULL; /* end of list */ else - sc->nextReturn = ylist_entry(next,yaffs_Object,siblings); + sc->nextReturn = ylist_entry(next,yaffs_obj_t,siblings); } } @@ -462,12 +462,12 @@ static void yaffs_search_advance(struct yaffs_SearchContext *sc) * We check open search contexts and advance any which are currently * on the object being iterated. */ -static void yaffs_remove_obj_callback(yaffs_Object *obj) +static void yaffs_remove_obj_callback(yaffs_obj_t *obj) { struct ylist_head *i; struct yaffs_SearchContext *sc; - struct ylist_head *search_contexts = &(yaffs_dev_to_lc(obj->myDev)->searchContexts); + struct ylist_head *search_contexts = &(yaffs_dev_to_lc(obj->my_dev)->searchContexts); /* Iterate through the directory search contexts. @@ -493,7 +493,7 @@ static int yaffs_readlink(struct dentry *dentry, char __user *buffer, unsigned char *alias; int ret; - yaffs_Device *dev = yaffs_dentry_to_obj(dentry)->myDev; + yaffs_dev_t *dev = yaffs_dentry_to_obj(dentry)->my_dev; yaffs_gross_lock(dev); @@ -513,7 +513,7 @@ static void *yaffs_follow_link(struct dentry *dentry, struct nameidata *nd) { unsigned char *alias; int ret; - yaffs_Device *dev = yaffs_dentry_to_obj(dentry)->myDev; + yaffs_dev_t *dev = yaffs_dentry_to_obj(dentry)->my_dev; yaffs_gross_lock(dev); @@ -536,7 +536,7 @@ void yaffs_put_link(struct dentry *dentry, struct nameidata *nd, void *alias) { } struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev, - yaffs_Object *obj); + yaffs_obj_t *obj); /* * Lookup is used to find objects in the fs @@ -545,17 +545,17 @@ struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev, static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *n) { - yaffs_Object *obj; + yaffs_obj_t *obj; struct inode *inode = NULL; /* NCB 2.5/2.6 needs NULL here */ - yaffs_Device *dev = yaffs_InodeToObject(dir)->myDev; + yaffs_dev_t *dev = yaffs_InodeToObject(dir)->my_dev; if(current != yaffs_dev_to_lc(dev)->readdirProcess) yaffs_gross_lock(dev); T(YAFFS_TRACE_OS, (TSTR("yaffs_lookup for %d:%s\n"), - yaffs_InodeToObject(dir)->objectId, dentry->d_name.name)); + yaffs_InodeToObject(dir)->obj_id, dentry->d_name.name)); obj = yaffs_find_by_name(yaffs_InodeToObject(dir), dentry->d_name.name); @@ -568,7 +568,7 @@ static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry, if (obj) { T(YAFFS_TRACE_OS, - (TSTR("yaffs_lookup found %d\n"), obj->objectId)); + (TSTR("yaffs_lookup found %d\n"), obj->obj_id)); inode = yaffs_get_inode(dir->i_sb, obj->yst_mode, 0, obj); @@ -614,12 +614,12 @@ static void yaffs_put_inode(struct inode *inode) #endif -static void yaffs_unstitch_obj(struct inode *inode, yaffs_Object *obj) +static void yaffs_unstitch_obj(struct inode *inode, yaffs_obj_t *obj) { /* Clear the association between the inode and - * the yaffs_Object. + * the yaffs_obj_t. */ - obj->myInode = NULL; + obj->my_inode = NULL; yaffs_InodeToObjectLV(inode) = NULL; /* If the object freeing was deferred, then the real @@ -635,8 +635,8 @@ static void yaffs_unstitch_obj(struct inode *inode, yaffs_Object *obj) */ static void yaffs_evict_inode( struct inode *inode) { - yaffs_Object *obj; - yaffs_Device *dev; + yaffs_obj_t *obj; + yaffs_dev_t *dev; int deleteme = 0; obj = yaffs_InodeToObject(inode); @@ -652,13 +652,13 @@ static void yaffs_evict_inode( struct inode *inode) end_writeback(inode); if(deleteme && obj){ - dev = obj->myDev; + dev = obj->my_dev; yaffs_gross_lock(dev); yaffs_del_obj(obj); yaffs_gross_unlock(dev); } if (obj) { - dev = obj->myDev; + dev = obj->my_dev; yaffs_gross_lock(dev); yaffs_unstitch_obj(inode,obj); yaffs_gross_unlock(dev); @@ -670,12 +670,12 @@ static void yaffs_evict_inode( struct inode *inode) static int yaffs_file_flush(struct file *file, fl_owner_t id) { - yaffs_Object *obj = yaffs_dentry_to_obj(file->f_dentry); + yaffs_obj_t *obj = yaffs_dentry_to_obj(file->f_dentry); - yaffs_Device *dev = obj->myDev; + yaffs_dev_t *dev = obj->my_dev; T(YAFFS_TRACE_OS, - (TSTR("yaffs_file_flush object %d (%s)\n"), obj->objectId, + (TSTR("yaffs_file_flush object %d (%s)\n"), obj->obj_id, obj->dirty ? "dirty" : "clean")); yaffs_gross_lock(dev); @@ -691,11 +691,11 @@ static int yaffs_readpage_nolock(struct file *f, struct page *pg) { /* Lifted from jffs2 */ - yaffs_Object *obj; + yaffs_obj_t *obj; unsigned char *pg_buf; int ret; - yaffs_Device *dev; + yaffs_dev_t *dev; T(YAFFS_TRACE_OS, (TSTR("yaffs_readpage_nolock at %08x, size %08x\n"), @@ -704,7 +704,7 @@ static int yaffs_readpage_nolock(struct file *f, struct page *pg) obj = yaffs_dentry_to_obj(f->f_dentry); - dev = obj->myDev; + dev = obj->my_dev; BUG_ON(!PageLocked(pg)); @@ -758,14 +758,14 @@ static int yaffs_readpage(struct file *f, struct page *pg) static int yaffs_writepage(struct page *page, struct writeback_control *wbc) { - yaffs_Device *dev; + yaffs_dev_t *dev; struct address_space *mapping = page->mapping; struct inode *inode; unsigned long end_index; char *buffer; - yaffs_Object *obj; + yaffs_obj_t *obj; int nWritten = 0; - unsigned nBytes; + unsigned n_bytes; loff_t i_size; if (!mapping) @@ -778,11 +778,11 @@ static int yaffs_writepage(struct page *page, struct writeback_control *wbc) end_index = i_size >> PAGE_CACHE_SHIFT; if(page->index < end_index) - nBytes = PAGE_CACHE_SIZE; + n_bytes = PAGE_CACHE_SIZE; else { - nBytes = i_size & (PAGE_CACHE_SIZE -1); + n_bytes = i_size & (PAGE_CACHE_SIZE -1); - if (page->index > end_index || !nBytes) { + if (page->index > end_index || !n_bytes) { T(YAFFS_TRACE_OS, (TSTR("yaffs_writepage at %08x, inode size = %08x!!!\n"), (unsigned)(page->index << PAGE_CACHE_SHIFT), @@ -798,32 +798,32 @@ static int yaffs_writepage(struct page *page, struct writeback_control *wbc) } } - if(nBytes != PAGE_CACHE_SIZE) - zero_user_segment(page,nBytes,PAGE_CACHE_SIZE); + if(n_bytes != PAGE_CACHE_SIZE) + zero_user_segment(page,n_bytes,PAGE_CACHE_SIZE); get_page(page); buffer = kmap(page); obj = yaffs_InodeToObject(inode); - dev = obj->myDev; + dev = obj->my_dev; yaffs_gross_lock(dev); T(YAFFS_TRACE_OS, (TSTR("yaffs_writepage at %08x, size %08x\n"), - (unsigned)(page->index << PAGE_CACHE_SHIFT), nBytes)); + (unsigned)(page->index << PAGE_CACHE_SHIFT), n_bytes)); T(YAFFS_TRACE_OS, (TSTR("writepag0: obj = %05x, ino = %05x\n"), - (int)obj->variant.fileVariant.fileSize, (int)inode->i_size)); + (int)obj->variant.file_variant.file_size, (int)inode->i_size)); nWritten = yaffs_wr_file(obj, buffer, - page->index << PAGE_CACHE_SHIFT, nBytes, 0); + page->index << PAGE_CACHE_SHIFT, n_bytes, 0); yaffs_touch_super(dev); T(YAFFS_TRACE_OS, (TSTR("writepag1: obj = %05x, ino = %05x\n"), - (int)obj->variant.fileVariant.fileSize, (int)inode->i_size)); + (int)obj->variant.file_variant.file_size, (int)inode->i_size)); yaffs_gross_unlock(dev); @@ -833,7 +833,7 @@ static int yaffs_writepage(struct page *page, struct writeback_control *wbc) end_page_writeback(page); put_page(page); - return (nWritten == nBytes) ? 0 : -ENOSPC; + return (nWritten == n_bytes) ? 0 : -ENOSPC; } @@ -905,7 +905,7 @@ static int yaffs_write_end(struct file *filp, struct address_space *mapping, addr = kva + offset_into_page; T(YAFFS_TRACE_OS, - ("yaffs_write_end addr %p pos %x nBytes %d\n", + ("yaffs_write_end addr %p pos %x n_bytes %d\n", addr,(unsigned)pos, copied)); ret = yaffs_file_write(filp, addr, copied, &pos); @@ -928,14 +928,14 @@ static int yaffs_write_end(struct file *filp, struct address_space *mapping, } -static void yaffs_fill_inode_from_obj(struct inode *inode, yaffs_Object *obj) +static void yaffs_fill_inode_from_obj(struct inode *inode, yaffs_obj_t *obj) { if (inode && obj) { /* Check mode against the variant type and attempt to repair if broken. */ __u32 mode = obj->yst_mode; - switch (obj->variantType) { + switch (obj->variant_type) { case YAFFS_OBJECT_TYPE_FILE: if (!S_ISREG(mode)) { obj->yst_mode &= ~S_IFMT; @@ -967,7 +967,7 @@ static void yaffs_fill_inode_from_obj(struct inode *inode, yaffs_Object *obj) inode->i_flags |= S_NOATIME; - inode->i_ino = obj->objectId; + inode->i_ino = obj->obj_id; inode->i_mode = obj->yst_mode; inode->i_uid = obj->yst_uid; inode->i_gid = obj->yst_gid; @@ -1012,7 +1012,7 @@ static void yaffs_fill_inode_from_obj(struct inode *inode, yaffs_Object *obj) yaffs_InodeToObjectLV(inode) = obj; - obj->myInode = inode; + obj->my_inode = inode; } else { T(YAFFS_TRACE_OS, @@ -1022,7 +1022,7 @@ static void yaffs_fill_inode_from_obj(struct inode *inode, yaffs_Object *obj) } struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev, - yaffs_Object *obj) + yaffs_obj_t *obj) { struct inode *inode; @@ -1041,9 +1041,9 @@ struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev, } T(YAFFS_TRACE_OS, - (TSTR("yaffs_get_inode for object %d\n"), obj->objectId)); + (TSTR("yaffs_get_inode for object %d\n"), obj->obj_id)); - inode = Y_IGET(sb, obj->objectId); + inode = Y_IGET(sb, obj->obj_id); if (IS_ERR(inode)) return NULL; @@ -1057,14 +1057,14 @@ struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev, static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n, loff_t *pos) { - yaffs_Object *obj; + yaffs_obj_t *obj; int nWritten, ipos; struct inode *inode; - yaffs_Device *dev; + yaffs_dev_t *dev; obj = yaffs_dentry_to_obj(f->f_dentry); - dev = obj->myDev; + dev = obj->my_dev; yaffs_gross_lock(dev); @@ -1082,7 +1082,7 @@ static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n, T(YAFFS_TRACE_OS, (TSTR("yaffs_file_write about to write writing %u(%x) bytes" "to object %d at %d(%x)\n"), - (unsigned) n, (unsigned) n, obj->objectId, ipos,ipos)); + (unsigned) n, (unsigned) n, obj->obj_id, ipos,ipos)); nWritten = yaffs_wr_file(obj, buf, ipos, n, 0); @@ -1116,34 +1116,34 @@ static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n, static ssize_t yaffs_hold_space(struct file *f) { - yaffs_Object *obj; - yaffs_Device *dev; + yaffs_obj_t *obj; + yaffs_dev_t *dev; - int nFreeChunks; + int n_free_chunks; obj = yaffs_dentry_to_obj(f->f_dentry); - dev = obj->myDev; + dev = obj->my_dev; yaffs_gross_lock(dev); - nFreeChunks = yaffs_get_n_free_chunks(dev); + n_free_chunks = yaffs_get_n_free_chunks(dev); yaffs_gross_unlock(dev); - return (nFreeChunks > 20) ? 1 : 0; + return (n_free_chunks > 20) ? 1 : 0; } static void yaffs_release_space(struct file *f) { - yaffs_Object *obj; - yaffs_Device *dev; + yaffs_obj_t *obj; + yaffs_dev_t *dev; obj = yaffs_dentry_to_obj(f->f_dentry); - dev = obj->myDev; + dev = obj->my_dev; yaffs_gross_lock(dev); @@ -1180,18 +1180,18 @@ static loff_t yaffs_dir_llseek(struct file *file, loff_t offset, int origin) static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir) { - yaffs_Object *obj; - yaffs_Device *dev; + yaffs_obj_t *obj; + yaffs_dev_t *dev; struct yaffs_SearchContext *sc; struct inode *inode = f->f_dentry->d_inode; unsigned long offset, curoffs; - yaffs_Object *l; + yaffs_obj_t *l; int retVal = 0; char name[YAFFS_MAX_NAME_LENGTH + 1]; obj = yaffs_dentry_to_obj(f->f_dentry); - dev = obj->myDev; + dev = obj->my_dev; yaffs_gross_lock(dev); @@ -1299,10 +1299,10 @@ static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode, { struct inode *inode; - yaffs_Object *obj = NULL; - yaffs_Device *dev; + yaffs_obj_t *obj = NULL; + yaffs_dev_t *dev; - yaffs_Object *parent = yaffs_InodeToObject(dir); + yaffs_obj_t *parent = yaffs_InodeToObject(dir); int error = -ENOSPC; uid_t uid = YCRED(current)->fsuid; @@ -1314,7 +1314,7 @@ static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode, if (parent) { T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod: parent object %d type %d\n"), - parent->objectId, parent->variantType)); + parent->obj_id, parent->variant_type)); } else { T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod: could not get parent object\n"))); @@ -1325,7 +1325,7 @@ static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode, "mode %x dev %x\n"), dentry->d_name.name, mode, rdev)); - dev = parent->myDev; + dev = parent->my_dev; yaffs_gross_lock(dev); @@ -1362,7 +1362,7 @@ static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode, update_dir_time(dir); T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod created object %d count = %d\n"), - obj->objectId, atomic_read(&inode->i_count))); + obj->obj_id, atomic_read(&inode->i_count))); error = 0; yaffs_fill_inode_from_obj(dir,parent); } else { @@ -1393,15 +1393,15 @@ static int yaffs_unlink(struct inode *dir, struct dentry *dentry) { int retVal; - yaffs_Device *dev; - yaffs_Object *obj; + yaffs_dev_t *dev; + yaffs_obj_t *obj; T(YAFFS_TRACE_OS, (TSTR("yaffs_unlink %d:%s\n"), (int)(dir->i_ino), dentry->d_name.name)); obj = yaffs_InodeToObject(dir); - dev = obj->myDev; + dev = obj->my_dev; yaffs_gross_lock(dev); @@ -1426,19 +1426,19 @@ static int yaffs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry) { struct inode *inode = old_dentry->d_inode; - yaffs_Object *obj = NULL; - yaffs_Object *link = NULL; - yaffs_Device *dev; + yaffs_obj_t *obj = NULL; + yaffs_obj_t *link = NULL; + yaffs_dev_t *dev; T(YAFFS_TRACE_OS, (TSTR("yaffs_link\n"))); obj = yaffs_InodeToObject(inode); - dev = obj->myDev; + dev = obj->my_dev; yaffs_gross_lock(dev); if (!S_ISDIR(inode->i_mode)) /* Don't link directories */ - link = yaffs_Link(yaffs_InodeToObject(dir), dentry->d_name.name, + link = yaffs_link_obj(yaffs_InodeToObject(dir), dentry->d_name.name, obj); if (link) { @@ -1464,14 +1464,14 @@ static int yaffs_link(struct dentry *old_dentry, struct inode *dir, static int yaffs_symlink(struct inode *dir, struct dentry *dentry, const char *symname) { - yaffs_Object *obj; - yaffs_Device *dev; + yaffs_obj_t *obj; + yaffs_dev_t *dev; uid_t uid = YCRED(current)->fsuid; gid_t gid = (dir->i_mode & S_ISGID) ? dir->i_gid : YCRED(current)->fsgid; T(YAFFS_TRACE_OS, (TSTR("yaffs_symlink\n"))); - dev = yaffs_InodeToObject(dir)->myDev; + dev = yaffs_InodeToObject(dir)->my_dev; yaffs_gross_lock(dev); obj = yaffs_create_symlink(yaffs_InodeToObject(dir), dentry->d_name.name, S_IFLNK | S_IRWXUGO, uid, gid, symname); @@ -1495,13 +1495,13 @@ static int yaffs_symlink(struct inode *dir, struct dentry *dentry, static int yaffs_sync_object(struct file *file, int datasync) { - yaffs_Object *obj; - yaffs_Device *dev; + yaffs_obj_t *obj; + yaffs_dev_t *dev; struct dentry *dentry = file->f_path.dentry; obj = yaffs_dentry_to_obj(dentry); - dev = obj->myDev; + dev = obj->my_dev; T(YAFFS_TRACE_OS | YAFFS_TRACE_SYNC, (TSTR("yaffs_sync_object\n"))); @@ -1519,12 +1519,12 @@ static int yaffs_sync_object(struct file *file, int datasync) static int yaffs_rename(struct inode *old_dir, struct dentry *old_dentry, struct inode *new_dir, struct dentry *new_dentry) { - yaffs_Device *dev; + yaffs_dev_t *dev; int retVal = YAFFS_FAIL; - yaffs_Object *target; + yaffs_obj_t *target; T(YAFFS_TRACE_OS, (TSTR("yaffs_rename\n"))); - dev = yaffs_InodeToObject(old_dir)->myDev; + dev = yaffs_InodeToObject(old_dir)->my_dev; yaffs_gross_lock(dev); @@ -1534,8 +1534,8 @@ static int yaffs_rename(struct inode *old_dir, struct dentry *old_dentry, - if (target && target->variantType == YAFFS_OBJECT_TYPE_DIRECTORY && - !ylist_empty(&target->variant.directoryVariant.children)) { + if (target && target->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY && + !ylist_empty(&target->variant.dir_variant.children)) { T(YAFFS_TRACE_OS, (TSTR("target is non-empty dir\n"))); @@ -1570,11 +1570,11 @@ static int yaffs_setattr(struct dentry *dentry, struct iattr *attr) { struct inode *inode = dentry->d_inode; int error = 0; - yaffs_Device *dev; + yaffs_dev_t *dev; T(YAFFS_TRACE_OS, (TSTR("yaffs_setattr of object %d\n"), - yaffs_InodeToObject(inode)->objectId)); + yaffs_InodeToObject(inode)->obj_id)); /* Fail if a requested resize >= 2GB */ if (attr->ia_valid & ATTR_SIZE && @@ -1593,7 +1593,7 @@ static int yaffs_setattr(struct dentry *dentry, struct iattr *attr) inode->i_blocks = (inode->i_size + 511) >> 9; } } - dev = yaffs_InodeToObject(inode)->myDev; + dev = yaffs_InodeToObject(inode)->my_dev; if (attr->ia_valid & ATTR_SIZE){ T(YAFFS_TRACE_OS,(TSTR("resize to %d(%x)\n"), (int)(attr->ia_size),(int)(attr->ia_size))); @@ -1621,17 +1621,17 @@ int yaffs_setxattr(struct dentry *dentry, const char *name, { struct inode *inode = dentry->d_inode; int error = 0; - yaffs_Device *dev; - yaffs_Object *obj = yaffs_InodeToObject(inode); + yaffs_dev_t *dev; + yaffs_obj_t *obj = yaffs_InodeToObject(inode); T(YAFFS_TRACE_OS, (TSTR("yaffs_setxattr of object %d\n"), - obj->objectId)); + obj->obj_id)); if (error == 0) { int result; - dev = obj->myDev; + dev = obj->my_dev; yaffs_gross_lock(dev); result = yaffs_set_xattrib(obj, name, value, size, flags); if(result == YAFFS_OK) @@ -1653,15 +1653,15 @@ ssize_t yaffs_getxattr(struct dentry *dentry, const char *name, void *buff, { struct inode *inode = dentry->d_inode; int error = 0; - yaffs_Device *dev; - yaffs_Object *obj = yaffs_InodeToObject(inode); + yaffs_dev_t *dev; + yaffs_obj_t *obj = yaffs_InodeToObject(inode); T(YAFFS_TRACE_OS, (TSTR("yaffs_getxattr \"%s\" from object %d\n"), - name, obj->objectId)); + name, obj->obj_id)); if (error == 0) { - dev = obj->myDev; + dev = obj->my_dev; yaffs_gross_lock(dev); error = yaffs_get_xattrib(obj, name, buff, size); yaffs_gross_unlock(dev); @@ -1677,17 +1677,17 @@ int yaffs_removexattr(struct dentry *dentry, const char *name) { struct inode *inode = dentry->d_inode; int error = 0; - yaffs_Device *dev; - yaffs_Object *obj = yaffs_InodeToObject(inode); + yaffs_dev_t *dev; + yaffs_obj_t *obj = yaffs_InodeToObject(inode); T(YAFFS_TRACE_OS, (TSTR("yaffs_removexattr of object %d\n"), - obj->objectId)); + obj->obj_id)); if (error == 0) { int result; - dev = obj->myDev; + dev = obj->my_dev; yaffs_gross_lock(dev); result = yaffs_remove_xattrib(obj, name); if(result == YAFFS_OK) @@ -1707,16 +1707,16 @@ ssize_t yaffs_listxattr(struct dentry *dentry, char *buff, size_t size) { struct inode *inode = dentry->d_inode; int error = 0; - yaffs_Device *dev; - yaffs_Object *obj = yaffs_InodeToObject(inode); + yaffs_dev_t *dev; + yaffs_obj_t *obj = yaffs_InodeToObject(inode); T(YAFFS_TRACE_OS, (TSTR("yaffs_listxattr of object %d\n"), - obj->objectId)); + obj->obj_id)); if (error == 0) { - dev = obj->myDev; + dev = obj->my_dev; yaffs_gross_lock(dev); error = yaffs_list_xattrib(obj, buff, size); yaffs_gross_unlock(dev); @@ -1733,7 +1733,7 @@ ssize_t yaffs_listxattr(struct dentry *dentry, char *buff, size_t size) static int yaffs_statfs(struct dentry *dentry, struct kstatfs *buf) { - yaffs_Device *dev = yaffs_dentry_to_obj(dentry)->myDev; + yaffs_dev_t *dev = yaffs_dentry_to_obj(dentry)->my_dev; struct super_block *sb = dentry->d_sb; T(YAFFS_TRACE_OS, (TSTR("yaffs_statfs\n"))); @@ -1744,43 +1744,43 @@ static int yaffs_statfs(struct dentry *dentry, struct kstatfs *buf) buf->f_bsize = sb->s_blocksize; buf->f_namelen = 255; - if (dev->nDataBytesPerChunk & (dev->nDataBytesPerChunk - 1)) { + if (dev->data_bytes_per_chunk & (dev->data_bytes_per_chunk - 1)) { /* Do this if chunk size is not a power of 2 */ uint64_t bytesInDev; uint64_t bytesFree; - bytesInDev = ((uint64_t)((dev->param.endBlock - dev->param.startBlock + 1))) * - ((uint64_t)(dev->param.nChunksPerBlock * dev->nDataBytesPerChunk)); + bytesInDev = ((uint64_t)((dev->param.end_block - dev->param.start_block + 1))) * + ((uint64_t)(dev->param.chunks_per_block * dev->data_bytes_per_chunk)); do_div(bytesInDev, sb->s_blocksize); /* bytesInDev becomes the number of blocks */ buf->f_blocks = bytesInDev; bytesFree = ((uint64_t)(yaffs_get_n_free_chunks(dev))) * - ((uint64_t)(dev->nDataBytesPerChunk)); + ((uint64_t)(dev->data_bytes_per_chunk)); do_div(bytesFree, sb->s_blocksize); buf->f_bfree = bytesFree; - } else if (sb->s_blocksize > dev->nDataBytesPerChunk) { + } else if (sb->s_blocksize > dev->data_bytes_per_chunk) { buf->f_blocks = - (dev->param.endBlock - dev->param.startBlock + 1) * - dev->param.nChunksPerBlock / - (sb->s_blocksize / dev->nDataBytesPerChunk); + (dev->param.end_block - dev->param.start_block + 1) * + dev->param.chunks_per_block / + (sb->s_blocksize / dev->data_bytes_per_chunk); buf->f_bfree = yaffs_get_n_free_chunks(dev) / - (sb->s_blocksize / dev->nDataBytesPerChunk); + (sb->s_blocksize / dev->data_bytes_per_chunk); } else { buf->f_blocks = - (dev->param.endBlock - dev->param.startBlock + 1) * - dev->param.nChunksPerBlock * - (dev->nDataBytesPerChunk / sb->s_blocksize); + (dev->param.end_block - dev->param.start_block + 1) * + dev->param.chunks_per_block * + (dev->data_bytes_per_chunk / sb->s_blocksize); buf->f_bfree = yaffs_get_n_free_chunks(dev) * - (dev->nDataBytesPerChunk / sb->s_blocksize); + (dev->data_bytes_per_chunk / sb->s_blocksize); } buf->f_files = 0; @@ -1796,13 +1796,13 @@ static int yaffs_statfs(struct dentry *dentry, struct kstatfs *buf) static void yaffs_flush_inodes(struct super_block *sb) { struct inode *iptr; - yaffs_Object *obj; + yaffs_obj_t *obj; list_for_each_entry(iptr,&sb->s_inodes, i_sb_list){ obj = yaffs_InodeToObject(iptr); if(obj){ T(YAFFS_TRACE_OS, (TSTR("flushing obj %d\n"), - obj->objectId)); + obj->obj_id)); yaffs_flush_file(obj,1,0); } } @@ -1811,7 +1811,7 @@ static void yaffs_flush_inodes(struct super_block *sb) static void yaffs_flush_super(struct super_block *sb, int do_checkpoint) { - yaffs_Device *dev = yaffs_SuperToDevice(sb); + yaffs_dev_t *dev = yaffs_SuperToDevice(sb); if(!dev) return; @@ -1823,22 +1823,22 @@ static void yaffs_flush_super(struct super_block *sb, int do_checkpoint) } -static unsigned yaffs_bg_gc_urgency(yaffs_Device *dev) +static unsigned yaffs_bg_gc_urgency(yaffs_dev_t *dev) { - unsigned erasedChunks = dev->nErasedBlocks * dev->param.nChunksPerBlock; + unsigned erasedChunks = dev->n_erased_blocks * dev->param.chunks_per_block; struct yaffs_LinuxContext *context = yaffs_dev_to_lc(dev); unsigned scatteredFree = 0; /* Free chunks not in an erased block */ - if(erasedChunks < dev->nFreeChunks) - scatteredFree = (dev->nFreeChunks - erasedChunks); + if(erasedChunks < dev->n_free_chunks) + scatteredFree = (dev->n_free_chunks - erasedChunks); if(!context->bgRunning) return 0; - else if(scatteredFree < (dev->param.nChunksPerBlock * 2)) + else if(scatteredFree < (dev->param.chunks_per_block * 2)) return 0; - else if(erasedChunks > dev->nFreeChunks/2) + else if(erasedChunks > dev->n_free_chunks/2) return 0; - else if(erasedChunks > dev->nFreeChunks/4) + else if(erasedChunks > dev->n_free_chunks/4) return 1; else return 2; @@ -1848,7 +1848,7 @@ static int yaffs_do_sync_fs(struct super_block *sb, int request_checkpoint) { - yaffs_Device *dev = yaffs_SuperToDevice(sb); + yaffs_dev_t *dev = yaffs_SuperToDevice(sb); unsigned int oneshot_checkpoint = (yaffs_auto_checkpoint & 4); unsigned gc_urgent = yaffs_bg_gc_urgency(dev); int do_checkpoint; @@ -1863,10 +1863,10 @@ static int yaffs_do_sync_fs(struct super_block *sb, yaffs_gross_lock(dev); do_checkpoint = ((request_checkpoint && !gc_urgent) || oneshot_checkpoint) && - !dev->isCheckpointed; + !dev->is_checkpointed; if (sb->s_dirt || do_checkpoint) { - yaffs_flush_super(sb, !dev->isCheckpointed && do_checkpoint); + yaffs_flush_super(sb, !dev->is_checkpointed && do_checkpoint); sb->s_dirt = 0; if(oneshot_checkpoint) yaffs_auto_checkpoint &= ~4; @@ -1896,7 +1896,7 @@ void yaffs_background_waker(unsigned long data) static int yaffs_bg_thread_fn(void *data) { - yaffs_Device *dev = (yaffs_Device *)data; + yaffs_dev_t *dev = (yaffs_dev_t *)data; struct yaffs_LinuxContext *context = yaffs_dev_to_lc(dev); unsigned long now = jiffies; unsigned long next_dir_update = now; @@ -1932,7 +1932,7 @@ static int yaffs_bg_thread_fn(void *data) } if(time_after(now,next_gc) && yaffs_bg_enable){ - if(!dev->isCheckpointed){ + if(!dev->is_checkpointed){ urgency = yaffs_bg_gc_urgency(dev); gcResult = yaffs_bg_gc(dev, urgency); if(urgency > 1) @@ -1968,12 +1968,12 @@ static int yaffs_bg_thread_fn(void *data) return 0; } -static int yaffs_bg_start(yaffs_Device *dev) +static int yaffs_bg_start(yaffs_dev_t *dev) { int retval = 0; struct yaffs_LinuxContext *context = yaffs_dev_to_lc(dev); - if(dev->readOnly) + if(dev->read_only) return -1; context->bgRunning = 1; @@ -1989,7 +1989,7 @@ static int yaffs_bg_start(yaffs_Device *dev) return retval; } -static void yaffs_bg_stop(yaffs_Device *dev) +static void yaffs_bg_stop(yaffs_dev_t *dev) { struct yaffs_LinuxContext *ctxt = yaffs_dev_to_lc(dev); @@ -2031,8 +2031,8 @@ static int yaffs_sync_fs(struct super_block *sb, int wait) static struct inode *yaffs_iget(struct super_block *sb, unsigned long ino) { struct inode *inode; - yaffs_Object *obj; - yaffs_Device *dev = yaffs_SuperToDevice(sb); + yaffs_obj_t *obj; + yaffs_dev_t *dev = yaffs_SuperToDevice(sb); T(YAFFS_TRACE_OS, (TSTR("yaffs_iget for %lu\n"), ino)); @@ -2065,7 +2065,7 @@ struct semaphore yaffs_context_lock; static void yaffs_put_super(struct super_block *sb) { - yaffs_Device *dev = yaffs_SuperToDevice(sb); + yaffs_dev_t *dev = yaffs_SuperToDevice(sb); T(YAFFS_TRACE_OS, (TSTR("yaffs_put_super\n"))); @@ -2111,7 +2111,7 @@ static void yaffs_MTDPutSuper(struct super_block *sb) } -static void yaffs_touch_super(yaffs_Device *dev) +static void yaffs_touch_super(yaffs_dev_t *dev) { struct super_block *sb = yaffs_dev_to_lc(dev)->superBlock; @@ -2203,15 +2203,15 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, int nBlocks; struct inode *inode = NULL; struct dentry *root; - yaffs_Device *dev = 0; + yaffs_dev_t *dev = 0; char devname_buf[BDEVNAME_SIZE + 1]; struct mtd_info *mtd; int err; char *data_str = (char *)data; struct yaffs_LinuxContext *context = NULL; - yaffs_DeviceParam *param; + yaffs_param_t *param; - int readOnly = 0; + int read_only = 0; yaffs_options options; @@ -2224,7 +2224,7 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, sb->s_op = &yaffs_super_ops; sb->s_flags |= MS_NOATIME; - readOnly =((sb->s_flags & MS_RDONLY) != 0); + read_only =((sb->s_flags & MS_RDONLY) != 0); sb->s_export_op = &yaffs_export_ops; @@ -2238,7 +2238,7 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, printk(KERN_INFO "yaffs: dev is %d name is \"%s\" %s\n", sb->s_dev, yaffs_devname(sb, devname_buf), - readOnly ? "ro" : "rw"); + read_only ? "ro" : "rw"); if (!data_str) data_str = ""; @@ -2361,16 +2361,16 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, /* OK, so if we got here, we have an MTD that's NAND and looks * like it has the right capabilities - * Set the yaffs_Device up for mtd + * Set the yaffs_dev_t up for mtd */ - if (!readOnly && !(mtd->flags & MTD_WRITEABLE)){ - readOnly = 1; + if (!read_only && !(mtd->flags & MTD_WRITEABLE)){ + read_only = 1; printk(KERN_INFO "yaffs: mtd is read only, setting superblock read only"); sb->s_flags |= MS_RDONLY; } - dev = kmalloc(sizeof(yaffs_Device), GFP_KERNEL); + dev = kmalloc(sizeof(yaffs_dev_t), GFP_KERNEL); context = kmalloc(sizeof(struct yaffs_LinuxContext),GFP_KERNEL); if(!dev || !context ){ @@ -2386,123 +2386,123 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, /* Deep shit could not allocate device structure */ T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs_read_super: Failed trying to allocate " - "yaffs_Device. \n"))); + "yaffs_dev_t. \n"))); return NULL; } - memset(dev, 0, sizeof(yaffs_Device)); + memset(dev, 0, sizeof(yaffs_dev_t)); param = &(dev->param); memset(context,0,sizeof(struct yaffs_LinuxContext)); - dev->osContext = context; + dev->os_context = context; YINIT_LIST_HEAD(&(context->contextList)); context->dev = dev; context->superBlock = sb; - dev->readOnly = readOnly; + dev->read_only = read_only; sb->s_fs_info = dev; - dev->driverContext = mtd; + dev->driver_context = mtd; param->name = mtd->name; /* Set up the memory size parameters.... */ nBlocks = YCALCBLOCKS(mtd->size, (YAFFS_CHUNKS_PER_BLOCK * YAFFS_BYTES_PER_CHUNK)); - param->startBlock = 0; - param->endBlock = nBlocks - 1; - param->nChunksPerBlock = YAFFS_CHUNKS_PER_BLOCK; - param->totalBytesPerChunk = YAFFS_BYTES_PER_CHUNK; - param->nReservedBlocks = 5; - param->nShortOpCaches = (options.no_cache) ? 0 : 10; - param->inbandTags = options.inband_tags; + param->start_block = 0; + param->end_block = nBlocks - 1; + param->chunks_per_block = YAFFS_CHUNKS_PER_BLOCK; + param->total_bytes_per_chunk = YAFFS_BYTES_PER_CHUNK; + param->n_reserved_blocks = 5; + param->n_caches = (options.no_cache) ? 0 : 10; + param->inband_tags = options.inband_tags; #ifdef CONFIG_YAFFS_DISABLE_LAZY_LOAD - param->disableLazyLoad = 1; + param->disable_lazy_load = 1; #endif #ifdef CONFIG_YAFFS_XATTR - param->enableXattr = 1; + param->enable_xattr = 1; #endif if(options.lazy_loading_overridden) - param->disableLazyLoad = !options.lazy_loading_enabled; + param->disable_lazy_load = !options.lazy_loading_enabled; #ifdef CONFIG_YAFFS_DISABLE_TAGS_ECC - param->noTagsECC = 1; + param->no_tags_ecc = 1; #endif #ifdef CONFIG_YAFFS_DISABLE_BACKGROUND #else - param->deferDirectoryUpdate = 1; + param->defered_dir_update = 1; #endif if(options.tags_ecc_overridden) - param->noTagsECC = !options.tags_ecc_on; + param->no_tags_ecc = !options.tags_ecc_on; #ifdef CONFIG_YAFFS_EMPTY_LOST_AND_FOUND - param->emptyLostAndFound = 1; + param->empty_lost_n_found = 1; #endif #ifdef CONFIG_YAFFS_DISABLE_BLOCK_REFRESHING - param->refreshPeriod = 0; + param->refresh_period = 0; #else - param->refreshPeriod = 500; + param->refresh_period = 500; #endif #ifdef CONFIG_YAFFS_ALWAYS_CHECK_CHUNK_ERASED - param->alwaysCheckErased = 1; + param->always_check_erased = 1; #endif if(options.empty_lost_and_found_overridden) - param->emptyLostAndFound = options.empty_lost_and_found; + param->empty_lost_n_found = options.empty_lost_and_found; /* ... and the functions. */ if (yaffs_version == 2) { - param->writeChunkWithTagsToNAND = + param->write_chunk_tags_fn = nandmtd2_WriteChunkWithTagsToNAND; - param->readChunkWithTagsFromNAND = + param->read_chunk_tags_fn = nandmtd2_ReadChunkWithTagsFromNAND; - param->markNANDBlockBad = nandmtd2_MarkNANDBlockBad; - param->queryNANDBlock = nandmtd2_QueryNANDBlock; + param->bad_block_fn = nandmtd2_MarkNANDBlockBad; + param->query_block_fn = nandmtd2_QueryNANDBlock; yaffs_dev_to_lc(dev)->spareBuffer = YMALLOC(mtd->oobsize); - param->isYaffs2 = 1; - param->totalBytesPerChunk = mtd->writesize; - param->nChunksPerBlock = mtd->erasesize / mtd->writesize; + param->is_yaffs2 = 1; + param->total_bytes_per_chunk = mtd->writesize; + param->chunks_per_block = mtd->erasesize / mtd->writesize; nBlocks = YCALCBLOCKS(mtd->size, mtd->erasesize); - param->startBlock = 0; - param->endBlock = nBlocks - 1; + param->start_block = 0; + param->end_block = nBlocks - 1; } else { /* use the MTD interface in yaffs_mtdif1.c */ - param->writeChunkWithTagsToNAND = + param->write_chunk_tags_fn = nandmtd1_WriteChunkWithTagsToNAND; - param->readChunkWithTagsFromNAND = + param->read_chunk_tags_fn = nandmtd1_ReadChunkWithTagsFromNAND; - param->markNANDBlockBad = nandmtd1_MarkNANDBlockBad; - param->queryNANDBlock = nandmtd1_QueryNANDBlock; - param->isYaffs2 = 0; + param->bad_block_fn = nandmtd1_MarkNANDBlockBad; + param->query_block_fn = nandmtd1_QueryNANDBlock; + param->is_yaffs2 = 0; } /* ... and common functions */ - param->eraseBlockInNAND = nandmtd_EraseBlockInNAND; - param->initialiseNAND = nandmtd_InitialiseNAND; + param->erase_fn = nandmtd_EraseBlockInNAND; + param->initialise_flash_fn = nandmtd_InitialiseNAND; yaffs_dev_to_lc(dev)->putSuperFunc = yaffs_MTDPutSuper; - param->markSuperBlockDirty = yaffs_touch_super; - param->gcControl = yaffs_gc_control_callback; + param->sb_dirty_fn = yaffs_touch_super; + param->gc_control = yaffs_gc_control_callback; yaffs_dev_to_lc(dev)->superBlock= sb; #ifndef CONFIG_YAFFS_DOES_ECC - param->useNANDECC = 1; + param->use_nand_ecc = 1; #endif #ifdef CONFIG_YAFFS_DISABLE_WIDE_TNODES - param->wideTnodesDisabled = 1; + param->wide_tnodes_disabled = 1; #endif - param->skipCheckpointRead = options.skip_checkpoint_read; - param->skipCheckpointWrite = options.skip_checkpoint_write; + param->skip_checkpt_rd = options.skip_checkpoint_read; + param->skip_checkpt_wr = options.skip_checkpoint_write; down(&yaffs_context_lock); /* Get a mount id */ @@ -2522,7 +2522,7 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, /* Directory search handling...*/ YINIT_LIST_HEAD(&(yaffs_dev_to_lc(dev)->searchContexts)); - param->removeObjectCallback = yaffs_remove_obj_callback; + param->remove_obj_fn = yaffs_remove_obj_callback; init_MUTEX(&(yaffs_dev_to_lc(dev)->grossLock)); @@ -2538,7 +2538,7 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, yaffs_bg_start(dev); if(!context->bgThread) - param->deferDirectoryUpdate = 0; + param->defered_dir_update = 0; /* Release lock before yaffs_get_inode() */ @@ -2547,7 +2547,7 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, /* Create root inode */ if (err == YAFFS_OK) inode = yaffs_get_inode(sb, S_IFDIR | 0755, 0, - yaffs_Root(dev)); + yaffs_root(dev)); if (!inode) return NULL; @@ -2566,10 +2566,10 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, return NULL; } sb->s_root = root; - sb->s_dirt = !dev->isCheckpointed; + sb->s_dirt = !dev->is_checkpointed; T(YAFFS_TRACE_ALWAYS, - (TSTR("yaffs_read_super: isCheckpointed %d\n"), - dev->isCheckpointed)); + (TSTR("yaffs_read_super: is_checkpointed %d\n"), + dev->is_checkpointed)); T(YAFFS_TRACE_OS, (TSTR("yaffs_read_super: done\n"))); return sb; @@ -2628,21 +2628,21 @@ static struct file_system_type yaffs2_fs_type = { 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_Device * dev) -{ - buf += sprintf(buf, "startBlock......... %d\n", dev->param.startBlock); - buf += sprintf(buf, "endBlock........... %d\n", dev->param.endBlock); - buf += sprintf(buf, "totalBytesPerChunk. %d\n", dev->param.totalBytesPerChunk); - buf += sprintf(buf, "useNANDECC......... %d\n", dev->param.useNANDECC); - buf += sprintf(buf, "noTagsECC.......... %d\n", dev->param.noTagsECC); - buf += sprintf(buf, "isYaffs2........... %d\n", dev->param.isYaffs2); - buf += sprintf(buf, "inbandTags......... %d\n", dev->param.inbandTags); - buf += sprintf(buf, "emptyLostAndFound.. %d\n", dev->param.emptyLostAndFound); - buf += sprintf(buf, "disableLazyLoad.... %d\n", dev->param.disableLazyLoad); - buf += sprintf(buf, "refreshPeriod...... %d\n", dev->param.refreshPeriod); - buf += sprintf(buf, "nShortOpCaches..... %d\n", dev->param.nShortOpCaches); - buf += sprintf(buf, "nReservedBlocks.... %d\n", dev->param.nReservedBlocks); - buf += sprintf(buf, "alwaysCheckErased...%d\n", dev->param.alwaysCheckErased); +static char *yaffs_dump_dev_part0(char *buf, yaffs_dev_t * dev) +{ + buf += sprintf(buf, "start_block......... %d\n", dev->param.start_block); + buf += sprintf(buf, "end_block........... %d\n", dev->param.end_block); + buf += sprintf(buf, "total_bytes_per_chunk. %d\n", dev->param.total_bytes_per_chunk); + buf += sprintf(buf, "use_nand_ecc......... %d\n", dev->param.use_nand_ecc); + buf += sprintf(buf, "no_tags_ecc.......... %d\n", dev->param.no_tags_ecc); + buf += sprintf(buf, "is_yaffs2........... %d\n", dev->param.is_yaffs2); + buf += sprintf(buf, "inband_tags......... %d\n", dev->param.inband_tags); + buf += sprintf(buf, "empty_lost_n_found.. %d\n", dev->param.empty_lost_n_found); + buf += sprintf(buf, "disable_lazy_load.... %d\n", dev->param.disable_lazy_load); + buf += sprintf(buf, "refresh_period...... %d\n", dev->param.refresh_period); + buf += sprintf(buf, "n_caches..... %d\n", dev->param.n_caches); + buf += sprintf(buf, "n_reserved_blocks.... %d\n", dev->param.n_reserved_blocks); + buf += sprintf(buf, "always_check_erased...%d\n", dev->param.always_check_erased); buf += sprintf(buf, "\n"); @@ -2650,39 +2650,39 @@ static char *yaffs_dump_dev_part0(char *buf, yaffs_Device * dev) } -static char *yaffs_dump_dev_part1(char *buf, yaffs_Device * dev) +static char *yaffs_dump_dev_part1(char *buf, yaffs_dev_t * dev) { - buf += sprintf(buf, "nDataBytesPerChunk. %d\n", dev->nDataBytesPerChunk); - buf += sprintf(buf, "chunkGroupBits..... %d\n", dev->chunkGroupBits); - buf += sprintf(buf, "chunkGroupSize..... %d\n", dev->chunkGroupSize); - buf += sprintf(buf, "nErasedBlocks...... %d\n", dev->nErasedBlocks); - buf += sprintf(buf, "blocksInCheckpoint. %d\n", dev->blocksInCheckpoint); + 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); + buf += sprintf(buf, "chunk_grp_size..... %d\n", dev->chunk_grp_size); + buf += sprintf(buf, "n_erased_blocks...... %d\n", dev->n_erased_blocks); + buf += sprintf(buf, "blocks_in_checkpt. %d\n", dev->blocks_in_checkpt); buf += sprintf(buf, "\n"); - buf += sprintf(buf, "nTnodes............ %d\n", dev->nTnodes); - buf += sprintf(buf, "nObjects........... %d\n", dev->nObjects); - buf += sprintf(buf, "nFreeChunks........ %d\n", dev->nFreeChunks); + buf += sprintf(buf, "n_tnodes............ %d\n", dev->n_tnodes); + buf += sprintf(buf, "n_obj........... %d\n", dev->n_obj); + buf += sprintf(buf, "n_free_chunks........ %d\n", dev->n_free_chunks); buf += sprintf(buf, "\n"); - buf += sprintf(buf, "nPageWrites........ %u\n", dev->nPageWrites); - buf += sprintf(buf, "nPageReads......... %u\n", dev->nPageReads); - buf += sprintf(buf, "nBlockErasures..... %u\n", dev->nBlockErasures); - buf += sprintf(buf, "nGCCopies.......... %u\n", dev->nGCCopies); - buf += sprintf(buf, "allGCs............. %u\n", dev->allGCs); - buf += sprintf(buf, "passiveGCs......... %u\n", dev->passiveGCs); - buf += sprintf(buf, "oldestDirtyGCs..... %u\n", dev->oldestDirtyGCs); - buf += sprintf(buf, "nGCBlocks.......... %u\n", dev->nGCBlocks); - buf += sprintf(buf, "backgroundGCs...... %u\n", dev->backgroundGCs); - buf += sprintf(buf, "nRetriedWrites..... %u\n", dev->nRetriedWrites); - buf += sprintf(buf, "nRetireBlocks...... %u\n", dev->nRetiredBlocks); - buf += sprintf(buf, "eccFixed........... %u\n", dev->eccFixed); - buf += sprintf(buf, "eccUnfixed......... %u\n", dev->eccUnfixed); - buf += sprintf(buf, "tagsEccFixed....... %u\n", dev->tagsEccFixed); - buf += sprintf(buf, "tagsEccUnfixed..... %u\n", dev->tagsEccUnfixed); - buf += sprintf(buf, "cacheHits.......... %u\n", dev->cacheHits); - buf += sprintf(buf, "nDeletedFiles...... %u\n", dev->nDeletedFiles); - buf += sprintf(buf, "nUnlinkedFiles..... %u\n", dev->nUnlinkedFiles); - buf += sprintf(buf, "refreshCount....... %u\n", dev->refreshCount); + buf += sprintf(buf, "n_page_writes........ %u\n", dev->n_page_writes); + buf += sprintf(buf, "n_page_reads......... %u\n", dev->n_page_reads); + buf += sprintf(buf, "n_erasures..... %u\n", dev->n_erasures); + buf += sprintf(buf, "n_gc_copies.......... %u\n", dev->n_gc_copies); + buf += sprintf(buf, "all_gcs............. %u\n", dev->all_gcs); + buf += sprintf(buf, "passive_gc_count......... %u\n", dev->passive_gc_count); + buf += sprintf(buf, "oldest_dirty_gc_count..... %u\n", dev->oldest_dirty_gc_count); + buf += sprintf(buf, "n_gc_blocks.......... %u\n", dev->n_gc_blocks); + buf += sprintf(buf, "bg_gcs...... %u\n", dev->bg_gcs); + buf += sprintf(buf, "n_retired_writes..... %u\n", dev->n_retired_writes); + buf += sprintf(buf, "nRetireBlocks...... %u\n", dev->n_retired_blocks); + buf += sprintf(buf, "n_ecc_fixed........... %u\n", dev->n_ecc_fixed); + buf += sprintf(buf, "n_ecc_unfixed......... %u\n", dev->n_ecc_unfixed); + buf += sprintf(buf, "n_tags_ecc_fixed....... %u\n", dev->n_tags_ecc_fixed); + buf += sprintf(buf, "n_tags_ecc_unfixed..... %u\n", dev->n_tags_ecc_unfixed); + buf += sprintf(buf, "cache_hits.......... %u\n", dev->cache_hits); + buf += sprintf(buf, "n_deleted_files...... %u\n", dev->n_deleted_files); + buf += sprintf(buf, "n_unlinked_files..... %u\n", dev->n_unlinked_files); + buf += sprintf(buf, "refresh_count....... %u\n", dev->refresh_count); buf += - sprintf(buf, "nBackgroudDeletions %u\n", dev->nBackgroundDeletions); + sprintf(buf, "nBackgroudDeletions %u\n", dev->n_bg_deletions); return buf; } @@ -2697,7 +2697,7 @@ static int yaffs_proc_read(char *page, int n = 0; /* Get proc_file_read() to step 'offset' by one on each sucessive call. - * We use 'offset' (*ppos) to indicate where we are in devList. + * We use 'offset' (*ppos) to indicate where we are in dev_list. * This also assumes the user has posted a read buffer large * enough to hold the complete output; but that's life in /proc. */ @@ -2717,7 +2717,7 @@ static int yaffs_proc_read(char *page, /* Locate and print the Nth entry. Order N-squared but N is small. */ ylist_for_each(item, &yaffs_context_list) { struct yaffs_LinuxContext *dc = ylist_entry(item, struct yaffs_LinuxContext, contextList); - yaffs_Device *dev = dc->dev; + yaffs_dev_t *dev = dc->dev; if (n < (step & ~1)) { n+=2; @@ -2750,16 +2750,16 @@ static int yaffs_stats_proc_read(char *page, /* Locate and print the Nth entry. Order N-squared but N is small. */ ylist_for_each(item, &yaffs_context_list) { struct yaffs_LinuxContext *dc = ylist_entry(item, struct yaffs_LinuxContext, contextList); - yaffs_Device *dev = dc->dev; + yaffs_dev_t *dev = dc->dev; int erasedChunks; - erasedChunks = dev->nErasedBlocks * dev->param.nChunksPerBlock; + erasedChunks = dev->n_erased_blocks * dev->param.chunks_per_block; buf += sprintf(buf,"%d, %d, %d, %u, %u, %u, %u\n", - n, dev->nFreeChunks, erasedChunks, - dev->backgroundGCs, dev->oldestDirtyGCs, - dev->nObjects, dev->nTnodes); + n, dev->n_free_chunks, erasedChunks, + dev->bg_gcs, dev->oldest_dirty_gc_count, + dev->n_obj, dev->n_tnodes); } up(&yaffs_context_lock); diff --git a/yaffs_vfs_multi.c b/yaffs_vfs_multi.c index a24e61f..7571b3e 100644 --- a/yaffs_vfs_multi.c +++ b/yaffs_vfs_multi.c @@ -24,11 +24,11 @@ * the VFS. * * Special notes: - * >> 2.4: sb->u.generic_sbp points to the yaffs_Device associated with + * >> 2.4: sb->u.generic_sbp points to the yaffs_dev_t associated with * this superblock - * >> 2.6: sb->s_fs_info points to the yaffs_Device associated with this + * >> 2.6: sb->s_fs_info points to the yaffs_dev_t associated with this * superblock - * >> inode->u.generic_ip points to the associated yaffs_Object. + * >> inode->u.generic_ip points to the associated yaffs_obj_t. */ /* @@ -209,13 +209,13 @@ static struct inode *yaffs_iget(struct super_block *sb, unsigned long ino); #define yaffs_InodeToObjectLV(iptr) ((iptr)->u.generic_ip) #endif -#define yaffs_InodeToObject(iptr) ((yaffs_Object *)(yaffs_InodeToObjectLV(iptr))) +#define yaffs_InodeToObject(iptr) ((yaffs_obj_t *)(yaffs_InodeToObjectLV(iptr))) #define yaffs_dentry_to_obj(dptr) yaffs_InodeToObject((dptr)->d_inode) #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0)) -#define yaffs_SuperToDevice(sb) ((yaffs_Device *)sb->s_fs_info) +#define yaffs_SuperToDevice(sb) ((yaffs_dev_t *)sb->s_fs_info) #else -#define yaffs_SuperToDevice(sb) ((yaffs_Device *)sb->u.generic_sbp) +#define yaffs_SuperToDevice(sb) ((yaffs_dev_t *)sb->u.generic_sbp) #endif @@ -340,7 +340,7 @@ static void *yaffs_follow_link(struct dentry *dentry, struct nameidata *nd); static int yaffs_follow_link(struct dentry *dentry, struct nameidata *nd); #endif -static void yaffs_touch_super(yaffs_Device *dev); +static void yaffs_touch_super(yaffs_dev_t *dev); static loff_t yaffs_dir_llseek(struct file *file, loff_t offset, int origin); @@ -507,19 +507,19 @@ static int yaffs_vfs_setsize(struct inode *inode, loff_t newsize) } -static unsigned yaffs_gc_control_callback(yaffs_Device *dev) +static unsigned yaffs_gc_control_callback(yaffs_dev_t *dev) { return yaffs_gc_control; } -static void yaffs_gross_lock(yaffs_Device *dev) +static void yaffs_gross_lock(yaffs_dev_t *dev) { T(YAFFS_TRACE_LOCK, (TSTR("yaffs locking %p\n"), current)); down(&(yaffs_dev_to_lc(dev)->grossLock)); T(YAFFS_TRACE_LOCK, (TSTR("yaffs locked %p\n"), current)); } -static void yaffs_gross_unlock(yaffs_Device *dev) +static void yaffs_gross_unlock(yaffs_dev_t *dev) { T(YAFFS_TRACE_LOCK, (TSTR("yaffs unlocking %p\n"), current)); up(&(yaffs_dev_to_lc(dev)->grossLock)); @@ -552,8 +552,8 @@ struct dentry *yaffs2_get_parent(struct dentry *dentry) struct dentry *parent = ERR_PTR(-ENOENT); struct inode *inode; unsigned long parent_ino; - yaffs_Object *d_obj; - yaffs_Object *parent_obj; + yaffs_obj_t *d_obj; + yaffs_obj_t *parent_obj; d_obj = yaffs_InodeToObject(dentry->d_inode); @@ -599,11 +599,11 @@ static struct export_operations yaffs_export_ops = * A search context iterates along a doubly linked list of siblings in the * directory. If the iterating object is deleted then this would corrupt * the list iteration, likely causing a crash. The search context avoids - * this by using the removeObjectCallback to move the search context to the + * this by using the remove_obj_fn to move the search context to the * next object before the object is deleted. * * Many readdirs (and thus seach conexts) may be alive simulateously so - * each yaffs_Device has a list of these. + * each yaffs_dev_t has a list of these. * * A seach context lives for the duration of a readdir. * @@ -611,9 +611,9 @@ static struct export_operations yaffs_export_ops = */ struct yaffs_SearchContext { - yaffs_Device *dev; - yaffs_Object *dirObj; - yaffs_Object *nextReturn; + yaffs_dev_t *dev; + yaffs_obj_t *dirObj; + yaffs_obj_t *nextReturn; struct ylist_head others; }; @@ -623,19 +623,19 @@ struct yaffs_SearchContext { * * Called at start of readdir. */ -static struct yaffs_SearchContext * yaffs_NewSearch(yaffs_Object *dir) +static struct yaffs_SearchContext * yaffs_NewSearch(yaffs_obj_t *dir) { - yaffs_Device *dev = dir->myDev; + yaffs_dev_t *dev = dir->my_dev; struct yaffs_SearchContext *sc = YMALLOC(sizeof(struct yaffs_SearchContext)); if(sc){ sc->dirObj = dir; sc->dev = dev; - if( ylist_empty(&sc->dirObj->variant.directoryVariant.children)) + if( ylist_empty(&sc->dirObj->variant.dir_variant.children)) sc->nextReturn = NULL; else sc->nextReturn = ylist_entry( - dir->variant.directoryVariant.children.next, - yaffs_Object,siblings); + dir->variant.dir_variant.children.next, + yaffs_obj_t,siblings); YINIT_LIST_HEAD(&sc->others); ylist_add(&sc->others,&(yaffs_dev_to_lc(dev)->searchContexts)); } @@ -664,15 +664,15 @@ static void yaffs_search_advance(struct yaffs_SearchContext *sc) return; if( sc->nextReturn == NULL || - ylist_empty(&sc->dirObj->variant.directoryVariant.children)) + ylist_empty(&sc->dirObj->variant.dir_variant.children)) sc->nextReturn = NULL; else { struct ylist_head *next = sc->nextReturn->siblings.next; - if( next == &sc->dirObj->variant.directoryVariant.children) + if( next == &sc->dirObj->variant.dir_variant.children) sc->nextReturn = NULL; /* end of list */ else - sc->nextReturn = ylist_entry(next,yaffs_Object,siblings); + sc->nextReturn = ylist_entry(next,yaffs_obj_t,siblings); } } @@ -681,12 +681,12 @@ static void yaffs_search_advance(struct yaffs_SearchContext *sc) * We check open search contexts and advance any which are currently * on the object being iterated. */ -static void yaffs_remove_obj_callback(yaffs_Object *obj) +static void yaffs_remove_obj_callback(yaffs_obj_t *obj) { struct ylist_head *i; struct yaffs_SearchContext *sc; - struct ylist_head *search_contexts = &(yaffs_dev_to_lc(obj->myDev)->searchContexts); + struct ylist_head *search_contexts = &(yaffs_dev_to_lc(obj->my_dev)->searchContexts); /* Iterate through the directory search contexts. @@ -712,7 +712,7 @@ static int yaffs_readlink(struct dentry *dentry, char __user *buffer, unsigned char *alias; int ret; - yaffs_Device *dev = yaffs_dentry_to_obj(dentry)->myDev; + yaffs_dev_t *dev = yaffs_dentry_to_obj(dentry)->my_dev; yaffs_gross_lock(dev); @@ -736,7 +736,7 @@ static int yaffs_follow_link(struct dentry *dentry, struct nameidata *nd) { unsigned char *alias; int ret; - yaffs_Device *dev = yaffs_dentry_to_obj(dentry)->myDev; + yaffs_dev_t *dev = yaffs_dentry_to_obj(dentry)->my_dev; yaffs_gross_lock(dev); @@ -768,7 +768,7 @@ void yaffs_put_link(struct dentry *dentry, struct nameidata *nd, void *alias) { #endif struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev, - yaffs_Object *obj); + yaffs_obj_t *obj); /* * Lookup is used to find objects in the fs @@ -781,17 +781,17 @@ static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry, static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry) #endif { - yaffs_Object *obj; + yaffs_obj_t *obj; struct inode *inode = NULL; /* NCB 2.5/2.6 needs NULL here */ - yaffs_Device *dev = yaffs_InodeToObject(dir)->myDev; + yaffs_dev_t *dev = yaffs_InodeToObject(dir)->my_dev; if(current != yaffs_dev_to_lc(dev)->readdirProcess) yaffs_gross_lock(dev); T(YAFFS_TRACE_OS, (TSTR("yaffs_lookup for %d:%s\n"), - yaffs_InodeToObject(dir)->objectId, dentry->d_name.name)); + yaffs_InodeToObject(dir)->obj_id, dentry->d_name.name)); obj = yaffs_find_by_name(yaffs_InodeToObject(dir), dentry->d_name.name); @@ -804,7 +804,7 @@ static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry) if (obj) { T(YAFFS_TRACE_OS, - (TSTR("yaffs_lookup found %d\n"), obj->objectId)); + (TSTR("yaffs_lookup found %d\n"), obj->obj_id)); inode = yaffs_get_inode(dir->i_sb, obj->yst_mode, 0, obj); @@ -850,12 +850,12 @@ static void yaffs_put_inode(struct inode *inode) #endif -static void yaffs_unstitch_obj(struct inode *inode, yaffs_Object *obj) +static void yaffs_unstitch_obj(struct inode *inode, yaffs_obj_t *obj) { /* Clear the association between the inode and - * the yaffs_Object. + * the yaffs_obj_t. */ - obj->myInode = NULL; + obj->my_inode = NULL; yaffs_InodeToObjectLV(inode) = NULL; /* If the object freeing was deferred, then the real @@ -872,8 +872,8 @@ static void yaffs_unstitch_obj(struct inode *inode, yaffs_Object *obj) */ static void yaffs_evict_inode( struct inode *inode) { - yaffs_Object *obj; - yaffs_Device *dev; + yaffs_obj_t *obj; + yaffs_dev_t *dev; int deleteme = 0; obj = yaffs_InodeToObject(inode); @@ -889,13 +889,13 @@ static void yaffs_evict_inode( struct inode *inode) end_writeback(inode); if(deleteme && obj){ - dev = obj->myDev; + dev = obj->my_dev; yaffs_gross_lock(dev); yaffs_del_obj(obj); yaffs_gross_unlock(dev); } if (obj) { - dev = obj->myDev; + dev = obj->my_dev; yaffs_gross_lock(dev); yaffs_unstitch_obj(inode,obj); yaffs_gross_unlock(dev); @@ -914,8 +914,8 @@ static void yaffs_evict_inode( struct inode *inode) static void yaffs_clear_inode(struct inode *inode) { - yaffs_Object *obj; - yaffs_Device *dev; + yaffs_obj_t *obj; + yaffs_dev_t *dev; obj = yaffs_InodeToObject(inode); @@ -925,7 +925,7 @@ static void yaffs_clear_inode(struct inode *inode) obj ? "object exists" : "null object")); if (obj) { - dev = obj->myDev; + dev = obj->my_dev; yaffs_gross_lock(dev); yaffs_unstitch_obj(inode,obj); yaffs_gross_unlock(dev); @@ -940,8 +940,8 @@ static void yaffs_clear_inode(struct inode *inode) */ static void yaffs_delete_inode(struct inode *inode) { - yaffs_Object *obj = yaffs_InodeToObject(inode); - yaffs_Device *dev; + yaffs_obj_t *obj = yaffs_InodeToObject(inode); + yaffs_dev_t *dev; T(YAFFS_TRACE_OS, (TSTR("yaffs_delete_inode: ino %d, count %d %s\n"), (int)inode->i_ino, @@ -949,7 +949,7 @@ static void yaffs_delete_inode(struct inode *inode) obj ? "object exists" : "null object")); if (obj) { - dev = obj->myDev; + dev = obj->my_dev; yaffs_gross_lock(dev); yaffs_del_obj(obj); yaffs_gross_unlock(dev); @@ -968,12 +968,12 @@ static int yaffs_file_flush(struct file *file, fl_owner_t id) static int yaffs_file_flush(struct file *file) #endif { - yaffs_Object *obj = yaffs_dentry_to_obj(file->f_dentry); + yaffs_obj_t *obj = yaffs_dentry_to_obj(file->f_dentry); - yaffs_Device *dev = obj->myDev; + yaffs_dev_t *dev = obj->my_dev; T(YAFFS_TRACE_OS, - (TSTR("yaffs_file_flush object %d (%s)\n"), obj->objectId, + (TSTR("yaffs_file_flush object %d (%s)\n"), obj->obj_id, obj->dirty ? "dirty" : "clean")); yaffs_gross_lock(dev); @@ -989,11 +989,11 @@ static int yaffs_readpage_nolock(struct file *f, struct page *pg) { /* Lifted from jffs2 */ - yaffs_Object *obj; + yaffs_obj_t *obj; unsigned char *pg_buf; int ret; - yaffs_Device *dev; + yaffs_dev_t *dev; T(YAFFS_TRACE_OS, (TSTR("yaffs_readpage_nolock at %08x, size %08x\n"), @@ -1002,7 +1002,7 @@ static int yaffs_readpage_nolock(struct file *f, struct page *pg) obj = yaffs_dentry_to_obj(f->f_dentry); - dev = obj->myDev; + dev = obj->my_dev; #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0)) BUG_ON(!PageLocked(pg)); @@ -1065,14 +1065,14 @@ static int yaffs_writepage(struct page *page, struct writeback_control *wbc) static int yaffs_writepage(struct page *page) #endif { - yaffs_Device *dev; + yaffs_dev_t *dev; struct address_space *mapping = page->mapping; struct inode *inode; unsigned long end_index; char *buffer; - yaffs_Object *obj; + yaffs_obj_t *obj; int nWritten = 0; - unsigned nBytes; + unsigned n_bytes; loff_t i_size; if (!mapping) @@ -1085,11 +1085,11 @@ static int yaffs_writepage(struct page *page) end_index = i_size >> PAGE_CACHE_SHIFT; if(page->index < end_index) - nBytes = PAGE_CACHE_SIZE; + n_bytes = PAGE_CACHE_SIZE; else { - nBytes = i_size & (PAGE_CACHE_SIZE -1); + n_bytes = i_size & (PAGE_CACHE_SIZE -1); - if (page->index > end_index || !nBytes) { + if (page->index > end_index || !n_bytes) { T(YAFFS_TRACE_OS, (TSTR("yaffs_writepage at %08x, inode size = %08x!!!\n"), (unsigned)(page->index << PAGE_CACHE_SHIFT), @@ -1105,32 +1105,32 @@ static int yaffs_writepage(struct page *page) } } - if(nBytes != PAGE_CACHE_SIZE) - zero_user_segment(page,nBytes,PAGE_CACHE_SIZE); + if(n_bytes != PAGE_CACHE_SIZE) + zero_user_segment(page,n_bytes,PAGE_CACHE_SIZE); get_page(page); buffer = kmap(page); obj = yaffs_InodeToObject(inode); - dev = obj->myDev; + dev = obj->my_dev; yaffs_gross_lock(dev); T(YAFFS_TRACE_OS, (TSTR("yaffs_writepage at %08x, size %08x\n"), - (unsigned)(page->index << PAGE_CACHE_SHIFT), nBytes)); + (unsigned)(page->index << PAGE_CACHE_SHIFT), n_bytes)); T(YAFFS_TRACE_OS, (TSTR("writepag0: obj = %05x, ino = %05x\n"), - (int)obj->variant.fileVariant.fileSize, (int)inode->i_size)); + (int)obj->variant.file_variant.file_size, (int)inode->i_size)); nWritten = yaffs_wr_file(obj, buffer, - page->index << PAGE_CACHE_SHIFT, nBytes, 0); + page->index << PAGE_CACHE_SHIFT, n_bytes, 0); yaffs_touch_super(dev); T(YAFFS_TRACE_OS, (TSTR("writepag1: obj = %05x, ino = %05x\n"), - (int)obj->variant.fileVariant.fileSize, (int)inode->i_size)); + (int)obj->variant.file_variant.file_size, (int)inode->i_size)); yaffs_gross_unlock(dev); @@ -1140,7 +1140,7 @@ static int yaffs_writepage(struct page *page) end_page_writeback(page); put_page(page); - return (nWritten == nBytes) ? 0 : -ENOSPC; + return (nWritten == n_bytes) ? 0 : -ENOSPC; } @@ -1230,7 +1230,7 @@ static int yaffs_write_end(struct file *filp, struct address_space *mapping, addr = kva + offset_into_page; T(YAFFS_TRACE_OS, - ("yaffs_write_end addr %p pos %x nBytes %d\n", + ("yaffs_write_end addr %p pos %x n_bytes %d\n", addr,(unsigned)pos, copied)); ret = yaffs_file_write(filp, addr, copied, &pos); @@ -1259,7 +1259,7 @@ static int yaffs_commit_write(struct file *f, struct page *pg, unsigned offset, void *addr, *kva; loff_t pos = (((loff_t) pg->index) << PAGE_CACHE_SHIFT) + offset; - int nBytes = to - offset; + int n_bytes = to - offset; int nWritten; unsigned spos = pos; @@ -1271,15 +1271,15 @@ static int yaffs_commit_write(struct file *f, struct page *pg, unsigned offset, saddr = (unsigned) addr; T(YAFFS_TRACE_OS, - (TSTR("yaffs_commit_write addr %x pos %x nBytes %d\n"), - saddr, spos, nBytes)); + (TSTR("yaffs_commit_write addr %x pos %x n_bytes %d\n"), + saddr, spos, n_bytes)); - nWritten = yaffs_file_write(f, addr, nBytes, &pos); + nWritten = yaffs_file_write(f, addr, n_bytes, &pos); - if (nWritten != nBytes) { + if (nWritten != n_bytes) { T(YAFFS_TRACE_OS, - (TSTR("yaffs_commit_write not same size nWritten %d nBytes %d\n"), - nWritten, nBytes)); + (TSTR("yaffs_commit_write not same size nWritten %d n_bytes %d\n"), + nWritten, n_bytes)); SetPageError(pg); } else { /* Nothing */ @@ -1289,21 +1289,21 @@ static int yaffs_commit_write(struct file *f, struct page *pg, unsigned offset, T(YAFFS_TRACE_OS, (TSTR("yaffs_commit_write returning %d\n"), - nWritten == nBytes ? 0 : nWritten)); + nWritten == n_bytes ? 0 : nWritten)); - return nWritten == nBytes ? 0 : nWritten; + return nWritten == n_bytes ? 0 : nWritten; } #endif -static void yaffs_fill_inode_from_obj(struct inode *inode, yaffs_Object *obj) +static void yaffs_fill_inode_from_obj(struct inode *inode, yaffs_obj_t *obj) { if (inode && obj) { /* Check mode against the variant type and attempt to repair if broken. */ __u32 mode = obj->yst_mode; - switch (obj->variantType) { + switch (obj->variant_type) { case YAFFS_OBJECT_TYPE_FILE: if (!S_ISREG(mode)) { obj->yst_mode &= ~S_IFMT; @@ -1335,7 +1335,7 @@ static void yaffs_fill_inode_from_obj(struct inode *inode, yaffs_Object *obj) inode->i_flags |= S_NOATIME; - inode->i_ino = obj->objectId; + inode->i_ino = obj->obj_id; inode->i_mode = obj->yst_mode; inode->i_uid = obj->yst_uid; inode->i_gid = obj->yst_gid; @@ -1394,7 +1394,7 @@ static void yaffs_fill_inode_from_obj(struct inode *inode, yaffs_Object *obj) yaffs_InodeToObjectLV(inode) = obj; - obj->myInode = inode; + obj->my_inode = inode; } else { T(YAFFS_TRACE_OS, @@ -1404,7 +1404,7 @@ static void yaffs_fill_inode_from_obj(struct inode *inode, yaffs_Object *obj) } struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev, - yaffs_Object *obj) + yaffs_obj_t *obj) { struct inode *inode; @@ -1423,9 +1423,9 @@ struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev, } T(YAFFS_TRACE_OS, - (TSTR("yaffs_get_inode for object %d\n"), obj->objectId)); + (TSTR("yaffs_get_inode for object %d\n"), obj->obj_id)); - inode = Y_IGET(sb, obj->objectId); + inode = Y_IGET(sb, obj->obj_id); if (IS_ERR(inode)) return NULL; @@ -1439,14 +1439,14 @@ struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev, static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n, loff_t *pos) { - yaffs_Object *obj; + yaffs_obj_t *obj; int nWritten, ipos; struct inode *inode; - yaffs_Device *dev; + yaffs_dev_t *dev; obj = yaffs_dentry_to_obj(f->f_dentry); - dev = obj->myDev; + dev = obj->my_dev; yaffs_gross_lock(dev); @@ -1464,7 +1464,7 @@ static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n, T(YAFFS_TRACE_OS, (TSTR("yaffs_file_write about to write writing %u(%x) bytes" "to object %d at %d(%x)\n"), - (unsigned) n, (unsigned) n, obj->objectId, ipos,ipos)); + (unsigned) n, (unsigned) n, obj->obj_id, ipos,ipos)); nWritten = yaffs_wr_file(obj, buf, ipos, n, 0); @@ -1498,34 +1498,34 @@ static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n, static ssize_t yaffs_hold_space(struct file *f) { - yaffs_Object *obj; - yaffs_Device *dev; + yaffs_obj_t *obj; + yaffs_dev_t *dev; - int nFreeChunks; + int n_free_chunks; obj = yaffs_dentry_to_obj(f->f_dentry); - dev = obj->myDev; + dev = obj->my_dev; yaffs_gross_lock(dev); - nFreeChunks = yaffs_get_n_free_chunks(dev); + n_free_chunks = yaffs_get_n_free_chunks(dev); yaffs_gross_unlock(dev); - return (nFreeChunks > 20) ? 1 : 0; + return (n_free_chunks > 20) ? 1 : 0; } static void yaffs_release_space(struct file *f) { - yaffs_Object *obj; - yaffs_Device *dev; + yaffs_obj_t *obj; + yaffs_dev_t *dev; obj = yaffs_dentry_to_obj(f->f_dentry); - dev = obj->myDev; + dev = obj->my_dev; yaffs_gross_lock(dev); @@ -1562,18 +1562,18 @@ static loff_t yaffs_dir_llseek(struct file *file, loff_t offset, int origin) static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir) { - yaffs_Object *obj; - yaffs_Device *dev; + yaffs_obj_t *obj; + yaffs_dev_t *dev; struct yaffs_SearchContext *sc; struct inode *inode = f->f_dentry->d_inode; unsigned long offset, curoffs; - yaffs_Object *l; + yaffs_obj_t *l; int retVal = 0; char name[YAFFS_MAX_NAME_LENGTH + 1]; obj = yaffs_dentry_to_obj(f->f_dentry); - dev = obj->myDev; + dev = obj->my_dev; yaffs_gross_lock(dev); @@ -1690,10 +1690,10 @@ static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode, { struct inode *inode; - yaffs_Object *obj = NULL; - yaffs_Device *dev; + yaffs_obj_t *obj = NULL; + yaffs_dev_t *dev; - yaffs_Object *parent = yaffs_InodeToObject(dir); + yaffs_obj_t *parent = yaffs_InodeToObject(dir); int error = -ENOSPC; uid_t uid = YCRED(current)->fsuid; @@ -1705,7 +1705,7 @@ static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode, if (parent) { T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod: parent object %d type %d\n"), - parent->objectId, parent->variantType)); + parent->obj_id, parent->variant_type)); } else { T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod: could not get parent object\n"))); @@ -1716,7 +1716,7 @@ static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode, "mode %x dev %x\n"), dentry->d_name.name, mode, rdev)); - dev = parent->myDev; + dev = parent->my_dev; yaffs_gross_lock(dev); @@ -1758,7 +1758,7 @@ static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode, update_dir_time(dir); T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod created object %d count = %d\n"), - obj->objectId, atomic_read(&inode->i_count))); + obj->obj_id, atomic_read(&inode->i_count))); error = 0; yaffs_fill_inode_from_obj(dir,parent); } else { @@ -1793,15 +1793,15 @@ static int yaffs_unlink(struct inode *dir, struct dentry *dentry) { int retVal; - yaffs_Device *dev; - yaffs_Object *obj; + yaffs_dev_t *dev; + yaffs_obj_t *obj; T(YAFFS_TRACE_OS, (TSTR("yaffs_unlink %d:%s\n"), (int)(dir->i_ino), dentry->d_name.name)); obj = yaffs_InodeToObject(dir); - dev = obj->myDev; + dev = obj->my_dev; yaffs_gross_lock(dev); @@ -1826,19 +1826,19 @@ static int yaffs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry) { struct inode *inode = old_dentry->d_inode; - yaffs_Object *obj = NULL; - yaffs_Object *link = NULL; - yaffs_Device *dev; + yaffs_obj_t *obj = NULL; + yaffs_obj_t *link = NULL; + yaffs_dev_t *dev; T(YAFFS_TRACE_OS, (TSTR("yaffs_link\n"))); obj = yaffs_InodeToObject(inode); - dev = obj->myDev; + dev = obj->my_dev; yaffs_gross_lock(dev); if (!S_ISDIR(inode->i_mode)) /* Don't link directories */ - link = yaffs_Link(yaffs_InodeToObject(dir), dentry->d_name.name, + link = yaffs_link_obj(yaffs_InodeToObject(dir), dentry->d_name.name, obj); if (link) { @@ -1864,14 +1864,14 @@ static int yaffs_link(struct dentry *old_dentry, struct inode *dir, static int yaffs_symlink(struct inode *dir, struct dentry *dentry, const char *symname) { - yaffs_Object *obj; - yaffs_Device *dev; + yaffs_obj_t *obj; + yaffs_dev_t *dev; uid_t uid = YCRED(current)->fsuid; gid_t gid = (dir->i_mode & S_ISGID) ? dir->i_gid : YCRED(current)->fsgid; T(YAFFS_TRACE_OS, (TSTR("yaffs_symlink\n"))); - dev = yaffs_InodeToObject(dir)->myDev; + dev = yaffs_InodeToObject(dir)->my_dev; yaffs_gross_lock(dev); obj = yaffs_create_symlink(yaffs_InodeToObject(dir), dentry->d_name.name, S_IFLNK | S_IRWXUGO, uid, gid, symname); @@ -1900,15 +1900,15 @@ static int yaffs_sync_object(struct file *file, struct dentry *dentry, #endif { - yaffs_Object *obj; - yaffs_Device *dev; + yaffs_obj_t *obj; + yaffs_dev_t *dev; #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 34)) struct dentry *dentry = file->f_path.dentry; #endif obj = yaffs_dentry_to_obj(dentry); - dev = obj->myDev; + dev = obj->my_dev; T(YAFFS_TRACE_OS | YAFFS_TRACE_SYNC, (TSTR("yaffs_sync_object\n"))); @@ -1926,12 +1926,12 @@ static int yaffs_sync_object(struct file *file, struct dentry *dentry, static int yaffs_rename(struct inode *old_dir, struct dentry *old_dentry, struct inode *new_dir, struct dentry *new_dentry) { - yaffs_Device *dev; + yaffs_dev_t *dev; int retVal = YAFFS_FAIL; - yaffs_Object *target; + yaffs_obj_t *target; T(YAFFS_TRACE_OS, (TSTR("yaffs_rename\n"))); - dev = yaffs_InodeToObject(old_dir)->myDev; + dev = yaffs_InodeToObject(old_dir)->my_dev; yaffs_gross_lock(dev); @@ -1941,8 +1941,8 @@ static int yaffs_rename(struct inode *old_dir, struct dentry *old_dentry, - if (target && target->variantType == YAFFS_OBJECT_TYPE_DIRECTORY && - !ylist_empty(&target->variant.directoryVariant.children)) { + if (target && target->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY && + !ylist_empty(&target->variant.dir_variant.children)) { T(YAFFS_TRACE_OS, (TSTR("target is non-empty dir\n"))); @@ -1977,11 +1977,11 @@ static int yaffs_setattr(struct dentry *dentry, struct iattr *attr) { struct inode *inode = dentry->d_inode; int error = 0; - yaffs_Device *dev; + yaffs_dev_t *dev; T(YAFFS_TRACE_OS, (TSTR("yaffs_setattr of object %d\n"), - yaffs_InodeToObject(inode)->objectId)); + yaffs_InodeToObject(inode)->obj_id)); /* Fail if a requested resize >= 2GB */ if (attr->ia_valid & ATTR_SIZE && @@ -2000,7 +2000,7 @@ static int yaffs_setattr(struct dentry *dentry, struct iattr *attr) inode->i_blocks = (inode->i_size + 511) >> 9; } } - dev = yaffs_InodeToObject(inode)->myDev; + dev = yaffs_InodeToObject(inode)->my_dev; if (attr->ia_valid & ATTR_SIZE){ T(YAFFS_TRACE_OS,(TSTR("resize to %d(%x)\n"), (int)(attr->ia_size),(int)(attr->ia_size))); @@ -2028,17 +2028,17 @@ int yaffs_setxattr(struct dentry *dentry, const char *name, { struct inode *inode = dentry->d_inode; int error = 0; - yaffs_Device *dev; - yaffs_Object *obj = yaffs_InodeToObject(inode); + yaffs_dev_t *dev; + yaffs_obj_t *obj = yaffs_InodeToObject(inode); T(YAFFS_TRACE_OS, (TSTR("yaffs_setxattr of object %d\n"), - obj->objectId)); + obj->obj_id)); if (error == 0) { int result; - dev = obj->myDev; + dev = obj->my_dev; yaffs_gross_lock(dev); result = yaffs_set_xattrib(obj, name, value, size, flags); if(result == YAFFS_OK) @@ -2060,15 +2060,15 @@ ssize_t yaffs_getxattr(struct dentry *dentry, const char *name, void *buff, { struct inode *inode = dentry->d_inode; int error = 0; - yaffs_Device *dev; - yaffs_Object *obj = yaffs_InodeToObject(inode); + yaffs_dev_t *dev; + yaffs_obj_t *obj = yaffs_InodeToObject(inode); T(YAFFS_TRACE_OS, (TSTR("yaffs_getxattr \"%s\" from object %d\n"), - name, obj->objectId)); + name, obj->obj_id)); if (error == 0) { - dev = obj->myDev; + dev = obj->my_dev; yaffs_gross_lock(dev); error = yaffs_get_xattrib(obj, name, buff, size); yaffs_gross_unlock(dev); @@ -2084,17 +2084,17 @@ int yaffs_removexattr(struct dentry *dentry, const char *name) { struct inode *inode = dentry->d_inode; int error = 0; - yaffs_Device *dev; - yaffs_Object *obj = yaffs_InodeToObject(inode); + yaffs_dev_t *dev; + yaffs_obj_t *obj = yaffs_InodeToObject(inode); T(YAFFS_TRACE_OS, (TSTR("yaffs_removexattr of object %d\n"), - obj->objectId)); + obj->obj_id)); if (error == 0) { int result; - dev = obj->myDev; + dev = obj->my_dev; yaffs_gross_lock(dev); result = yaffs_remove_xattrib(obj, name); if(result == YAFFS_OK) @@ -2114,16 +2114,16 @@ ssize_t yaffs_listxattr(struct dentry *dentry, char *buff, size_t size) { struct inode *inode = dentry->d_inode; int error = 0; - yaffs_Device *dev; - yaffs_Object *obj = yaffs_InodeToObject(inode); + yaffs_dev_t *dev; + yaffs_obj_t *obj = yaffs_InodeToObject(inode); T(YAFFS_TRACE_OS, (TSTR("yaffs_listxattr of object %d\n"), - obj->objectId)); + obj->obj_id)); if (error == 0) { - dev = obj->myDev; + dev = obj->my_dev; yaffs_gross_lock(dev); error = yaffs_list_xattrib(obj, buff, size); yaffs_gross_unlock(dev); @@ -2141,16 +2141,16 @@ ssize_t yaffs_listxattr(struct dentry *dentry, char *buff, size_t size) #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17)) static int yaffs_statfs(struct dentry *dentry, struct kstatfs *buf) { - yaffs_Device *dev = yaffs_dentry_to_obj(dentry)->myDev; + yaffs_dev_t *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_Device *dev = yaffs_SuperToDevice(sb); + yaffs_dev_t *dev = yaffs_SuperToDevice(sb); #else static int yaffs_statfs(struct super_block *sb, struct statfs *buf) { - yaffs_Device *dev = yaffs_SuperToDevice(sb); + yaffs_dev_t *dev = yaffs_SuperToDevice(sb); #endif T(YAFFS_TRACE_OS, (TSTR("yaffs_statfs\n"))); @@ -2161,43 +2161,43 @@ static int yaffs_statfs(struct super_block *sb, struct statfs *buf) buf->f_bsize = sb->s_blocksize; buf->f_namelen = 255; - if (dev->nDataBytesPerChunk & (dev->nDataBytesPerChunk - 1)) { + if (dev->data_bytes_per_chunk & (dev->data_bytes_per_chunk - 1)) { /* Do this if chunk size is not a power of 2 */ uint64_t bytesInDev; uint64_t bytesFree; - bytesInDev = ((uint64_t)((dev->param.endBlock - dev->param.startBlock + 1))) * - ((uint64_t)(dev->param.nChunksPerBlock * dev->nDataBytesPerChunk)); + bytesInDev = ((uint64_t)((dev->param.end_block - dev->param.start_block + 1))) * + ((uint64_t)(dev->param.chunks_per_block * dev->data_bytes_per_chunk)); do_div(bytesInDev, sb->s_blocksize); /* bytesInDev becomes the number of blocks */ buf->f_blocks = bytesInDev; bytesFree = ((uint64_t)(yaffs_get_n_free_chunks(dev))) * - ((uint64_t)(dev->nDataBytesPerChunk)); + ((uint64_t)(dev->data_bytes_per_chunk)); do_div(bytesFree, sb->s_blocksize); buf->f_bfree = bytesFree; - } else if (sb->s_blocksize > dev->nDataBytesPerChunk) { + } else if (sb->s_blocksize > dev->data_bytes_per_chunk) { buf->f_blocks = - (dev->param.endBlock - dev->param.startBlock + 1) * - dev->param.nChunksPerBlock / - (sb->s_blocksize / dev->nDataBytesPerChunk); + (dev->param.end_block - dev->param.start_block + 1) * + dev->param.chunks_per_block / + (sb->s_blocksize / dev->data_bytes_per_chunk); buf->f_bfree = yaffs_get_n_free_chunks(dev) / - (sb->s_blocksize / dev->nDataBytesPerChunk); + (sb->s_blocksize / dev->data_bytes_per_chunk); } else { buf->f_blocks = - (dev->param.endBlock - dev->param.startBlock + 1) * - dev->param.nChunksPerBlock * - (dev->nDataBytesPerChunk / sb->s_blocksize); + (dev->param.end_block - dev->param.start_block + 1) * + dev->param.chunks_per_block * + (dev->data_bytes_per_chunk / sb->s_blocksize); buf->f_bfree = yaffs_get_n_free_chunks(dev) * - (dev->nDataBytesPerChunk / sb->s_blocksize); + (dev->data_bytes_per_chunk / sb->s_blocksize); } buf->f_files = 0; @@ -2213,13 +2213,13 @@ static int yaffs_statfs(struct super_block *sb, struct statfs *buf) static void yaffs_flush_inodes(struct super_block *sb) { struct inode *iptr; - yaffs_Object *obj; + yaffs_obj_t *obj; list_for_each_entry(iptr,&sb->s_inodes, i_sb_list){ obj = yaffs_InodeToObject(iptr); if(obj){ T(YAFFS_TRACE_OS, (TSTR("flushing obj %d\n"), - obj->objectId)); + obj->obj_id)); yaffs_flush_file(obj,1,0); } } @@ -2228,7 +2228,7 @@ static void yaffs_flush_inodes(struct super_block *sb) static void yaffs_flush_super(struct super_block *sb, int do_checkpoint) { - yaffs_Device *dev = yaffs_SuperToDevice(sb); + yaffs_dev_t *dev = yaffs_SuperToDevice(sb); if(!dev) return; @@ -2240,22 +2240,22 @@ static void yaffs_flush_super(struct super_block *sb, int do_checkpoint) } -static unsigned yaffs_bg_gc_urgency(yaffs_Device *dev) +static unsigned yaffs_bg_gc_urgency(yaffs_dev_t *dev) { - unsigned erasedChunks = dev->nErasedBlocks * dev->param.nChunksPerBlock; + unsigned erasedChunks = dev->n_erased_blocks * dev->param.chunks_per_block; struct yaffs_LinuxContext *context = yaffs_dev_to_lc(dev); unsigned scatteredFree = 0; /* Free chunks not in an erased block */ - if(erasedChunks < dev->nFreeChunks) - scatteredFree = (dev->nFreeChunks - erasedChunks); + if(erasedChunks < dev->n_free_chunks) + scatteredFree = (dev->n_free_chunks - erasedChunks); if(!context->bgRunning) return 0; - else if(scatteredFree < (dev->param.nChunksPerBlock * 2)) + else if(scatteredFree < (dev->param.chunks_per_block * 2)) return 0; - else if(erasedChunks > dev->nFreeChunks/2) + else if(erasedChunks > dev->n_free_chunks/2) return 0; - else if(erasedChunks > dev->nFreeChunks/4) + else if(erasedChunks > dev->n_free_chunks/4) return 1; else return 2; @@ -2265,7 +2265,7 @@ static int yaffs_do_sync_fs(struct super_block *sb, int request_checkpoint) { - yaffs_Device *dev = yaffs_SuperToDevice(sb); + yaffs_dev_t *dev = yaffs_SuperToDevice(sb); unsigned int oneshot_checkpoint = (yaffs_auto_checkpoint & 4); unsigned gc_urgent = yaffs_bg_gc_urgency(dev); int do_checkpoint; @@ -2280,10 +2280,10 @@ static int yaffs_do_sync_fs(struct super_block *sb, yaffs_gross_lock(dev); do_checkpoint = ((request_checkpoint && !gc_urgent) || oneshot_checkpoint) && - !dev->isCheckpointed; + !dev->is_checkpointed; if (sb->s_dirt || do_checkpoint) { - yaffs_flush_super(sb, !dev->isCheckpointed && do_checkpoint); + yaffs_flush_super(sb, !dev->is_checkpointed && do_checkpoint); sb->s_dirt = 0; if(oneshot_checkpoint) yaffs_auto_checkpoint &= ~4; @@ -2314,7 +2314,7 @@ void yaffs_background_waker(unsigned long data) static int yaffs_bg_thread_fn(void *data) { - yaffs_Device *dev = (yaffs_Device *)data; + yaffs_dev_t *dev = (yaffs_dev_t *)data; struct yaffs_LinuxContext *context = yaffs_dev_to_lc(dev); unsigned long now = jiffies; unsigned long next_dir_update = now; @@ -2353,7 +2353,7 @@ static int yaffs_bg_thread_fn(void *data) } if(time_after(now,next_gc) && yaffs_bg_enable){ - if(!dev->isCheckpointed){ + if(!dev->is_checkpointed){ urgency = yaffs_bg_gc_urgency(dev); gcResult = yaffs_bg_gc(dev, urgency); if(urgency > 1) @@ -2393,12 +2393,12 @@ static int yaffs_bg_thread_fn(void *data) return 0; } -static int yaffs_bg_start(yaffs_Device *dev) +static int yaffs_bg_start(yaffs_dev_t *dev) { int retval = 0; struct yaffs_LinuxContext *context = yaffs_dev_to_lc(dev); - if(dev->readOnly) + if(dev->read_only) return -1; context->bgRunning = 1; @@ -2414,7 +2414,7 @@ static int yaffs_bg_start(yaffs_Device *dev) return retval; } -static void yaffs_bg_stop(yaffs_Device *dev) +static void yaffs_bg_stop(yaffs_dev_t *dev) { struct yaffs_LinuxContext *ctxt = yaffs_dev_to_lc(dev); @@ -2431,12 +2431,12 @@ static int yaffs_bg_thread_fn(void *data) return 0; } -static int yaffs_bg_start(yaffs_Device *dev) +static int yaffs_bg_start(yaffs_dev_t *dev) { return 0; } -static void yaffs_bg_stop(yaffs_Device *dev) +static void yaffs_bg_stop(yaffs_dev_t *dev) { } #endif @@ -2484,8 +2484,8 @@ static int yaffs_sync_fs(struct super_block *sb) static struct inode *yaffs_iget(struct super_block *sb, unsigned long ino) { struct inode *inode; - yaffs_Object *obj; - yaffs_Device *dev = yaffs_SuperToDevice(sb); + yaffs_obj_t *obj; + yaffs_dev_t *dev = yaffs_SuperToDevice(sb); T(YAFFS_TRACE_OS, (TSTR("yaffs_iget for %lu\n"), ino)); @@ -2522,8 +2522,8 @@ static void yaffs_read_inode(struct inode *inode) * need to lock again. */ - yaffs_Object *obj; - yaffs_Device *dev = yaffs_SuperToDevice(inode->i_sb); + yaffs_obj_t *obj; + yaffs_dev_t *dev = yaffs_SuperToDevice(inode->i_sb); T(YAFFS_TRACE_OS, (TSTR("yaffs_read_inode for %d\n"), (int)inode->i_ino)); @@ -2546,7 +2546,7 @@ struct semaphore yaffs_context_lock; static void yaffs_put_super(struct super_block *sb) { - yaffs_Device *dev = yaffs_SuperToDevice(sb); + yaffs_dev_t *dev = yaffs_SuperToDevice(sb); T(YAFFS_TRACE_OS, (TSTR("yaffs_put_super\n"))); @@ -2592,7 +2592,7 @@ static void yaffs_MTDPutSuper(struct super_block *sb) } -static void yaffs_touch_super(yaffs_Device *dev) +static void yaffs_touch_super(yaffs_dev_t *dev) { struct super_block *sb = yaffs_dev_to_lc(dev)->superBlock; @@ -2684,15 +2684,15 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, int nBlocks; struct inode *inode = NULL; struct dentry *root; - yaffs_Device *dev = 0; + yaffs_dev_t *dev = 0; char devname_buf[BDEVNAME_SIZE + 1]; struct mtd_info *mtd; int err; char *data_str = (char *)data; struct yaffs_LinuxContext *context = NULL; - yaffs_DeviceParam *param; + yaffs_param_t *param; - int readOnly = 0; + int read_only = 0; yaffs_options options; @@ -2705,7 +2705,7 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, sb->s_op = &yaffs_super_ops; sb->s_flags |= MS_NOATIME; - readOnly =((sb->s_flags & MS_RDONLY) != 0); + read_only =((sb->s_flags & MS_RDONLY) != 0); #ifdef YAFFS_COMPILE_EXPORTFS @@ -2722,7 +2722,7 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, printk(KERN_INFO "yaffs: dev is %d name is \"%s\" %s\n", sb->s_dev, yaffs_devname(sb, devname_buf), - readOnly ? "ro" : "rw"); + read_only ? "ro" : "rw"); if (!data_str) data_str = ""; @@ -2859,16 +2859,16 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, /* OK, so if we got here, we have an MTD that's NAND and looks * like it has the right capabilities - * Set the yaffs_Device up for mtd + * Set the yaffs_dev_t up for mtd */ - if (!readOnly && !(mtd->flags & MTD_WRITEABLE)){ - readOnly = 1; + if (!read_only && !(mtd->flags & MTD_WRITEABLE)){ + read_only = 1; printk(KERN_INFO "yaffs: mtd is read only, setting superblock read only"); sb->s_flags |= MS_RDONLY; } - dev = kmalloc(sizeof(yaffs_Device), GFP_KERNEL); + dev = kmalloc(sizeof(yaffs_dev_t), GFP_KERNEL); context = kmalloc(sizeof(struct yaffs_LinuxContext),GFP_KERNEL); if(!dev || !context ){ @@ -2884,19 +2884,19 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, /* Deep shit could not allocate device structure */ T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs_read_super: Failed trying to allocate " - "yaffs_Device. \n"))); + "yaffs_dev_t. \n"))); return NULL; } - memset(dev, 0, sizeof(yaffs_Device)); + memset(dev, 0, sizeof(yaffs_dev_t)); param = &(dev->param); memset(context,0,sizeof(struct yaffs_LinuxContext)); - dev->osContext = context; + dev->os_context = context; YINIT_LIST_HEAD(&(context->contextList)); context->dev = dev; context->superBlock = sb; - dev->readOnly = readOnly; + dev->read_only = read_only; #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0)) sb->s_fs_info = dev; @@ -2904,117 +2904,117 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, sb->u.generic_sbp = dev; #endif - dev->driverContext = mtd; + dev->driver_context = mtd; param->name = mtd->name; /* Set up the memory size parameters.... */ nBlocks = YCALCBLOCKS(mtd->size, (YAFFS_CHUNKS_PER_BLOCK * YAFFS_BYTES_PER_CHUNK)); - param->startBlock = 0; - param->endBlock = nBlocks - 1; - param->nChunksPerBlock = YAFFS_CHUNKS_PER_BLOCK; - param->totalBytesPerChunk = YAFFS_BYTES_PER_CHUNK; - param->nReservedBlocks = 5; - param->nShortOpCaches = (options.no_cache) ? 0 : 10; - param->inbandTags = options.inband_tags; + param->start_block = 0; + param->end_block = nBlocks - 1; + param->chunks_per_block = YAFFS_CHUNKS_PER_BLOCK; + param->total_bytes_per_chunk = YAFFS_BYTES_PER_CHUNK; + param->n_reserved_blocks = 5; + param->n_caches = (options.no_cache) ? 0 : 10; + param->inband_tags = options.inband_tags; #ifdef CONFIG_YAFFS_DISABLE_LAZY_LOAD - param->disableLazyLoad = 1; + param->disable_lazy_load = 1; #endif #ifdef CONFIG_YAFFS_XATTR - param->enableXattr = 1; + param->enable_xattr = 1; #endif if(options.lazy_loading_overridden) - param->disableLazyLoad = !options.lazy_loading_enabled; + param->disable_lazy_load = !options.lazy_loading_enabled; #ifdef CONFIG_YAFFS_DISABLE_TAGS_ECC - param->noTagsECC = 1; + param->no_tags_ecc = 1; #endif #ifdef CONFIG_YAFFS_DISABLE_BACKGROUND #else - param->deferDirectoryUpdate = 1; + param->defered_dir_update = 1; #endif if(options.tags_ecc_overridden) - param->noTagsECC = !options.tags_ecc_on; + param->no_tags_ecc = !options.tags_ecc_on; #ifdef CONFIG_YAFFS_EMPTY_LOST_AND_FOUND - param->emptyLostAndFound = 1; + param->empty_lost_n_found = 1; #endif #ifdef CONFIG_YAFFS_DISABLE_BLOCK_REFRESHING - param->refreshPeriod = 0; + param->refresh_period = 0; #else - param->refreshPeriod = 500; + param->refresh_period = 500; #endif #ifdef CONFIG_YAFFS__ALWAYS_CHECK_CHUNK_ERASED - param->alwaysCheckErased = 1; + param->always_check_erased = 1; #endif if(options.empty_lost_and_found_overridden) - param->emptyLostAndFound = options.empty_lost_and_found; + param->empty_lost_n_found = options.empty_lost_and_found; /* ... and the functions. */ if (yaffs_version == 2) { - param->writeChunkWithTagsToNAND = + param->write_chunk_tags_fn = nandmtd2_WriteChunkWithTagsToNAND; - param->readChunkWithTagsFromNAND = + param->read_chunk_tags_fn = nandmtd2_ReadChunkWithTagsFromNAND; - param->markNANDBlockBad = nandmtd2_MarkNANDBlockBad; - param->queryNANDBlock = nandmtd2_QueryNANDBlock; + param->bad_block_fn = nandmtd2_MarkNANDBlockBad; + param->query_block_fn = nandmtd2_QueryNANDBlock; yaffs_dev_to_lc(dev)->spareBuffer = YMALLOC(mtd->oobsize); - param->isYaffs2 = 1; + param->is_yaffs2 = 1; #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17)) - param->totalBytesPerChunk = mtd->writesize; - param->nChunksPerBlock = mtd->erasesize / mtd->writesize; + param->total_bytes_per_chunk = mtd->writesize; + param->chunks_per_block = mtd->erasesize / mtd->writesize; #else - param->totalBytesPerChunk = mtd->oobblock; - param->nChunksPerBlock = mtd->erasesize / mtd->oobblock; + param->total_bytes_per_chunk = mtd->oobblock; + param->chunks_per_block = mtd->erasesize / mtd->oobblock; #endif nBlocks = YCALCBLOCKS(mtd->size, mtd->erasesize); - param->startBlock = 0; - param->endBlock = nBlocks - 1; + param->start_block = 0; + param->end_block = nBlocks - 1; } else { #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17)) /* use the MTD interface in yaffs_mtdif1.c */ - param->writeChunkWithTagsToNAND = + param->write_chunk_tags_fn = nandmtd1_WriteChunkWithTagsToNAND; - param->readChunkWithTagsFromNAND = + param->read_chunk_tags_fn = nandmtd1_ReadChunkWithTagsFromNAND; - param->markNANDBlockBad = nandmtd1_MarkNANDBlockBad; - param->queryNANDBlock = nandmtd1_QueryNANDBlock; + param->bad_block_fn = nandmtd1_MarkNANDBlockBad; + param->query_block_fn = nandmtd1_QueryNANDBlock; #else - param->writeChunkToNAND = nandmtd_WriteChunkToNAND; - param->readChunkFromNAND = nandmtd_ReadChunkFromNAND; + param->write_chunk_fn = nandmtd_WriteChunkToNAND; + param->read_chunk_fn = nandmtd_ReadChunkFromNAND; #endif - param->isYaffs2 = 0; + param->is_yaffs2 = 0; } /* ... and common functions */ - param->eraseBlockInNAND = nandmtd_EraseBlockInNAND; - param->initialiseNAND = nandmtd_InitialiseNAND; + param->erase_fn = nandmtd_EraseBlockInNAND; + param->initialise_flash_fn = nandmtd_InitialiseNAND; yaffs_dev_to_lc(dev)->putSuperFunc = yaffs_MTDPutSuper; - param->markSuperBlockDirty = yaffs_touch_super; - param->gcControl = yaffs_gc_control_callback; + param->sb_dirty_fn = yaffs_touch_super; + param->gc_control = yaffs_gc_control_callback; yaffs_dev_to_lc(dev)->superBlock= sb; #ifndef CONFIG_YAFFS_DOES_ECC - param->useNANDECC = 1; + param->use_nand_ecc = 1; #endif #ifdef CONFIG_YAFFS_DISABLE_WIDE_TNODES - param->wideTnodesDisabled = 1; + param->wide_tnodes_disabled = 1; #endif - param->skipCheckpointRead = options.skip_checkpoint_read; - param->skipCheckpointWrite = options.skip_checkpoint_write; + param->skip_checkpt_rd = options.skip_checkpoint_read; + param->skip_checkpt_wr = options.skip_checkpoint_write; down(&yaffs_context_lock); /* Get a mount id */ @@ -3034,7 +3034,7 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, /* Directory search handling...*/ YINIT_LIST_HEAD(&(yaffs_dev_to_lc(dev)->searchContexts)); - param->removeObjectCallback = yaffs_remove_obj_callback; + param->remove_obj_fn = yaffs_remove_obj_callback; init_MUTEX(&(yaffs_dev_to_lc(dev)->grossLock)); @@ -3050,7 +3050,7 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, yaffs_bg_start(dev); if(!context->bgThread) - param->deferDirectoryUpdate = 0; + param->defered_dir_update = 0; /* Release lock before yaffs_get_inode() */ @@ -3059,7 +3059,7 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, /* Create root inode */ if (err == YAFFS_OK) inode = yaffs_get_inode(sb, S_IFDIR | 0755, 0, - yaffs_Root(dev)); + yaffs_root(dev)); if (!inode) return NULL; @@ -3078,10 +3078,10 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, return NULL; } sb->s_root = root; - sb->s_dirt = !dev->isCheckpointed; + sb->s_dirt = !dev->is_checkpointed; T(YAFFS_TRACE_ALWAYS, - (TSTR("yaffs_read_super: isCheckpointed %d\n"), - dev->isCheckpointed)); + (TSTR("yaffs_read_super: is_checkpointed %d\n"), + dev->is_checkpointed)); T(YAFFS_TRACE_OS, (TSTR("yaffs_read_super: done\n"))); return sb; @@ -3185,21 +3185,21 @@ static DECLARE_FSTYPE(yaffs2_fs_type, "yaffs2", yaffs2_read_super, static struct proc_dir_entry *my_proc_entry; static struct proc_dir_entry *debug_proc_entry; -static char *yaffs_dump_dev_part0(char *buf, yaffs_Device * dev) -{ - buf += sprintf(buf, "startBlock......... %d\n", dev->param.startBlock); - buf += sprintf(buf, "endBlock........... %d\n", dev->param.endBlock); - buf += sprintf(buf, "totalBytesPerChunk. %d\n", dev->param.totalBytesPerChunk); - buf += sprintf(buf, "useNANDECC......... %d\n", dev->param.useNANDECC); - buf += sprintf(buf, "noTagsECC.......... %d\n", dev->param.noTagsECC); - buf += sprintf(buf, "isYaffs2........... %d\n", dev->param.isYaffs2); - buf += sprintf(buf, "inbandTags......... %d\n", dev->param.inbandTags); - buf += sprintf(buf, "emptyLostAndFound.. %d\n", dev->param.emptyLostAndFound); - buf += sprintf(buf, "disableLazyLoad.... %d\n", dev->param.disableLazyLoad); - buf += sprintf(buf, "refreshPeriod...... %d\n", dev->param.refreshPeriod); - buf += sprintf(buf, "nShortOpCaches..... %d\n", dev->param.nShortOpCaches); - buf += sprintf(buf, "nReservedBlocks.... %d\n", dev->param.nReservedBlocks); - buf += sprintf(buf, "alwaysCheckErased.. %d\n", dev->param.alwaysCheckErased); +static char *yaffs_dump_dev_part0(char *buf, yaffs_dev_t * dev) +{ + buf += sprintf(buf, "start_block......... %d\n", dev->param.start_block); + buf += sprintf(buf, "end_block........... %d\n", dev->param.end_block); + buf += sprintf(buf, "total_bytes_per_chunk. %d\n", dev->param.total_bytes_per_chunk); + buf += sprintf(buf, "use_nand_ecc......... %d\n", dev->param.use_nand_ecc); + buf += sprintf(buf, "no_tags_ecc.......... %d\n", dev->param.no_tags_ecc); + buf += sprintf(buf, "is_yaffs2........... %d\n", dev->param.is_yaffs2); + buf += sprintf(buf, "inband_tags......... %d\n", dev->param.inband_tags); + buf += sprintf(buf, "empty_lost_n_found.. %d\n", dev->param.empty_lost_n_found); + buf += sprintf(buf, "disable_lazy_load.... %d\n", dev->param.disable_lazy_load); + buf += sprintf(buf, "refresh_period...... %d\n", dev->param.refresh_period); + buf += sprintf(buf, "n_caches..... %d\n", dev->param.n_caches); + buf += sprintf(buf, "n_reserved_blocks.... %d\n", dev->param.n_reserved_blocks); + buf += sprintf(buf, "always_check_erased.. %d\n", dev->param.always_check_erased); buf += sprintf(buf, "\n"); @@ -3207,39 +3207,39 @@ static char *yaffs_dump_dev_part0(char *buf, yaffs_Device * dev) } -static char *yaffs_dump_dev_part1(char *buf, yaffs_Device * dev) +static char *yaffs_dump_dev_part1(char *buf, yaffs_dev_t * dev) { - buf += sprintf(buf, "nDataBytesPerChunk. %d\n", dev->nDataBytesPerChunk); - buf += sprintf(buf, "chunkGroupBits..... %d\n", dev->chunkGroupBits); - buf += sprintf(buf, "chunkGroupSize..... %d\n", dev->chunkGroupSize); - buf += sprintf(buf, "nErasedBlocks...... %d\n", dev->nErasedBlocks); - buf += sprintf(buf, "blocksInCheckpoint. %d\n", dev->blocksInCheckpoint); + 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); + buf += sprintf(buf, "chunk_grp_size..... %d\n", dev->chunk_grp_size); + buf += sprintf(buf, "n_erased_blocks...... %d\n", dev->n_erased_blocks); + buf += sprintf(buf, "blocks_in_checkpt. %d\n", dev->blocks_in_checkpt); buf += sprintf(buf, "\n"); - buf += sprintf(buf, "nTnodes............ %d\n", dev->nTnodes); - buf += sprintf(buf, "nObjects........... %d\n", dev->nObjects); - buf += sprintf(buf, "nFreeChunks........ %d\n", dev->nFreeChunks); + buf += sprintf(buf, "n_tnodes............ %d\n", dev->n_tnodes); + buf += sprintf(buf, "n_obj........... %d\n", dev->n_obj); + buf += sprintf(buf, "n_free_chunks........ %d\n", dev->n_free_chunks); buf += sprintf(buf, "\n"); - buf += sprintf(buf, "nPageWrites........ %u\n", dev->nPageWrites); - buf += sprintf(buf, "nPageReads......... %u\n", dev->nPageReads); - buf += sprintf(buf, "nBlockErasures..... %u\n", dev->nBlockErasures); - buf += sprintf(buf, "nGCCopies.......... %u\n", dev->nGCCopies); - buf += sprintf(buf, "allGCs............. %u\n", dev->allGCs); - buf += sprintf(buf, "passiveGCs......... %u\n", dev->passiveGCs); - buf += sprintf(buf, "oldestDirtyGCs..... %u\n", dev->oldestDirtyGCs); - buf += sprintf(buf, "nGCBlocks.......... %u\n", dev->nGCBlocks); - buf += sprintf(buf, "backgroundGCs...... %u\n", dev->backgroundGCs); - buf += sprintf(buf, "nRetriedWrites..... %u\n", dev->nRetriedWrites); - buf += sprintf(buf, "nRetireBlocks...... %u\n", dev->nRetiredBlocks); - buf += sprintf(buf, "eccFixed........... %u\n", dev->eccFixed); - buf += sprintf(buf, "eccUnfixed......... %u\n", dev->eccUnfixed); - buf += sprintf(buf, "tagsEccFixed....... %u\n", dev->tagsEccFixed); - buf += sprintf(buf, "tagsEccUnfixed..... %u\n", dev->tagsEccUnfixed); - buf += sprintf(buf, "cacheHits.......... %u\n", dev->cacheHits); - buf += sprintf(buf, "nDeletedFiles...... %u\n", dev->nDeletedFiles); - buf += sprintf(buf, "nUnlinkedFiles..... %u\n", dev->nUnlinkedFiles); - buf += sprintf(buf, "refreshCount....... %u\n", dev->refreshCount); + buf += sprintf(buf, "n_page_writes........ %u\n", dev->n_page_writes); + buf += sprintf(buf, "n_page_reads......... %u\n", dev->n_page_reads); + buf += sprintf(buf, "n_erasures..... %u\n", dev->n_erasures); + buf += sprintf(buf, "n_gc_copies.......... %u\n", dev->n_gc_copies); + buf += sprintf(buf, "all_gcs............. %u\n", dev->all_gcs); + buf += sprintf(buf, "passive_gc_count......... %u\n", dev->passive_gc_count); + buf += sprintf(buf, "oldest_dirty_gc_count..... %u\n", dev->oldest_dirty_gc_count); + buf += sprintf(buf, "n_gc_blocks.......... %u\n", dev->n_gc_blocks); + buf += sprintf(buf, "bg_gcs...... %u\n", dev->bg_gcs); + buf += sprintf(buf, "n_retired_writes..... %u\n", dev->n_retired_writes); + buf += sprintf(buf, "nRetireBlocks...... %u\n", dev->n_retired_blocks); + buf += sprintf(buf, "n_ecc_fixed........... %u\n", dev->n_ecc_fixed); + buf += sprintf(buf, "n_ecc_unfixed......... %u\n", dev->n_ecc_unfixed); + buf += sprintf(buf, "n_tags_ecc_fixed....... %u\n", dev->n_tags_ecc_fixed); + buf += sprintf(buf, "n_tags_ecc_unfixed..... %u\n", dev->n_tags_ecc_unfixed); + buf += sprintf(buf, "cache_hits.......... %u\n", dev->cache_hits); + buf += sprintf(buf, "n_deleted_files...... %u\n", dev->n_deleted_files); + buf += sprintf(buf, "n_unlinked_files..... %u\n", dev->n_unlinked_files); + buf += sprintf(buf, "refresh_count....... %u\n", dev->refresh_count); buf += - sprintf(buf, "nBackgroudDeletions %u\n", dev->nBackgroundDeletions); + sprintf(buf, "nBackgroudDeletions %u\n", dev->n_bg_deletions); return buf; } @@ -3254,7 +3254,7 @@ static int yaffs_proc_read(char *page, int n = 0; /* Get proc_file_read() to step 'offset' by one on each sucessive call. - * We use 'offset' (*ppos) to indicate where we are in devList. + * We use 'offset' (*ppos) to indicate where we are in dev_list. * This also assumes the user has posted a read buffer large * enough to hold the complete output; but that's life in /proc. */ @@ -3274,7 +3274,7 @@ static int yaffs_proc_read(char *page, /* Locate and print the Nth entry. Order N-squared but N is small. */ ylist_for_each(item, &yaffs_context_list) { struct yaffs_LinuxContext *dc = ylist_entry(item, struct yaffs_LinuxContext, contextList); - yaffs_Device *dev = dc->dev; + yaffs_dev_t *dev = dc->dev; if (n < (step & ~1)) { n+=2; @@ -3307,16 +3307,16 @@ static int yaffs_stats_proc_read(char *page, /* Locate and print the Nth entry. Order N-squared but N is small. */ ylist_for_each(item, &yaffs_context_list) { struct yaffs_LinuxContext *dc = ylist_entry(item, struct yaffs_LinuxContext, contextList); - yaffs_Device *dev = dc->dev; + yaffs_dev_t *dev = dc->dev; int erasedChunks; - erasedChunks = dev->nErasedBlocks * dev->param.nChunksPerBlock; + erasedChunks = dev->n_erased_blocks * dev->param.chunks_per_block; buf += sprintf(buf,"%d, %d, %d, %u, %u, %u, %u\n", - n, dev->nFreeChunks, erasedChunks, - dev->backgroundGCs, dev->oldestDirtyGCs, - dev->nObjects, dev->nTnodes); + n, dev->n_free_chunks, erasedChunks, + dev->bg_gcs, dev->oldest_dirty_gc_count, + dev->n_obj, dev->n_tnodes); } up(&yaffs_context_lock); diff --git a/yaffs_yaffs1.c b/yaffs_yaffs1.c index 5e2d79a..cc71746 100644 --- a/yaffs_yaffs1.c +++ b/yaffs_yaffs1.c @@ -18,9 +18,9 @@ #include "yaffs_nand.h" -int yaffs1_scan(yaffs_Device *dev) +int yaffs1_scan(yaffs_dev_t *dev) { - yaffs_ExtendedTags tags; + yaffs_ext_tags tags; int blk; int blockIterator; int startIterator; @@ -30,17 +30,17 @@ int yaffs1_scan(yaffs_Device *dev) int chunk; int c; int deleted; - yaffs_BlockState state; - yaffs_Object *hardList = NULL; - yaffs_BlockInfo *bi; - __u32 sequenceNumber; - yaffs_ObjectHeader *oh; - yaffs_Object *in; - yaffs_Object *parent; + yaffs_block_state_t state; + yaffs_obj_t *hard_list = NULL; + yaffs_block_info_t *bi; + __u32 seq_number; + yaffs_obj_header *oh; + yaffs_obj_t *in; + yaffs_obj_t *parent; int alloc_failed = 0; - struct yaffs_ShadowFixerStruct *shadowFixerList = NULL; + struct yaffs_shadow_fixer_s *shadowFixerList = NULL; __u8 *chunkData; @@ -49,30 +49,30 @@ int yaffs1_scan(yaffs_Device *dev) T(YAFFS_TRACE_SCAN, (TSTR("yaffs1_scan starts intstartblk %d intendblk %d..." TENDSTR), - dev->internalStartBlock, dev->internalEndBlock)); + dev->internal_start_block, dev->internal_end_block)); chunkData = yaffs_get_temp_buffer(dev, __LINE__); - dev->sequenceNumber = YAFFS_LOWEST_SEQUENCE_NUMBER; + dev->seq_number = YAFFS_LOWEST_SEQUENCE_NUMBER; /* Scan all the blocks to determine their state */ - bi = dev->blockInfo; - for (blk = dev->internalStartBlock; blk <= dev->internalEndBlock; blk++) { + bi = dev->block_info; + for (blk = dev->internal_start_block; blk <= dev->internal_end_block; blk++) { yaffs_clear_chunk_bits(dev, blk); - bi->pagesInUse = 0; - bi->softDeletions = 0; + bi->pages_in_use = 0; + bi->soft_del_pages = 0; - yaffs_query_init_block_state(dev, blk, &state, &sequenceNumber); + yaffs_query_init_block_state(dev, blk, &state, &seq_number); - bi->blockState = state; - bi->sequenceNumber = sequenceNumber; + bi->block_state = state; + bi->seq_number = seq_number; - if (bi->sequenceNumber == YAFFS_SEQUENCE_BAD_BLOCK) - bi->blockState = state = YAFFS_BLOCK_STATE_DEAD; + if (bi->seq_number == YAFFS_SEQUENCE_BAD_BLOCK) + bi->block_state = state = YAFFS_BLOCK_STATE_DEAD; T(YAFFS_TRACE_SCAN_DEBUG, (TSTR("Block scanning block %d state %d seq %d" TENDSTR), blk, - state, sequenceNumber)); + state, seq_number)); if (state == YAFFS_BLOCK_STATE_DEAD) { T(YAFFS_TRACE_BAD_BLOCKS, @@ -80,14 +80,14 @@ int yaffs1_scan(yaffs_Device *dev) } else if (state == YAFFS_BLOCK_STATE_EMPTY) { T(YAFFS_TRACE_SCAN_DEBUG, (TSTR("Block empty " TENDSTR))); - dev->nErasedBlocks++; - dev->nFreeChunks += dev->param.nChunksPerBlock; + dev->n_erased_blocks++; + dev->n_free_chunks += dev->param.chunks_per_block; } bi++; } - startIterator = dev->internalStartBlock; - endIterator = dev->internalEndBlock; + startIterator = dev->internal_start_block; + endIterator = dev->internal_end_block; /* For each block.... */ for (blockIterator = startIterator; !alloc_failed && blockIterator <= endIterator; @@ -100,29 +100,29 @@ int yaffs1_scan(yaffs_Device *dev) blk = blockIterator; bi = yaffs_get_block_info(dev, blk); - state = bi->blockState; + state = bi->block_state; deleted = 0; /* For each chunk in each block that needs scanning....*/ - for (c = 0; !alloc_failed && c < dev->param.nChunksPerBlock && + for (c = 0; !alloc_failed && c < dev->param.chunks_per_block && state == YAFFS_BLOCK_STATE_NEEDS_SCANNING; c++) { /* Read the tags and decide what to do */ - chunk = blk * dev->param.nChunksPerBlock + c; + chunk = blk * dev->param.chunks_per_block + c; result = yaffs_rd_chunk_tags_nand(dev, chunk, NULL, &tags); /* Let's have a good look at this chunk... */ - if (tags.eccResult == YAFFS_ECC_RESULT_UNFIXED || tags.chunkDeleted) { + if (tags.ecc_result == YAFFS_ECC_RESULT_UNFIXED || tags.is_deleted) { /* YAFFS1 only... * A deleted chunk */ deleted++; - dev->nFreeChunks++; + dev->n_free_chunks++; /*T((" %d %d deleted\n",blk,c)); */ - } else if (!tags.chunkUsed) { + } else if (!tags.chunk_used) { /* An unassigned chunk in the block * This means that either the block is empty or * this is the one being allocated from @@ -131,7 +131,7 @@ int yaffs1_scan(yaffs_Device *dev) if (c == 0) { /* We're looking at the first chunk in the block so the block is unused */ state = YAFFS_BLOCK_STATE_EMPTY; - dev->nErasedBlocks++; + dev->n_erased_blocks++; } else { /* this is the block being allocated from */ T(YAFFS_TRACE_SCAN, @@ -139,73 +139,73 @@ int yaffs1_scan(yaffs_Device *dev) (" Allocating from %d %d" TENDSTR), blk, c)); state = YAFFS_BLOCK_STATE_ALLOCATING; - dev->allocationBlock = blk; - dev->allocationPage = c; - dev->allocationBlockFinder = blk; + dev->alloc_block = blk; + dev->alloc_page = c; + dev->alloc_block_finder = blk; /* Set block finder here to encourage the allocator to go forth from here. */ } - dev->nFreeChunks += (dev->param.nChunksPerBlock - c); - } else if (tags.chunkId > 0) { - /* chunkId > 0 so it is a data chunk... */ + dev->n_free_chunks += (dev->param.chunks_per_block - c); + } else if (tags.chunk_id > 0) { + /* chunk_id > 0 so it is a data chunk... */ unsigned int endpos; yaffs_set_chunk_bit(dev, blk, c); - bi->pagesInUse++; + bi->pages_in_use++; in = yaffs_find_or_create_by_number(dev, tags. - objectId, + obj_id, YAFFS_OBJECT_TYPE_FILE); /* PutChunkIntoFile checks for a clash (two data chunks with - * the same chunkId). + * the same chunk_id). */ if (!in) alloc_failed = 1; if (in) { - if (!yaffs_put_chunk_in_file(in, tags.chunkId, chunk, 1)) + if (!yaffs_put_chunk_in_file(in, tags.chunk_id, chunk, 1)) alloc_failed = 1; } endpos = - (tags.chunkId - 1) * dev->nDataBytesPerChunk + - tags.byteCount; + (tags.chunk_id - 1) * dev->data_bytes_per_chunk + + tags.n_bytes; if (in && - in->variantType == YAFFS_OBJECT_TYPE_FILE - && in->variant.fileVariant.scannedFileSize < + in->variant_type == YAFFS_OBJECT_TYPE_FILE + && in->variant.file_variant.scanned_size < endpos) { - in->variant.fileVariant. - scannedFileSize = endpos; - if (!dev->param.useHeaderFileSize) { - in->variant.fileVariant. - fileSize = - in->variant.fileVariant. - scannedFileSize; + in->variant.file_variant. + scanned_size = endpos; + if (!dev->param.use_header_file_size) { + in->variant.file_variant. + file_size = + in->variant.file_variant. + scanned_size; } } - /* T((" %d %d data %d %d\n",blk,c,tags.objectId,tags.chunkId)); */ + /* T((" %d %d data %d %d\n",blk,c,tags.obj_id,tags.chunk_id)); */ } else { - /* chunkId == 0, so it is an ObjectHeader. + /* chunk_id == 0, so it is an ObjectHeader. * Thus, we read in the object header and make the object */ yaffs_set_chunk_bit(dev, blk, c); - bi->pagesInUse++; + bi->pages_in_use++; result = yaffs_rd_chunk_tags_nand(dev, chunk, chunkData, NULL); - oh = (yaffs_ObjectHeader *) chunkData; + oh = (yaffs_obj_header *) chunkData; in = yaffs_find_by_number(dev, - tags.objectId); - if (in && in->variantType != oh->type) { + tags.obj_id); + if (in && in->variant_type != oh->type) { /* This should not happen, but somehow - * Wev'e ended up with an objectId that has been reused but not yet + * Wev'e ended up with an obj_id that has been reused but not yet * deleted, and worse still it has changed type. Delete the old object. */ @@ -216,25 +216,25 @@ int yaffs1_scan(yaffs_Device *dev) in = yaffs_find_or_create_by_number(dev, tags. - objectId, + obj_id, oh->type); if (!in) alloc_failed = 1; - if (in && oh->shadowsObject > 0) { + if (in && oh->shadows_obj > 0) { - struct yaffs_ShadowFixerStruct *fixer; - fixer = YMALLOC(sizeof(struct yaffs_ShadowFixerStruct)); + struct yaffs_shadow_fixer_s *fixer; + fixer = YMALLOC(sizeof(struct yaffs_shadow_fixer_s)); if (fixer) { fixer->next = shadowFixerList; shadowFixerList = fixer; - fixer->objectId = tags.objectId; - fixer->shadowedId = oh->shadowsObject; + fixer->obj_id = tags.obj_id; + fixer->shadowed_id = oh->shadows_obj; T(YAFFS_TRACE_SCAN, (TSTR (" Shadow fixer: %d shadows %d" TENDSTR), - fixer->objectId, fixer->shadowedId)); + fixer->obj_id, fixer->shadowed_id)); } @@ -244,12 +244,12 @@ int yaffs1_scan(yaffs_Device *dev) /* We have already filled this one. We have a duplicate and need to resolve it. */ unsigned existingSerial = in->serial; - unsigned newSerial = tags.serialNumber; + unsigned newSerial = tags.serial_number; if (((existingSerial + 1) & 3) == newSerial) { /* Use new one - destroy the exisiting one */ yaffs_chunk_del(dev, - in->hdrChunk, + in->hdr_chunk, 1, __LINE__); in->valid = 0; } else { @@ -260,11 +260,11 @@ int yaffs1_scan(yaffs_Device *dev) } if (in && !in->valid && - (tags.objectId == YAFFS_OBJECTID_ROOT || - tags.objectId == YAFFS_OBJECTID_LOSTNFOUND)) { + (tags.obj_id == YAFFS_OBJECTID_ROOT || + tags.obj_id == YAFFS_OBJECTID_LOSTNFOUND)) { /* We only load some info, don't fiddle with directory structure */ in->valid = 1; - in->variantType = oh->type; + in->variant_type = oh->type; in->yst_mode = oh->yst_mode; #ifdef CONFIG_YAFFS_WINCE @@ -282,14 +282,14 @@ int yaffs1_scan(yaffs_Device *dev) in->yst_ctime = oh->yst_ctime; in->yst_rdev = oh->yst_rdev; #endif - in->hdrChunk = chunk; - in->serial = tags.serialNumber; + in->hdr_chunk = chunk; + in->serial = tags.serial_number; } else if (in && !in->valid) { /* we need to load this info */ in->valid = 1; - in->variantType = oh->type; + in->variant_type = oh->type; in->yst_mode = oh->yst_mode; #ifdef CONFIG_YAFFS_WINCE @@ -307,8 +307,8 @@ int yaffs1_scan(yaffs_Device *dev) in->yst_ctime = oh->yst_ctime; in->yst_rdev = oh->yst_rdev; #endif - in->hdrChunk = chunk; - in->serial = tags.serialNumber; + in->hdr_chunk = chunk; + in->serial = tags.serial_number; yaffs_set_obj_name_from_oh(in, oh); in->dirty = 0; @@ -319,19 +319,19 @@ int yaffs1_scan(yaffs_Device *dev) parent = yaffs_find_or_create_by_number - (dev, oh->parentObjectId, + (dev, oh->parent_obj_id, YAFFS_OBJECT_TYPE_DIRECTORY); if (!parent) alloc_failed = 1; - if (parent && parent->variantType == + if (parent && parent->variant_type == YAFFS_OBJECT_TYPE_UNKNOWN) { /* Set up as a directory */ - parent->variantType = + parent->variant_type = YAFFS_OBJECT_TYPE_DIRECTORY; YINIT_LIST_HEAD(&parent->variant. - directoryVariant. + dir_variant. children); - } else if (!parent || parent->variantType != + } else if (!parent || parent->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) { /* Hoosterman, another problem.... * We're trying to use a non-directory as a directory @@ -341,15 +341,15 @@ int yaffs1_scan(yaffs_Device *dev) (TSTR ("yaffs tragedy: attempting to use non-directory as a directory in scan. Put in lost+found." TENDSTR))); - parent = dev->lostNFoundDir; + parent = dev->lost_n_found; } yaffs_add_obj_to_dir(parent, in); - if (0 && (parent == dev->deletedDir || - parent == dev->unlinkedDir)) { + if (0 && (parent == dev->del_dir || + parent == dev->unlinked_dir)) { in->deleted = 1; /* If it is unlinked at start up then it wants deleting */ - dev->nDeletedFiles++; + dev->n_deleted_files++; } /* Note re hardlinks. * Since we might scan a hardlink before its equivalent object is scanned @@ -358,26 +358,26 @@ int yaffs1_scan(yaffs_Device *dev) * list and fix up all the chains. */ - switch (in->variantType) { + switch (in->variant_type) { case YAFFS_OBJECT_TYPE_UNKNOWN: /* Todo got a problem */ break; case YAFFS_OBJECT_TYPE_FILE: - if (dev->param.useHeaderFileSize) + if (dev->param.use_header_file_size) - in->variant.fileVariant. - fileSize = - oh->fileSize; + in->variant.file_variant. + file_size = + oh->file_size; break; case YAFFS_OBJECT_TYPE_HARDLINK: - in->variant.hardLinkVariant. - equivalentObjectId = - oh->equivalentObjectId; - in->hardLinks.next = + in->variant.hardlink_variant. + equiv_id = + oh->equiv_id; + in->hard_links.next = (struct ylist_head *) - hardList; - hardList = in; + hard_list; + hard_list = in; break; case YAFFS_OBJECT_TYPE_DIRECTORY: /* Do nothing */ @@ -386,9 +386,9 @@ int yaffs1_scan(yaffs_Device *dev) /* Do nothing */ break; case YAFFS_OBJECT_TYPE_SYMLINK: - in->variant.symLinkVariant.alias = + in->variant.symlink_variant.alias = yaffs_clone_str(oh->alias); - if (!in->variant.symLinkVariant.alias) + if (!in->variant.symlink_variant.alias) alloc_failed = 1; break; } @@ -405,15 +405,15 @@ int yaffs1_scan(yaffs_Device *dev) if (state == YAFFS_BLOCK_STATE_ALLOCATING) { /* If the block was partially allocated then treat it as fully allocated.*/ state = YAFFS_BLOCK_STATE_FULL; - dev->allocationBlock = -1; + dev->alloc_block = -1; } - bi->blockState = state; + bi->block_state = state; /* Now let's see if it was dirty */ - if (bi->pagesInUse == 0 && - !bi->hasShrinkHeader && - bi->blockState == YAFFS_BLOCK_STATE_FULL) { + if (bi->pages_in_use == 0 && + !bi->has_shrink_hdr && + bi->block_state == YAFFS_BLOCK_STATE_FULL) { yaffs_block_became_dirty(dev, blk); } @@ -426,12 +426,12 @@ int yaffs1_scan(yaffs_Device *dev) * hardlinks. */ - yaffs_link_fixup(dev, hardList); + yaffs_link_fixup(dev, hard_list); /* Fix up any shadowed objects */ { - struct yaffs_ShadowFixerStruct *fixer; - yaffs_Object *obj; + struct yaffs_shadow_fixer_s *fixer; + yaffs_obj_t *obj; while (shadowFixerList) { fixer = shadowFixerList; @@ -439,11 +439,11 @@ int yaffs1_scan(yaffs_Device *dev) /* Complete the rename transaction by deleting the shadowed object * then setting the object header to unshadowed. */ - obj = yaffs_find_by_number(dev, fixer->shadowedId); + obj = yaffs_find_by_number(dev, fixer->shadowed_id); if (obj) yaffs_del_obj(obj); - obj = yaffs_find_by_number(dev, fixer->objectId); + obj = yaffs_find_by_number(dev, fixer->obj_id); if (obj) yaffs_update_oh(obj, NULL, 1, 0, 0, NULL); diff --git a/yaffs_yaffs1.h b/yaffs_yaffs1.h index 20c190f..1f60b0c 100644 --- a/yaffs_yaffs1.h +++ b/yaffs_yaffs1.h @@ -17,6 +17,6 @@ #define __YAFFS_YAFFS1_H__ #include "yaffs_guts.h" -int yaffs1_scan(yaffs_Device *dev); +int yaffs1_scan(yaffs_dev_t *dev); #endif diff --git a/yaffs_yaffs2.c b/yaffs_yaffs2.c index d108399..58c3600 100644 --- a/yaffs_yaffs2.c +++ b/yaffs_yaffs2.c @@ -41,90 +41,90 @@ * yaffs2_find_oldest_dirty_seq() * Calculate the oldest dirty sequence number if we don't know it. */ -void yaffs_calc_oldest_dirty_seq(yaffs_Device *dev) +void yaffs_calc_oldest_dirty_seq(yaffs_dev_t *dev) { int i; unsigned seq; - unsigned blockNo = 0; - yaffs_BlockInfo *b; + unsigned block_no = 0; + yaffs_block_info_t *b; - if(!dev->param.isYaffs2) + if(!dev->param.is_yaffs2) return; /* Find the oldest dirty sequence number. */ - seq = dev->sequenceNumber + 1; - b = dev->blockInfo; - for (i = dev->internalStartBlock; i <= dev->internalEndBlock; i++) { - if (b->blockState == YAFFS_BLOCK_STATE_FULL && - (b->pagesInUse - b->softDeletions) < dev->param.nChunksPerBlock && - b->sequenceNumber < seq) { - seq = b->sequenceNumber; - blockNo = i; + seq = dev->seq_number + 1; + b = dev->block_info; + for (i = dev->internal_start_block; i <= dev->internal_end_block; i++) { + if (b->block_state == YAFFS_BLOCK_STATE_FULL && + (b->pages_in_use - b->soft_del_pages) < dev->param.chunks_per_block && + b->seq_number < seq) { + seq = b->seq_number; + block_no = i; } b++; } - if(blockNo){ - dev->oldestDirtySequence = seq; - dev->oldestDirtyBlock = blockNo; + if(block_no){ + dev->oldest_dirty_seq = seq; + dev->oldest_dirty_block = block_no; } } -void yaffs2_find_oldest_dirty_seq(yaffs_Device *dev) +void yaffs2_find_oldest_dirty_seq(yaffs_dev_t *dev) { - if(!dev->param.isYaffs2) + if(!dev->param.is_yaffs2) return; - if(!dev->oldestDirtySequence) + if(!dev->oldest_dirty_seq) yaffs_calc_oldest_dirty_seq(dev); } /* * yaffs_clear_oldest_dirty_seq() - * Called when a block is erased or marked bad. (ie. when its sequenceNumber + * Called when a block is erased or marked bad. (ie. when its seq_number * becomes invalid). If the value matches the oldest then we clear - * dev->oldestDirtySequence to force its recomputation. + * dev->oldest_dirty_seq to force its recomputation. */ -void yaffs2_clear_oldest_dirty_seq(yaffs_Device *dev, yaffs_BlockInfo *bi) +void yaffs2_clear_oldest_dirty_seq(yaffs_dev_t *dev, yaffs_block_info_t *bi) { - if(!dev->param.isYaffs2) + if(!dev->param.is_yaffs2) return; - if(!bi || bi->sequenceNumber == dev->oldestDirtySequence){ - dev->oldestDirtySequence = 0; - dev->oldestDirtyBlock = 0; + if(!bi || bi->seq_number == dev->oldest_dirty_seq){ + dev->oldest_dirty_seq = 0; + dev->oldest_dirty_block = 0; } } /* * yaffs2_update_oldest_dirty_seq() * Update the oldest dirty sequence number whenever we dirty a block. - * Only do this if the oldestDirtySequence is actually being tracked. + * Only do this if the oldest_dirty_seq is actually being tracked. */ -void yaffs2_update_oldest_dirty_seq(yaffs_Device *dev, unsigned blockNo, yaffs_BlockInfo *bi) +void yaffs2_update_oldest_dirty_seq(yaffs_dev_t *dev, unsigned block_no, yaffs_block_info_t *bi) { - if(!dev->param.isYaffs2) + if(!dev->param.is_yaffs2) return; - if(dev->oldestDirtySequence){ - if(dev->oldestDirtySequence > bi->sequenceNumber){ - dev->oldestDirtySequence = bi->sequenceNumber; - dev->oldestDirtyBlock = blockNo; + if(dev->oldest_dirty_seq){ + if(dev->oldest_dirty_seq > bi->seq_number){ + dev->oldest_dirty_seq = bi->seq_number; + dev->oldest_dirty_block = block_no; } } } -int yaffs_block_ok_for_gc(yaffs_Device *dev, - yaffs_BlockInfo *bi) +int yaffs_block_ok_for_gc(yaffs_dev_t *dev, + yaffs_block_info_t *bi) { - if (!dev->param.isYaffs2) + if (!dev->param.is_yaffs2) return 1; /* disqualification only applies to yaffs2. */ - if (!bi->hasShrinkHeader) + if (!bi->has_shrink_hdr) return 1; /* can gc */ yaffs2_find_oldest_dirty_seq(dev); @@ -132,7 +132,7 @@ int yaffs_block_ok_for_gc(yaffs_Device *dev, /* Can't do gc of this block if there are any blocks older than this one that have * discarded pages. */ - return (bi->sequenceNumber <= dev->oldestDirtySequence); + return (bi->seq_number <= dev->oldest_dirty_seq); } /* @@ -140,31 +140,31 @@ int yaffs_block_ok_for_gc(yaffs_Device *dev, * periodically finds the oldest full block by sequence number for refreshing. * Only for yaffs2. */ -__u32 yaffs2_find_refresh_block(yaffs_Device *dev) +__u32 yaffs2_find_refresh_block(yaffs_dev_t *dev) { __u32 b ; __u32 oldest = 0; __u32 oldestSequence = 0; - yaffs_BlockInfo *bi; + yaffs_block_info_t *bi; - if(!dev->param.isYaffs2) + if(!dev->param.is_yaffs2) return oldest; /* * If refresh period < 10 then refreshing is disabled. */ - if(dev->param.refreshPeriod < 10) + if(dev->param.refresh_period < 10) return oldest; /* * Fix broken values. */ - if(dev->refreshSkip > dev->param.refreshPeriod) - dev->refreshSkip = dev->param.refreshPeriod; + if(dev->refresh_skip > dev->param.refresh_period) + dev->refresh_skip = dev->param.refresh_period; - if(dev->refreshSkip > 0) + if(dev->refresh_skip > 0) return oldest; /* @@ -172,17 +172,17 @@ __u32 yaffs2_find_refresh_block(yaffs_Device *dev) * We'll do a refresh this time around.... * Update the refresh skip and find the oldest block. */ - dev->refreshSkip = dev->param.refreshPeriod; - dev->refreshCount++; - bi = dev->blockInfo; - for (b = dev->internalStartBlock; b <=dev->internalEndBlock; b++){ + dev->refresh_skip = dev->param.refresh_period; + dev->refresh_count++; + bi = dev->block_info; + for (b = dev->internal_start_block; b <=dev->internal_end_block; b++){ - if (bi->blockState == YAFFS_BLOCK_STATE_FULL){ + if (bi->block_state == YAFFS_BLOCK_STATE_FULL){ if(oldest < 1 || - bi->sequenceNumber < oldestSequence){ + bi->seq_number < oldestSequence){ oldest = b; - oldestSequence = bi->sequenceNumber; + oldestSequence = bi->seq_number; } } bi++; @@ -190,58 +190,58 @@ __u32 yaffs2_find_refresh_block(yaffs_Device *dev) if (oldest > 0) { T(YAFFS_TRACE_GC, - (TSTR("GC refresh count %d selected block %d with sequenceNumber %d" TENDSTR), - dev->refreshCount, oldest, oldestSequence)); + (TSTR("GC refresh count %d selected block %d with seq_number %d" TENDSTR), + dev->refresh_count, oldest, oldestSequence)); } return oldest; } -int yaffs2_checkpt_required(yaffs_Device *dev) +int yaffs2_checkpt_required(yaffs_dev_t *dev) { int nblocks; - if(!dev->param.isYaffs2) + if(!dev->param.is_yaffs2) return 0; - nblocks = dev->internalEndBlock - dev->internalStartBlock + 1 ; + nblocks = dev->internal_end_block - dev->internal_start_block + 1 ; - return !dev->param.skipCheckpointWrite && - !dev->readOnly && + return !dev->param.skip_checkpt_wr && + !dev->read_only && (nblocks >= YAFFS_CHECKPOINT_MIN_BLOCKS); } -int yaffs_calc_checkpt_blocks_required(yaffs_Device *dev) +int yaffs_calc_checkpt_blocks_required(yaffs_dev_t *dev) { int retval; - if(!dev->param.isYaffs2) + if(!dev->param.is_yaffs2) return 0; - if (!dev->nCheckpointBlocksRequired && + if (!dev->checkpoint_blocks_required && yaffs2_checkpt_required(dev)){ /* Not a valid value so recalculate */ - int nBytes = 0; + int n_bytes = 0; int nBlocks; - int devBlocks = (dev->param.endBlock - dev->param.startBlock + 1); + int devBlocks = (dev->param.end_block - dev->param.start_block + 1); - nBytes += sizeof(yaffs_CheckpointValidity); - nBytes += sizeof(yaffs_CheckpointDevice); - nBytes += devBlocks * sizeof(yaffs_BlockInfo); - nBytes += devBlocks * dev->chunkBitmapStride; - nBytes += (sizeof(yaffs_CheckpointObject) + sizeof(__u32)) * (dev->nObjects); - nBytes += (dev->tnodeSize + sizeof(__u32)) * (dev->nTnodes); - nBytes += sizeof(yaffs_CheckpointValidity); - nBytes += sizeof(__u32); /* checksum*/ + n_bytes += sizeof(yaffs_checkpt_validty_t); + n_bytes += sizeof(yaffs_checkpt_dev_t); + n_bytes += devBlocks * sizeof(yaffs_block_info_t); + n_bytes += devBlocks * dev->chunk_bit_stride; + n_bytes += (sizeof(yaffs_checkpt_obj_t) + 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(__u32); /* checksum*/ /* Round up and add 2 blocks to allow for some bad blocks, so add 3 */ - nBlocks = (nBytes/(dev->nDataBytesPerChunk * dev->param.nChunksPerBlock)) + 3; + nBlocks = (n_bytes/(dev->data_bytes_per_chunk * dev->param.chunks_per_block)) + 3; - dev->nCheckpointBlocksRequired = nBlocks; + dev->checkpoint_blocks_required = nBlocks; } - retval = dev->nCheckpointBlocksRequired - dev->blocksInCheckpoint; + retval = dev->checkpoint_blocks_required - dev->blocks_in_checkpt; if(retval < 0) retval = 0; return retval; @@ -250,13 +250,13 @@ int yaffs_calc_checkpt_blocks_required(yaffs_Device *dev) /*--------------------- Checkpointing --------------------*/ -static int yaffs2_wr_checkpt_validity_marker(yaffs_Device *dev, int head) +static int yaffs2_wr_checkpt_validity_marker(yaffs_dev_t *dev, int head) { - yaffs_CheckpointValidity cp; + yaffs_checkpt_validty_t cp; memset(&cp, 0, sizeof(cp)); - cp.structType = sizeof(cp); + cp.struct_type = sizeof(cp); cp.magic = YAFFS_MAGIC; cp.version = YAFFS_CHECKPOINT_VERSION; cp.head = (head) ? 1 : 0; @@ -265,85 +265,85 @@ static int yaffs2_wr_checkpt_validity_marker(yaffs_Device *dev, int head) 1 : 0; } -static int yaffs2_rd_checkpt_validty_marker(yaffs_Device *dev, int head) +static int yaffs2_rd_checkpt_validty_marker(yaffs_dev_t *dev, int head) { - yaffs_CheckpointValidity cp; + yaffs_checkpt_validty_t cp; int ok; ok = (yaffs2_checkpt_rd(dev, &cp, sizeof(cp)) == sizeof(cp)); if (ok) - ok = (cp.structType == sizeof(cp)) && + ok = (cp.struct_type == sizeof(cp)) && (cp.magic == YAFFS_MAGIC) && (cp.version == YAFFS_CHECKPOINT_VERSION) && (cp.head == ((head) ? 1 : 0)); return ok ? 1 : 0; } -static void yaffs2_dev_to_checkpt_dev(yaffs_CheckpointDevice *cp, - yaffs_Device *dev) +static void yaffs2_dev_to_checkpt_dev(yaffs_checkpt_dev_t *cp, + yaffs_dev_t *dev) { - cp->nErasedBlocks = dev->nErasedBlocks; - cp->allocationBlock = dev->allocationBlock; - cp->allocationPage = dev->allocationPage; - cp->nFreeChunks = dev->nFreeChunks; + cp->n_erased_blocks = dev->n_erased_blocks; + cp->alloc_block = dev->alloc_block; + cp->alloc_page = dev->alloc_page; + cp->n_free_chunks = dev->n_free_chunks; - cp->nDeletedFiles = dev->nDeletedFiles; - cp->nUnlinkedFiles = dev->nUnlinkedFiles; - cp->nBackgroundDeletions = dev->nBackgroundDeletions; - cp->sequenceNumber = dev->sequenceNumber; + cp->n_deleted_files = dev->n_deleted_files; + cp->n_unlinked_files = dev->n_unlinked_files; + cp->n_bg_deletions = dev->n_bg_deletions; + cp->seq_number = dev->seq_number; } -static void yaffs_checkpt_dev_to_dev(yaffs_Device *dev, - yaffs_CheckpointDevice *cp) +static void yaffs_checkpt_dev_to_dev(yaffs_dev_t *dev, + yaffs_checkpt_dev_t *cp) { - dev->nErasedBlocks = cp->nErasedBlocks; - dev->allocationBlock = cp->allocationBlock; - dev->allocationPage = cp->allocationPage; - dev->nFreeChunks = cp->nFreeChunks; - - dev->nDeletedFiles = cp->nDeletedFiles; - dev->nUnlinkedFiles = cp->nUnlinkedFiles; - dev->nBackgroundDeletions = cp->nBackgroundDeletions; - dev->sequenceNumber = cp->sequenceNumber; + dev->n_erased_blocks = cp->n_erased_blocks; + dev->alloc_block = cp->alloc_block; + dev->alloc_page = cp->alloc_page; + dev->n_free_chunks = cp->n_free_chunks; + + dev->n_deleted_files = cp->n_deleted_files; + dev->n_unlinked_files = cp->n_unlinked_files; + dev->n_bg_deletions = cp->n_bg_deletions; + dev->seq_number = cp->seq_number; } -static int yaffs2_wr_checkpt_dev(yaffs_Device *dev) +static int yaffs2_wr_checkpt_dev(yaffs_dev_t *dev) { - yaffs_CheckpointDevice cp; - __u32 nBytes; - __u32 nBlocks = (dev->internalEndBlock - dev->internalStartBlock + 1); + yaffs_checkpt_dev_t cp; + __u32 n_bytes; + __u32 nBlocks = (dev->internal_end_block - dev->internal_start_block + 1); int ok; /* Write device runtime values*/ yaffs2_dev_to_checkpt_dev(&cp, dev); - cp.structType = sizeof(cp); + cp.struct_type = sizeof(cp); ok = (yaffs2_checkpt_wr(dev, &cp, sizeof(cp)) == sizeof(cp)); /* Write block info */ if (ok) { - nBytes = nBlocks * sizeof(yaffs_BlockInfo); - ok = (yaffs2_checkpt_wr(dev, dev->blockInfo, nBytes) == nBytes); + n_bytes = nBlocks * sizeof(yaffs_block_info_t); + ok = (yaffs2_checkpt_wr(dev, dev->block_info, n_bytes) == n_bytes); } /* Write chunk bits */ if (ok) { - nBytes = nBlocks * dev->chunkBitmapStride; - ok = (yaffs2_checkpt_wr(dev, dev->chunkBits, nBytes) == nBytes); + n_bytes = nBlocks * dev->chunk_bit_stride; + ok = (yaffs2_checkpt_wr(dev, dev->chunk_bits, n_bytes) == n_bytes); } return ok ? 1 : 0; } -static int yaffs2_rd_checkpt_dev(yaffs_Device *dev) +static int yaffs2_rd_checkpt_dev(yaffs_dev_t *dev) { - yaffs_CheckpointDevice cp; - __u32 nBytes; - __u32 nBlocks = (dev->internalEndBlock - dev->internalStartBlock + 1); + yaffs_checkpt_dev_t cp; + __u32 n_bytes; + __u32 nBlocks = (dev->internal_end_block - dev->internal_start_block + 1); int ok; @@ -351,111 +351,111 @@ static int yaffs2_rd_checkpt_dev(yaffs_Device *dev) if (!ok) return 0; - if (cp.structType != sizeof(cp)) + if (cp.struct_type != sizeof(cp)) return 0; yaffs_checkpt_dev_to_dev(dev, &cp); - nBytes = nBlocks * sizeof(yaffs_BlockInfo); + n_bytes = nBlocks * sizeof(yaffs_block_info_t); - ok = (yaffs2_checkpt_rd(dev, dev->blockInfo, nBytes) == nBytes); + ok = (yaffs2_checkpt_rd(dev, dev->block_info, n_bytes) == n_bytes); if (!ok) return 0; - nBytes = nBlocks * dev->chunkBitmapStride; + n_bytes = nBlocks * dev->chunk_bit_stride; - ok = (yaffs2_checkpt_rd(dev, dev->chunkBits, nBytes) == nBytes); + ok = (yaffs2_checkpt_rd(dev, dev->chunk_bits, n_bytes) == n_bytes); return ok ? 1 : 0; } -static void yaffs2_obj_checkpt_obj(yaffs_CheckpointObject *cp, - yaffs_Object *obj) +static void yaffs2_obj_checkpt_obj(yaffs_checkpt_obj_t *cp, + yaffs_obj_t *obj) { - cp->objectId = obj->objectId; - cp->parentId = (obj->parent) ? obj->parent->objectId : 0; - cp->hdrChunk = obj->hdrChunk; - cp->variantType = obj->variantType; + cp->obj_id = obj->obj_id; + cp->parent_id = (obj->parent) ? obj->parent->obj_id : 0; + cp->hdr_chunk = obj->hdr_chunk; + cp->variant_type = obj->variant_type; cp->deleted = obj->deleted; - cp->softDeleted = obj->softDeleted; + cp->soft_del = obj->soft_del; cp->unlinked = obj->unlinked; cp->fake = obj->fake; - cp->renameAllowed = obj->renameAllowed; - cp->unlinkAllowed = obj->unlinkAllowed; + cp->rename_allowed = obj->rename_allowed; + cp->unlink_allowed = obj->unlink_allowed; cp->serial = obj->serial; - cp->nDataChunks = obj->nDataChunks; + cp->n_data_chunks = obj->n_data_chunks; - if (obj->variantType == YAFFS_OBJECT_TYPE_FILE) - cp->fileSizeOrEquivalentObjectId = obj->variant.fileVariant.fileSize; - else if (obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK) - cp->fileSizeOrEquivalentObjectId = obj->variant.hardLinkVariant.equivalentObjectId; + if (obj->variant_type == YAFFS_OBJECT_TYPE_FILE) + cp->size_or_equiv_obj = obj->variant.file_variant.file_size; + else if (obj->variant_type == YAFFS_OBJECT_TYPE_HARDLINK) + cp->size_or_equiv_obj = obj->variant.hardlink_variant.equiv_id; } -static int taffs2_checkpt_obj_to_obj(yaffs_Object *obj, yaffs_CheckpointObject *cp) +static int taffs2_checkpt_obj_to_obj(yaffs_obj_t *obj, yaffs_checkpt_obj_t *cp) { - yaffs_Object *parent; + yaffs_obj_t *parent; - if (obj->variantType != cp->variantType) { + if (obj->variant_type != cp->variant_type) { T(YAFFS_TRACE_ERROR, (TSTR("Checkpoint read object %d type %d " TCONT("chunk %d does not match existing object type %d") - TENDSTR), cp->objectId, cp->variantType, cp->hdrChunk, - obj->variantType)); + TENDSTR), cp->obj_id, cp->variant_type, cp->hdr_chunk, + obj->variant_type)); return 0; } - obj->objectId = cp->objectId; + obj->obj_id = cp->obj_id; - if (cp->parentId) + if (cp->parent_id) parent = yaffs_find_or_create_by_number( - obj->myDev, - cp->parentId, + obj->my_dev, + cp->parent_id, YAFFS_OBJECT_TYPE_DIRECTORY); else parent = NULL; if (parent) { - if (parent->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) { + if (parent->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) { T(YAFFS_TRACE_ALWAYS, (TSTR("Checkpoint read object %d parent %d type %d" TCONT(" chunk %d Parent type, %d, not directory") TENDSTR), - cp->objectId, cp->parentId, cp->variantType, - cp->hdrChunk, parent->variantType)); + cp->obj_id, cp->parent_id, cp->variant_type, + cp->hdr_chunk, parent->variant_type)); return 0; } yaffs_add_obj_to_dir(parent, obj); } - obj->hdrChunk = cp->hdrChunk; - obj->variantType = cp->variantType; + obj->hdr_chunk = cp->hdr_chunk; + obj->variant_type = cp->variant_type; obj->deleted = cp->deleted; - obj->softDeleted = cp->softDeleted; + obj->soft_del = cp->soft_del; obj->unlinked = cp->unlinked; obj->fake = cp->fake; - obj->renameAllowed = cp->renameAllowed; - obj->unlinkAllowed = cp->unlinkAllowed; + obj->rename_allowed = cp->rename_allowed; + obj->unlink_allowed = cp->unlink_allowed; obj->serial = cp->serial; - obj->nDataChunks = cp->nDataChunks; + obj->n_data_chunks = cp->n_data_chunks; - if (obj->variantType == YAFFS_OBJECT_TYPE_FILE) - obj->variant.fileVariant.fileSize = cp->fileSizeOrEquivalentObjectId; - else if (obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK) - obj->variant.hardLinkVariant.equivalentObjectId = cp->fileSizeOrEquivalentObjectId; + if (obj->variant_type == YAFFS_OBJECT_TYPE_FILE) + obj->variant.file_variant.file_size = cp->size_or_equiv_obj; + else if (obj->variant_type == YAFFS_OBJECT_TYPE_HARDLINK) + obj->variant.hardlink_variant.equiv_id = cp->size_or_equiv_obj; - if (obj->hdrChunk > 0) - obj->lazyLoaded = 1; + if (obj->hdr_chunk > 0) + obj->lazy_loaded = 1; return 1; } -static int yaffs2_checkpt_tnode_worker(yaffs_Object *in, yaffs_tnode_t *tn, - __u32 level, int chunkOffset) +static int yaffs2_checkpt_tnode_worker(yaffs_obj_t *in, yaffs_tnode_t *tn, + __u32 level, int chunk_offset) { int i; - yaffs_Device *dev = in->myDev; + yaffs_dev_t *dev = in->my_dev; int ok = 1; if (tn) { @@ -466,14 +466,14 @@ static int yaffs2_checkpt_tnode_worker(yaffs_Object *in, yaffs_tnode_t *tn, ok = yaffs2_checkpt_tnode_worker(in, tn->internal[i], level - 1, - (chunkOffset<<YAFFS_TNODES_INTERNAL_BITS) + i); + (chunk_offset<<YAFFS_TNODES_INTERNAL_BITS) + i); } } } else if (level == 0) { - __u32 baseOffset = chunkOffset << YAFFS_TNODES_LEVEL0_BITS; + __u32 baseOffset = chunk_offset << YAFFS_TNODES_LEVEL0_BITS; ok = (yaffs2_checkpt_wr(dev, &baseOffset, sizeof(baseOffset)) == sizeof(baseOffset)); if (ok) - ok = (yaffs2_checkpt_wr(dev, tn, dev->tnodeSize) == dev->tnodeSize); + ok = (yaffs2_checkpt_wr(dev, tn, dev->tnode_size) == dev->tnode_size); } } @@ -481,30 +481,30 @@ static int yaffs2_checkpt_tnode_worker(yaffs_Object *in, yaffs_tnode_t *tn, } -static int yaffs2_wr_checkpt_tnodes(yaffs_Object *obj) +static int yaffs2_wr_checkpt_tnodes(yaffs_obj_t *obj) { __u32 endMarker = ~0; int ok = 1; - if (obj->variantType == YAFFS_OBJECT_TYPE_FILE) { + if (obj->variant_type == YAFFS_OBJECT_TYPE_FILE) { ok = yaffs2_checkpt_tnode_worker(obj, - obj->variant.fileVariant.top, - obj->variant.fileVariant.topLevel, + obj->variant.file_variant.top, + obj->variant.file_variant.top_level, 0); if (ok) - ok = (yaffs2_checkpt_wr(obj->myDev, &endMarker, sizeof(endMarker)) == + ok = (yaffs2_checkpt_wr(obj->my_dev, &endMarker, sizeof(endMarker)) == sizeof(endMarker)); } return ok ? 1 : 0; } -static int yaffs2_rd_checkpt_tnodes(yaffs_Object *obj) +static int yaffs2_rd_checkpt_tnodes(yaffs_obj_t *obj) { __u32 baseChunk; int ok = 1; - yaffs_Device *dev = obj->myDev; - yaffs_FileStructure *fileStructPtr = &obj->variant.fileVariant; + yaffs_dev_t *dev = obj->my_dev; + yaffs_file_s *fileStructPtr = &obj->variant.file_variant; yaffs_tnode_t *tn; int nread = 0; @@ -517,7 +517,7 @@ static int yaffs2_rd_checkpt_tnodes(yaffs_Object *obj) tn = yaffs_get_tnode(dev); if (tn){ - ok = (yaffs2_checkpt_rd(dev, tn, dev->tnodeSize) == dev->tnodeSize); + ok = (yaffs2_checkpt_rd(dev, tn, dev->tnode_size) == dev->tnode_size); } else ok = 0; @@ -540,10 +540,10 @@ static int yaffs2_rd_checkpt_tnodes(yaffs_Object *obj) } -static int yaffs2_wr_checkpt_objs(yaffs_Device *dev) +static int yaffs2_wr_checkpt_objs(yaffs_dev_t *dev) { - yaffs_Object *obj; - yaffs_CheckpointObject cp; + yaffs_obj_t *obj; + yaffs_checkpt_obj_t cp; int i; int ok = 1; struct ylist_head *lh; @@ -554,20 +554,20 @@ static int yaffs2_wr_checkpt_objs(yaffs_Device *dev) */ for (i = 0; ok && i < YAFFS_NOBJECT_BUCKETS; i++) { - ylist_for_each(lh, &dev->objectBucket[i].list) { + ylist_for_each(lh, &dev->obj_bucket[i].list) { if (lh) { - obj = ylist_entry(lh, yaffs_Object, hashLink); - if (!obj->deferedFree) { + obj = ylist_entry(lh, yaffs_obj_t, hash_link); + if (!obj->defered_free) { yaffs2_obj_checkpt_obj(&cp, obj); - cp.structType = sizeof(cp); + cp.struct_type = sizeof(cp); T(YAFFS_TRACE_CHECKPOINT, ( TSTR("Checkpoint write object %d parent %d type %d chunk %d obj addr %p" TENDSTR), - cp.objectId, cp.parentId, cp.variantType, cp.hdrChunk, obj)); + cp.obj_id, cp.parent_id, cp.variant_type, cp.hdr_chunk, obj)); ok = (yaffs2_checkpt_wr(dev, &cp, sizeof(cp)) == sizeof(cp)); - if (ok && obj->variantType == YAFFS_OBJECT_TYPE_FILE) + if (ok && obj->variant_type == YAFFS_OBJECT_TYPE_FILE) ok = yaffs2_wr_checkpt_tnodes(obj); } } @@ -575,8 +575,8 @@ static int yaffs2_wr_checkpt_objs(yaffs_Device *dev) } /* Dump end of list */ - memset(&cp, 0xFF, sizeof(yaffs_CheckpointObject)); - cp.structType = sizeof(cp); + memset(&cp, 0xFF, sizeof(yaffs_checkpt_obj_t)); + cp.struct_type = sizeof(cp); if (ok) ok = (yaffs2_checkpt_wr(dev, &cp, sizeof(cp)) == sizeof(cp)); @@ -584,39 +584,39 @@ static int yaffs2_wr_checkpt_objs(yaffs_Device *dev) return ok ? 1 : 0; } -static int yaffs2_rd_checkpt_objs(yaffs_Device *dev) +static int yaffs2_rd_checkpt_objs(yaffs_dev_t *dev) { - yaffs_Object *obj; - yaffs_CheckpointObject cp; + yaffs_obj_t *obj; + yaffs_checkpt_obj_t cp; int ok = 1; int done = 0; - yaffs_Object *hardList = NULL; + yaffs_obj_t *hard_list = NULL; while (ok && !done) { ok = (yaffs2_checkpt_rd(dev, &cp, sizeof(cp)) == sizeof(cp)); - if (cp.structType != sizeof(cp)) { + if (cp.struct_type != sizeof(cp)) { T(YAFFS_TRACE_CHECKPOINT, (TSTR("struct size %d instead of %d ok %d"TENDSTR), - cp.structType, (int)sizeof(cp), ok)); + cp.struct_type, (int)sizeof(cp), ok)); ok = 0; } T(YAFFS_TRACE_CHECKPOINT, (TSTR("Checkpoint read object %d parent %d type %d chunk %d " TENDSTR), - cp.objectId, cp.parentId, cp.variantType, cp.hdrChunk)); + cp.obj_id, cp.parent_id, cp.variant_type, cp.hdr_chunk)); - if (ok && cp.objectId == ~0) + if (ok && cp.obj_id == ~0) done = 1; else if (ok) { - obj = yaffs_find_or_create_by_number(dev, cp.objectId, cp.variantType); + obj = yaffs_find_or_create_by_number(dev, cp.obj_id, cp.variant_type); if (obj) { ok = taffs2_checkpt_obj_to_obj(obj, &cp); if (!ok) break; - if (obj->variantType == YAFFS_OBJECT_TYPE_FILE) { + if (obj->variant_type == YAFFS_OBJECT_TYPE_FILE) { ok = yaffs2_rd_checkpt_tnodes(obj); - } else if (obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK) { - obj->hardLinks.next = - (struct ylist_head *) hardList; - hardList = obj; + } else if (obj->variant_type == YAFFS_OBJECT_TYPE_HARDLINK) { + obj->hard_links.next = + (struct ylist_head *) hard_list; + hard_list = obj; } } else ok = 0; @@ -624,19 +624,19 @@ static int yaffs2_rd_checkpt_objs(yaffs_Device *dev) } if (ok) - yaffs_link_fixup(dev, hardList); + yaffs_link_fixup(dev, hard_list); return ok ? 1 : 0; } -static int yaffs2_wr_checkpt_sum(yaffs_Device *dev) +static int yaffs2_wr_checkpt_sum(yaffs_dev_t *dev) { - __u32 checkpointSum; + __u32 checkpt_sum; int ok; - yaffs2_get_checkpt_sum(dev, &checkpointSum); + yaffs2_get_checkpt_sum(dev, &checkpt_sum); - ok = (yaffs2_checkpt_wr(dev, &checkpointSum, sizeof(checkpointSum)) == sizeof(checkpointSum)); + ok = (yaffs2_checkpt_wr(dev, &checkpt_sum, sizeof(checkpt_sum)) == sizeof(checkpt_sum)); if (!ok) return 0; @@ -644,27 +644,27 @@ static int yaffs2_wr_checkpt_sum(yaffs_Device *dev) return 1; } -static int yaffs2_rd_checkpt_sum(yaffs_Device *dev) +static int yaffs2_rd_checkpt_sum(yaffs_dev_t *dev) { - __u32 checkpointSum0; - __u32 checkpointSum1; + __u32 checkpt_sum0; + __u32 checkpt_sum1; int ok; - yaffs2_get_checkpt_sum(dev, &checkpointSum0); + yaffs2_get_checkpt_sum(dev, &checkpt_sum0); - ok = (yaffs2_checkpt_rd(dev, &checkpointSum1, sizeof(checkpointSum1)) == sizeof(checkpointSum1)); + ok = (yaffs2_checkpt_rd(dev, &checkpt_sum1, sizeof(checkpt_sum1)) == sizeof(checkpt_sum1)); if (!ok) return 0; - if (checkpointSum0 != checkpointSum1) + if (checkpt_sum0 != checkpt_sum1) return 0; return 1; } -static int yaffs2_wr_checkpt_data(yaffs_Device *dev) +static int yaffs2_wr_checkpt_data(yaffs_dev_t *dev) { int ok = 1; @@ -700,21 +700,21 @@ static int yaffs2_wr_checkpt_data(yaffs_Device *dev) ok = 0; if (ok) - dev->isCheckpointed = 1; + dev->is_checkpointed = 1; else - dev->isCheckpointed = 0; + dev->is_checkpointed = 0; - return dev->isCheckpointed; + return dev->is_checkpointed; } -static int yaffs2_rd_checkpt_data(yaffs_Device *dev) +static int yaffs2_rd_checkpt_data(yaffs_dev_t *dev) { int ok = 1; - if(!dev->param.isYaffs2) + if(!dev->param.is_yaffs2) ok = 0; - if (ok && dev->param.skipCheckpointRead) { + if (ok && dev->param.skip_checkpt_rd) { T(YAFFS_TRACE_CHECKPOINT, (TSTR("skipping checkpoint read" TENDSTR))); ok = 0; } @@ -748,64 +748,64 @@ static int yaffs2_rd_checkpt_data(yaffs_Device *dev) ok = 0; if (ok) - dev->isCheckpointed = 1; + dev->is_checkpointed = 1; else - dev->isCheckpointed = 0; + dev->is_checkpointed = 0; return ok ? 1 : 0; } -void yaffs2_checkpt_invalidate(yaffs_Device *dev) +void yaffs2_checkpt_invalidate(yaffs_dev_t *dev) { - if (dev->isCheckpointed || - dev->blocksInCheckpoint > 0) { - dev->isCheckpointed = 0; + if (dev->is_checkpointed || + dev->blocks_in_checkpt > 0) { + dev->is_checkpointed = 0; yaffs2_checkpt_invalidate_stream(dev); } - if (dev->param.markSuperBlockDirty) - dev->param.markSuperBlockDirty(dev); + if (dev->param.sb_dirty_fn) + dev->param.sb_dirty_fn(dev); } -int yaffs_checkpoint_save(yaffs_Device *dev) +int yaffs_checkpoint_save(yaffs_dev_t *dev) { - T(YAFFS_TRACE_CHECKPOINT, (TSTR("save entry: isCheckpointed %d"TENDSTR), dev->isCheckpointed)); + T(YAFFS_TRACE_CHECKPOINT, (TSTR("save entry: is_checkpointed %d"TENDSTR), dev->is_checkpointed)); yaffs_verify_objects(dev); yaffs_verify_blocks(dev); yaffs_verify_free_chunks(dev); - if (!dev->isCheckpointed) { + if (!dev->is_checkpointed) { yaffs2_checkpt_invalidate(dev); yaffs2_wr_checkpt_data(dev); } - T(YAFFS_TRACE_ALWAYS, (TSTR("save exit: isCheckpointed %d"TENDSTR), dev->isCheckpointed)); + T(YAFFS_TRACE_ALWAYS, (TSTR("save exit: is_checkpointed %d"TENDSTR), dev->is_checkpointed)); - return dev->isCheckpointed; + return dev->is_checkpointed; } -int yaffs2_checkpt_restore(yaffs_Device *dev) +int yaffs2_checkpt_restore(yaffs_dev_t *dev) { int retval; - T(YAFFS_TRACE_CHECKPOINT, (TSTR("restore entry: isCheckpointed %d"TENDSTR), dev->isCheckpointed)); + T(YAFFS_TRACE_CHECKPOINT, (TSTR("restore entry: is_checkpointed %d"TENDSTR), dev->is_checkpointed)); retval = yaffs2_rd_checkpt_data(dev); - if (dev->isCheckpointed) { + if (dev->is_checkpointed) { yaffs_verify_objects(dev); yaffs_verify_blocks(dev); yaffs_verify_free_chunks(dev); } - T(YAFFS_TRACE_CHECKPOINT, (TSTR("restore exit: isCheckpointed %d"TENDSTR), dev->isCheckpointed)); + T(YAFFS_TRACE_CHECKPOINT, (TSTR("restore exit: is_checkpointed %d"TENDSTR), dev->is_checkpointed)); return retval; } -int yaffs2_handle_hole(yaffs_Object *obj, loff_t newSize) +int yaffs2_handle_hole(yaffs_obj_t *obj, loff_t new_size) { /* if newsSize > oldFileSize. * We're going to be writing a hole. @@ -817,7 +817,7 @@ int yaffs2_handle_hole(yaffs_Object *obj, loff_t newSize) int increase; int smallHole ; int result = YAFFS_OK; - yaffs_Device *dev = NULL; + yaffs_dev_t *dev = NULL; __u8 *localBuffer = NULL; @@ -826,23 +826,23 @@ int yaffs2_handle_hole(yaffs_Object *obj, loff_t newSize) if(!obj) return YAFFS_FAIL; - if(obj->variantType != YAFFS_OBJECT_TYPE_FILE) + if(obj->variant_type != YAFFS_OBJECT_TYPE_FILE) return YAFFS_FAIL; - dev = obj->myDev; + dev = obj->my_dev; /* Bail out if not yaffs2 mode */ - if(!dev->param.isYaffs2) + if(!dev->param.is_yaffs2) return YAFFS_OK; - oldFileSize = obj->variant.fileVariant.fileSize; + oldFileSize = obj->variant.file_variant.file_size; - if (newSize <= oldFileSize) + if (new_size <= oldFileSize) return YAFFS_OK; - increase = newSize - oldFileSize; + increase = new_size - oldFileSize; - if(increase < YAFFS_SMALL_HOLE_THRESHOLD * dev->nDataBytesPerChunk && + if(increase < YAFFS_SMALL_HOLE_THRESHOLD * dev->data_bytes_per_chunk && yaffs_check_alloc_available(dev, YAFFS_SMALL_HOLE_THRESHOLD + 1)) smallHole = 1; else @@ -856,13 +856,13 @@ int yaffs2_handle_hole(yaffs_Object *obj, loff_t newSize) int pos = oldFileSize; int thisWrite; int written; - memset(localBuffer,0,dev->nDataBytesPerChunk); + memset(localBuffer,0,dev->data_bytes_per_chunk); smallIncreaseOk = 1; while(increase > 0 && smallIncreaseOk){ thisWrite = increase; - if(thisWrite > dev->nDataBytesPerChunk) - thisWrite = dev->nDataBytesPerChunk; + if(thisWrite > dev->data_bytes_per_chunk) + thisWrite = dev->data_bytes_per_chunk; written = yaffs_do_file_wr(obj,localBuffer,pos,thisWrite,0); if(written == thisWrite){ pos += thisWrite; @@ -880,8 +880,8 @@ int yaffs2_handle_hole(yaffs_Object *obj, loff_t newSize) if (!smallIncreaseOk && obj->parent && - obj->parent->objectId != YAFFS_OBJECTID_UNLINKED && - obj->parent->objectId != YAFFS_OBJECTID_DELETED){ + obj->parent->obj_id != YAFFS_OBJECTID_UNLINKED && + obj->parent->obj_id != YAFFS_OBJECTID_DELETED){ /* Write a hole start header with the old file size */ yaffs_update_oh(obj, NULL, 0, 1, 0, NULL); } @@ -909,9 +909,9 @@ static int yaffs2_ybicmp(const void *a, const void *b) return aseq - bseq; } -int yaffs2_scan_backwards(yaffs_Device *dev) +int yaffs2_scan_backwards(yaffs_dev_t *dev) { - yaffs_ExtendedTags tags; + yaffs_ext_tags tags; int blk; int blockIterator; int startIterator; @@ -922,21 +922,21 @@ int yaffs2_scan_backwards(yaffs_Device *dev) int result; int c; int deleted; - yaffs_BlockState state; - yaffs_Object *hardList = NULL; - yaffs_BlockInfo *bi; - __u32 sequenceNumber; - yaffs_ObjectHeader *oh; - yaffs_Object *in; - yaffs_Object *parent; - int nBlocks = dev->internalEndBlock - dev->internalStartBlock + 1; + yaffs_block_state_t state; + yaffs_obj_t *hard_list = NULL; + yaffs_block_info_t *bi; + __u32 seq_number; + yaffs_obj_header *oh; + yaffs_obj_t *in; + yaffs_obj_t *parent; + int nBlocks = dev->internal_end_block - dev->internal_start_block + 1; int itsUnlinked; __u8 *chunkData; - int fileSize; - int isShrink; + int file_size; + int is_shrink; int foundChunksInBlock; - int equivalentObjectId; + int equiv_id; int alloc_failed = 0; @@ -946,10 +946,10 @@ int yaffs2_scan_backwards(yaffs_Device *dev) T(YAFFS_TRACE_SCAN, (TSTR ("yaffs2_scan_backwards starts intstartblk %d intendblk %d..." - TENDSTR), dev->internalStartBlock, dev->internalEndBlock)); + TENDSTR), dev->internal_start_block, dev->internal_end_block)); - dev->sequenceNumber = YAFFS_LOWEST_SEQUENCE_NUMBER; + dev->seq_number = YAFFS_LOWEST_SEQUENCE_NUMBER; blockIndex = YMALLOC(nBlocks * sizeof(yaffs_BlockIndex)); @@ -964,34 +964,34 @@ int yaffs2_scan_backwards(yaffs_Device *dev) return YAFFS_FAIL; } - dev->blocksInCheckpoint = 0; + dev->blocks_in_checkpt = 0; chunkData = yaffs_get_temp_buffer(dev, __LINE__); /* Scan all the blocks to determine their state */ - bi = dev->blockInfo; - for (blk = dev->internalStartBlock; blk <= dev->internalEndBlock; blk++) { + bi = dev->block_info; + for (blk = dev->internal_start_block; blk <= dev->internal_end_block; blk++) { yaffs_clear_chunk_bits(dev, blk); - bi->pagesInUse = 0; - bi->softDeletions = 0; + bi->pages_in_use = 0; + bi->soft_del_pages = 0; - yaffs_query_init_block_state(dev, blk, &state, &sequenceNumber); + yaffs_query_init_block_state(dev, blk, &state, &seq_number); - bi->blockState = state; - bi->sequenceNumber = sequenceNumber; + bi->block_state = state; + bi->seq_number = seq_number; - if (bi->sequenceNumber == YAFFS_SEQUENCE_CHECKPOINT_DATA) - bi->blockState = state = YAFFS_BLOCK_STATE_CHECKPOINT; - if (bi->sequenceNumber == YAFFS_SEQUENCE_BAD_BLOCK) - bi->blockState = state = YAFFS_BLOCK_STATE_DEAD; + if (bi->seq_number == YAFFS_SEQUENCE_CHECKPOINT_DATA) + bi->block_state = state = YAFFS_BLOCK_STATE_CHECKPOINT; + if (bi->seq_number == YAFFS_SEQUENCE_BAD_BLOCK) + bi->block_state = state = YAFFS_BLOCK_STATE_DEAD; T(YAFFS_TRACE_SCAN_DEBUG, (TSTR("Block scanning block %d state %d seq %d" TENDSTR), blk, - state, sequenceNumber)); + state, seq_number)); if (state == YAFFS_BLOCK_STATE_CHECKPOINT) { - dev->blocksInCheckpoint++; + dev->blocks_in_checkpt++; } else if (state == YAFFS_BLOCK_STATE_DEAD) { T(YAFFS_TRACE_BAD_BLOCKS, @@ -999,27 +999,27 @@ int yaffs2_scan_backwards(yaffs_Device *dev) } else if (state == YAFFS_BLOCK_STATE_EMPTY) { T(YAFFS_TRACE_SCAN_DEBUG, (TSTR("Block empty " TENDSTR))); - dev->nErasedBlocks++; - dev->nFreeChunks += dev->param.nChunksPerBlock; + dev->n_erased_blocks++; + dev->n_free_chunks += dev->param.chunks_per_block; } else if (state == YAFFS_BLOCK_STATE_NEEDS_SCANNING) { /* Determine the highest sequence number */ - if (sequenceNumber >= YAFFS_LOWEST_SEQUENCE_NUMBER && - sequenceNumber < YAFFS_HIGHEST_SEQUENCE_NUMBER) { + if (seq_number >= YAFFS_LOWEST_SEQUENCE_NUMBER && + seq_number < YAFFS_HIGHEST_SEQUENCE_NUMBER) { - blockIndex[nBlocksToScan].seq = sequenceNumber; + blockIndex[nBlocksToScan].seq = seq_number; blockIndex[nBlocksToScan].block = blk; nBlocksToScan++; - if (sequenceNumber >= dev->sequenceNumber) - dev->sequenceNumber = sequenceNumber; + if (seq_number >= dev->seq_number) + dev->seq_number = seq_number; } else { /* TODO: Nasty sequence number! */ T(YAFFS_TRACE_SCAN, (TSTR ("Block scanning block %d has bad sequence number %d" - TENDSTR), blk, sequenceNumber)); + TENDSTR), blk, seq_number)); } } @@ -1059,13 +1059,13 @@ int yaffs2_scan_backwards(yaffs_Device *dev) bi = yaffs_get_block_info(dev, blk); - state = bi->blockState; + state = bi->block_state; deleted = 0; /* For each chunk in each block that needs scanning.... */ foundChunksInBlock = 0; - for (c = dev->param.nChunksPerBlock - 1; + for (c = dev->param.chunks_per_block - 1; !alloc_failed && c >= 0 && (state == YAFFS_BLOCK_STATE_NEEDS_SCANNING || state == YAFFS_BLOCK_STATE_ALLOCATING); c--) { @@ -1073,14 +1073,14 @@ int yaffs2_scan_backwards(yaffs_Device *dev) * Read the tags and decide what to do */ - chunk = blk * dev->param.nChunksPerBlock + c; + chunk = blk * dev->param.chunks_per_block + c; result = yaffs_rd_chunk_tags_nand(dev, chunk, NULL, &tags); /* Let's have a good look at this chunk... */ - if (!tags.chunkUsed) { + if (!tags.chunk_used) { /* An unassigned chunk in the block. * If there are used chunks after this one, then * it is a chunk that was skipped due to failing the erased @@ -1095,11 +1095,11 @@ int yaffs2_scan_backwards(yaffs_Device *dev) } else if (c == 0) { /* We're looking at the first chunk in the block so the block is unused */ state = YAFFS_BLOCK_STATE_EMPTY; - dev->nErasedBlocks++; + dev->n_erased_blocks++; } else { if (state == YAFFS_BLOCK_STATE_NEEDS_SCANNING || state == YAFFS_BLOCK_STATE_ALLOCATING) { - if (dev->sequenceNumber == bi->sequenceNumber) { + if (dev->seq_number == bi->seq_number) { /* this is the block being allocated from */ T(YAFFS_TRACE_SCAN, @@ -1108,9 +1108,9 @@ int yaffs2_scan_backwards(yaffs_Device *dev) TENDSTR), blk, c)); state = YAFFS_BLOCK_STATE_ALLOCATING; - dev->allocationBlock = blk; - dev->allocationPage = c; - dev->allocationBlockFinder = blk; + dev->alloc_block = blk; + dev->alloc_page = c; + dev->alloc_block_finder = blk; } else { /* This is a partially written block that is not * the current allocation block. @@ -1123,40 +1123,40 @@ int yaffs2_scan_backwards(yaffs_Device *dev) } } - dev->nFreeChunks++; + dev->n_free_chunks++; - } else if (tags.eccResult == YAFFS_ECC_RESULT_UNFIXED) { + } else if (tags.ecc_result == YAFFS_ECC_RESULT_UNFIXED) { T(YAFFS_TRACE_SCAN, (TSTR(" Unfixed ECC in chunk(%d:%d), chunk ignored"TENDSTR), blk, c)); - dev->nFreeChunks++; + dev->n_free_chunks++; - } else if (tags.objectId > YAFFS_MAX_OBJECT_ID || - tags.chunkId > YAFFS_MAX_CHUNK_ID || - (tags.chunkId > 0 && tags.byteCount > dev->nDataBytesPerChunk) || - tags.sequenceNumber != bi->sequenceNumber ) { + } else if (tags.obj_id > YAFFS_MAX_OBJECT_ID || + tags.chunk_id > YAFFS_MAX_CHUNK_ID || + (tags.chunk_id > 0 && tags.n_bytes > dev->data_bytes_per_chunk) || + tags.seq_number != bi->seq_number ) { T(YAFFS_TRACE_SCAN, - (TSTR("Chunk (%d:%d) with bad tags:obj = %d, chunkId = %d, byteCount = %d, ignored"TENDSTR), - blk, c,tags.objectId, tags.chunkId, tags.byteCount)); + (TSTR("Chunk (%d:%d) with bad tags:obj = %d, chunk_id = %d, n_bytes = %d, ignored"TENDSTR), + blk, c,tags.obj_id, tags.chunk_id, tags.n_bytes)); - dev->nFreeChunks++; + dev->n_free_chunks++; - } else if (tags.chunkId > 0) { - /* chunkId > 0 so it is a data chunk... */ + } else if (tags.chunk_id > 0) { + /* chunk_id > 0 so it is a data chunk... */ unsigned int endpos; __u32 chunkBase = - (tags.chunkId - 1) * dev->nDataBytesPerChunk; + (tags.chunk_id - 1) * dev->data_bytes_per_chunk; foundChunksInBlock = 1; yaffs_set_chunk_bit(dev, blk, c); - bi->pagesInUse++; + bi->pages_in_use++; in = yaffs_find_or_create_by_number(dev, tags. - objectId, + obj_id, YAFFS_OBJECT_TYPE_FILE); if (!in) { /* Out of memory */ @@ -1164,22 +1164,22 @@ int yaffs2_scan_backwards(yaffs_Device *dev) } if (in && - in->variantType == YAFFS_OBJECT_TYPE_FILE - && chunkBase < in->variant.fileVariant.shrinkSize) { + in->variant_type == YAFFS_OBJECT_TYPE_FILE + && chunkBase < in->variant.file_variant.shrink_size) { /* This has not been invalidated by a resize */ - if (!yaffs_put_chunk_in_file(in, tags.chunkId, chunk, -1)) { + if (!yaffs_put_chunk_in_file(in, tags.chunk_id, chunk, -1)) { alloc_failed = 1; } /* File size is calculated by looking at the data chunks if we have not * seen an object header yet. Stop this practice once we find an object header. */ - endpos = chunkBase + tags.byteCount; + endpos = chunkBase + tags.n_bytes; if (!in->valid && /* have not got an object header yet */ - in->variant.fileVariant.scannedFileSize < endpos) { - in->variant.fileVariant.scannedFileSize = endpos; - in->variant.fileVariant.fileSize = endpos; + in->variant.file_variant.scanned_size < endpos) { + in->variant.file_variant.scanned_size = endpos; + in->variant.file_variant.file_size = endpos; } } else if (in) { @@ -1189,31 +1189,31 @@ int yaffs2_scan_backwards(yaffs_Device *dev) } } else { - /* chunkId == 0, so it is an ObjectHeader. + /* chunk_id == 0, so it is an ObjectHeader. * Thus, we read in the object header and make the object */ foundChunksInBlock = 1; yaffs_set_chunk_bit(dev, blk, c); - bi->pagesInUse++; + bi->pages_in_use++; oh = NULL; in = NULL; - if (tags.extraHeaderInfoAvailable) { + if (tags.extra_available) { in = yaffs_find_or_create_by_number(dev, - tags.objectId, - tags.extraObjectType); + tags.obj_id, + tags.extra_obj_type); if (!in) alloc_failed = 1; } if (!in || - (!in->valid && dev->param.disableLazyLoad) || - tags.extraShadows || + (!in->valid && dev->param.disable_lazy_load) || + tags.extra_shadows || (!in->valid && - (tags.objectId == YAFFS_OBJECTID_ROOT || - tags.objectId == YAFFS_OBJECTID_LOSTNFOUND))) { + (tags.obj_id == YAFFS_OBJECTID_ROOT || + tags.obj_id == YAFFS_OBJECTID_LOSTNFOUND))) { /* If we don't have valid info then we need to read the chunk * TODO In future we can probably defer reading the chunk and @@ -1225,16 +1225,16 @@ int yaffs2_scan_backwards(yaffs_Device *dev) chunkData, NULL); - oh = (yaffs_ObjectHeader *) chunkData; + oh = (yaffs_obj_header *) chunkData; - if (dev->param.inbandTags) { + if (dev->param.inband_tags) { /* Fix up the header if they got corrupted by inband tags */ - oh->shadowsObject = oh->inbandShadowsObject; - oh->isShrink = oh->inbandIsShrink; + oh->shadows_obj = oh->inband_shadowed_obj_id; + oh->is_shrink = oh->inband_is_shrink; } if (!in) { - in = yaffs_find_or_create_by_number(dev, tags.objectId, oh->type); + in = yaffs_find_or_create_by_number(dev, tags.obj_id, oh->type); if (!in) alloc_failed = 1; } @@ -1246,7 +1246,7 @@ int yaffs2_scan_backwards(yaffs_Device *dev) T(YAFFS_TRACE_ERROR, (TSTR ("yaffs tragedy: Could not make object for object %d at chunk %d during scan" - TENDSTR), tags.objectId, chunk)); + TENDSTR), tags.obj_id, chunk)); continue; } @@ -1256,40 +1256,40 @@ int yaffs2_scan_backwards(yaffs_Device *dev) * we first have to suck out resize info if it is a file. */ - if ((in->variantType == YAFFS_OBJECT_TYPE_FILE) && + if ((in->variant_type == YAFFS_OBJECT_TYPE_FILE) && ((oh && oh->type == YAFFS_OBJECT_TYPE_FILE) || - (tags.extraHeaderInfoAvailable && - tags.extraObjectType == YAFFS_OBJECT_TYPE_FILE))) { + (tags.extra_available && + tags.extra_obj_type == YAFFS_OBJECT_TYPE_FILE))) { __u32 thisSize = - (oh) ? oh->fileSize : tags. - extraFileLength; - __u32 parentObjectId = + (oh) ? oh->file_size : tags. + extra_length; + __u32 parent_obj_id = (oh) ? oh-> - parentObjectId : tags. - extraParentObjectId; + parent_obj_id : tags. + extra_parent_id; - isShrink = - (oh) ? oh->isShrink : tags. - extraIsShrinkHeader; + is_shrink = + (oh) ? oh->is_shrink : tags. + extra_is_shrink; /* If it is deleted (unlinked at start also means deleted) * we treat the file size as being zeroed at this point. */ - if (parentObjectId == + if (parent_obj_id == YAFFS_OBJECTID_DELETED - || parentObjectId == + || parent_obj_id == YAFFS_OBJECTID_UNLINKED) { thisSize = 0; - isShrink = 1; + is_shrink = 1; } - if (isShrink && in->variant.fileVariant.shrinkSize > thisSize) - in->variant.fileVariant.shrinkSize = thisSize; + if (is_shrink && in->variant.file_variant.shrink_size > thisSize) + in->variant.file_variant.shrink_size = thisSize; - if (isShrink) - bi->hasShrinkHeader = 1; + if (is_shrink) + bi->has_shrink_hdr = 1; } /* Use existing - destroy this one. */ @@ -1297,20 +1297,20 @@ int yaffs2_scan_backwards(yaffs_Device *dev) } - if (!in->valid && in->variantType != - (oh ? oh->type : tags.extraObjectType)) + if (!in->valid && in->variant_type != + (oh ? oh->type : tags.extra_obj_type)) T(YAFFS_TRACE_ERROR, ( TSTR("yaffs tragedy: Bad object type, " TCONT("%d != %d, for object %d at chunk ") TCONT("%d during scan") TENDSTR), oh ? - oh->type : tags.extraObjectType, - in->variantType, tags.objectId, + oh->type : tags.extra_obj_type, + in->variant_type, tags.obj_id, chunk)); if (!in->valid && - (tags.objectId == YAFFS_OBJECTID_ROOT || - tags.objectId == + (tags.obj_id == YAFFS_OBJECTID_ROOT || + tags.obj_id == YAFFS_OBJECTID_LOSTNFOUND)) { /* We only load some info, don't fiddle with directory structure */ in->valid = 1; @@ -1333,22 +1333,22 @@ int yaffs2_scan_backwards(yaffs_Device *dev) in->yst_ctime = oh->yst_ctime; in->yst_rdev = oh->yst_rdev; - in->lazyLoaded = 0; + in->lazy_loaded = 0; #endif } else - in->lazyLoaded = 1; + in->lazy_loaded = 1; - in->hdrChunk = chunk; + in->hdr_chunk = chunk; } else if (!in->valid) { /* we need to load this info */ in->valid = 1; - in->hdrChunk = chunk; + in->hdr_chunk = chunk; if (oh) { - in->variantType = oh->type; + in->variant_type = oh->type; in->yst_mode = oh->yst_mode; #ifdef CONFIG_YAFFS_WINCE @@ -1367,10 +1367,10 @@ int yaffs2_scan_backwards(yaffs_Device *dev) in->yst_rdev = oh->yst_rdev; #endif - if (oh->shadowsObject > 0) + if (oh->shadows_obj > 0) yaffs_handle_shadowed_obj(dev, oh-> - shadowsObject, + shadows_obj, 1); @@ -1378,23 +1378,23 @@ int yaffs2_scan_backwards(yaffs_Device *dev) yaffs_set_obj_name_from_oh(in, oh); parent = yaffs_find_or_create_by_number - (dev, oh->parentObjectId, + (dev, oh->parent_obj_id, YAFFS_OBJECT_TYPE_DIRECTORY); - fileSize = oh->fileSize; - isShrink = oh->isShrink; - equivalentObjectId = oh->equivalentObjectId; + file_size = oh->file_size; + is_shrink = oh->is_shrink; + equiv_id = oh->equiv_id; } else { - in->variantType = tags.extraObjectType; + in->variant_type = tags.extra_obj_type; parent = yaffs_find_or_create_by_number - (dev, tags.extraParentObjectId, + (dev, tags.extra_parent_id, YAFFS_OBJECT_TYPE_DIRECTORY); - fileSize = tags.extraFileLength; - isShrink = tags.extraIsShrinkHeader; - equivalentObjectId = tags.extraEquivalentObjectId; - in->lazyLoaded = 1; + file_size = tags.extra_length; + is_shrink = tags.extra_is_shrink; + equiv_id = tags.extra_equiv_id; + in->lazy_loaded = 1; } in->dirty = 0; @@ -1406,15 +1406,15 @@ int yaffs2_scan_backwards(yaffs_Device *dev) * hook up to parent */ - if (parent && parent->variantType == + if (parent && parent->variant_type == YAFFS_OBJECT_TYPE_UNKNOWN) { /* Set up as a directory */ - parent->variantType = + parent->variant_type = YAFFS_OBJECT_TYPE_DIRECTORY; YINIT_LIST_HEAD(&parent->variant. - directoryVariant. + dir_variant. children); - } else if (!parent || parent->variantType != + } else if (!parent || parent->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) { /* Hoosterman, another problem.... * We're trying to use a non-directory as a directory @@ -1424,17 +1424,17 @@ int yaffs2_scan_backwards(yaffs_Device *dev) (TSTR ("yaffs tragedy: attempting to use non-directory as a directory in scan. Put in lost+found." TENDSTR))); - parent = dev->lostNFoundDir; + parent = dev->lost_n_found; } yaffs_add_obj_to_dir(parent, in); - itsUnlinked = (parent == dev->deletedDir) || - (parent == dev->unlinkedDir); + itsUnlinked = (parent == dev->del_dir) || + (parent == dev->unlinked_dir); - if (isShrink) { + if (is_shrink) { /* Mark the block as having a shrinkHeader */ - bi->hasShrinkHeader = 1; + bi->has_shrink_hdr = 1; } /* Note re hardlinks. @@ -1444,35 +1444,35 @@ int yaffs2_scan_backwards(yaffs_Device *dev) * through this list and fix up all the chains. */ - switch (in->variantType) { + switch (in->variant_type) { case YAFFS_OBJECT_TYPE_UNKNOWN: /* Todo got a problem */ break; case YAFFS_OBJECT_TYPE_FILE: - if (in->variant.fileVariant. - scannedFileSize < fileSize) { + if (in->variant.file_variant. + scanned_size < file_size) { /* This covers the case where the file size is greater * than where the data is * This will happen if the file is resized to be larger * than its current data extents. */ - in->variant.fileVariant.fileSize = fileSize; - in->variant.fileVariant.scannedFileSize = fileSize; + in->variant.file_variant.file_size = file_size; + in->variant.file_variant.scanned_size = file_size; } - if (in->variant.fileVariant.shrinkSize > fileSize) - in->variant.fileVariant.shrinkSize = fileSize; + if (in->variant.file_variant.shrink_size > file_size) + in->variant.file_variant.shrink_size = file_size; break; case YAFFS_OBJECT_TYPE_HARDLINK: if (!itsUnlinked) { - in->variant.hardLinkVariant.equivalentObjectId = - equivalentObjectId; - in->hardLinks.next = - (struct ylist_head *) hardList; - hardList = in; + in->variant.hardlink_variant.equiv_id = + equiv_id; + in->hard_links.next = + (struct ylist_head *) hard_list; + hard_list = in; } break; case YAFFS_OBJECT_TYPE_DIRECTORY: @@ -1483,9 +1483,9 @@ int yaffs2_scan_backwards(yaffs_Device *dev) break; case YAFFS_OBJECT_TYPE_SYMLINK: if (oh) { - in->variant.symLinkVariant.alias = + in->variant.symlink_variant.alias = yaffs_clone_str(oh->alias); - if (!in->variant.symLinkVariant.alias) + if (!in->variant.symlink_variant.alias) alloc_failed = 1; } break; @@ -1503,12 +1503,12 @@ int yaffs2_scan_backwards(yaffs_Device *dev) } - bi->blockState = state; + bi->block_state = state; /* Now let's see if it was dirty */ - if (bi->pagesInUse == 0 && - !bi->hasShrinkHeader && - bi->blockState == YAFFS_BLOCK_STATE_FULL) { + if (bi->pages_in_use == 0 && + !bi->has_shrink_hdr && + bi->block_state == YAFFS_BLOCK_STATE_FULL) { yaffs_block_became_dirty(dev, blk); } @@ -1526,7 +1526,7 @@ int yaffs2_scan_backwards(yaffs_Device *dev) * We should now have scanned all the objects, now it's time to add these * hardlinks. */ - yaffs_link_fixup(dev, hardList); + yaffs_link_fixup(dev, hard_list); yaffs_release_temp_buffer(dev, chunkData, __LINE__); diff --git a/yaffs_yaffs2.h b/yaffs_yaffs2.h index e54bc6c..e012aec 100644 --- a/yaffs_yaffs2.h +++ b/yaffs_yaffs2.h @@ -16,21 +16,21 @@ #include "yaffs_guts.h" -void yaffs_calc_oldest_dirty_seq(yaffs_Device *dev); -void yaffs2_find_oldest_dirty_seq(yaffs_Device *dev); -void yaffs2_clear_oldest_dirty_seq(yaffs_Device *dev, yaffs_BlockInfo *bi); -void yaffs2_update_oldest_dirty_seq(yaffs_Device *dev, unsigned blockNo, yaffs_BlockInfo *bi); -int yaffs_block_ok_for_gc(yaffs_Device *dev, yaffs_BlockInfo *bi); -__u32 yaffs2_find_refresh_block(yaffs_Device *dev); -int yaffs2_checkpt_required(yaffs_Device *dev); -int yaffs_calc_checkpt_blocks_required(yaffs_Device *dev); +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 yaffs2_checkpt_invalidate(yaffs_Device *dev); -int yaffs2_checkpt_save(yaffs_Device *dev); -int yaffs2_checkpt_restore(yaffs_Device *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); -int yaffs2_handle_hole(yaffs_Object *obj, loff_t newSize); -int yaffs2_scan_backwards(yaffs_Device *dev); +int yaffs2_handle_hole(yaffs_obj_t *obj, loff_t new_size); +int yaffs2_scan_backwards(yaffs_dev_t *dev); #endif |